', 9999)\n UDP_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # creating UDP client to broadcast to server\n UDP_client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # this function is called so this object uses\n # ~ UDP protocol\n\n UDP_client.settimeout(1)\n\n connected_to_UDP_server = False\n while connected_to_UDP_server == False:\n try:\n UDP_client.sendto(bytes(\"A\", encoding='utf-8'), UDP_client_address)\n \"\"\"\n After broadcasting, if the expected server to listen is listening, it will respond to the letter 'A' \n with a letter 'B'. in that case we know that the server and the client have found each other. Which \n means that we will have the ip address of the server and then we can establish a TCP connection with the\n server. This ip address could be found in the 1st index of the tuple 'server_addr'\n \"\"\"\n recv_data_from_server, server_addr = UDP_client.recvfrom(2048)\n msg = recv_data_from_server.decode('utf-8')\n\n if msg == \"B\":\n IP_ADDRESS_OF_SERVER = server_addr[0]\n connected_to_UDP_server = True\n recv_port_from_server, server_addr = UDP_client.recvfrom(2048)\n port_from_server = recv_port_from_server.decode('utf-8')\n self.class_connection_list[2] = int(port_from_server)\n print(\"the port from server is: \" + str(self.class_connection_list[2]))\n\n except socket.timeout:\n print(\" UDP Server not listening\")\n connected_to_UDP_server = False\n\n # ================= Establishing the TCP connection below this line ===========================\n self.class_connection_list[1] = IP_ADDRESS_OF_SERVER # storing the ip in second location of the list\n\n connectedToServer = False # Defining a boolean to show whether client is connected to server\n while (connectedToServer == False): # trying to connecting the client to the server while it is not connected\n try: # program tries to connect to server\n client = socket.socket() # creating client object\n address = (self.class_connection_list[1], self.class_connection_list[2]) # creating address tuple\n client.connect(address) # connecting to the server using address\n connectedToServer = True # assuming that the client has successfully connected to the server and\n # ~ hence,changing the boolean accordingly (if connecting fails or , the exception clause below will run\n except ConnectionRefusedError: # This exception is raised if the server is not listening\n connectedToServer = False # since there is no server, we change the boolean back to false\n print(\"(refused) Server not listening...\")\n print(self.class_connection_list[2])\n print(IP_ADDRESS_OF_SERVER)\n sleep(1)\n client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # since there has been a failed connection\n # ~ for the previous client object, something has changed inside it and hence, it can not try to\n # connect again. So we create a new client object.\n\n # client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)\n\n except ConnectionResetError:\n connectedToServer = False # since there is no server, we change the boolean back to false\n print(\"(reset) Server not listening...\")\n sleep(1)\n client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # since there has been a failed connection\n # ~ for the previous client object, something has changed inside it and hence, it can not try to\n # connect again. So we create a new client object.\n\n # client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)\n\n\n self.class_connection_list[0] = client\n self.class_connection_list[0].settimeout(0.5) # setting a time out for the thread so it doesn't spend time on\n # ~ the task for more than 0.5 seconds; so if it doesn't receive anything for 0.5 seconds, it stops trying to\n # ~ receive sth from client and starts sending stuff, if there are any\n\n return client # returning client, which is a socket object","def Main(self):\n while not self.IsStopping():\n success = False\n while not success:\n for unused_i in range(_CONNECT_LOG_INTERVAL):\n success = self.GetSocket()\n if self.IsStopping():\n return\n if success:\n break\n self.Sleep(_CONNECT_INTERVAL)\n if not success:\n self.warning('Connection to target unavailable')\n\n receiver = input_socket.InputSocketReceiver(\n self.logger.name, self._sock, self)\n receiver.ProcessRequest()","def broadcast(self, msg_type, msg, t=5):\n return None"],"string":"[\n \"def receive_broadcast_thread():\\n current_node = get_node_uuid()\\n while True:\\n # TODO: write logic for receiving broadcasts.\\n data, (ip, port) = broadcaster.recvfrom(4096)\\n items = data.decode('UTF-8').split(' ')\\n key = items[0]\\n actual_port = int(items[2])\\n if key != current_node:\\n print_blue(f\\\"RECV: {data} FROM: {ip}:{port}\\\")\\n\\n if key not in neighbor_information or neighbor_information[key].last_timestamp % 10 == 0:\\n tcp_thread = daemon_thread_builder(exchange_timestamps_thread, args=(key, ip, actual_port, ))\\n tcp_thread.start()\\n else:\\n neighbor_information[key].last_timestamp = neighbor_information[key].last_timestamp + 1\",\n \"def receive_broadcast_thread():\\r\\n while True:\\r\\n data, (ip, port) = broadcaster.recvfrom(4096)\\r\\n print_blue(f\\\"RECV: {data} FROM: {ip}:{port}\\\")\\r\\n data = data.decode(\\\"utf-8\\\").split()\\r\\n node_id = data[0]\\r\\n node_port = data[2]\\r\\n\\r\\n # to put a condition for creating a thread not just mindlessly creating them\\r\\n if not node_id in neighbor_information.keys():\\r\\n print(\\\"new node spotted\\\")\\r\\n timestamp_thread = daemon_thread_builder(exchange_timestamps_thread,\\r\\n args=(node_id, ip, node_port,))\\r\\n timestamp_thread.start()\",\n \"def receive_broadcast_thread():\\n while True:\\n # TODO: write logic for receiving broadcasts.\\n data, (ip, port) = broadcaster.recvfrom(4096)\\n print_blue(f\\\"RECV: {data} FROM: {ip}:{port}\\\")\\n unpacked_data = struct.unpack('!8s4sH', data)\\n neighbour_UUID = unpacked_data[0].decode('utf-8')\\n neighbour_tcp_port = unpacked_data[2]\\n\\n if neighbour_UUID != node_uuid:\\n if neighbour_UUID in neighbor_information:\\n broadcast_count = neighbor_information[neighbour_UUID].broadcast_count\\n neighbor_information[neighbour_UUID].broadcast_count += 1\\n else:\\n broadcast_count = 0\\n if neighbour_UUID not in neighbor_information or broadcast_count % 10 == 0:\\n thread_recv_tcp = daemon_thread_builder(exchange_timestamps_thread, (neighbour_UUID, ip, neighbour_tcp_port))\\n thread_send_tcp = daemon_thread_builder(tcp_server_thread, ( ))\\n \\n thread_send_tcp.start()\\n thread_recv_tcp.start()\",\n \"def receive_broadcast_thread():\\n myuuid = get_node_uuid()\\n while True:\\n # TODO: write logic for receiving broadcasts.\\n data, (ip, port) = broadcaster.recvfrom(4096)\\n uuid, port = handlebroadcast(data)\\n\\n if uuid == myuuid:\\n continue\\n\\n map_sem.acquire()\\n new_dict = deepcopy(neighbor_information)\\n new_keys = new_dict.keys()\\n map_sem.release()\\n\\n if uuid in new_keys:\\n continue\\n\\n exchanging_thread = daemon_thread_builder(exchange_timestamps_thread, (uuid, ip, port))\\n exchanging_thread.start()\\n print_blue(f\\\"RECV: {uuid} FROM: {ip}:{port}\\\")\",\n \"def start(self):\\n\\n self.__new_bus_Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.__bus_stations_Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n self.__ipv4 = (socket.gethostbyname(socket.gethostname()))\\n if self.__telegram_bot == None:\\n print(\\\"telegram bot connection is not set yet\\\")\\n return\\n if self.__message_sender == None:\\n print(\\\"message sender connection is not set yet\\\")\\n return\\n new_bus_receiver = threading.Thread(target=self.__new_bus_reciever, args=(), name=\\\"new_bus_reciever\\\")\\n new_bus_receiver.start()\\n updates_tracker = threading.Thread(target=self.__track_updates, args=(), name=\\\"updates_tracker\\\")\\n updates_tracker.start()\\n heart_beat = threading.Thread(target=self.__heart, args=(), name=\\\"Heart beats\\\")\\n heart_beat.start()\",\n \"def init_thread(self):\\n logger.info('broadcast thread start with interval %ds (dpid=%s)', self.tbl.advertise_interval, dpid_to_str(self.dp.id))\\n broadcast_thread = Thread(target=self.broadcast_thread)\\n broadcast_thread.setDaemon(True)\\n broadcast_thread.start()\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\r\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\r\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n sock.connect((other_ip, int(other_tcp_port)))\\r\\n other_time = sock.recv(4096)\\r\\n other_time = struct.unpack(\\\"!f\\\", other_time)\\r\\n print(\\\"*\\\" * 50)\\r\\n my_time = datetime.datetime.utcnow().timestamp()\\r\\n delay = my_time - other_time[0]\\r\\n neighbor = NeighborInfo(delay, my_time, other_ip,\\r\\n other_tcp_port, broadcast_count)\\r\\n print_red(neighbor_information)\\r\\n #neighbor_information.update({other_uuid: neighbor})\\r\\n neighbor_information[other_uuid] = neighbor\\r\\n print_red(neighbor_information)\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\\n\\n # send our timestamp\\n try:\\n s.connect((other_ip, other_tcp_port))\\n now = time.time()\\n our_timestamp = struct.pack(\\\"!d\\\", now)\\n\\n s.sendall(our_timestamp)\\n data = s.recv(1024)\\n except ConnectionRefusedError:\\n return\\n except ConnectionResetError:\\n return\\n\\n # receive timestamp\\n last_timestamp = struct.unpack(\\\"!d\\\", data)[0]\\n print_yellow(f'received from {other_ip} {other_tcp_port} time stamp {last_timestamp}')\\n delay = time.time() - last_timestamp\\n neighbor_node = NeighborInfo(delay, last_timestamp, ip=other_ip, tcp_port=other_tcp_port)\\n print('inserting into neighbour in exchange')\\n insertIntoNeighbour(other_uuid, neighbor_node)\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n try:\\n client.connect((other_ip, other_tcp_port))\\n data = client.recv(1024)\\n except ConnectionError:\\n print_red(\\\"connection refused\\\") \\n exit()\\n timestamp = struct.unpack(\\\"!d\\\", data)\\n # calculate delay\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n delay = my_timestamp - timestamp[0]\\n\\n if other_uuid in neighbor_information:\\n neighbor_information[other_uuid].delay = delay\\n # neighbor_information[other_uuid].last_timestamp = timestamp[0]\\n\\n else:\\n neighbour_node = NeighborInfo(delay, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: neighbour_node})\\n\\n client.close()\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n address = (other_ip, other_tcp_port)\\n tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n tcp_socket.connect(address)\\n received_time_stamp = struct.unpack('!f', tcp_socket.recv(4096))[0]\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n\\n delay = current_timestamp - received_time_stamp\\n # print_red(f'Current: [{current_timestamp}] ==> Received [{received_time_stamp}]')\\n print_red(f'[{other_uuid}] Current delay {abs(delay)}')\\n node = NeighborInfo(delay, 1, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: node})\\n\\n pass\",\n \"def tcp_server_thread():\\n neigbour_sock, neighbour_addr = server.accept()\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n packed = struct.pack(\\\"!d\\\", my_timestamp)\\n neigbour_sock.send(packed)\\n pass\",\n \"def broadcast_thread(self):\\n while True:\\n try:\\n logger.info('broadcast routing table (dpid=%s)', dpid_to_str(self.dp.id))\\n for port_no, port in self.ports.items():\\n if port.neighbor_switch_dpid:\\n self.switches[port.neighbor_switch_dpid].add_to_queue((port, self.tbl))\\n self.switches[port.neighbor_switch_dpid].trigger_update()\\n time.sleep(self.tbl.advertise_interval)\\n except:\\n logger.info('broadcast thread of dpid=%s is killed', dpid_to_str(self.dp.id))\\n break\",\n \"def run(self):\\n if self.is_running:\\n print('Broadcaster is already running')\\n return\\n\\n if not self._thread:\\n logger.debug('Creating server for given database ...')\\n #Create server\\n self.server = SimpleServer()\\n self.server.createPV(prefix, self.db)\\n\\n #Create driver\\n self.driver = LightDriver(self.cmds)\\n\\n #Create thread\\n self._thread = ServerThread(self.server)\\n\\n #Start the server\\n logger.info('Starting pcaspy server ...')\\n self._thread.start()\\n\\n #Update all the callbacks\\n logger.debug(\\\"Running stored callbacks to update broadcast PVs\\\")\\n [cb() for cb in self.subs.keys()]\",\n \"def __track_updates(self):\\n\\n self.__bus_stations_Socket.bind((self.__ipv4, BusController.STATIONS_PORT))\\n self.__bus_stations_Socket.listen(1)\\n while not self.__stop_threads:\\n # establish a connection\\n try:\\n message = \\\"empty message\\\"\\n client_socket, addr = self.__bus_stations_Socket.accept()\\n data = client_socket.recv(1024).decode()\\n print(f\\\"recieved {data}\\\")\\n if \\\"message\\\" in data:\\n line_num, station_num, id, keyword = data.split(\\\":\\\")[0].split(\\\" \\\")\\n message = data.split(\\\":\\\")[1]\\n else:\\n line_num, station_num, id = data.split(\\\" \\\")\\n\\n if not (line_num.isdigit() and station_num.isdigit() and id.isdigit()):\\n print(\\\"some bus tried to access the system, but his ID doesn't match the expected\\\")\\n elif int(line_num) not in self.__bus_dict.keys() or id not in map(lambda bus: bus.id,\\n self.__bus_dict[int(line_num)]):\\n print(\\\"an unregistered bus tried to access the system, ignored.\\\")\\n elif \\\"message\\\" in data:\\n\\n self.__bus_messages.append({\\n \\\"sender\\\": self.__find_bus_by_id(id),\\n \\\"time\\\": time.time(),\\n \\\"text\\\": message\\n })\\n if len(self.__bus_messages) > BusController.MAX_MESSAGES_TO_DISPLAY:\\n self.__bus_messages = self.__bus_messages[:-BusController.MAX_MESSAGES_TO_DISPLAY:]\\n\\n print(f\\\"recieved a message, added to the list: {self.__bus_messages}\\\")\\n else:\\n\\n relevant_bus = self.__find_bus_by_id(id)\\n relevant_bus.set_station(station_num)\\n self.__telegram_bot.notify_passengers_about_incoming_bus(relevant_bus)\\n self.__try_remove_people_from_the_station(bus=relevant_bus)\\n if int(station_num) >= BusController.MAX_STATION:\\n self.remove_bus(relevant_bus)\\n self.__message_sender.send_line(int(line_num), update_buses=True)\\n\\n except Exception as e:\\n print(f\\\"exception in __track_updates: {e}\\\")\\n print(\\\"closed track_updates\\\")\",\n \"def run(self):\\n self.stopped = False\\n # receives incoming 'host up' requests\\n serverSocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)\\n serverSocket.bind(('255.255.255.255', Globals.BROADCAST_PORT))\\n \\n # wait for UDP broadcast, send TCP ACK\\n while 1:\\n \\n # open a socket and listen for a message\\n value,address = serverSocket.recvfrom(256)\\n host,port = address\\n \\n # this actually prevents a seg fault ;( for some reason\\n if self.stopped:\\n return\\n \\n if value == 'host up':\\n \\n sendSocket = socket.socket(socket.AF_INET, \\n socket.SOCK_STREAM, 0)\\n sendSocket.connect((host, Globals.ACK_PORT))\\n sendSocket.send('host up ack')\\n sendSocket.close()\\n sendSocket = None\\n self._addHost(host)\\n \\n elif value.find('host down') == 0:\\n self._removeHost(host)\\n \\n elif value.find('add group') == 0:\\n self._postEvent(value)\\n \\n elif value.find('remove group') == 0:\\n self._postEvent(value)\\n \\n elif value.find('group beat') == 0:\\n self._postEvent(value)\\n \\n serverSocket.close()\",\n \"def sending():\\n # don't use socket.connect because it fixes a\\n # remote address and causes problems when receiving\\n # from other sockets and sending to them\\n\\n # we also need to cater for sending normal data\\n\\n global DATA\\n start = current_time()\\n while True:\\n if(current_time() - start) < 10:\\n time.sleep(2)\\n continue\\n else:\\n data_to_send = pickle.dumps(DATA[\\\"distance_vec\\\"])\\n for every_neighbor in DATA[\\\"neighbor\\\"]:\\n send_address = (\\\"127.0.0.1\\\", every_neighbor[2])\\n SOCKET1.sendto(data_to_send, send_address)\\n start = current_time()\",\n \"def broadcast():\\n # global receiving_message\\n # if not receiving_message:\\n router.broadcast(clients.copy(), json.dumps(current_state))\",\n \"def runNodesListener(self):\\n \\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n socketNodes.bind((self.ip_address, 5003))\\n\\n while True:\\n socketNodes.listen(5)\\n try :\\n conn, addr1 = socketNodes.accept()\\n data = conn.recv(self.BUFFER_SIZE)\\n if data:\\n decriptedData = ast.literal_eval(data.decode('utf-8'))\\n addr = decriptedData[0]\\n try:\\n \\\"\\\"\\\"\\n We want to know what kind of message we received\\n Here we consider it is a new block\\n \\\"\\\"\\\"\\n \\n receivedBlock = decriptedData[1]['Block']\\n if self.blockchain.chain == []:\\n self.arrivingBlock(decriptedData[1], addr, receivedBlock) \\n\\n else:\\n if receivedBlock['previous_hash'] == self.blockchain.last_block['hash']:\\n self.arrivingBlock(decriptedData[1], addr, receivedBlock)\\n else:\\n self.message = self.setMessage((self.ip_address,{'Confirmation':'block rejected'}))\\n nodesMessage = Thread(target = self.runNodesMessage) #Problem. We kill the last thread even if it didn't accomplished the task\\n nodesMessage.setDaemon(True)\\n nodesMessage.start()\\n \\n \\n except KeyError:\\n try:\\n \\\"\\\"\\\"\\n The message is not a new block but a response to a received block\\n If the block is rejected we drop everything and broadcast a message of rejection\\n If it is accepted we check if it is accepted by every neighbour if yes we ad it to the chain\\n and broadcast the info\\n \\\"\\\"\\\"\\n if self.blockchain.waiting_blocks != []:\\n receivedConfirmation = decriptedData[1]['Confirmation']\\n \\n if receivedConfirmation == 'block rejected':\\n self.blockchain.waiting_blocks.clear()\\n self.contactedIP.clear()\\n self.message = self.setMessage((self.ip_address,decriptedData[1]))\\n nodesMessage = Thread(target = self.runNodesMessage) #Problem. We kill the last thread even if it didn't accomplished the task\\n nodesMessage.setDaemon(True)\\n nodesMessage.start()\\n elif receivedConfirmation == 'All my neighbours ok':\\n if addr in self.neighboursOk:\\n pass\\n else:\\n self.neighboursOk.append(addr)\\n if self.verifyConfirmed(self.neighboursOk):\\n if self.blockchain.waiting_blocks != []:\\n self.blockchain.chain.append(self.blockchain.waiting_blocks[0])\\n print(self.blockchain.chain)\\n self.blockchain.waiting_blocks.clear()\\n self.neighboursOk.clear()\\n self.confirmed.clear() \\n else:\\n continue\\n except KeyError:\\n continue\\n else:\\n continue\\n except socket.timeout:\\n pass\",\n \"def run(self):\\n\\n udp_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)\\n\\n # Allow multiple receiving endpoints.\\n if sys.platform in ['darwin']:\\n udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)\\n elif sys.platform in ['linux', 'win32']:\\n udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n\\n # Accept UDP packets from any host.\\n address = ('', self._udp_port)\\n udp_socket.bind(address)\\n\\n selector = selectors.DefaultSelector()\\n\\n key_udp_socket = selector.register(udp_socket, selectors.EVENT_READ)\\n key_socketpair = selector.register(self._socketpair[0], selectors.EVENT_READ)\\n\\n logging.info(\\\"Receiver thread started, reading UDP packets from port {}.\\\".format(self._udp_port))\\n\\n quitflag = False\\n while not quitflag:\\n for (key, events) in selector.select():\\n timestamp = time.time()\\n if key == key_udp_socket:\\n # All telemetry UDP packets fit in 2048 bytes with room to spare.\\n packet = udp_socket.recv(2048)\\n timestamped_packet = TimestampedPacket(timestamp, packet)\\n self._recorder_thread.record_packet(timestamped_packet)\\n elif key == key_socketpair:\\n quitflag = True\\n\\n selector.close()\\n udp_socket.close()\\n for sock in self._socketpair:\\n sock.close()\\n\\n logging.info(\\\"Receiver thread stopped.\\\")\",\n \"def run(self):\\n broker_channel = broker.init_broker_channel()\\n\\n print(\\\"Starting Twitter Stream Thread: %s\\\" % self.routing_key)\\n while not self.shutdown_flag.is_set():\\n tweet = 'Tweet {0}: {1}'.format(random.randint(1, 100), int(time.time()))\\n lng = random.uniform(self.location['sw']['lng'], self.location['ne']['lng'])\\n lat = random.uniform(self.location['sw']['lat'], self.location['ne']['lat'])\\n\\n cleaned_data = json.dumps({'tweet': tweet, 'lat': lat, 'lng': lng})\\n\\n broker_channel.basic_publish(exchange=broker.broker_exchange, routing_key=self.routing_key, body=cleaned_data)\\n time.sleep(10+random.randint(0, 3))\\n\\n print(\\\"Exiting Twitter Stream Thread: %s\\\" % self.routing_key)\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n tcpserver=daemon_thread_builder(tcp_server_thread, args=(other_uuid, other_tcp_port))\\n\\n SENDER = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n SENDER.connect((other_ip,int(other_tcp_port)))\\n address = (other_ip, int(other_tcp_port))\\n time_now = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n SENDER.sendto(struct.pack('!f', time_now), address)\\n \\n tcpserver.start()\\n tcpserver.join()\\n SENDER.close()\\n\\n pass\",\n \"def broadcast(self, session, params):\\n session.set_status('running')\\n FMT = self.udp_schema['format']\\n FMT_LEN = struct.calcsize(FMT)\\n UDP_PORT = self.udp['port']\\n udp_data = []\\n fields = self.udp_schema['fields']\\n session.data = {}\\n\\n # BroadcastStreamControl instance.\\n stream = self.acu_control.streams['main']\\n\\n class MonitorUDP(protocol.DatagramProtocol):\\n def datagramReceived(self, data, src_addr):\\n host, port = src_addr\\n offset = 0\\n while len(data) - offset >= FMT_LEN:\\n d = struct.unpack(FMT, data[offset:offset + FMT_LEN])\\n udp_data.append(d)\\n offset += FMT_LEN\\n\\n handler = reactor.listenUDP(int(UDP_PORT), MonitorUDP())\\n influx_data = {}\\n influx_data['Time_bcast_influx'] = []\\n for i in range(2, len(fields)):\\n influx_data[fields[i].replace(' ', '_') + '_bcast_influx'] = []\\n\\n active = True\\n last_packet_time = time.time()\\n\\n while session.status in ['running']:\\n now = time.time()\\n if len(udp_data) >= 200:\\n if not active:\\n self.log.info('UDP packets are being received.')\\n active = True\\n last_packet_time = now\\n\\n process_data = udp_data[:200]\\n udp_data = udp_data[200:]\\n for d in process_data:\\n data_ctime = sh.timecode(d[0] + d[1] / sh.DAY)\\n self.data['broadcast']['Time'] = data_ctime\\n influx_data['Time_bcast_influx'].append(data_ctime)\\n for i in range(2, len(d)):\\n self.data['broadcast'][fields[i].replace(' ', '_')] = d[i]\\n influx_data[fields[i].replace(' ', '_') + '_bcast_influx'].append(d[i])\\n acu_udp_stream = {'timestamp': self.data['broadcast']['Time'],\\n 'block_name': 'ACU_broadcast',\\n 'data': self.data['broadcast']\\n }\\n self.agent.publish_to_feed('acu_udp_stream',\\n acu_udp_stream, from_reactor=True)\\n influx_means = {}\\n for key in influx_data.keys():\\n influx_means[key] = np.mean(influx_data[key])\\n influx_data[key] = []\\n acu_broadcast_influx = {'timestamp': influx_means['Time_bcast_influx'],\\n 'block_name': 'ACU_bcast_influx',\\n 'data': influx_means,\\n }\\n self.agent.publish_to_feed('acu_broadcast_influx', acu_broadcast_influx, from_reactor=True)\\n sd = {}\\n for ky in influx_means:\\n sd[ky.split('_bcast_influx')[0]] = influx_means[ky]\\n session.data.update(sd)\\n else:\\n # Consider logging an outage, attempting reconfig.\\n if active and now - last_packet_time > 3:\\n self.log.info('No UDP packets are being received.')\\n active = False\\n next_reconfig = time.time()\\n if not active and params['auto_enable'] and next_reconfig <= time.time():\\n self.log.info('Requesting UDP stream enable.')\\n try:\\n cfg, raw = yield stream.safe_enable()\\n except Exception as err:\\n self.log.info('Exception while trying to enable stream: {err}', err=err)\\n next_reconfig += 60\\n yield dsleep(1)\\n\\n yield dsleep(0.005)\\n\\n handler.stopListening()\\n return True, 'Acquisition exited cleanly.'\",\n \"def subscribe(receiver, updateInterval=10):\",\n \"def runNodesMessage(self):\\n while True:\\n for neighbour in self.nextIP:\\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n while True:\\n try:\\n socketNodes.connect((neighbour, 5003))\\n socketNodes.send(self.message)\\n break\\n except TimeoutError:\\n pass\\n except ConnectionRefusedError:\\n pass\\n socketNodes.close()\\n break\",\n \"def peer_server(self):\\n try:\\n listener_thread = threading.Thread(target=self.peer_server_listener)\\n listener_thread.setDaemon(True)\\n\\n operations_thread = threading.Thread(target=self.peer_server_host)\\n operations_thread.setDaemon(True)\\n\\n listener_thread.start()\\n operations_thread.start()\\n\\n threads = []\\n threads.append(listener_thread)\\n threads.append(operations_thread)\\n\\n for t in threads:\\n t.join()\\n except Exception as e:\\n print \\\"Peer Server Error, %s\\\" % e\\n sys.exit(1)\",\n \"def listen(self):\\n import _thread\\n\\n def server():\\n TCPSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n TCPSock.bind(('', 2190))\\n TCPSock.listen(5)\\n\\n while True:\\n # Wait for a connection\\n client, address = TCPSock.accept()\\n\\n # Accept (and discard) the client's beacon\\n self.recv_packet(client)\\n\\n # Send ours\\n self.send_packet(client, self.format_beacon('connected'))\\n\\n client.close()\\n\\n _thread.start_new_thread(server, ())\",\n \"def _listen_for_clients (self):\\n self.broadcast_socket.bind(('0.0.0.0',self.broadcast_port))\\n self.broadcast_socket.listen(5)\\n while self.work:\\n connection, _ = self.broadcast_socket.accept()\\n self.clients.append(connection)\\n logging.debug(\\\"Client connected {0}\\\".format(connection.getsockname()))\",\n \"def connectToServer(self):\\n client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n client_sock.bind((self.ip, self.port))\\n client_sock.connect((self.serverPC_ip, 9090))\\n #create CREQ message\\n message = Message('CREQ', self.ip, '\\\\0')\\n client_sock.sendall(message.generateByteMessage())\\n print('Sent CREQ message to serverPC at ' + self.serverPC_ip)\\n #recieve response as string\\n response_message = self.parseMessage(client_sock)\\n if (response_message.type == 'OKAY'):\\n print('OKAY message received')\\n #payload contains host area, and list of connected hosts\\n payload_array = response_message.payload.split(',')\\n i = 1\\n lost_payload = ''\\n while i < len(payload_array):\\n indicator = self.setupHostConnection(payload_array[i])\\n if(indicator == False):\\n lost_payload += payload_array[i]+\\\",\\\"\\n else:\\n self.host_ips.append(payload_array[i])\\n i += 1\\n self.x_min = self.curr_x_max\\n self.x_max = self.x_min + self.x_scalar\\n #this message contains the hosts that have disconnected from the network and notifes the serverPC about the change\\n del_message = Message('LHST', self.ip, lost_payload)\\n print('sent LHST to serverPC with payload: ' + lost_payload)\\n client_sock.sendall(del_message.generateByteMessage())\\n if self.curr_x_min_ip == '':\\n #there was no other host, you are your own neighbor\\n self.r_neighbor = self.ip\\n self.l_neighbor = self.ip\\n else:\\n #else, there is another host - check if there are any other hosts\\n self.r_neighbor = self.curr_x_min_ip\\n\\n if self.l_neighbor == '':\\n #there isnt a left neighbor - left neighbor is right neighbor\\n self.l_neighbor = self.r_neighbor\\n # need to start the listening thread and the work thread now\\n listening_thread = Thread(target=lambda: self.listeningPort())\\n listening_thread.daemon = True\\n listening_thread.start()\\n work_thread = Thread(target=lambda: self.processWork())\\n work_thread.daemon = True\\n work_thread.start()\\n else:\\n print('Invalid message type received from ' + message.origin)\",\n \"def run(self):\\n self.thread_send.start()\\n self.thread_receive.start()\",\n \"def run(self):\\n global socket_connections\\n\\n self.start_server_socket(self.ticks_per_min)\\n\\n while True: \\n\\n try: \\n # keep track of the time that the server started\\n start_time = time.time() \\n c, addr = self.server.accept()\\n data, addr_2 = c.recvfrom(1024)\\n\\n self.server.shutdown(socket.SHUT_RDWR)\\n self.server.close()\\n\\n # keep track of the time that the server finishes receiving\\n # a request\\n end_time = time.time() \\n\\n # set the timeout of the server to end_time - start_time to get\\n # around the GIL\\n self.start_server_socket(end_time - start_time)\\n\\n data = data.decode()\\n\\n # add the received message to the msg_queue\\n if data: \\n self.msg_queue.put(data)\\n print str(self.id) + \\\" got some! \\\" + data\\n\\n # every time the socket timesout, callback to the clock's instruction\\n except Exception, e:\\n # shutdown the server first \\n try: \\n self.server.shutdown(socket.SHUT_RDWR)\\n except:\\n pass\\n self.server.close()\\n print \\\"exception: \\\" + str(e)\\n print \\\"complete an instruction\\\"\\n self.perform_clock_instruction()\\n # restart server\\n self.start_server_socket(self.ticks_per_min)\",\n \"def tcp_server_thread():\\n while True:\\n server.listen(4096)\\n conn, addr = server.accept()\\n with conn:\\n print_green(f\\\"Connected by {addr} \\\")\\n now = time.time()\\n our_timestamp = struct.pack(\\\"!d\\\", now)\\n conn.sendall(our_timestamp)\",\n \"def on_run(self):\\n wxMediator.on_run(self)\\n listener_evt = InterThreadEventWX(self,\\n wxEVT_NEW_LISTEN_CONN) \\n talker_evt = InterThreadEventWX(self,\\n wxEVT_NEW_TALK_CONN) \\n server = self.server()\\n sys.stderr.write('Starting server threads...\\\\n')\\n sys.stderr.flush()\\n server.start_other_threads(listener_evt, talker_evt)\",\n \"def broadcast_new_block(self):\\n\\t\\tneighbors = self.blockchain.nodes\\n\\n\\t\\tfor node in neighbors:\\n\\t\\t\\tprint(f\\\"Requesting {node} to resolve\\\")\\n\\t\\t\\tresponse = requests.get(f'http://{node}/nodes/resolve')\\n\\t\\t\\t# if response.status_code != 200:\\n\\t\\t\\t# \\traise ValueError(f'Node {node} responded bad status code')\\n\\t\\t\\t# print(f\\\"{node} resolve completed\\\")\\n\\n\\t\\tprint(\\\"Broadcast Complete\\\")\",\n \"def background_thread():\\n count = 0\\n while True:\\n socketio.sleep(1)\\n count += 1\\n t = time.strftime('%M:%S', time.localtime())\\n cpus = [1,2,3,4] #\\n print('sending')\\n socketio.emit('server_response',\\n {'data': [t, cpus[0],cpus[1],cpus[2],cpus[3]], 'count': count})\",\n \"def _connect(self):\\n if self._is_running:\\n return\\n\\n # Create thread for receiving motion capture data\\n self._data_thread = DataThread(self._adapter, self._local_ip, self._multicast_ip, self._data_port)\\n self._data_thread.daemon = True\\n self._data_thread.start()\\n\\n # Create thread for sending commands and receiving result\\n self._command_thread = CommandThread(self._adapter, self._server_ip, self._command_port)\\n self._command_thread.daemon = True\\n self._command_thread.start()\\n\\n self._is_running = True\",\n \"def background_lora():\\n # time.sleep(15)\\n sock = socket.socket(socket.AF_INET, # Internet\\n socket.SOCK_DGRAM) # UDP\\n sock.bind((UDP_IP, UDP_LORA))\\n print \\\"LoRa UDP listening on port\\\", UDP_LORA\\n while True:\\n recv, addr = sock.recvfrom(1024) # buffer size is 1024 bytes\\n print recv\\n data = bytearray(recv)\\n parsed = parse_frame(data)\\n message = make_message(parsed)\\n socketio.emit('lora', message)\\n time.sleep(0.10)\",\n \"def main():\\n # Prepare context and sockets\\n context = zmq.Context.instance()\\n frontend = context.socket(zmq.ROUTER)\\n frontend.identity = 'BROKER'.encode('utf-8')\\n frontend.bind(names.BROKER_IN)\\n\\n # Initialize main loop state\\n count = NBR_DEVS\\n devs = set()\\n poller = zmq.Poller() \\n \\n # setup Tk window\\n top = tk.Tk()\\n top.geometry(\\\"1000x250\\\")\\n devs_frame = tk.Frame(top)\\n lbl = tk.Label(devs_frame, text=\\\"Connected Devices\\\")\\n listbox = tk.Listbox(devs_frame)\\n lbl.pack()\\n listbox.pack()\\n devs_frame.pack(side=tk.LEFT)\\n log_frame = tk.Frame(top)\\n msg_log = tk.Text(log_frame)\\n msg_log.pack()\\n log_frame.pack(side=tk.LEFT)\\n gui_running = True\\n\\n poller.register(frontend, zmq.POLLIN)\\n\\n mail_table = {}\\n\\n def update_gui():\\n listbox.delete(0, tk.END)\\n i = 1\\n for dev in devs:\\n listbox.insert(i, str(dev))\\n i = i + 1\\n top.update_idletasks()\\n top.update()\\n \\n def on_closing():\\n gui_running = False\\n\\n top.protocol(\\\"WM_DELETE_WINDOW\\\", on_closing)\\n\\n def print_connections():\\n for id, (from_addr, to_addr, timestamp, msg) in mail_table.items():\\n if time.time() - timestamp > 5:\\n app_log.debug('Message from {} to {} is older than 5 seconds'.format(from_addr.decode('utf-8'), to_addr.decode('utf-8')))\\n if len(devs) > 0:\\n app_log.info('connected devices: {}'.format(devs))\\n else:\\n app_log.info('no connected devices.')\\n\\n tasks = [print_connections, update_gui]\\n times = [1, 0.2]\\n timers = times.copy()\\n\\n while gui_running:\\n start_time = time.time()\\n\\n msg_log.delete(1.0, tk.END)\\n msg_log.insert(tk.END, print_mail_table(mail_table))\\n\\n sockets = dict(poller.poll(20))\\n\\n if frontend in sockets:\\n # msg will be [socket identity, b'', b'HI' or b'BYE' or msg_id]\\n msg = frontend.recv_multipart()\\n app_log.info('received: {}'.format(msg))\\n from_addr = msg[0]\\n cmd = msg[2]\\n \\\"\\\"\\\"\\n Handle messages from workers to broker\\n \\\"\\\"\\\"\\n if cmd == b\\\"HI\\\":\\n if from_addr in devs:\\n app_log.warning(\\\"{} tried to join, but it already joined\\\".format(from_addr))\\n msg = [from_addr, b\\\"\\\", b\\\"ERR\\\", b\\\"Device already connected\\\"]\\n else:\\n devs.add(from_addr)\\n msg = [from_addr, b\\\"\\\", b\\\"OK\\\"]\\n frontend.send_multipart(msg)\\n app_log.debug('sending {}'.format(msg))\\n elif cmd == b\\\"BYE\\\":\\n try:\\n devs.remove(from_addr)\\n for x in mail_table:\\n if x[0] == from_addr:\\n del x\\n except KeyError:\\n app_log.warning('received BYE from {} but {} is not listed in devs'.format(from_addr, from_addr))\\n else:\\n \\\"\\\"\\\"\\n Message should begin with msg_id, possibly dest, then (GET, SET, RET, MET), then extra info\\n out_msg is the message sent to to_addr\\n reply is the message sent to from_addr\\n \\\"\\\"\\\"\\n msg_id = msg[2]\\n msg = msg[3:] # strip everything up to and including msg_id\\n out_msg = None # goes to the to_addr, which is extracted from message or mail_table\\n reply = None # goes to the from_addr\\n if msg_id not in mail_table: # this could be a new request\\n to_addr = msg[0]\\n cmd = msg[1]\\n msg = msg[1:] # strip the to_addr\\n if to_addr in devs:\\n if cmd == b'GET':\\n out_msg = [to_addr, b'', msg_id] + msg\\n reply = [from_addr, b'', msg_id, b'ACK']\\n mail_table[msg_id] = (from_addr, to_addr, time.time(), msg)\\n app_log.debug('Processed GET')\\n elif cmd == b'SET':\\n out_msg = [to_addr, b'', msg_id] + msg\\n reply = [from_addr, b'', msg_id, b'ACK']\\n mail_table[msg_id] = (from_addr, to_addr, time.time(), msg)\\n app_log.debug('Processed SET')\\n else:\\n reply = [from_addr, b'', msg_id, b'ERR', b'Command not understood']\\n app_log.warning('command {} not yet supported'.format(cmd))\\n else:\\n reply = [from_addr, b'', msg_id, b'ERR', b'Device not connected']\\n app_log.debug('requested device {} does not exist'.format(to_addr))\\n app_log.debug(print_mail_table(mail_table))\\n else: # this could be a reply to a request\\n to_addr = mail_table[msg_id][0] # lookup message requestor\\n cmd = msg[0]\\n if to_addr in devs:\\n if from_addr != mail_table[msg_id][1]:\\n app_log.critical('{} sent a message ID that does not agree with mail table.'.format(from_addr))\\n app_log.critical(msg)\\n app_log.critical(print_mail_table(mail_table))\\n elif cmd == b'RET':\\n out_msg = [to_addr, b'', msg_id] + msg\\n del mail_table[msg_id]\\n app_log.debug('Processed RET')\\n elif cmd == b'MET':\\n out_msg = [to_addr, b'', msg_id] + msg\\n del mail_table[msg_id]\\n app_log.debug('Processed MET')\\n elif cmd == b'ERR':\\n del mail_table[msg_id]\\n out_msg = [to_addr, b'', msg_id] + msg\\n else:\\n del mail_table[msg_id]\\n out_msg = [to_addr, b'', msg_id, b'ERR', b'Device replied poorly']\\n app_log.warning('{} sent unrecognized response: {}'.format(from_addr, msg))\\n else:\\n app_log.warning('original requestor {} no longer connected'.format(to_addr))\\n if out_msg is not None:\\n try:\\n frontend.send_multipart(out_msg)\\n app_log.debug('sending {}'.format(out_msg))\\n except zmq.ZMQBaseError as err:\\n app_log.debug('failed to send {} with error: {}'.format(msg, err))\\n if reply is not None:\\n try:\\n frontend.send_multipart(reply)\\n app_log.debug('sending {}'.format(reply))\\n except zmq.ZMQBaseError as err:\\n app_log.debug('failed to send {} with error: {}'.format(msg, err))\\n\\n end_time = time.time()\\n dt = end_time - start_time\\n timers = [x - dt for x in timers]\\n for i, x in enumerate(timers):\\n if x < 0:\\n tasks[i]()\\n timers[i] = times[i]\\n\\n # Clean up\\n frontend.close()\\n context.term()\\n top.destroy()\",\n \"def subscribe(receiver, updateInterval=None):\",\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 \"def onRegisterNetworkBroadcast(self):\\n pass\",\n \"def start_peers(self):\\n for i in self.nodes:\\n i.start()\",\n \"def run(self):\\n logger.info(\\\"Starting script...\\\")\\n\\n while True:\\n logger.info(\\\"Connecting to the primary...\\\")\\n connected = False\\n while connected is False:\\n try:\\n connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n connection.connect(self.server_address)\\n self.connection_handler = ConnectionHandler(connection)\\n connected = True\\n except socket.error as e:\\n logger.info(\\\"Failed to connect to primary, waiting 60 seconds and trying again\\\")\\n time.sleep(60)\\n\\n logger.info(\\\"Successfully connected to the primary\\\")\\n\\n try:\\n logger.info(\\\"Sending an initial hello to primary\\\")\\n self.connection_handler.send_message(\\\"uuid\\\", \\\"info\\\")\\n message = self.connection_handler.get_message()\\n self.uuid = message['payload']\\n logger.info(\\\"My assigned UUID is \\\" + self.uuid)\\n\\n self.connection_handler.send_message(get_node_baseinfo(), 'node_baseinfo')\\n self.connection_handler.send_message(\\\"node_baseinfo\\\", \\\"info\\\")\\n\\n message = self.connection_handler.get_message()\\n logger.info(\\\"We have information about the primary \\\" + json.dumps(message['payload']))\\n\\n # TODO: possibly add some way to signal to the thread that we want to stop\\n vitals_last_sent = 0\\n while True:\\n if (vitals_last_sent + 60) < time.time():\\n logger.info(\\\"Sending vitals to primary node\\\")\\n current_vitals = get_current_node_vitals()\\n self.connection_handler.send_message(current_vitals.get_flat_payload(), \\\"vitals\\\")\\n vitals_last_sent = time.time()\\n self.perform_action()\\n\\n except DisconnectionException as e:\\n logger.info(\\\"Got disconnection exception with message: \\\" + e.message)\\n logger.info(\\\"Secondary will try and reconnect once primary is back online\\\")\",\n \"def startListener(self):\\n self.send_conn = None\\n self.recv_conn = None\\n listener = threading.Thread(target=self.listen, args=(self.recv_conn,))\\n sender = threading.Thread(target=self.send, args=(self.send_conn,))\\n listener.daemon = True # setting daemon to true means threads wont stop program from closing\\n sender.daemon = True\\n listener.start()\\n sender.start()\",\n \"def broadcast(msg):\\r\\n for user in clients:\\r\\n msg_client(msg, user)\",\n \"def start(self):\\n self.listener.start()\\n # No need to start broadcaster, it just sends when necessary\",\n \"def start_listening(self):\\n assert not self.listening\\n assert not self.connected\\n ctx = zmq.Context.instance()\\n self._recv_socket = ctx.socket(zmq.SUB)\\n self._recv_poller = zmq.Poller()\\n self._recv_socket.setsockopt(zmq.SUBSCRIBE, b\\\"\\\")\\n self._recv_poller.register(self._recv_socket, zmq.POLLIN)\\n for i in range(N):\\n if i != self.ID:\\n address = NODE_INFOS[i].address\\n port = NODE_INFOS[i].port\\n self._recv_socket.connect(f\\\"tcp://{address}:{port}\\\")\\n self.listening = True\",\n \"def _subscribe_to_peers(self):\\n if not self.config['PEERS']:\\n return\\n context = zmq.Context()\\n socket = context.socket(zmq.SUB)\\n socket.setsockopt(zmq.SUBSCRIBE, '')\\n\\n for ip, pub_port, api_port in self.config['PEERS']:\\n if not self._is_self(ip, pub_port):\\n address = '%s:%s' % (ip, pub_port)\\n self.logger.debug('Subscribing to peer at: %s' % address)\\n socket.connect('tcp://%s' % address)\\n\\n def new_msg_handler(sender, msg=None):\\n topic, delimiter, packed = msg.partition(' ')\\n topic = int(topic)\\n message_dict = msgpack.unpackb(packed)\\n #self.logger.debug('News for topic %s:%s arrived' %\\n # (topic, constants.topics.get(topic)))\\n self._handle_topic(topic, message_dict)\\n\\n sig = signal(constants.NEW_MESSAGE_TOPIC)\\n sig.connect(new_msg_handler, weak=False)\\n\\n while True:\\n msg = socket.recv()\\n sig.send(self, msg=msg)\\n gevent.sleep(.1)\",\n \"def _recv_thread_func(self):\\r\\n reconnect_time = 1\\r\\n use_ssl = self.config.get_bool(\\\"gox\\\", \\\"use_ssl\\\")\\r\\n wsp = {True: \\\"wss://\\\", False: \\\"ws://\\\"}[use_ssl]\\r\\n port = {True: 443, False: 80}[use_ssl]\\r\\n ws_origin = \\\"%s:%d\\\" % (self.hostname, port)\\r\\n ws_headers = [\\\"User-Agent: %s\\\" % USER_AGENT]\\r\\n while not self._terminating: #loop 0 (connect, reconnect)\\r\\n try:\\r\\n # channels separated by \\\"/\\\", wildcards allowed. Available\\r\\n # channels see here: https://mtgox.com/api/2/stream/list_public\\r\\n # example: ws://websocket.mtgox.com/?Channel=depth.LTCEUR/ticker.LTCEUR\\r\\n # the trades and lag channel will be subscribed after connect\\r\\n sym = \\\"%s%s\\\" % (self.curr_base, self.curr_quote)\\r\\n if not FORCE_NO_DEPTH:\\r\\n ws_url = \\\"%s%s?Channel=depth.%s/ticker.%s\\\" % \\\\\\r\\n (wsp, self.hostname, sym, sym)\\r\\n else:\\r\\n ws_url = \\\"%s%s?Channel=ticker.%s\\\" % \\\\\\r\\n (wsp, self.hostname, sym)\\r\\n self.debug(\\\"### trying plain old Websocket: %s ... \\\" % ws_url)\\r\\n\\r\\n self.socket = websocket.WebSocket()\\r\\n # The server is somewhat picky when it comes to the exact\\r\\n # host:port syntax of the origin header, so I am supplying\\r\\n # my own origin header instead of the auto-generated one\\r\\n self.socket.connect(ws_url, origin=ws_origin, header=ws_headers)\\r\\n self._time_last_received = time.time()\\r\\n self.connected = True\\r\\n self.debug(\\\"### connected, subscribing needed channels\\\")\\r\\n self.channel_subscribe()\\r\\n self.debug(\\\"### waiting for data...\\\")\\r\\n self.signal_connected(self, None)\\r\\n while not self._terminating: #loop1 (read messages)\\r\\n str_json = self.socket.recv()\\r\\n self._time_last_received = time.time()\\r\\n if str_json[0] == \\\"{\\\":\\r\\n self.signal_recv(self, (str_json))\\r\\n\\r\\n except Exception as exc:\\r\\n self.connected = False\\r\\n self.signal_disconnected(self, None)\\r\\n if not self._terminating:\\r\\n self.debug(\\\"### \\\", exc.__class__.__name__, exc,\\r\\n \\\"reconnecting in %i seconds...\\\" % reconnect_time)\\r\\n if self.socket:\\r\\n self.socket.close()\\r\\n time.sleep(reconnect_time)\",\n \"def peer_server_listener(self):\\n try:\\n peer_server_socket = socket.socket(\\n socket.AF_INET, socket.SOCK_STREAM)\\n peer_server_socket.setsockopt(\\n socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n peer_server_socket.setsockopt(\\n socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\\n peer_server_host = self.peer.peer_hostname\\n peer_server_port = self.peer.peer_port\\n peer_server_socket.bind(\\n (peer_server_host, peer_server_port))\\n peer_server_socket.listen(10)\\n while True:\\n conn, addr = peer_server_socket.accept()\\n conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\\n #print \\\"Got connection from %s on port %s\\\" \\\\\\n # % (addr[0], addr[1])\\n self.peer_server_listener_queue.put((conn,addr))\\n except Exception as e:\\n print \\\"Peer Server Listener on port Failed: %s\\\" % e\\n sys.exit(1)\",\n \"def run_server(self):\\n self.establish_connection()\\n while True:\\n self.receive_data(self.conn)\",\n \"def test_broadcast(self):\\n if _debug: TestSimple._debug(\\\"test_broadcast\\\")\\n\\n # create a network\\n tnet = TNetwork()\\n\\n # make a PDU from node 1 to node 2\\n pdu_data = xtob('dead.beef')\\n pdu = PDU(pdu_data, source=tnet.td.address, destination=LocalBroadcast())\\n if _debug: TestSimple._debug(\\\" - pdu: %r\\\", pdu)\\n\\n # test device sends it, iut gets it\\n tnet.td.start_state.send(pdu).success()\\n tnet.iut.start_state.receive(PDU, pduSource=tnet.td.address).success()\\n\\n # sniffer sees message on the wire\\n tnet.sniffer.start_state.receive(OriginalBroadcastNPDU,\\n pduSource=tnet.td.address.addrTuple,\\n# pduDestination=('192.168.4.255', 47808),\\n pduData=pdu_data,\\n ).timeout(1.0).success()\\n\\n # run the group\\n tnet.run()\",\n \"def broadcast(self, new_par):\\n for client in self.clients:\\n client.recv(new_par.copy())\",\n \"def peer_server_host(self):\\n try:\\n while True:\\n while not self.peer_server_listener_queue.empty():\\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\\n conn, addr = self.peer_server_listener_queue.get()\\n data_received = json.loads(conn.recv(1024))\\n\\n if data_received['command'] == 'obtain_active':\\n fut = executor.submit(\\n self.peer_server_upload, conn, data_received)\\n except Exception as e:\\n print \\\"Peer Server Hosting Error, %s\\\" % e\",\n \"def listen(self):\\n while True:\\n peer, address = self.server.accept()\\n peer_port = int(peer.recv(self.CHUNK_SIZE).decode(self.FORMAT))\\n peer.send(bytes(str(self.PEER_LIST),self.FORMAT))\\n if (address[0], peer_port) not in self.PEER_LIST:\\n self.PEER_LIST.append((address[0], peer_port))\\n output_message = f\\\"{datetime.now().timestamp()} : Added <{address[0]}:{peer_port}> to the Peer_list\\\"\\n self.dump_to_file(output_message)\\n print(output_message)\\n thread = threading.Thread(target=self.handlePeers, args=(peer, ))\\n thread.start()\",\n \"def run(self):\\r\\n self.logger.info('NetworkReceiverThread thread started')\\r\\n global receiver_running\\r\\n\\r\\n self.server.bind(('', self.port))\\r\\n self.server.listen(5)\\r\\n\\r\\n while receiver_running:\\r\\n # test which socket sent data\\r\\n all_sockets = self.sockets.values() + [self.server]\\r\\n recv_from_sockets, _, _ = select.select(all_sockets, [], [], 0.2)\\r\\n\\r\\n for s in recv_from_sockets:\\r\\n # if new client trying to connect, accept it\\r\\n if s is self.server:\\r\\n new_socket, address = s.accept()\\r\\n ip = new_socket.getpeername()[0]\\r\\n self.sockets[ip] = new_socket\\r\\n\\r\\n message = protocol.thread.new_socket(\\r\\n socket=new_socket)\\r\\n self.network_queue.put(message)\\r\\n\\r\\n self.logger.debug('new connection to client %s' % ip)\\r\\n # if a connected client send a message, receive it\\r\\n else:\\r\\n # if this is a part of a message that alreay begun to send,\\r\\n # add it to the messages dict\\r\\n if s in self.messages:\\r\\n buff, missing_bytes = self.messages[s]\\r\\n received = self.receive(s, missing_bytes)\\r\\n\\r\\n buff.write(received)\\r\\n missing_bytes -= len(received)\\r\\n\\r\\n self.messages[s] = buff, missing_bytes\\r\\n # if no bytes are missing, the message is received\\r\\n # pass it to the logic thread, and remove from queue\\r\\n if missing_bytes == 0:\\r\\n\\r\\n content = buff.getvalue()\\r\\n buff.close()\\r\\n message = protocol.thread.received(\\r\\n message=content, client=s.getpeername()[0])\\r\\n self.logic_queue.put(message)\\r\\n del self.messages[s]\\r\\n\\r\\n self.logger.debug(\\r\\n 'received a message from %s: %s...'\\r\\n % (s.getpeername()[0], repr(content[:5])))\\r\\n else:\\r\\n self.logger.debug('received part of message. ' +\\r\\n 'total bytes: %s, left %s.' %\\r\\n (len(received), missing_bytes))\\r\\n\\r\\n # if this is the first part of a message,\\r\\n # add it to the message dict\\r\\n else:\\r\\n size_str = self.receive(s, 4)\\r\\n\\r\\n # if connection is closed, remove it\\r\\n if size_str != '':\\r\\n size = protocol.get_size(size_str)\\r\\n self.messages[s] = (StringIO.StringIO(), size)\\r\\n self.logger.debug('new message of size %s' % size)\\r\\n\\r\\n self.server.close()\\r\\n self.logger.info('NetworkReceiverThread thread ended')\",\n \"def run(self):\\n self.connect()\\n self.run_forever()\",\n \"def main():\\n channel_watcher = ChannelWatcher()\\n channel_watcher.create_threads()\\n for thread in channel_watcher.threads:\\n thread.join()\\n return\",\n \"def main(waiting_time = seconds):\\n key = 'YOUR-API-KEY-HERE'\\n messages = []\\n #my_client = WebSocketClient(STOCKS_CLUSTER, key, my_custom_process_message(messages))\\n my_client = WebSocketClient(CRYPTO_CLUSTER, key, my_custom_process_message(messages))\\n #my_client = WebSocketClient(FOREX_CLUSTER, key, my_custom_process_message(messages))\\n my_client.run_async()\\n\\n #my_client.subscribe(\\\"T.MSFT\\\", \\\"T.AAPL\\\", \\\"T.AMD\\\", \\\"T.NVDA\\\") # Stock data\\n my_client.subscribe(\\\"XA.BTC-USD\\\", \\\"XA.ETH-USD\\\", \\\"XA.LTC-USD\\\") # Crypto data\\n #my_client.subscribe(\\\"C.USD/CNH\\\", \\\"C.USD/EUR\\\") # Forex data\\n time.sleep(waiting_time)\\n\\n my_client.close_connection()\\n\\n df = pd.DataFrame(messages)\\n\\n df = df.iloc[5:, 0].to_frame()\\n df.columns = [\\\"data\\\"]\\n df[\\\"data\\\"] = df[\\\"data\\\"].astype(\\\"str\\\")\\n\\n df = pd.json_normalize(df[\\\"data\\\"].apply(lambda x : dict(eval(x))))\\n\\n # export data to sqlite\\n with sqlite3.connect(\\\"realtime_crypto.sqlite\\\") as conn:\\n df.to_sql(\\\"data\\\", con=conn, if_exists=\\\"append\\\", index=False)\",\n \"def watch_for_rtt_messages(self):\\n while True:\\n message = self.socket_manager.get_rtt_message()\\n self.ensure_sender_is_known(message)\\n if message.stage == \\\"0\\\":\\n self.respond_to_rtt_message(message)\\n elif message.stage == \\\"1\\\":\\n self.handle_rtt_response(message)\\n elif message.stage == \\\"2\\\":\\n self.handle_rtt_broadcast(message)\",\n \"def on_connect(self):\\n self.log.info('(Re)Connected to the /tasks namespace')\\n self.node_worker_ref.sync_task_queue_with_server()\\n self.log.debug(\\\"Tasks synced again with the server...\\\")\\n self.node_worker_ref.share_node_details()\",\n \"def start_sockets_threads():\\n\\n # register clean_up_threads to run on crash signals\\n for sig in (SIGABRT, SIGINT, SIGTERM):\\n signal(sig, ServerSockets.clean_up_threads)\\n\\n # spawn all listen threads\\n app.socket_threads.append(spawn(ServerSockets.listen_for_users))\\n app.socket_threads.append(spawn(ServerSockets.listen_for_ingredients))\\n app.socket_threads.append(spawn(ServerSockets.listen_for_menu))\",\n \"def run(self):\\n receiver = threading.Thread(target=self.receive_data)\\n # Setting daemon to True means that this Thread will be terminated when the main program ends.\\n receiver.daemon = True\\n receiver.start()\",\n \"def _run(self):\\n try:\\n # Send a connect message\\n self.socket.send_json({\\\"worker_id\\\": self.socket_id, \\\"message\\\": \\\"connect\\\"})\\n while not self.stop_event.is_set():\\n job = self.socket.recv_json()\\n if self.debug:\\n print(\\\"Received task %s\\\" % job)\\n value = self._do_work(job)\\n self.socket.send_json(\\n {\\n \\\"worker_id\\\": self.socket_id,\\n \\\"message\\\": \\\"job_done\\\",\\n \\\"job\\\": Job.get_result(job, value),\\n }\\n )\\n except KeyboardInterrupt:\\n pass\\n except Exception as e:\\n print(e)\\n finally:\\n self._disconnect()\",\n \"async def on_connect(self):\\r\\n self._try_shutdown_twitch()\\r\\n self.stream_thread = self.connect_thread()\",\n \"async def start(self) -> None:\\n for broadcast_port in self._broadcast_ports:\\n logger.info(\\\"starting the udp bridge on port %s\\\", broadcast_port)\\n protocol_factory = UdpClientProtocol(\\n partial(_parse_device_from_datagram, self._on_device)\\n )\\n transport, protocol = await get_running_loop().create_datagram_endpoint(\\n lambda: protocol_factory,\\n local_addr=(\\\"0.0.0.0\\\", broadcast_port), # nosec\\n family=AF_INET,\\n )\\n self._transports[broadcast_port] = transport\\n logger.debug(\\\"udp bridge on port %s started\\\", broadcast_port)\\n\\n self._is_running = True\",\n \"def run(self):\\n print('starting up on {} port {}'.format(*self.listener_address))\\n self.selector.register(self.listener, selectors.EVENT_READ)\\n\\n # Serialize our listener's host and port\\n serializedAdd = fxp_bytes_subscriber.serialize_address(\\n self.listener_address[0], self.listener_address[1])\\n\\n # Contact with Publisher\\n self.listener.sendto(serializedAdd, self.gcd_address)\\n\\n while True:\\n events = self.selector.select(CHECK_INTERVAL)\\n for key, mask in events:\\n data = self.receive_message()\\n self.removeOldQuote()\\n self.createGraph(data)\\n self.arbitrage()\\n self.checkTimeout()\",\n \"def send_heartbeat_messages(self):\\n while True:\\n for node in self.directory.get_current_list():\\n heartbeat_message = MessageFactory.generate_heartbeat_message(\\n origin_node=self.socket_manager.node,\\n destination_node=node\\n )\\n self.socket_manager.send_message(heartbeat_message)\\n time.sleep(3)\",\n \"def on_broadcast_tasks(self, evt, proto) -> None:\\n self.log.debug(\\\"accepted an event from the local console:\\\\n\\\\tfunction: {}\\\\n\\\\tquery: {}\\\\n\\\\targs: {}\\\",\\n evt.fun, evt.tgt, evt.arg)\\n clientlist = self.peer_registry.get_targets(query=evt.tgt)\\n offline_clientlist = self.peer_registry.get_offline_targets() if evt.offline else []\\n\\n msg = sugar.transport.ServerMsgFactory.create_console_msg()\\n if clientlist or offline_clientlist:\\n evt.jid = self.jobstore.new(query=evt.tgt, clientslist=clientlist + offline_clientlist,\\n uri=evt.fun, args=json.dumps(evt.arg),\\n job_type=\\\"runner\\\")\\n for target in clientlist:\\n threads.deferToThread(self.fire_event, event=evt, target=target)\\n self.log.debug(\\\"Created a new job: '{}' for {} online and {} offline machines\\\",\\n evt.jid, len(clientlist), len(offline_clientlist))\\n msg.ret.msg_template = \\\"Targeted {} machines. JID: {}\\\"\\n msg.ret.msg_args = [len(clientlist + offline_clientlist), evt.jid]\\n else:\\n self.log.error(\\\"No targets found for function '{}' on query '{}'.\\\", evt.fun, evt.tgt)\\n msg.ret.message = \\\"No targets found\\\"\\n proto.sendMessage(ServerMsgFactory.pack(msg), isBinary=True)\",\n \"def _init_threads(self):\\n\\n startTh = Thread(name='InitialStart', target = self._singleUpdate, args=(self.outPs, ))\\n self.threads.append(startTh)\\n\\n sendTh = Thread(name='SteeringListen',target = self._listen_for_steering, args = (self.inPs[0], self.outPs, ))\\n self.threads.append(sendTh)\",\n \"def _recv_thread_func(self):\\r\\n use_ssl = self.config.get_bool(\\\"gox\\\", \\\"use_ssl\\\")\\r\\n wsp = {True: \\\"wss://\\\", False: \\\"ws://\\\"}[use_ssl]\\r\\n while not self._terminating: #loop 0 (connect, reconnect)\\r\\n try:\\r\\n url = \\\"%s%s/socket.io/1\\\" % (wsp, self.hostname)\\r\\n\\r\\n # subscribing depth and ticker through the querystring,\\r\\n # the trade and lag will be subscribed later after connect\\r\\n sym = \\\"%s%s\\\" % (self.curr_base, self.curr_quote)\\r\\n if not FORCE_NO_DEPTH:\\r\\n querystring = \\\"Channel=depth.%s/ticker.%s\\\" % (sym, sym)\\r\\n else:\\r\\n querystring = \\\"Channel=ticker.%s\\\" % (sym)\\r\\n self.debug(\\\"### trying Socket.IO: %s?%s ...\\\" % (url, querystring))\\r\\n self.socket = SocketIO()\\r\\n self.socket.connect(url, query=querystring)\\r\\n\\r\\n self._time_last_received = time.time()\\r\\n self.connected = True\\r\\n self.debug(\\\"### connected\\\")\\r\\n self.socket.send(\\\"1::/mtgox\\\")\\r\\n\\r\\n self.debug(self.socket.recv())\\r\\n self.debug(self.socket.recv())\\r\\n\\r\\n self.debug(\\\"### subscribing to channels\\\")\\r\\n self.channel_subscribe()\\r\\n\\r\\n self.debug(\\\"### waiting for data...\\\")\\r\\n self.signal_connected(self, None)\\r\\n while not self._terminating: #loop1 (read messages)\\r\\n msg = self.socket.recv()\\r\\n self._time_last_received = time.time()\\r\\n if msg == \\\"2::\\\":\\r\\n #self.debug(\\\"### ping -> pong\\\")\\r\\n self.socket.send(\\\"2::\\\")\\r\\n continue\\r\\n prefix = msg[:10]\\r\\n if prefix == \\\"4::/mtgox:\\\":\\r\\n str_json = msg[10:]\\r\\n if str_json[0] == \\\"{\\\":\\r\\n self.signal_recv(self, (str_json))\\r\\n\\r\\n except Exception as exc:\\r\\n self.connected = False\\r\\n self.signal_disconnected(self, None)\\r\\n if not self._terminating:\\r\\n self.debug(\\\"### \\\", exc.__class__.__name__, exc, \\\\\\r\\n \\\"reconnecting in 1 seconds...\\\")\\r\\n self.socket.close()\\r\\n time.sleep(1)\",\n \"def connect_thread():\\n return factory.connect_thread(SlaveService, remote_service = SlaveService)\",\n \"def run(self):\\n data = ''\\n while not rospy.is_shutdown():\\n if (rospy.Time.now() - self.lastsync).to_sec() > (self.timeout * 3):\\n rospy.logerr(\\\"Lost sync with device, restarting...\\\")\\n self.requestTopics()\\n self.lastsync = rospy.Time.now() \\n \\n flag = [0,0]\\n flag[0] = self.port.read(1)\\n if (flag[0] != '\\\\xff'):\\n continue\\n flag[1] = self.port.read(1)\\n if ( flag[1] != '\\\\xff'):\\n rospy.loginfo(\\\"Failed Packet Flags \\\")\\n continue\\n # topic id (2 bytes)\\n header = self.port.read(4)\\n if (len(header) != 4):\\n #self.port.flushInput()\\n continue\\n \\n topic_id, msg_length = struct.unpack(\\\"<hh\\\", header)\\n msg = self.port.read(msg_length)\\n if (len(msg) != msg_length):\\n rospy.loginfo(\\\"Packet Failed : Failed to read msg data\\\")\\n #self.port.flushInput()\\n continue\\n chk = self.port.read(1)\\n checksum = sum(map(ord,header) ) + sum(map(ord, msg)) + ord(chk)\\n\\n if checksum%256 == 255:\\n if topic_id == TopicInfo.ID_PUBLISHER:\\n try:\\n m = TopicInfo()\\n m.deserialize(msg)\\n self.senders[m.topic_id] = Publisher(m.topic_name, m.message_type)\\n rospy.loginfo(\\\"Setup Publisher on %s [%s]\\\" % (m.topic_name, m.message_type) )\\n except Exception as e:\\n rospy.logerr(\\\"Failed to parse publisher: %s\\\", e)\\n elif topic_id == TopicInfo.ID_SUBSCRIBER:\\n try:\\n m = TopicInfo()\\n m.deserialize(msg)\\n self.receivers[m.topic_name] = [m.topic_id, Subscriber(m.topic_name, m.message_type, self)]\\n rospy.loginfo(\\\"Setup Subscriber on %s [%s]\\\" % (m.topic_name, m.message_type))\\n except Exception as e:\\n rospy.logerr(\\\"Failed to parse subscriber. %s\\\"%e)\\n elif topic_id == TopicInfo.ID_SERVICE_SERVER:\\n try:\\n m = TopicInfo()\\n m.deserialize(msg)\\n\\t\\t\\tservice = ServiceServer(m.topic_name, m.message_type, self)\\n self.receivers[m.topic_name] = [m.topic_id, service]\\n self.senders[m.topic_id] = service\\n rospy.loginfo(\\\"Setup ServiceServer on %s [%s]\\\"%(m.topic_name, m.message_type) )\\n except:\\n rospy.logerr(\\\"Failed to parse service server\\\")\\n elif topic_id == TopicInfo.ID_SERVICE_CLIENT:\\n pass\\n \\n elif topic_id == TopicInfo.ID_PARAMETER_REQUEST:\\n self.handleParameterRequest(msg)\\n \\n elif topic_id == TopicInfo.ID_LOG:\\n self.handleLogging(msg)\\n \\n elif topic_id == TopicInfo.ID_TIME:\\n t = Time()\\n t.data = rospy.Time.now()\\n data_buffer = StringIO.StringIO()\\n t.serialize(data_buffer)\\n self.send( TopicInfo.ID_TIME, data_buffer.getvalue() )\\n self.lastsync = rospy.Time.now()\\n elif topic_id >= 100: # TOPIC\\n try:\\n self.senders[topic_id].handlePacket(msg)\\n except KeyError:\\n rospy.logerr(\\\"Tried to publish before configured, topic id %d\\\" % topic_id)\\n else:\\n rospy.logerr(\\\"Unrecognized command topic!\\\")\\n rospy.sleep(0.001)\",\n \"async def test_basic_messaging(self):\\n async with Node() as n1:\\n async with Node() as n2:\\n await n2.join_network(n1.nid())\\n\\n n1bcast = Network_Message()\\n n2bcast = Network_Message()\\n n1.attach_broadcast_callback(n1bcast.msg_callback)\\n n2.attach_broadcast_callback(n2bcast.msg_callback)\\n\\n n1dmsg = Network_Message()\\n n2dmsg = Network_Message()\\n n1.attach_direct_message_callback(n1dmsg.msg_callback)\\n n2.attach_direct_message_callback(n2dmsg.msg_callback)\\n\\n await n1.send_broadcast('hello world')\\n msg_succ = await n2bcast.wait_msg()\\n self.assertTrue(msg_succ)\\n self.assertEqual(n2bcast.nid, n1.nid())\\n self.assertEqual(n2bcast.msg, 'hello world')\\n\\n # nodes shouldnt receive their own broadcast\\n msg_succ = await n1bcast.wait_msg(1)\\n self.assertFalse(msg_succ)\\n\\n await n2.send_message(n1.nid(), '42')\\n msg_succ = await n1dmsg.wait_msg()\\n self.assertTrue(msg_succ)\\n self.assertEqual(n1dmsg.nid, n2.nid())\\n self.assertEqual(n1dmsg.msg, '42')\\n\\n # nodes shouldnt receive their own direct meessage\\n msg_succ = await n2dmsg.wait_msg(1)\\n self.assertFalse(msg_succ)\",\n \"def run(self):\\n log.info(\\\"Starting thread\\\")\\n if self.open_listener():\\n\\n # This feels so dirty, but we need to make sure the thread isn't always blocking so we\\n # can safely shutdown the thread. Given that the Listener address is always an IP\\n # it should be safe. Should be, famous last words of course...\\n conn = self.listener._listener._socket\\n\\n while self.running:\\n r_list, w_list, e_list = select.select([conn, ], [conn, ], [conn, ], 0.01)\\n\\n if conn in r_list:\\n connection = None\\n try:\\n connection = self.listener.accept()\\n log.info(\\\"Connection opened by %s\\\", self.listener.last_accepted)\\n\\n while self.running:\\n if connection.poll():\\n msg = connection.recv()\\n globals.strip_data.spi_recv(msg)\\n except (IOError, EOFError):\\n if connection:\\n connection.close()\\n log.info(\\\"Connection closed %s\\\", self.listener.last_accepted)\\n\\n log.info(\\\"Exiting thread\\\")\",\n \"def run(self):\\n self.listen(self.input_topics.filter_by(transmission='tcp'))\\n\\n logging.info('Getting into the listening loop')\\n self.running = True\\n while self.running:\\n self.loop()\",\n \"def execute(self):\\n self.go_online()\\n empty_tuple = ()\\n thread.start_new_thread(self.get_user_input, empty_tuple)\\n while not self.suspended:\\n ds, addr = self.s.accept()\\n client = ClientNode(self, addr, ds)\\n # self.clients.append(client) # Now happens after username is verified in clientNode.py\\n print 'Incoming connection from', addr\\n if not self.suspended:\\n thread.start_new_thread(client.execute, empty_tuple)\\n print 'Server is suspended. Thank you!'\",\n \"def run(self):\\r\\n self.logger.info('NetworkThread thread started')\\r\\n global receiver_running\\r\\n\\r\\n while self.running:\\r\\n # get a message from the queue\\r\\n message = self.network_queue.get()\\r\\n message_type = message['type']\\r\\n\\r\\n # send a message to the clients\\r\\n if message_type == 'send':\\r\\n\\r\\n client = message['client']\\r\\n net_message = message['message']\\r\\n\\r\\n if client == '*':\\r\\n for ip in self.sockets:\\r\\n self.send(self.sockets[ip], net_message)\\r\\n elif client in self.sockets:\\r\\n self.send(self.sockets[client], net_message)\\r\\n else:\\r\\n self.logger.warning(\\r\\n 'there is no client %s, can\\\\'t send message' % client)\\r\\n\\r\\n # add new socket to the list\\r\\n elif message_type == 'new_socket':\\r\\n s = message['socket']\\r\\n ip = s.getpeername()[0]\\r\\n self.sockets[ip] = s\\r\\n message = protocol.thread.connected(ip=ip)\\r\\n self.logic_queue.put(message)\\r\\n\\r\\n # remove a socket from the list\\r\\n elif message_type == 'disconnected':\\r\\n ip = message['client']\\r\\n try:\\r\\n self.sockets[ip].close()\\r\\n except:\\r\\n pass\\r\\n del self.sockets[ip]\\r\\n\\r\\n # thread exit\\r\\n elif message_type == 'exit':\\r\\n self.running = False\\r\\n receiver_running = False\\r\\n for s in self.sockets.values():\\r\\n s.close()\\r\\n\\r\\n self.logger.info('NetworkThread thread ended')\",\n \"def run_mainloop():\\n \\n # List of sensor node addresses expected to be in the network\\n node_addr = [2, 3]\\n \\n # Data gathering time parameters [Frequenct data gathering and network discovery for testing]\\n data_gathering_interval = 60*1000 # [msec]\\n net_discovery_interval = 3 # (re)do network discovery every 3 cycles \\n \\n # Enable the NM3 power supply on the powermodule\\n powermodule = PowerModule()\\n powermodule.enable_nm3()\\n\\n # Enable power supply to 232 driver\\n pyb.Pin.board.EN_3V3.on()\\n pyb.Pin('Y5', pyb.Pin.OUT, value=0) # enable Y4 Pin as output\\n max3221e = MAX3221E(pyb.Pin.board.Y5)\\n max3221e.tx_force_on() # Enable Tx Driver\\n \\n # Wait for 6 seconds to let the modem start up\\n print(\\\"6 second delay to allow the NM3 to boot up...\\\")\\n pyb.delay(6*1000)\\n\\n # Initialize UART and NM3 object\\n uart = machine.UART(1, 9600, bits=8, parity=None, stop=1, timeout=1000)\\n modem = Nm3(uart)\\n\\n # Create and initialize the network protocol object\\n net_protocol = gw_node.NetProtocol()\\n net_protocol.init(modem, node_addr)\\n \\n # Start by doing the network discovery and setup\\n net_protocol.do_net_discovery()\\n net_protocol.setup_net_schedule() # guard interval [msec] can be specified as function input (default: 500)\\n \\n # Extract network topology and schedule information as JSON\\n net_info = net_protocol.get_net_info_json()\\n print(net_info) # print it in this test script (send over Wi-Fi in the real app)\\n\\n # Start an infinite loop, gathering sensor data\\n cycle_counter = 0\\n while True:\\n \\n # Perform a cycle of data gathering\\n cycle_counter += 1\\n frame_start_time = utime.ticks_ms() # update the frame start time\\n stay_awake = (cycle_counter == net_discovery_interval) # if this is the last cycle before network re-discovery\\n time_till_next_frame = data_gathering_interval # for sleep synchronisation (this can also be variable between frames)\\n packets = net_protocol.gather_sensor_data(time_till_next_frame, stay_awake)\\n # A list of MessagePacket objects is returned, to be processed and transmitted over Wi-Fi\\n \\n # If this was the last cycle before network re-discovery\\n if (cycle_counter == net_discovery_interval):\\n # Do network discovery and setup again (the network should be awake now)\\n net_protocol.do_net_discovery()\\n net_protocol.setup_net_schedule()\\n cycle_counter = 0\\n # When finished, instruct the network to sleep until the next frame\\n time_till_next_frame = data_gathering_interval - utime.ticks_diff(utime.ticks_ms(), frame_start_time)\\n net_protocol.set_network_to_sleep(time_till_next_frame)\\n # Extract network topology and schedule information as JSON\\n net_info = net_protocol.get_net_info_json()\\n print(net_info) # print it in this test script (send over Wi-Fi in the real app)\\n\\n # Go to sleep yourself until the start of next frame\\n # [This will need to be replaced by a proper sleep mode (with powered down modules)]\\n time_till_next_frame = data_gathering_interval - utime.ticks_diff(utime.ticks_ms(), frame_start_time)\\n pyb.delay(time_till_next_frame)\",\n \"def tcp_server_thread(id, tcpPort):\\n global server\\n \\n # TCP Connection\\n conn,adrr = server.accept()\\n received_time_stamp = struct.unpack('!f', conn.recv(4096))[0]\\n \\n exchange = daemon_thread_builder(CalcDelay, args=(received_time_stamp, id,tcpPort ))\\n exchange.start()\\n exchange.join()\\n\\n pass\",\n \"async def listen(self):\\n\\n while True:\\n if not self.connected:\\n # sleep and hope the checker fixes us\\n await asyncio.sleep(5)\\n continue\\n data = await self.read_one_message()\\n if data is None:\\n await asyncio.sleep(1)\\n continue\\n mtype = self.find_balboa_mtype(data)\\n\\n if mtype is None:\\n self.log.error(\\\"Spa sent an unknown message type.\\\")\\n await asyncio.sleep(0.1)\\n continue\\n if mtype == BMTR_CONFIG_RESP:\\n (self.macaddr, junk, morejunk) = self.parse_config_resp(data)\\n await asyncio.sleep(0.1)\\n continue\\n if mtype == BMTR_STATUS_UPDATE:\\n await self.parse_status_update(data)\\n await asyncio.sleep(0.1)\\n continue\\n if mtype == BMTR_PANEL_RESP:\\n self.parse_panel_config_resp(data)\\n await asyncio.sleep(0.1)\\n continue\\n if mtype == BMTR_PANEL_NOCLUE1:\\n self.parse_noclue1(data)\\n await asyncio.sleep(0.1)\\n continue\\n self.log.error(\\\"Unhandled mtype {0}\\\".format(mtype))\",\n \"def do_start(self):\\n threading.Thread(group = None, \\n target = self._subscribe_message, name = \\\"RabbitMQSubscribeThread\\\") .start()\\n threading.Thread(group = None, \\n target = self._publish_message, name = \\\"RabbitMQPublishThread\\\").start()\",\n \"def broadcastMsg(filename):\\n\\tthreads = []\\n\\tGLOBALS.BROADCAST_STATUS = 1\\n\\tglobal num\\n\\tid = num\\n\\tglobal response\\n\\taddMessage()\\n\\tfor x in range(len(GLOBALS.SUPER_PEER_LIST)):\\n\\t\\tif x == GLOBALS.SUPER_PEER_ID:\\n\\t\\t\\tcontinue\\n\\t\\tproc = Thread(target = broadcastThread, args = [filename, response, id, x])\\n\\t\\tproc.start()\\n\\t\\tthreads.append(proc)\\n\\n\\t#print(\\\"[info] Broadcast lib: All threads created\\\")\\n\\tfor proc in threads:\\n\\t\\tproc.join()\\n\\tGLOBALS.BROADCAST_STATUS = 0\\n\\treturn response[id]\",\n \"def receiver():\\r\\n global data\\r\\n DW1000.newReceive()\\r\\n DW1000.receivePermanently()\\r\\n DW1000.startReceive()\",\n \"def start(self):\\n self.sender.start()\\n self.receiver.start()\",\n \"def start(self):\\n self.sender.start()\\n self.receiver.start()\",\n \"def run(self):\\n self.logger.info(\\\"Starting messenger.\\\")\\n self.recv()\",\n \"def main():\\n logging.basicConfig(level=logging.INFO)\\n logging.info('\\\\nStarting node server...')\\n\\n # Unpack network file\\n with open(\\\"./photoblocks/network.json\\\") as f:\\n network = json.load(f)\\n\\n # Test local db connection\\n db = redis.Redis(host='redis', port=6379)\\n while True:\\n try:\\n if db.execute_command('PING'):\\n logging.info(f'\\\\nConnected to the local database server.')\\n break\\n else:\\n continue\\n except Exception as e:\\n logging.error(f'\\\\n{e}')\\n continue\\n\\n # Construct Node object\\n logging.info('\\\\nCreating Node data structure from configuration...')\\n node = Node(network[\\\"local\\\"])\\n logging.info(f'\\\\nNode data structure created.')\\n\\n # Start a node socket client\\n logging.info('\\\\nStarting node socket client on background thread...')\\n thread = threading.Thread(target=ClientSock, args=(network, node))\\n logging.info('\\\\nThread process created.')\\n thread.daemon = True\\n thread.start()\\n logging.info('\\\\nThread process started.')\\n time.sleep(5)\\n\\n # Start node socket server\\n logging.info('\\\\nStarting node socket server on background thread...')\\n thread = threading.Thread(target=serversock, args=())\\n logging.info('\\\\nThread process created.')\\n thread.daemon = True\\n thread.start()\\n logging.info('\\\\nThread process started.')\\n\\n while True:\\n time.sleep(5)\",\n \"def send(self):\\n while True:\\n for neighbor_name in self.neighbors:\\n if not self.neighbors[neighbor_name].is_killed:\\n if self.neighbors[neighbor_name].update_ready:\\n self.send_update(self.neighbors[neighbor_name])\\n if self.neighbors[neighbor_name].linkup_ready:\\n self.send_linkup(self.neighbors[neighbor_name])\\n if self.neighbors[neighbor_name].linkdown_ready:\\n self.send_linkdown(self.neighbors[neighbor_name])\",\n \"def run():\\n listen_active_email_channel()\",\n \"def __runRemoteListeningSockets(self, address, localHostName):\\n ## Get the local machine name and the remote nodes one\\n remoteNodesIP = self.__getLocalAndRemoteMachineNames()\\n\\n ## Strip out the nodes' names\\n availableNodes = [node.strip() for node in self.runInfoDict['Nodes']]\\n\\n ## Get unique nodes\\n uniqueNodes = list(set(availableNodes) - set([localHostName]))\\n servers = []\\n self.remoteServers = {}\\n if len(uniqueNodes) > 0:\\n ## There are remote nodes that need to be activated\\n ## Modify the python path used by the local environment\\n localEnv = os.environ.copy()\\n pathSeparator = os.pathsep\\n if \\\"PYTHONPATH\\\" in localEnv and len(localEnv[\\\"PYTHONPATH\\\"].strip()) > 0:\\n previousPath = localEnv[\\\"PYTHONPATH\\\"].strip()+pathSeparator\\n else:\\n previousPath = \\\"\\\"\\n localEnv[\\\"PYTHONPATH\\\"] = previousPath+pathSeparator.join(sys.path)\\n ## Start\\n for nodeId in uniqueNodes:\\n ## Check how many processors are available in the node\\n ntasks = availableNodes.count(nodeId)\\n remoteHostName = remoteNodesIP[nodeId]\\n\\n ## Activate the remote socketing system\\n ## let's build the command and then call the os-agnostic version\\n if self._parallelLib == ParallelLibEnum.ray:\\n self.raiseADebug(\\\"Setting up RAY server in node: \\\"+nodeId.strip())\\n runScript = os.path.join(self.runInfoDict['FrameworkDir'],\\\"RemoteNodeScripts\\\",\\\"start_remote_servers.sh\\\")\\n command=\\\" \\\".join([runScript,\\\"--remote-node-address\\\",nodeId, \\\"--address\\\",address, \\\"--num-cpus\\\",str(ntasks),\\\" --working-dir \\\",self.runInfoDict['WorkingDir'],\\\" --raven-framework-dir\\\",self.runInfoDict[\\\"FrameworkDir\\\"],\\\"--remote-bash-profile\\\",self.runInfoDict['RemoteRunCommand']])\\n self.raiseADebug(\\\"command is: \\\"+command)\\n command += \\\" --python-path \\\"+localEnv[\\\"PYTHONPATH\\\"]\\n self.remoteServers[nodeId] = utils.pickleSafeSubprocessPopen([command],shell=True,env=localEnv)\\n elif self._parallelLib == ParallelLibEnum.dask:\\n remoteServerScript = os.path.join(self.runInfoDict['FrameworkDir'],\\n \\\"RemoteNodeScripts\\\",\\\"start_dask.sh\\\")\\n outputFile = os.path.join(self.runInfoDict['WorkingDir'],\\\"server_debug_\\\"+nodeId)\\n command = ['ssh',nodeId,remoteServerScript,outputFile,\\n self.daskSchedulerFile,str(ntasks),\\n self.runInfoDict[\\\"FrameworkDir\\\"],\\n self.runInfoDict['RemoteRunCommand'],\\n self.runInfoDict['WorkingDir']]\\n self.raiseADebug(\\\"command is: \\\"+\\\" \\\".join(command))\\n command.append(self.__removeLibPythonFromPath(localEnv[\\\"PYTHONPATH\\\"]))\\n self.remoteServers[nodeId] = utils.pickleSafeSubprocessPopen(command, env=localEnv)\\n ## update list of servers\\n servers.append(nodeId)\\n if self._parallelLib == ParallelLibEnum.ray or self._parallelLib == ParallelLibEnum.dask:\\n #wait for the servers to finish starting (prevents zombies)\\n for nodeId in uniqueNodes:\\n self.remoteServers[nodeId].wait()\\n self.raiseADebug(\\\"server \\\"+str(nodeId)+\\\" result: \\\"+str(self.remoteServers[nodeId]))\\n\\n return servers\",\n \"def broadcastThread(filename, response, id, index):\\n\\tip = GLOBALS.SUPER_PEER_LIST[index][1]\\n\\tport = int(GLOBALS.SUPER_PEER_LIST[index][2])\\n\\ttry:\\n\\t\\tsock = socket.socket()\\n\\t\\tsock.connect((ip, port))\\n\\t\\tmsg = pickle.dumps(filename)\\n\\t\\tsock.send(msg)\\n\\t\\tdata = sock.recv(1024)\\n\\t\\tdata = pickle.loads(data)\\n\\t\\tprint(\\\"[info] Broadcast lib: Response from Super Peer: \\\" + str(index) + \\\" : \\\" + str(data))\\n\\t\\tresponse[id][index] = data\\n\\texcept socket.error as err:\\n\\t\\tprint(\\\"[ERROR] Broadcast lib: Error connecting \\\" + str(ip) + \\\":\\\" + str(port))\\n\\tsock.close()\\n\\treturn\",\n \"def tcp_server_thread(accepted_socket, address):\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n accepted_socket.sendto(struct.pack('!f', current_timestamp), address)\\n accepted_socket.close()\\n pass\",\n \"def broadcast(msg):\\n\\n for sock in clients:\\n sock.send(bytes(msg, \\\"utf-8\\\"))\",\n \"def connect(self):\\n\\t\\tself.printed_sub = False\\n\\t\\tself.client.connect(BROKER)\\n\\t\\tself.client.loop_forever()\",\n \"def main():\\n # Clear the terminal before a new run\\n os.system('cls') \\n\\n # Create the server_socket object and bind it to the desired address\\n server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n server_socket.bind(SERVER_ADDRESS)\\n \\n # Start listening for new connections\\n server_socket.listen()\\n print(f\\\"[LISTENING] SERVER IS NOW LISTENING FOR NEW CONNECTIONS ON {SERVER_ADDRESS}\\\")\\n\\n while True:\\n # Accept a new connection\\n conn, addr = server_socket.accept()\\n # Start a new thread handling the new connection\\n client_thread = threading.Thread(target=handle_client, args=(conn, addr))\\n client_thread.start()\",\n \"def _broadcast (self):\\n self.input_socket.bind(('0.0.0.0',self.input_port))\\n if (self.input_proto == socket.SOCK_STREAM):\\n self.input_socket.listen(0)\\n \\n if (self.input_proto == socket.SOCK_STREAM):\\n input_conn = self._wait_input_connection()\\n\\n while self.work:\\n try:\\n if (self.input_proto == socket.SOCK_STREAM):\\n data = input_conn.recv(1024)\\n else:\\n data, _ = self.input_socket.recvfrom(1024)\\n if not data and self.input_proto == socket.SOCK_STREAM:\\n raise Exception (\\\"Connection is broken\\\")\\n \\n for client in self.clients[:]:\\n try:\\n client.sendall(data)\\n except Exception as e:\\n logging.error(\\\"Error occured while sending data to client. Reason: {0}\\\".format(e))\\n try_close(client)\\n self.clients.remove(client)\\n except Exception as e:\\n if (self.input_proto == socket.SOCK_STREAM):\\n try_close(input_conn) \\n logging.error(\\\"Error occured while reading data. Reason: {0}\\\".format(e))\\n input_conn = self._wait_input_connection()\",\n \"def run(self):\\n self.logger.info(\\\"starting Dashi consumer\\\")\\n while not self.shutdown:\\n self.rpc.listen()\",\n \"def connectToServer(self): # creates a client and connects it to the server\\n\\n UDP_client_address = ('<broadcast>', 9999)\\n UDP_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # creating UDP client to broadcast to server\\n UDP_client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # this function is called so this object uses\\n # ~ UDP protocol\\n\\n UDP_client.settimeout(1)\\n\\n connected_to_UDP_server = False\\n while connected_to_UDP_server == False:\\n try:\\n UDP_client.sendto(bytes(\\\"A\\\", encoding='utf-8'), UDP_client_address)\\n \\\"\\\"\\\"\\n After broadcasting, if the expected server to listen is listening, it will respond to the letter 'A' \\n with a letter 'B'. in that case we know that the server and the client have found each other. Which \\n means that we will have the ip address of the server and then we can establish a TCP connection with the\\n server. This ip address could be found in the 1st index of the tuple 'server_addr'\\n \\\"\\\"\\\"\\n recv_data_from_server, server_addr = UDP_client.recvfrom(2048)\\n msg = recv_data_from_server.decode('utf-8')\\n\\n if msg == \\\"B\\\":\\n IP_ADDRESS_OF_SERVER = server_addr[0]\\n connected_to_UDP_server = True\\n recv_port_from_server, server_addr = UDP_client.recvfrom(2048)\\n port_from_server = recv_port_from_server.decode('utf-8')\\n self.class_connection_list[2] = int(port_from_server)\\n print(\\\"the port from server is: \\\" + str(self.class_connection_list[2]))\\n\\n except socket.timeout:\\n print(\\\" UDP Server not listening\\\")\\n connected_to_UDP_server = False\\n\\n # ================= Establishing the TCP connection below this line ===========================\\n self.class_connection_list[1] = IP_ADDRESS_OF_SERVER # storing the ip in second location of the list\\n\\n connectedToServer = False # Defining a boolean to show whether client is connected to server\\n while (connectedToServer == False): # trying to connecting the client to the server while it is not connected\\n try: # program tries to connect to server\\n client = socket.socket() # creating client object\\n address = (self.class_connection_list[1], self.class_connection_list[2]) # creating address tuple\\n client.connect(address) # connecting to the server using address\\n connectedToServer = True # assuming that the client has successfully connected to the server and\\n # ~ hence,changing the boolean accordingly (if connecting fails or , the exception clause below will run\\n except ConnectionRefusedError: # This exception is raised if the server is not listening\\n connectedToServer = False # since there is no server, we change the boolean back to false\\n print(\\\"(refused) Server not listening...\\\")\\n print(self.class_connection_list[2])\\n print(IP_ADDRESS_OF_SERVER)\\n sleep(1)\\n client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # since there has been a failed connection\\n # ~ for the previous client object, something has changed inside it and hence, it can not try to\\n # connect again. So we create a new client object.\\n\\n # client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)\\n\\n except ConnectionResetError:\\n connectedToServer = False # since there is no server, we change the boolean back to false\\n print(\\\"(reset) Server not listening...\\\")\\n sleep(1)\\n client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # since there has been a failed connection\\n # ~ for the previous client object, something has changed inside it and hence, it can not try to\\n # connect again. So we create a new client object.\\n\\n # client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)\\n\\n\\n self.class_connection_list[0] = client\\n self.class_connection_list[0].settimeout(0.5) # setting a time out for the thread so it doesn't spend time on\\n # ~ the task for more than 0.5 seconds; so if it doesn't receive anything for 0.5 seconds, it stops trying to\\n # ~ receive sth from client and starts sending stuff, if there are any\\n\\n return client # returning client, which is a socket object\",\n \"def Main(self):\\n while not self.IsStopping():\\n success = False\\n while not success:\\n for unused_i in range(_CONNECT_LOG_INTERVAL):\\n success = self.GetSocket()\\n if self.IsStopping():\\n return\\n if success:\\n break\\n self.Sleep(_CONNECT_INTERVAL)\\n if not success:\\n self.warning('Connection to target unavailable')\\n\\n receiver = input_socket.InputSocketReceiver(\\n self.logger.name, self._sock, self)\\n receiver.ProcessRequest()\",\n \"def broadcast(self, msg_type, msg, t=5):\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7504","0.74852496","0.7020729","0.67168087","0.6220197","0.6190433","0.6159416","0.6031282","0.59475446","0.5942349","0.59308153","0.5887535","0.58224946","0.57985353","0.57363206","0.56215864","0.5614009","0.5613697","0.5607666","0.5605568","0.56008685","0.55879766","0.556863","0.5560667","0.5534769","0.5534466","0.55210674","0.55210537","0.55181545","0.5496348","0.549375","0.5491854","0.5473694","0.54584986","0.544809","0.5435139","0.54047734","0.5397601","0.5369105","0.536776","0.536701","0.5356518","0.5355985","0.5346182","0.53338337","0.5333627","0.5331032","0.5324212","0.53060335","0.53028274","0.5299491","0.5297158","0.5294671","0.5284406","0.52841955","0.5276615","0.5269329","0.5268079","0.52620655","0.5253086","0.5249503","0.52401316","0.5234231","0.5226034","0.5223507","0.521608","0.5215862","0.5212745","0.5208312","0.52040446","0.52025765","0.51998955","0.51988137","0.5185624","0.5179846","0.51792943","0.5176192","0.5172164","0.5150798","0.5146665","0.51417136","0.51392514","0.5134659","0.512293","0.512293","0.51049024","0.5103482","0.51020217","0.509439","0.50925225","0.50845736","0.5081467","0.5071142","0.50688154","0.50584066","0.5056322","0.50556284","0.5054794","0.5053513","0.50500214"],"string":"[\n \"0.7504\",\n \"0.74852496\",\n \"0.7020729\",\n \"0.67168087\",\n \"0.6220197\",\n \"0.6190433\",\n \"0.6159416\",\n \"0.6031282\",\n \"0.59475446\",\n \"0.5942349\",\n \"0.59308153\",\n \"0.5887535\",\n \"0.58224946\",\n \"0.57985353\",\n \"0.57363206\",\n \"0.56215864\",\n \"0.5614009\",\n \"0.5613697\",\n \"0.5607666\",\n \"0.5605568\",\n \"0.56008685\",\n \"0.55879766\",\n \"0.556863\",\n \"0.5560667\",\n \"0.5534769\",\n \"0.5534466\",\n \"0.55210674\",\n \"0.55210537\",\n \"0.55181545\",\n \"0.5496348\",\n \"0.549375\",\n \"0.5491854\",\n \"0.5473694\",\n \"0.54584986\",\n \"0.544809\",\n \"0.5435139\",\n \"0.54047734\",\n \"0.5397601\",\n \"0.5369105\",\n \"0.536776\",\n \"0.536701\",\n \"0.5356518\",\n \"0.5355985\",\n \"0.5346182\",\n \"0.53338337\",\n \"0.5333627\",\n \"0.5331032\",\n \"0.5324212\",\n \"0.53060335\",\n \"0.53028274\",\n \"0.5299491\",\n \"0.5297158\",\n \"0.5294671\",\n \"0.5284406\",\n \"0.52841955\",\n \"0.5276615\",\n \"0.5269329\",\n \"0.5268079\",\n \"0.52620655\",\n \"0.5253086\",\n \"0.5249503\",\n \"0.52401316\",\n \"0.5234231\",\n \"0.5226034\",\n \"0.5223507\",\n \"0.521608\",\n \"0.5215862\",\n \"0.5212745\",\n \"0.5208312\",\n \"0.52040446\",\n \"0.52025765\",\n \"0.51998955\",\n \"0.51988137\",\n \"0.5185624\",\n \"0.5179846\",\n \"0.51792943\",\n \"0.5176192\",\n \"0.5172164\",\n \"0.5150798\",\n \"0.5146665\",\n \"0.51417136\",\n \"0.51392514\",\n \"0.5134659\",\n \"0.512293\",\n \"0.512293\",\n \"0.51049024\",\n \"0.5103482\",\n \"0.51020217\",\n \"0.509439\",\n \"0.50925225\",\n \"0.50845736\",\n \"0.5081467\",\n \"0.5071142\",\n \"0.50688154\",\n \"0.50584066\",\n \"0.5056322\",\n \"0.50556284\",\n \"0.5054794\",\n \"0.5053513\",\n \"0.50500214\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6493267"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":85151,"cells":{"query":{"kind":"string","value":"Accept connections from other nodes and send them this node's timestamp once they connect."},"document":{"kind":"string","value":"def tcp_server_thread(id, tcpPort):\n global server\n \n # TCP Connection\n conn,adrr = server.accept()\n received_time_stamp = struct.unpack('!f', conn.recv(4096))[0]\n \n exchange = daemon_thread_builder(CalcDelay, args=(received_time_stamp, id,tcpPort ))\n exchange.start()\n exchange.join()\n\n pass"},"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 tcp_server_thread():\n neigbour_sock, neighbour_addr = server.accept()\n my_timestamp = datetime.datetime.utcnow().timestamp()\n packed = struct.pack(\"!d\", my_timestamp)\n neigbour_sock.send(packed)\n pass","def tcp_server_thread():\n while True:\n server.listen(4096)\n conn, addr = server.accept()\n with conn:\n print_green(f\"Connected by {addr} \")\n now = time.time()\n our_timestamp = struct.pack(\"!d\", now)\n conn.sendall(our_timestamp)","def accept_connections(self):\n for c in self.all_connections:\n c.close()\n self.all_connections = []\n # self.all_addresses = []\n while 1:\n\n try:\n # lock.acquire()\n conn, address = self.socket.accept()\n # If set blocking is 0 server does not wait for message and this try block fails.\n conn.setblocking(1)\n\n # This is a special message since it is authentication\n json_string = self.read_message_from_connection(conn).decode(\"utf-8\")\n\n print(\"Accepting connection \" + str(json_string))\n\n # new_message = Message.json_string_to_message(json_string)\n json_package = json.loads(json_string)\n username = json_package[\"username\"]\n password = json_package[\"password\"]\n hostname = json_package[\"hostname\"]\n host_system_username = json_package[\"host_system_username\"]\n\n # Ping timer checks whether the client is alive or not by pinging it\n t = Timer(self.ping_timer_time, self.ping, [username])\n t.start()\n\n except Exception as e:\n ColorPrint.print_message(\"ERROR\", \"accept_connections\", 'Error accepting connections: %s' % str(e))\n # Loop indefinitely\n continue\n # lock.release()\n # we need setblocking 0 so that select works in server_controller.\n conn.setblocking(0)\n self.all_connections.append(conn)\n # Put the newly connected client to the list\n self.all_clients[username] = conn\n # Push a message to the queue to notify that a new client is connected\n client_connected_message = Message(username, \"server\", \"event\", \"Connected\")\n\n client_received.put(client_connected_message)","def accept_connection(self):\n # if not settings.USE_SOCKETS:\n # return\n self.dbg(\"sockets_event\",\n \"Blocking on accept_connection for {}\",\n [self.data_name])\n # now keep talking with the client\n self.conn, self.addr = self.s.accept()","def tcp_server_thread():\r\n while True:\r\n temp_socket, _ = server.accept()\r\n time_now = datetime.datetime.utcnow().timestamp()\r\n print(time_now)\r\n time_now = struct.pack(\"!f\", time_now)\r\n temp_socket.send(time_now)\r\n temp_socket.close()","def accept_connections(self):\n (connection_with_client, client_info) = server.MAIN_CONNECTION.accept()\n\n self.connection_with_client = connection_with_client\n self.client_info = client_info","def accept_connection(self):\n pass","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n\n # send our timestamp\n try:\n s.connect((other_ip, other_tcp_port))\n now = time.time()\n our_timestamp = struct.pack(\"!d\", now)\n\n s.sendall(our_timestamp)\n data = s.recv(1024)\n except ConnectionRefusedError:\n return\n except ConnectionResetError:\n return\n\n # receive timestamp\n last_timestamp = struct.unpack(\"!d\", data)[0]\n print_yellow(f'received from {other_ip} {other_tcp_port} time stamp {last_timestamp}')\n delay = time.time() - last_timestamp\n neighbor_node = NeighborInfo(delay, last_timestamp, ip=other_ip, tcp_port=other_tcp_port)\n print('inserting into neighbour in exchange')\n insertIntoNeighbour(other_uuid, neighbor_node)","def connectionMade(self):\n self.connection_timestamp = datetime.datetime.now()\n self.factory.open_connections.add((self.connection_timestamp,\n self.transport.getPeer()))\n self.lc = LoopingCall(self.sendRandomBytes)\n self.lc.start(self.send_interval)\n self.log.info(\"Connection made from: {address}\",\n address=self.transport.getPeer())","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\r\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\r\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n sock.connect((other_ip, int(other_tcp_port)))\r\n other_time = sock.recv(4096)\r\n other_time = struct.unpack(\"!f\", other_time)\r\n print(\"*\" * 50)\r\n my_time = datetime.datetime.utcnow().timestamp()\r\n delay = my_time - other_time[0]\r\n neighbor = NeighborInfo(delay, my_time, other_ip,\r\n other_tcp_port, broadcast_count)\r\n print_red(neighbor_information)\r\n #neighbor_information.update({other_uuid: neighbor})\r\n neighbor_information[other_uuid] = neighbor\r\n print_red(neighbor_information)","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n address = (other_ip, other_tcp_port)\n tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n tcp_socket.connect(address)\n received_time_stamp = struct.unpack('!f', tcp_socket.recv(4096))[0]\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n\n delay = current_timestamp - received_time_stamp\n # print_red(f'Current: [{current_timestamp}] ==> Received [{received_time_stamp}]')\n print_red(f'[{other_uuid}] Current delay {abs(delay)}')\n node = NeighborInfo(delay, 1, other_ip, other_tcp_port)\n neighbor_information.update({other_uuid: node})\n\n pass","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n try:\n client.connect((other_ip, other_tcp_port))\n data = client.recv(1024)\n except ConnectionError:\n print_red(\"connection refused\") \n exit()\n timestamp = struct.unpack(\"!d\", data)\n # calculate delay\n my_timestamp = datetime.datetime.utcnow().timestamp()\n delay = my_timestamp - timestamp[0]\n\n if other_uuid in neighbor_information:\n neighbor_information[other_uuid].delay = delay\n # neighbor_information[other_uuid].last_timestamp = timestamp[0]\n\n else:\n neighbour_node = NeighborInfo(delay, other_ip, other_tcp_port)\n neighbor_information.update({other_uuid: neighbour_node})\n\n client.close()","def listening(self):\n while True:\n client_socket, address = self.s.accept()\n print(\"Connection from \" + str(address[0]) + \" has been established.\")\n\n data = get_top_random_toy()\n\n msg = pickle.dumps(data)\n\n # prepend message length to message\n msg = bytes(f'{len(msg):<{self.__HEADER_SIZE}}', \"utf-8\") + msg\n client_socket.send(msg)","def accept(self) -> (\"RDTSocket\", (str, int)):\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n self.conn = None\n\n while not self.conn:\n time.sleep(0.1)\n\n self.debug_print([\"Client address: \", self.conn.dst_addr])\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return self.conn, self.conn.dst_addr","def connectionMade(self):\n print \"connection received from\", self.addr","def runNodesMessage(self):\n while True:\n for neighbour in self.nextIP:\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n while True:\n try:\n socketNodes.connect((neighbour, 5003))\n socketNodes.send(self.message)\n break\n except TimeoutError:\n pass\n except ConnectionRefusedError:\n pass\n socketNodes.close()\n break","def listen(self):\n while True:\n peer, address = self.server.accept()\n peer_port = int(peer.recv(self.CHUNK_SIZE).decode(self.FORMAT))\n peer.send(bytes(str(self.PEER_LIST),self.FORMAT))\n if (address[0], peer_port) not in self.PEER_LIST:\n self.PEER_LIST.append((address[0], peer_port))\n output_message = f\"{datetime.now().timestamp()} : Added <{address[0]}:{peer_port}> to the Peer_list\"\n self.dump_to_file(output_message)\n print(output_message)\n thread = threading.Thread(target=self.handlePeers, args=(peer, ))\n thread.start()","def peer_server_listener(self):\n try:\n peer_server_socket = socket.socket(\n socket.AF_INET, socket.SOCK_STREAM)\n peer_server_socket.setsockopt(\n socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n peer_server_socket.setsockopt(\n socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\n peer_server_host = self.peer.peer_hostname\n peer_server_port = self.peer.peer_port\n peer_server_socket.bind(\n (peer_server_host, peer_server_port))\n peer_server_socket.listen(10)\n while True:\n conn, addr = peer_server_socket.accept()\n conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\n #print \"Got connection from %s on port %s\" \\\n # % (addr[0], addr[1])\n self.peer_server_listener_queue.put((conn,addr))\n except Exception as e:\n print \"Peer Server Listener on port Failed: %s\" % e\n sys.exit(1)","def _establish_connection(self):\n self.conn = self.listener.accept()","def handleClientConnected(client_reader, client_writer):\n loop.TOTAL_CONNECTIONS += 1\n addr = client_writer.get_extra_info('peername')\n print(\"Connected to\", addr, \"(%s pending connections)\" % loop.TOTAL_CONNECTIONS)\n distantreader, distantwriter = yield from asyncio.open_connection(distanthost, distantport, loop=loop)\n t1 = loop.create_task(transmitData(loop, distantreader, client_writer))\n t2 = loop.create_task(transmitData(loop, client_reader, distantwriter))\n transmitted1, transmitted2 = yield from asyncio.gather(t1, t2)\n loop.TOTAL_CONNECTIONS -= 1\n print(\"End of communication to\", addr, \"(%s pending connections)\" % loop.TOTAL_CONNECTIONS, \"(Transmitted: %s/%s)\" % (transmitted1, transmitted2))","def accept(self) -> ('RDTSocket', (str, int)): # sever端，被动接受client端连接,非阻塞式等待连接的到来\n conn, addr = RDTSocket(self._rate), None\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n while True:\n print(\"----- Server start listening -------\")\n data_client, addr_client = self.recvfrom(1024)\n print(\"----- Server received -------\")\n data_client = segment.parse(data_client) # 将受到的数据解码\n if data_client.sin == 1: # 收到连接请求\n conn.recvSin = True\n conn.ackNum = data_client.seqNumber + 1\n # print(\"accept:receive connection request!\")\n start_time = time.time()\n conn.sendto(segment(sin=1, ack=1, ackNumber=conn.ackNum).getSegment(), addr_client) # 发sin ack\n # print(\"accept:send sin ack\")\n while True:\n data_client2, addr_client2 = conn.recvfrom(1024)\n self.RTT = time.time() - start_time # 初步确定RTT\n data_client2 = segment.parse(data_client2)\n # if data_client2.sin == 1 and data_client2.ack == 1 and addr_client2 == addr_client and data_client2.seqNumber == self.ackNum: # 收到了原来的地址发来的正确报文\n if data_client2.ack == 1 and data_client2.seqNumber == conn.ackNum and addr_client2 == addr_client: # 收到了原来的地址发来的正确报文\n conn.connectAddr = addr_client # 建立连接\n conn.isConnected = True\n print(\"accept:connection established\")\n conn.status.append('connect')\n self.reset() # 重置socket\n break\n break\n return conn, addr_client\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return conn, addr","def connect_to_peer(self):\n pass","def accept(self)->(RDTSocket, (str, int)):\n conn, addr = RDTSocket(self._rate), None\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n \n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return conn, addr","def accept_incoming_connections():\n\twhile True:\n\t\tclient, client_address = server.accept()\n\t\tprint(str(client_address[0]) + \":\" + str(client_address[1]) + \" has connected.\")\n\t\taddresses[client] = client_address\n\t\tThread(target=handle_client, args=(client,)).start()","def accept_connections():\n while True:\n client, client_address = server.accept()\n print(\"%s:%s has connected.\" % client_address)\n client.send(bytes(\"Hello honey! Please type your name and press Enter.\", \"utf8\")) \n addresses[client] = client_address\n Thread(target=manage_connections, args=(client,)).start()","def tcp_incoming_connections():\n while True:\n client, client_address = SERVER.accept()\n print(\"%s:%s has connected.\" % client_address)\n client.send(bytes(\"Greetings from the cave! Now type your name and press enter!\"))\n addresses[client] = client_address\n Thread(target=handle_client, args=(client,)).start()","def accept(self, s):\n conn, addr = s.accept()\n conn.setblocking(0)\n\n self.conns[conn] = Connection(conn, addr)\n self.inputs.append(conn)\n self.log(\"New connection from: %s\", addr)\n self.mq[conn.fileno()] = Queue()","async def publish(self):\n for sock in self.subscribers:\n sock.send_json(self.main_server.state)\n await asyncio.sleep(0)","def tcp_server_thread(accepted_socket, address):\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n accepted_socket.sendto(struct.pack('!f', current_timestamp), address)\n accepted_socket.close()\n pass","def listen_connections(self):\n self.MAIN_CONNECTION.listen(server.MAX_CONNECTIONS)","def on_connect(self):\n self.log.info('(Re)Connected to the /tasks namespace')\n self.node_worker_ref.sync_task_queue_with_server()\n self.log.debug(\"Tasks synced again with the server...\")\n self.node_worker_ref.share_node_details()","def accept(self) -> Tuple[socket, Tuple[str, int]]:\n ...","def AcceptSocket(self) -> Socket:","def accept(self):\n try:\n cs, addr = self.ss.accept()\n except Exception as e:\n return\n # cs.setblocking(True)\n cs.settimeout(5000)\n self._sock = cs\n print(\"accepted connection from\", addr)\n try:\n cs.write(VERSION)\n cs.write(b'\\n')\n pwd = self.readline()\n if pwd != getattr(secrets, 'mp_pwd', ''):\n cs.write(b'wrong password\\n')\n return\n cs.write(b'OK\\n')\n self.serve()\n except Exception as e:\n print(\"*** accept\", e)\n finally:\n cs.close()\n print(\"\\nclosed client connection\")","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","def monitor(self):\n while True:\n client_socket, client_address = self.server_socket.accept()\n print(\"New client connection accepted: {}:{}\".format(*client_address))\n threading.Thread(target=self.handle_client, args=[client_socket]).start()","def connect(self):\n broadcast(\n \"Connect\", \n self.connection, \n self.network\n )\n \n listen(self.address, self.connection, self.message_handler)","def handle_new(s: socket, inputs: list[socket]):\n connection, client_address = s.accept()\n print(' connection from', client_address, file=stderr)\n connection.setblocking(False)\n inputs.append(connection)","def serviceConnects(self):\n #log.debug(f\"{self.name}: servicing new connections for.\")\n for ca, ix in list(self.server.ixes.items()):\n if ix.cutoff:\n self.closeConnection(ca)\n continue\n\n if ca not in self.connections:\n log.debug(f\"Adding new connection for {ix}.\")\n self.connections[ca] = Requester(self.dhtdoer, remoter=ix, name=ca)\n\n if ix.timeout > 0.0 and ix.tymer.expired:\n self.closeConnection(ca)","def dispecher(self):\r\n while True:\r\n connection, address = self._sockobj.accept()\r\n print('server connected by', address)\r\n print('at', self.now())\r\n thread.start_new(self.handleClient, (connection, address,))","def accept_incoming_connections():\r\n while True:\r\n client, client_address = SERVER.accept()\r\n print(\"%s:%s has connected.\" % client_address)\r\n client.send(bytes(\"Greetings from the cave!\"+\r\n \"Now type your name and press enter!\", \"utf8\"))\r\n addresses[client] = client_address\r\n Thread(target=handle_client, args=(client,)).start()","def accept_incoming_connections():\n while True:\n client, client_address = SERVER.accept()\n print(\"%s:%s está online.\" % client_address)\n client.send(bytes(\"Bem vindo a urna!@Coloque seu nome e a legenda do candidato.\", \"utf8\"))\n addresses[client] = client_address #Salvar o endereço do cliente na lista de endereços\n Thread(target=handle_client, args=(client,)).start() #Startar uma nova thread para a atividade de handle_client, passando o cliente como argumento","def __accept_new_connection(self):\r\n c, addr = self._server_socket.accept()\r\n SidecarProcess.logger.info(\"Accepting connection for backuping\")\r\n return c","def establish_connection(self):\n print('Listening...')\n self.socket.listen()\n self.conn, addr = self.socket.accept()\n print('Received connection', addr)","def connectionMade(self):\n self.transport.write('{0}{1}'.format(self._uidServer.getUID(),\n self.delimiter))\n self.transport.loseConnection()","def handle_accept(self):\r\n pair = self.accept()\r\n if pair is not None:\r\n sock, addr = pair\r\n server_log.info('Client connection from {}, assigning client id {}'.format(repr(addr), self.client_id))\r\n handler = ClientHandler(sock, addr, self.client_id)\r\n self.client_list.update({self.client_id: handler})\r\n self.client_id += 1","def accept_incoming_connections():\n while True:\n client, client_address = SERVER.accept()\n print(\"%s:%s has connected.\" % client_address)\n #client.send(bytes(\"Greetings from the cave! Now type your name and press enter!\", \"utf8\"))\n addresses[client] = client_address\n Thread(target=handle_client, args=(client,)).start()","def accept_client(self):\n while True:\n if len(self.session_with_client_class.clients_data) < MAX_CLIENTS:\n\n client_socket, client_address = self.server_socket.accept()\n\n client_address = client_address[0]\n\n receiving_stream_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n receiving_stream_socket.bind((SERVER_IP, STREAM_FROM_CLIENT_PORT))\n\n sending_stream_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n\n print \"new client\"\n self.session_with_client_class.open_chat(client_socket, client_address,\n receiving_stream_socket, sending_stream_socket)\n else:\n print \"Max clients reached, can't add more clients.\"\n break","def _accept_client(server_socket):\n (player_socket, player_address) = server_socket.accept()\n print \"a player has joind the game!\"\n new_player = Player.player(player_socket=player_socket, player_address=player_address)\n players.append(new_player)\n # send the index of the player to that player\n new_player.player_socket.send(str(new_player.index) + \"\\n\")","async def accept(self) -> SocketStream[T_SockAddr]:","def accept_in_connections():\r\n while True:\r\n client, client_address = SERVER.accept()\r\n print(\"%s:%s si è collegato.\" % client_address)\r\n\r\n #information about the game\r\n msg_client('Benvenuto!', client)\r\n msg_client('Rispondi più velocemente possibile alle domande', client)\r\n msg_client('Chi ha il punteggio più alto alla fine del tempo, vince!', client)\r\n \r\n \r\n #Dictionary for client\r\n address[client] = client_address\r\n #Thread - one for each client\r\n Thread(target=manage_client, args=(client,)).start()","def _listen_for_clients (self):\n self.broadcast_socket.bind(('0.0.0.0',self.broadcast_port))\n self.broadcast_socket.listen(5)\n while self.work:\n connection, _ = self.broadcast_socket.accept()\n self.clients.append(connection)\n logging.debug(\"Client connected {0}\".format(connection.getsockname()))","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n tcpserver=daemon_thread_builder(tcp_server_thread, args=(other_uuid, other_tcp_port))\n\n SENDER = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n SENDER.connect((other_ip,int(other_tcp_port)))\n address = (other_ip, int(other_tcp_port))\n time_now = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n SENDER.sendto(struct.pack('!f', time_now), address)\n \n tcpserver.start()\n tcpserver.join()\n SENDER.close()\n\n pass","def connect_to_server(self):\r\n self.client_socket.connect((SERVER_IP, SERVER_PORT))\r\n print('[CLIENT] connected to streamer.')","def on_connect(self):\n log.info(\"Stream connected\")","def connect(self):\r\n\r\n\t\tprint('Connecting to server')\r\n\r\n\t\tself.t = threading.Thread(target=self.daemon.requestLoop)\r\n\t\tself.t.daemon = True\r\n\t\tself.t.start()\r\n\t\tprint('daemon thread started')\r\n\t\tmessages = self.chat.connect(self.my_uri)\r\n\r\n\t\t#in case the connection is refused:\r\n\t\tif isinstance(messages, bool) and not messages:\r\n\t\t\traise ValueError(f\"Username {self.username} already taken\")\r\n\r\n\t\tprint('Connected')\r\n\r\n\t\t#if the connection is accepted, the last 20 messages are sent\r\n\t\t#those messages will now be printed.\r\n\t\tfor message in messages:\r\n\t\t\tself.incoming_message(message)","async def on_connect(self):\r\n self._try_shutdown_twitch()\r\n self.stream_thread = self.connect_thread()","def connection_to_server_made(self, transport):\n\n local_data = self._socket.getsockname()\n peer_data = transport.get_extra_info('peername')\n\n self._logger.info('[%s] local %s:%s connected to %s:%s',\n self._sock_id, local_data[0], local_data[1],\n peer_data[0], peer_data[1])\n\n # No delay OFF -> Nagle's alg used\n self._socket.setsockopt(\n socket.IPPROTO_TCP,\n socket.TCP_NODELAY,\n 0)\n\n # If required - turn off Nagle's alg (No Delay ON)\n if self._no_delay:\n self._socket.setsockopt(\n socket.IPPROTO_TCP,\n socket.TCP_NODELAY,\n 1)\n\n # Set Socket TX/RX buffer sizes if specified\n if self._window:\n self._logger.debug('Setting socket buffer sizes to %s B', self._window)\n self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, self._window)\n self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self._window)\n\n # Print current buf sizes:\n rx_buf = self._socket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)\n tx_buf = self._socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)\n\n self._logger.debug('Socket TX buffer: %s B; RX buffer: %s B;', tx_buf, rx_buf)\n\n self._stream.connection_established(self)","def connect(self):\n self.conn.add_listener(self.handle_connection_change)\n self.conn.start_async()","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)","def send_heartbeat_messages(self):\n while True:\n for node in self.directory.get_current_list():\n heartbeat_message = MessageFactory.generate_heartbeat_message(\n origin_node=self.socket_manager.node,\n destination_node=node\n )\n self.socket_manager.send_message(heartbeat_message)\n time.sleep(3)","async def connect(self):\n await asyncio.gather(self._exchange_connection.connect_to_server(), self.on_connection())","def handle_connect(self):\n LOGGER.debug(\"server connected(%d)\", id(self))\n self.append_connect = False\n self.send_dict_pack(MoloSocketHelper.reg_proxy(self.client_id))","def _accept_conn(listen_sock, tracker_conn, ping_period=2):\n old_keyset = set()\n # Report resource to tracker\n if tracker_conn:\n matchkey = base.random_key(rpc_key)\n base.sendjson(tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr])\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\n else:\n matchkey = rpc_key\n\n unmatch_period_count = 0\n unmatch_timeout = 4\n # Wait until we get a valid connection\n while True:\n if tracker_conn:\n trigger = select.select([listen_sock], [], [], ping_period)\n if not listen_sock in trigger[0]:\n base.sendjson(tracker_conn, [TrackerCode.GET_PENDING_MATCHKEYS])\n pending_keys = base.recvjson(tracker_conn)\n old_keyset.add(matchkey)\n # if match key not in pending key set\n # it means the key is acquired by a client but not used.\n if matchkey not in pending_keys:\n unmatch_period_count += 1\n else:\n unmatch_period_count = 0\n # regenerate match key if key is acquired but not used for a while\n if unmatch_period_count * ping_period > unmatch_timeout + ping_period:\n logger.info(\"no incoming connections, regenerate key ...\")\n matchkey = base.random_key(rpc_key, cmap=old_keyset)\n base.sendjson(\n tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr]\n )\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\n unmatch_period_count = 0\n continue\n conn, addr = listen_sock.accept()\n magic = struct.unpack(\"<i\", base.recvall(conn, 4))[0]\n if magic != base.RPC_MAGIC:\n conn.close()\n continue\n keylen = struct.unpack(\"<i\", base.recvall(conn, 4))[0]\n key = py_str(base.recvall(conn, keylen))\n arr = key.split()\n expect_header = \"client:\" + matchkey\n server_key = \"server:\" + rpc_key\n if arr[0] != expect_header:\n conn.sendall(struct.pack(\"<i\", base.RPC_CODE_MISMATCH))\n conn.close()\n logger.warning(\"mismatch key from %s\", addr)\n continue\n conn.sendall(struct.pack(\"<i\", base.RPC_CODE_SUCCESS))\n conn.sendall(struct.pack(\"<i\", len(server_key)))\n conn.sendall(server_key.encode(\"utf-8\"))\n return conn, addr, _parse_server_opt(arr[1:])","def run(self):\n inputs = [self.server]\n\n while self.running:\n print '1'\n try:\n readable, writeable, exceptional = \\\n select.select(inputs, [], [])\n except select.error, e:\n print 'select:error[%s]' % e.message\n break\n\n for sock in readable:\n print '2'\n if sock == self.server:\n client, address = self.server.accept()\n client.setblocking(0)\n inputs.append(client)\n # self.outputs.append(client)\n\n print 'Client[%s] connected!' % address[0]\n self.clients[client] = address[0]\n\n else:\n print '3'\n self.recv_data(sock)","def connecting_peer(self, peer):\n if peer.next_heart_beat_time < self.app.tick:\n self.declare_no_connection(peer)\n else:\n logger.log(TRACE, \"%s is connecting (has until %r, now is %r)\",\n peer, peer.next_heart_beat_time, self.app.tick)","def connectionMade(self):\n protocol.Protocol.connectionMade(self)\n self.port = self.transport.getHost().port\n #Start the inactivity timer the connection is dropped if we receive no data\n self.activateInactivityTimer()\n self.sessionState = SMPPSessionStates.OPEN\n self.log.warning(\"SMPP connection established from %s to port %s\", self.transport.getPeer().host, self.port)","def listen_to_connection(self, conn):\n with conn:\n print(\"Connected\")\n while self.running:\n data = conn.recv(32)\n if not data: \n return\n \n print(\"Recived Data:\"+str(data))\n self.__update(data)","def _listen_loop(sock, port, rpc_key, tracker_addr, load_library, custom_addr):\n\n def _accept_conn(listen_sock, tracker_conn, ping_period=2):\n \"\"\"Accept connection from the other places.\n\n Parameters\n ----------\n listen_sock: Socket\n The socket used by listening process.\n\n tracker_conn : connection to tracker\n Tracker connection\n\n ping_period : float, optional\n ping tracker every k seconds if no connection is accepted.\n \"\"\"\n old_keyset = set()\n # Report resource to tracker\n if tracker_conn:\n matchkey = base.random_key(rpc_key)\n base.sendjson(tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr])\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\n else:\n matchkey = rpc_key\n\n unmatch_period_count = 0\n unmatch_timeout = 4\n # Wait until we get a valid connection\n while True:\n if tracker_conn:\n trigger = select.select([listen_sock], [], [], ping_period)\n if not listen_sock in trigger[0]:\n base.sendjson(tracker_conn, [TrackerCode.GET_PENDING_MATCHKEYS])\n pending_keys = base.recvjson(tracker_conn)\n old_keyset.add(matchkey)\n # if match key not in pending key set\n # it means the key is acquired by a client but not used.\n if matchkey not in pending_keys:\n unmatch_period_count += 1\n else:\n unmatch_period_count = 0\n # regenerate match key if key is acquired but not used for a while\n if unmatch_period_count * ping_period > unmatch_timeout + ping_period:\n logger.info(\"no incoming connections, regenerate key ...\")\n matchkey = base.random_key(rpc_key, cmap=old_keyset)\n base.sendjson(\n tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr]\n )\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\n unmatch_period_count = 0\n continue\n conn, addr = listen_sock.accept()\n magic = struct.unpack(\"<i\", base.recvall(conn, 4))[0]\n if magic != base.RPC_MAGIC:\n conn.close()\n continue\n keylen = struct.unpack(\"<i\", base.recvall(conn, 4))[0]\n key = py_str(base.recvall(conn, keylen))\n arr = key.split()\n expect_header = \"client:\" + matchkey\n server_key = \"server:\" + rpc_key\n if arr[0] != expect_header:\n conn.sendall(struct.pack(\"<i\", base.RPC_CODE_MISMATCH))\n conn.close()\n logger.warning(\"mismatch key from %s\", addr)\n continue\n conn.sendall(struct.pack(\"<i\", base.RPC_CODE_SUCCESS))\n conn.sendall(struct.pack(\"<i\", len(server_key)))\n conn.sendall(server_key.encode(\"utf-8\"))\n return conn, addr, _parse_server_opt(arr[1:])\n\n # Server logic\n tracker_conn = None\n while True:\n try:\n # step 1: setup tracker and report to tracker\n if tracker_addr and tracker_conn is None:\n tracker_conn = base.connect_with_retry(tracker_addr)\n tracker_conn.sendall(struct.pack(\"<i\", base.RPC_TRACKER_MAGIC))\n magic = struct.unpack(\"<i\", base.recvall(tracker_conn, 4))[0]\n if magic != base.RPC_TRACKER_MAGIC:\n raise RuntimeError(f\"{str(tracker_addr)} is not RPC Tracker\")\n # report status of current queue\n cinfo = {\"key\": \"server:\" + rpc_key, \"addr\": (custom_addr, port)}\n base.sendjson(tracker_conn, [TrackerCode.UPDATE_INFO, cinfo])\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\n\n # step 2: wait for in-coming connections\n conn, addr, opts = _accept_conn(sock, tracker_conn)\n except (socket.error, IOError):\n # retry when tracker is dropped\n if tracker_conn:\n tracker_conn.close()\n tracker_conn = None\n continue\n except RuntimeError as exc:\n raise exc\n\n # step 3: serving\n _serving(conn, addr, opts, load_library)","def handle_connect(self):\n LOGGER.debug(\"local session connected(%d)\", id(self))\n self.append_connect = False","def on_connect(self):\n print('Client connected!')","def __sendToAll(self, message, author = None):\n\n self.messageCallback(message)\n\n for user in self.__connections:\n\n if not user is author:\n try: \n user[\"connection\"].send((message + self.separator).encode())\n except: \n user[\"online\"] = False","def accept_incoming_connections():\n while True:\n client, client_address = SERVER.accept()\n print(\"%s:%s has connected.\" % client_address)\n addresses[client] = client_address\n username = client.recv(BUFSIZ).decode(\"utf8\")\n clients[client]=username\n Thread(target=handle_client, args=(client,)).start()","def connectToServer(self):\n client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n client_sock.bind((self.ip, self.port))\n client_sock.connect((self.serverPC_ip, 9090))\n #create CREQ message\n message = Message('CREQ', self.ip, '\\0')\n client_sock.sendall(message.generateByteMessage())\n print('Sent CREQ message to serverPC at ' + self.serverPC_ip)\n #recieve response as string\n response_message = self.parseMessage(client_sock)\n if (response_message.type == 'OKAY'):\n print('OKAY message received')\n #payload contains host area, and list of connected hosts\n payload_array = response_message.payload.split(',')\n i = 1\n lost_payload = ''\n while i < len(payload_array):\n indicator = self.setupHostConnection(payload_array[i])\n if(indicator == False):\n lost_payload += payload_array[i]+\",\"\n else:\n self.host_ips.append(payload_array[i])\n i += 1\n self.x_min = self.curr_x_max\n self.x_max = self.x_min + self.x_scalar\n #this message contains the hosts that have disconnected from the network and notifes the serverPC about the change\n del_message = Message('LHST', self.ip, lost_payload)\n print('sent LHST to serverPC with payload: ' + lost_payload)\n client_sock.sendall(del_message.generateByteMessage())\n if self.curr_x_min_ip == '':\n #there was no other host, you are your own neighbor\n self.r_neighbor = self.ip\n self.l_neighbor = self.ip\n else:\n #else, there is another host - check if there are any other hosts\n self.r_neighbor = self.curr_x_min_ip\n\n if self.l_neighbor == '':\n #there isnt a left neighbor - left neighbor is right neighbor\n self.l_neighbor = self.r_neighbor\n # need to start the listening thread and the work thread now\n listening_thread = Thread(target=lambda: self.listeningPort())\n listening_thread.daemon = True\n listening_thread.start()\n work_thread = Thread(target=lambda: self.processWork())\n work_thread.daemon = True\n work_thread.start()\n else:\n print('Invalid message type received from ' + message.origin)","def connectionMade(self):\n\n self.connected_users[self.user_key] = {\n \"host\": self.addr.host,\n \"type\": self.addr.type,\n \"authorized\": False,\n \"main\": {\n \"player_name\": None,\n \"base\": None,\n \"dungeon\": None\n },\n }\n self.log_to_debug(\n line=f\"{self.addr.host}:{self.addr.port} Connected...\"\n )\n self.log_file.log_all(\n priority=3,\n string=f\"{self.addr.host}:{self.addr.port} Connected to server\"\n )\n self.send_one(\n response=UtilityModule.generate_response(\n action=\"connectToServer\",\n code=100\n )\n )","def listen(self):\r\n self.theSocket.listen(0)\r\n print('Socket now listening')\r\n \r\n #wait to accept a connection - blocking call\r\n self.conn, self.addr = self.theSocket.accept()\r\n\r\n print('Connected with ' + self.addr[0] + ':' + str(self.addr[1]))\r\n return self.conn","def receive_data(self):\n self.new_socket.listen(5)\n while True:\n channel, address = self.new_socket.accept()\n if self.clients_count < 5:\n Thread(target=self.listen_clients, args=(channel, address)).start()\n self.clients_count += 1\n print(\"No. of clients connected:\" + str(self.clients_count))\n else:\n print(\"No new threads allowed\")\n break","def connectionMade(self):\n self.transport.write('{0}{1}'.format(self._uidServer.getUID(),\n self.delimiter))","def _accept_conn(self, conn_data_cls: 'ConnectionData') -> None:\n conn_data_cls.conn, conn_data_cls.addr = self._socket.accept()","def accept_incoming_connections():\n while True:\n # Accept connection and receive info\n client, client_address = SERVER.accept()\n print(\"%s:%s has connected.\" % client_address)\n client.send(bytes(\"Greetings from the cave!\", \"utf8\"))\n client.send(bytes(\"Enter Username: \",\"utf8\"))\n uname = client.recv(BUFSIZ).decode(\"utf8\")\n client.send(bytes(\"Enter Password: \",\"utf8\"))\n pw = client.recv(BUFSIZ).decode(\"utf8\")\n # Connect to database in order to check username and pw\n cursor = SVconnectSQL()\n client_Login(cursor,uname,pw,client)\n\n addresses[client] = client_address\n Thread(target=handle_client, args=(client,uname)).start()","def run(self):\n try:\n self.is_activated=True\n while self.is_activated:\n try:\n #make sure all of the connections are saved.\n connection = self._socket.accept()\n self._connections.append(connection)\n except timeout: pass\n except Exception as e:\n logging.exception(e)\n finally:\n self.deactivate()","def on_connect(self, connection, event):\r\n print('[{}] Connected to {}' .format(event.type.upper(), event.source))\r\n print(\"{}\".format(event.arguments))\r\n\r\n res = self.cursor.execute(\"\"\"SELECT * FROM `IRC_servers` WHERE `Registred_users_userID` = %s AND `serverID` = %s;\"\"\", (self.userID, connection.serverID))\r\n if res != 0:\r\n result = self.cursor.fetchall()\r\n serverID_res = int(result[0][0])\r\n #res = self.cursor.execute(\"\"\"UPDATE `IRC_servers` SET `isConnected` = %s WHERE `serverID` = %s;\"\"\", (1, serverID_res))\r\n\r\n if serverID_res == int(connection.serverID): # pokud se získané ID z databáze rovná tomu, které v sobě uchovává connection, redundantní check, ale JTS\r\n res = self.cursor.execute(\"\"\"SELECT * FROM `IRC_channels` WHERE `IRC_servers_serverID` = %s;\"\"\", (serverID_res,))\r\n if res != 0:\r\n result = self.cursor.fetchall()\r\n print(\"For serverID = {}: {}\".format(serverID_res, result))\r\n\r\n channels = list()\r\n for resa in result:\r\n channelID = resa[0]\r\n channelName = resa[1]\r\n channelPassword = resa[2]\r\n lastOpened = resa[3]\r\n channel_serverID = resa[4]\r\n\r\n temp_dict = {\"channelName\": channelName, \"channelPassword\": channelPassword}\r\n channels.append(temp_dict)\r\n\r\n for channel in channels:\r\n if client.is_channel(channel[\"channelName\"]):\r\n connection.join(channel[\"channelName\"], key=channel[\"channelPassword\"])\r\n else:\r\n print(\"The channel in database is not a channel.\")\r\n else:\r\n print(\"[WARNING on_connect]: No channels to join on this server (serverID = {})\".format(serverID_res))","def connect_trade_stream(message):\r\n # accept the incoming connection\r\n message.reply_channel.send({'accept': True})\r\n # add the reply_channel of this connection to the trade_stream group,\r\n # so that it can receive updates sent to the group (all group members\r\n # will be able to get the same message)\r\n Group('trade_stream').add(message.reply_channel)","def handle_new_conn(self):\n self.latest_client_socket, self.latest_client_address = self.server_listen_socket.accept()\n print(\"Accepted new connection from {0}:{1}\".format(self.latest_client_address[0], self.latest_client_address[1]))\n user = self.receive_message(self.latest_client_socket)\n if user is False:\n return False\n\n self.sockets_list.append(self.latest_client_socket)\n self.clients[self.latest_client_socket] = user\n print(\"Accepted new user: {0}\".format(user['data'].decode('utf-8')))\n return True","def __accept_new_client(self):\n client_socket, client_addr = self.__server_socket.accept()\n new_client = client.Client(client_socket, client_addr)\n self.__logger.info(\"Accepted new client from {}\".format(client_addr))\n self.__connected_clients.append(new_client)","def connectionMade(self):\n self.protocol.makeConnection(BridgeTransport(self.transport))","def connect():","async def connection_made(self):\n logging.info('connecting to %s:%s' % self.address)","async def on_connect(self, payload):\n # You can `raise` from here to reject the connection.\n print(\"New client connected!\")","def connect(self) -> None:\n ...","def watch_for_rtt_messages(self):\n while True:\n message = self.socket_manager.get_rtt_message()\n self.ensure_sender_is_known(message)\n if message.stage == \"0\":\n self.respond_to_rtt_message(message)\n elif message.stage == \"1\":\n self.handle_rtt_response(message)\n elif message.stage == \"2\":\n self.handle_rtt_broadcast(message)","def handle_accept(self):\n pair = self.accept()\n if pair is not None:\n sock, addr = pair\n print(repr(addr), \"comes\")\n RPCHandler(sock, addr)","def connect_as_referee(remote_IP_1='127.0.0.1', remote_IP_2='127.0.0.1', verbose=False, timeout=None):\n\n # init verbose display\n if verbose:\n print '\\n----------------------------------------------------------------------------'\n\n # open sockets (as server) to receive orders\n socket_in = []\n for player_id in (1, 2):\n socket_in.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\n socket_in[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if remote_IP_1 == '127.0.0.1' and remote_IP_2 == '127.0.0.1':\n local_IP = '127.0.0.1'\n else:\n local_IP = get_IP()\n local_port = 42000 + (3-player_id)\n\n if verbose:\n print 'referee binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\n socket_in[player_id-1].bind((local_IP, local_port))\n socket_in[player_id-1].listen(1)\n if verbose:\n print ' done -> referee is now waiting for player %d to connect on %s:%d' % (player_id, local_IP, local_port)\n\n if verbose:\n print\n\n # open sockets (as client) to send orders\n socket_out = []\n for player_id in (1, 2):\n socket_out.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\n socket_out[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if player_id == 1:\n remote_IP = remote_IP_1\n else:\n remote_IP = remote_IP_2\n\n local_IP = get_IP()\n\n if remote_IP == '127.0.0.1' or remote_IP == local_IP:\n remote_port = 42000 + 100 + player_id\n else:\n remote_port = 42000 + player_id\n\n connected = False\n msg_shown = False\n while not connected:\n try:\n if verbose and not msg_shown:\n print 'referee connecting on %s:%d to forward orders to player %d...' % (remote_IP, remote_port, player_id)\n socket_out[player_id-1].connect((remote_IP, remote_port))\n connected = True\n if verbose:\n print ' done -> referee is now forwarding orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\n except:\n if verbose and not msg_shown:\n print ' connection failed -> referee will try again every 100 msec...'\n time.sleep(.1)\n msg_shown = True\n\n if verbose:\n print\n\n # accept connection to the server sockets to the server socket to receive orders from remote player\n for player_id in (1, 2):\n socket_in[player_id-1], remote_address = socket_in[player_id-1].accept()\n if verbose:\n print 'now listening to orders from player %d' % (player_id)\n\n if verbose:\n print\n\n # setting timeout if necessary\n if timeout != None:\n socket_in[0].settimeout(timeout)\n socket_in[1].settimeout(timeout)\n socket_out[0].settimeout(timeout)\n socket_out[1].settimeout(timeout)\n\n if verbose:\n print 'warning: remote players are given %d sec. for each request' % timeout\n else:\n if verbose:\n print 'warning: remote players have no time limit to answer requests'\n\n # end verbose display\n if verbose:\n print '\\nconnection to remote players successful\\n----------------------------------------------------------------------------\\n'\n\n # return sockets for further use\n return (socket_in[0], socket_out[0]), (socket_in[1], socket_out[1])","def connection_made(self, transport) -> None:\n peername = transport.get_extra_info(\"peername\")\n logging.info(f\"Server: New connection from {peername}.\")\n self.transport = transport\n loop = asyncio.get_event_loop()\n self.task = loop.create_task(self.serve_data())","def connect(self) -> None:","def peer_server_host(self):\n try:\n while True:\n while not self.peer_server_listener_queue.empty():\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\n conn, addr = self.peer_server_listener_queue.get()\n data_received = json.loads(conn.recv(1024))\n\n if data_received['command'] == 'obtain_active':\n fut = executor.submit(\n self.peer_server_upload, conn, data_received)\n except Exception as e:\n print \"Peer Server Hosting Error, %s\" % e","def serverAccept(self):\n self.handshake_deferred.callback(self.protocol_to_accept)\n logger.debug(\"WebSocket %s accepted by application\", self.reply_channel)","def accept(self):\n while self.active:\n try:\n sock, addrinfo = self.listener.accept()\n except socket.timeout:\n pass\n except socket.error:\n ex = sys.exc_info()[1]\n if get_exc_errno(ex) in (errno.EINTR, errno.EAGAIN):\n pass\n else:\n raise EOFError()\n else:\n break\n\n if not self.active:\n return\n\n sock.setblocking(True)\n self.logger.info(f\"accepted {addrinfo} with fd {sock.fileno()}\")\n self.clients.add(sock)\n self._accept_method(sock)","def add_connections(self, connections):\r\n\r\n for node1, node2 in connections:\r\n self.add(node1, node2)","def connect(self):\n self.wss.start()\n while not self.wss.conn.connected.is_set():\n time.sleep(1e-4)\n\n for _type in self.types:\n for symbol in self.symbols:\n self.subscribe(_type, symbol)","def _add_connections(self, connections):\r\n\r\n for node1, node2 in connections:\r\n self._add(node1, node2)"],"string":"[\n \"def tcp_server_thread():\\n neigbour_sock, neighbour_addr = server.accept()\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n packed = struct.pack(\\\"!d\\\", my_timestamp)\\n neigbour_sock.send(packed)\\n pass\",\n \"def tcp_server_thread():\\n while True:\\n server.listen(4096)\\n conn, addr = server.accept()\\n with conn:\\n print_green(f\\\"Connected by {addr} \\\")\\n now = time.time()\\n our_timestamp = struct.pack(\\\"!d\\\", now)\\n conn.sendall(our_timestamp)\",\n \"def accept_connections(self):\\n for c in self.all_connections:\\n c.close()\\n self.all_connections = []\\n # self.all_addresses = []\\n while 1:\\n\\n try:\\n # lock.acquire()\\n conn, address = self.socket.accept()\\n # If set blocking is 0 server does not wait for message and this try block fails.\\n conn.setblocking(1)\\n\\n # This is a special message since it is authentication\\n json_string = self.read_message_from_connection(conn).decode(\\\"utf-8\\\")\\n\\n print(\\\"Accepting connection \\\" + str(json_string))\\n\\n # new_message = Message.json_string_to_message(json_string)\\n json_package = json.loads(json_string)\\n username = json_package[\\\"username\\\"]\\n password = json_package[\\\"password\\\"]\\n hostname = json_package[\\\"hostname\\\"]\\n host_system_username = json_package[\\\"host_system_username\\\"]\\n\\n # Ping timer checks whether the client is alive or not by pinging it\\n t = Timer(self.ping_timer_time, self.ping, [username])\\n t.start()\\n\\n except Exception as e:\\n ColorPrint.print_message(\\\"ERROR\\\", \\\"accept_connections\\\", 'Error accepting connections: %s' % str(e))\\n # Loop indefinitely\\n continue\\n # lock.release()\\n # we need setblocking 0 so that select works in server_controller.\\n conn.setblocking(0)\\n self.all_connections.append(conn)\\n # Put the newly connected client to the list\\n self.all_clients[username] = conn\\n # Push a message to the queue to notify that a new client is connected\\n client_connected_message = Message(username, \\\"server\\\", \\\"event\\\", \\\"Connected\\\")\\n\\n client_received.put(client_connected_message)\",\n \"def accept_connection(self):\\n # if not settings.USE_SOCKETS:\\n # return\\n self.dbg(\\\"sockets_event\\\",\\n \\\"Blocking on accept_connection for {}\\\",\\n [self.data_name])\\n # now keep talking with the client\\n self.conn, self.addr = self.s.accept()\",\n \"def tcp_server_thread():\\r\\n while True:\\r\\n temp_socket, _ = server.accept()\\r\\n time_now = datetime.datetime.utcnow().timestamp()\\r\\n print(time_now)\\r\\n time_now = struct.pack(\\\"!f\\\", time_now)\\r\\n temp_socket.send(time_now)\\r\\n temp_socket.close()\",\n \"def accept_connections(self):\\n (connection_with_client, client_info) = server.MAIN_CONNECTION.accept()\\n\\n self.connection_with_client = connection_with_client\\n self.client_info = client_info\",\n \"def accept_connection(self):\\n pass\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\\n\\n # send our timestamp\\n try:\\n s.connect((other_ip, other_tcp_port))\\n now = time.time()\\n our_timestamp = struct.pack(\\\"!d\\\", now)\\n\\n s.sendall(our_timestamp)\\n data = s.recv(1024)\\n except ConnectionRefusedError:\\n return\\n except ConnectionResetError:\\n return\\n\\n # receive timestamp\\n last_timestamp = struct.unpack(\\\"!d\\\", data)[0]\\n print_yellow(f'received from {other_ip} {other_tcp_port} time stamp {last_timestamp}')\\n delay = time.time() - last_timestamp\\n neighbor_node = NeighborInfo(delay, last_timestamp, ip=other_ip, tcp_port=other_tcp_port)\\n print('inserting into neighbour in exchange')\\n insertIntoNeighbour(other_uuid, neighbor_node)\",\n \"def connectionMade(self):\\n self.connection_timestamp = datetime.datetime.now()\\n self.factory.open_connections.add((self.connection_timestamp,\\n self.transport.getPeer()))\\n self.lc = LoopingCall(self.sendRandomBytes)\\n self.lc.start(self.send_interval)\\n self.log.info(\\\"Connection made from: {address}\\\",\\n address=self.transport.getPeer())\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\r\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\r\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n sock.connect((other_ip, int(other_tcp_port)))\\r\\n other_time = sock.recv(4096)\\r\\n other_time = struct.unpack(\\\"!f\\\", other_time)\\r\\n print(\\\"*\\\" * 50)\\r\\n my_time = datetime.datetime.utcnow().timestamp()\\r\\n delay = my_time - other_time[0]\\r\\n neighbor = NeighborInfo(delay, my_time, other_ip,\\r\\n other_tcp_port, broadcast_count)\\r\\n print_red(neighbor_information)\\r\\n #neighbor_information.update({other_uuid: neighbor})\\r\\n neighbor_information[other_uuid] = neighbor\\r\\n print_red(neighbor_information)\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n address = (other_ip, other_tcp_port)\\n tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n tcp_socket.connect(address)\\n received_time_stamp = struct.unpack('!f', tcp_socket.recv(4096))[0]\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n\\n delay = current_timestamp - received_time_stamp\\n # print_red(f'Current: [{current_timestamp}] ==> Received [{received_time_stamp}]')\\n print_red(f'[{other_uuid}] Current delay {abs(delay)}')\\n node = NeighborInfo(delay, 1, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: node})\\n\\n pass\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n try:\\n client.connect((other_ip, other_tcp_port))\\n data = client.recv(1024)\\n except ConnectionError:\\n print_red(\\\"connection refused\\\") \\n exit()\\n timestamp = struct.unpack(\\\"!d\\\", data)\\n # calculate delay\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n delay = my_timestamp - timestamp[0]\\n\\n if other_uuid in neighbor_information:\\n neighbor_information[other_uuid].delay = delay\\n # neighbor_information[other_uuid].last_timestamp = timestamp[0]\\n\\n else:\\n neighbour_node = NeighborInfo(delay, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: neighbour_node})\\n\\n client.close()\",\n \"def listening(self):\\n while True:\\n client_socket, address = self.s.accept()\\n print(\\\"Connection from \\\" + str(address[0]) + \\\" has been established.\\\")\\n\\n data = get_top_random_toy()\\n\\n msg = pickle.dumps(data)\\n\\n # prepend message length to message\\n msg = bytes(f'{len(msg):<{self.__HEADER_SIZE}}', \\\"utf-8\\\") + msg\\n client_socket.send(msg)\",\n \"def accept(self) -> (\\\"RDTSocket\\\", (str, int)):\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n self.conn = None\\n\\n while not self.conn:\\n time.sleep(0.1)\\n\\n self.debug_print([\\\"Client address: \\\", self.conn.dst_addr])\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return self.conn, self.conn.dst_addr\",\n \"def connectionMade(self):\\n print \\\"connection received from\\\", self.addr\",\n \"def runNodesMessage(self):\\n while True:\\n for neighbour in self.nextIP:\\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n while True:\\n try:\\n socketNodes.connect((neighbour, 5003))\\n socketNodes.send(self.message)\\n break\\n except TimeoutError:\\n pass\\n except ConnectionRefusedError:\\n pass\\n socketNodes.close()\\n break\",\n \"def listen(self):\\n while True:\\n peer, address = self.server.accept()\\n peer_port = int(peer.recv(self.CHUNK_SIZE).decode(self.FORMAT))\\n peer.send(bytes(str(self.PEER_LIST),self.FORMAT))\\n if (address[0], peer_port) not in self.PEER_LIST:\\n self.PEER_LIST.append((address[0], peer_port))\\n output_message = f\\\"{datetime.now().timestamp()} : Added <{address[0]}:{peer_port}> to the Peer_list\\\"\\n self.dump_to_file(output_message)\\n print(output_message)\\n thread = threading.Thread(target=self.handlePeers, args=(peer, ))\\n thread.start()\",\n \"def peer_server_listener(self):\\n try:\\n peer_server_socket = socket.socket(\\n socket.AF_INET, socket.SOCK_STREAM)\\n peer_server_socket.setsockopt(\\n socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n peer_server_socket.setsockopt(\\n socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\\n peer_server_host = self.peer.peer_hostname\\n peer_server_port = self.peer.peer_port\\n peer_server_socket.bind(\\n (peer_server_host, peer_server_port))\\n peer_server_socket.listen(10)\\n while True:\\n conn, addr = peer_server_socket.accept()\\n conn.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\\n #print \\\"Got connection from %s on port %s\\\" \\\\\\n # % (addr[0], addr[1])\\n self.peer_server_listener_queue.put((conn,addr))\\n except Exception as e:\\n print \\\"Peer Server Listener on port Failed: %s\\\" % e\\n sys.exit(1)\",\n \"def _establish_connection(self):\\n self.conn = self.listener.accept()\",\n \"def handleClientConnected(client_reader, client_writer):\\n loop.TOTAL_CONNECTIONS += 1\\n addr = client_writer.get_extra_info('peername')\\n print(\\\"Connected to\\\", addr, \\\"(%s pending connections)\\\" % loop.TOTAL_CONNECTIONS)\\n distantreader, distantwriter = yield from asyncio.open_connection(distanthost, distantport, loop=loop)\\n t1 = loop.create_task(transmitData(loop, distantreader, client_writer))\\n t2 = loop.create_task(transmitData(loop, client_reader, distantwriter))\\n transmitted1, transmitted2 = yield from asyncio.gather(t1, t2)\\n loop.TOTAL_CONNECTIONS -= 1\\n print(\\\"End of communication to\\\", addr, \\\"(%s pending connections)\\\" % loop.TOTAL_CONNECTIONS, \\\"(Transmitted: %s/%s)\\\" % (transmitted1, transmitted2))\",\n \"def accept(self) -> ('RDTSocket', (str, int)): # sever端，被动接受client端连接,非阻塞式等待连接的到来\\n conn, addr = RDTSocket(self._rate), None\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n while True:\\n print(\\\"----- Server start listening -------\\\")\\n data_client, addr_client = self.recvfrom(1024)\\n print(\\\"----- Server received -------\\\")\\n data_client = segment.parse(data_client) # 将受到的数据解码\\n if data_client.sin == 1: # 收到连接请求\\n conn.recvSin = True\\n conn.ackNum = data_client.seqNumber + 1\\n # print(\\\"accept:receive connection request!\\\")\\n start_time = time.time()\\n conn.sendto(segment(sin=1, ack=1, ackNumber=conn.ackNum).getSegment(), addr_client) # 发sin ack\\n # print(\\\"accept:send sin ack\\\")\\n while True:\\n data_client2, addr_client2 = conn.recvfrom(1024)\\n self.RTT = time.time() - start_time # 初步确定RTT\\n data_client2 = segment.parse(data_client2)\\n # if data_client2.sin == 1 and data_client2.ack == 1 and addr_client2 == addr_client and data_client2.seqNumber == self.ackNum: # 收到了原来的地址发来的正确报文\\n if data_client2.ack == 1 and data_client2.seqNumber == conn.ackNum and addr_client2 == addr_client: # 收到了原来的地址发来的正确报文\\n conn.connectAddr = addr_client # 建立连接\\n conn.isConnected = True\\n print(\\\"accept:connection established\\\")\\n conn.status.append('connect')\\n self.reset() # 重置socket\\n break\\n break\\n return conn, addr_client\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return conn, addr\",\n \"def connect_to_peer(self):\\n pass\",\n \"def accept(self)->(RDTSocket, (str, int)):\\n conn, addr = RDTSocket(self._rate), None\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n \\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return conn, addr\",\n \"def accept_incoming_connections():\\n\\twhile True:\\n\\t\\tclient, client_address = server.accept()\\n\\t\\tprint(str(client_address[0]) + \\\":\\\" + str(client_address[1]) + \\\" has connected.\\\")\\n\\t\\taddresses[client] = client_address\\n\\t\\tThread(target=handle_client, args=(client,)).start()\",\n \"def accept_connections():\\n while True:\\n client, client_address = server.accept()\\n print(\\\"%s:%s has connected.\\\" % client_address)\\n client.send(bytes(\\\"Hello honey! Please type your name and press Enter.\\\", \\\"utf8\\\")) \\n addresses[client] = client_address\\n Thread(target=manage_connections, args=(client,)).start()\",\n \"def tcp_incoming_connections():\\n while True:\\n client, client_address = SERVER.accept()\\n print(\\\"%s:%s has connected.\\\" % client_address)\\n client.send(bytes(\\\"Greetings from the cave! Now type your name and press enter!\\\"))\\n addresses[client] = client_address\\n Thread(target=handle_client, args=(client,)).start()\",\n \"def accept(self, s):\\n conn, addr = s.accept()\\n conn.setblocking(0)\\n\\n self.conns[conn] = Connection(conn, addr)\\n self.inputs.append(conn)\\n self.log(\\\"New connection from: %s\\\", addr)\\n self.mq[conn.fileno()] = Queue()\",\n \"async def publish(self):\\n for sock in self.subscribers:\\n sock.send_json(self.main_server.state)\\n await asyncio.sleep(0)\",\n \"def tcp_server_thread(accepted_socket, address):\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n accepted_socket.sendto(struct.pack('!f', current_timestamp), address)\\n accepted_socket.close()\\n pass\",\n \"def listen_connections(self):\\n self.MAIN_CONNECTION.listen(server.MAX_CONNECTIONS)\",\n \"def on_connect(self):\\n self.log.info('(Re)Connected to the /tasks namespace')\\n self.node_worker_ref.sync_task_queue_with_server()\\n self.log.debug(\\\"Tasks synced again with the server...\\\")\\n self.node_worker_ref.share_node_details()\",\n \"def accept(self) -> Tuple[socket, Tuple[str, int]]:\\n ...\",\n \"def AcceptSocket(self) -> Socket:\",\n \"def accept(self):\\n try:\\n cs, addr = self.ss.accept()\\n except Exception as e:\\n return\\n # cs.setblocking(True)\\n cs.settimeout(5000)\\n self._sock = cs\\n print(\\\"accepted connection from\\\", addr)\\n try:\\n cs.write(VERSION)\\n cs.write(b'\\\\n')\\n pwd = self.readline()\\n if pwd != getattr(secrets, 'mp_pwd', ''):\\n cs.write(b'wrong password\\\\n')\\n return\\n cs.write(b'OK\\\\n')\\n self.serve()\\n except Exception as e:\\n print(\\\"*** accept\\\", e)\\n finally:\\n cs.close()\\n print(\\\"\\\\nclosed client connection\\\")\",\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 monitor(self):\\n while True:\\n client_socket, client_address = self.server_socket.accept()\\n print(\\\"New client connection accepted: {}:{}\\\".format(*client_address))\\n threading.Thread(target=self.handle_client, args=[client_socket]).start()\",\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 \"def handle_new(s: socket, inputs: list[socket]):\\n connection, client_address = s.accept()\\n print(' connection from', client_address, file=stderr)\\n connection.setblocking(False)\\n inputs.append(connection)\",\n \"def serviceConnects(self):\\n #log.debug(f\\\"{self.name}: servicing new connections for.\\\")\\n for ca, ix in list(self.server.ixes.items()):\\n if ix.cutoff:\\n self.closeConnection(ca)\\n continue\\n\\n if ca not in self.connections:\\n log.debug(f\\\"Adding new connection for {ix}.\\\")\\n self.connections[ca] = Requester(self.dhtdoer, remoter=ix, name=ca)\\n\\n if ix.timeout > 0.0 and ix.tymer.expired:\\n self.closeConnection(ca)\",\n \"def dispecher(self):\\r\\n while True:\\r\\n connection, address = self._sockobj.accept()\\r\\n print('server connected by', address)\\r\\n print('at', self.now())\\r\\n thread.start_new(self.handleClient, (connection, address,))\",\n \"def accept_incoming_connections():\\r\\n while True:\\r\\n client, client_address = SERVER.accept()\\r\\n print(\\\"%s:%s has connected.\\\" % client_address)\\r\\n client.send(bytes(\\\"Greetings from the cave!\\\"+\\r\\n \\\"Now type your name and press enter!\\\", \\\"utf8\\\"))\\r\\n addresses[client] = client_address\\r\\n Thread(target=handle_client, args=(client,)).start()\",\n \"def accept_incoming_connections():\\n while True:\\n client, client_address = SERVER.accept()\\n print(\\\"%s:%s está online.\\\" % client_address)\\n client.send(bytes(\\\"Bem vindo a urna!@Coloque seu nome e a legenda do candidato.\\\", \\\"utf8\\\"))\\n addresses[client] = client_address #Salvar o endereço do cliente na lista de endereços\\n Thread(target=handle_client, args=(client,)).start() #Startar uma nova thread para a atividade de handle_client, passando o cliente como argumento\",\n \"def __accept_new_connection(self):\\r\\n c, addr = self._server_socket.accept()\\r\\n SidecarProcess.logger.info(\\\"Accepting connection for backuping\\\")\\r\\n return c\",\n \"def establish_connection(self):\\n print('Listening...')\\n self.socket.listen()\\n self.conn, addr = self.socket.accept()\\n print('Received connection', addr)\",\n \"def connectionMade(self):\\n self.transport.write('{0}{1}'.format(self._uidServer.getUID(),\\n self.delimiter))\\n self.transport.loseConnection()\",\n \"def handle_accept(self):\\r\\n pair = self.accept()\\r\\n if pair is not None:\\r\\n sock, addr = pair\\r\\n server_log.info('Client connection from {}, assigning client id {}'.format(repr(addr), self.client_id))\\r\\n handler = ClientHandler(sock, addr, self.client_id)\\r\\n self.client_list.update({self.client_id: handler})\\r\\n self.client_id += 1\",\n \"def accept_incoming_connections():\\n while True:\\n client, client_address = SERVER.accept()\\n print(\\\"%s:%s has connected.\\\" % client_address)\\n #client.send(bytes(\\\"Greetings from the cave! Now type your name and press enter!\\\", \\\"utf8\\\"))\\n addresses[client] = client_address\\n Thread(target=handle_client, args=(client,)).start()\",\n \"def accept_client(self):\\n while True:\\n if len(self.session_with_client_class.clients_data) < MAX_CLIENTS:\\n\\n client_socket, client_address = self.server_socket.accept()\\n\\n client_address = client_address[0]\\n\\n receiving_stream_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n receiving_stream_socket.bind((SERVER_IP, STREAM_FROM_CLIENT_PORT))\\n\\n sending_stream_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n\\n print \\\"new client\\\"\\n self.session_with_client_class.open_chat(client_socket, client_address,\\n receiving_stream_socket, sending_stream_socket)\\n else:\\n print \\\"Max clients reached, can't add more clients.\\\"\\n break\",\n \"def _accept_client(server_socket):\\n (player_socket, player_address) = server_socket.accept()\\n print \\\"a player has joind the game!\\\"\\n new_player = Player.player(player_socket=player_socket, player_address=player_address)\\n players.append(new_player)\\n # send the index of the player to that player\\n new_player.player_socket.send(str(new_player.index) + \\\"\\\\n\\\")\",\n \"async def accept(self) -> SocketStream[T_SockAddr]:\",\n \"def accept_in_connections():\\r\\n while True:\\r\\n client, client_address = SERVER.accept()\\r\\n print(\\\"%s:%s si è collegato.\\\" % client_address)\\r\\n\\r\\n #information about the game\\r\\n msg_client('Benvenuto!', client)\\r\\n msg_client('Rispondi più velocemente possibile alle domande', client)\\r\\n msg_client('Chi ha il punteggio più alto alla fine del tempo, vince!', client)\\r\\n \\r\\n \\r\\n #Dictionary for client\\r\\n address[client] = client_address\\r\\n #Thread - one for each client\\r\\n Thread(target=manage_client, args=(client,)).start()\",\n \"def _listen_for_clients (self):\\n self.broadcast_socket.bind(('0.0.0.0',self.broadcast_port))\\n self.broadcast_socket.listen(5)\\n while self.work:\\n connection, _ = self.broadcast_socket.accept()\\n self.clients.append(connection)\\n logging.debug(\\\"Client connected {0}\\\".format(connection.getsockname()))\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n tcpserver=daemon_thread_builder(tcp_server_thread, args=(other_uuid, other_tcp_port))\\n\\n SENDER = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n SENDER.connect((other_ip,int(other_tcp_port)))\\n address = (other_ip, int(other_tcp_port))\\n time_now = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n SENDER.sendto(struct.pack('!f', time_now), address)\\n \\n tcpserver.start()\\n tcpserver.join()\\n SENDER.close()\\n\\n pass\",\n \"def connect_to_server(self):\\r\\n self.client_socket.connect((SERVER_IP, SERVER_PORT))\\r\\n print('[CLIENT] connected to streamer.')\",\n \"def on_connect(self):\\n log.info(\\\"Stream connected\\\")\",\n \"def connect(self):\\r\\n\\r\\n\\t\\tprint('Connecting to server')\\r\\n\\r\\n\\t\\tself.t = threading.Thread(target=self.daemon.requestLoop)\\r\\n\\t\\tself.t.daemon = True\\r\\n\\t\\tself.t.start()\\r\\n\\t\\tprint('daemon thread started')\\r\\n\\t\\tmessages = self.chat.connect(self.my_uri)\\r\\n\\r\\n\\t\\t#in case the connection is refused:\\r\\n\\t\\tif isinstance(messages, bool) and not messages:\\r\\n\\t\\t\\traise ValueError(f\\\"Username {self.username} already taken\\\")\\r\\n\\r\\n\\t\\tprint('Connected')\\r\\n\\r\\n\\t\\t#if the connection is accepted, the last 20 messages are sent\\r\\n\\t\\t#those messages will now be printed.\\r\\n\\t\\tfor message in messages:\\r\\n\\t\\t\\tself.incoming_message(message)\",\n \"async def on_connect(self):\\r\\n self._try_shutdown_twitch()\\r\\n self.stream_thread = self.connect_thread()\",\n \"def connection_to_server_made(self, transport):\\n\\n local_data = self._socket.getsockname()\\n peer_data = transport.get_extra_info('peername')\\n\\n self._logger.info('[%s] local %s:%s connected to %s:%s',\\n self._sock_id, local_data[0], local_data[1],\\n peer_data[0], peer_data[1])\\n\\n # No delay OFF -> Nagle's alg used\\n self._socket.setsockopt(\\n socket.IPPROTO_TCP,\\n socket.TCP_NODELAY,\\n 0)\\n\\n # If required - turn off Nagle's alg (No Delay ON)\\n if self._no_delay:\\n self._socket.setsockopt(\\n socket.IPPROTO_TCP,\\n socket.TCP_NODELAY,\\n 1)\\n\\n # Set Socket TX/RX buffer sizes if specified\\n if self._window:\\n self._logger.debug('Setting socket buffer sizes to %s B', self._window)\\n self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, self._window)\\n self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, self._window)\\n\\n # Print current buf sizes:\\n rx_buf = self._socket.getsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF)\\n tx_buf = self._socket.getsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF)\\n\\n self._logger.debug('Socket TX buffer: %s B; RX buffer: %s B;', tx_buf, rx_buf)\\n\\n self._stream.connection_established(self)\",\n \"def connect(self):\\n self.conn.add_listener(self.handle_connection_change)\\n self.conn.start_async()\",\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 send_heartbeat_messages(self):\\n while True:\\n for node in self.directory.get_current_list():\\n heartbeat_message = MessageFactory.generate_heartbeat_message(\\n origin_node=self.socket_manager.node,\\n destination_node=node\\n )\\n self.socket_manager.send_message(heartbeat_message)\\n time.sleep(3)\",\n \"async def connect(self):\\n await asyncio.gather(self._exchange_connection.connect_to_server(), self.on_connection())\",\n \"def handle_connect(self):\\n LOGGER.debug(\\\"server connected(%d)\\\", id(self))\\n self.append_connect = False\\n self.send_dict_pack(MoloSocketHelper.reg_proxy(self.client_id))\",\n \"def _accept_conn(listen_sock, tracker_conn, ping_period=2):\\n old_keyset = set()\\n # Report resource to tracker\\n if tracker_conn:\\n matchkey = base.random_key(rpc_key)\\n base.sendjson(tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr])\\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\\n else:\\n matchkey = rpc_key\\n\\n unmatch_period_count = 0\\n unmatch_timeout = 4\\n # Wait until we get a valid connection\\n while True:\\n if tracker_conn:\\n trigger = select.select([listen_sock], [], [], ping_period)\\n if not listen_sock in trigger[0]:\\n base.sendjson(tracker_conn, [TrackerCode.GET_PENDING_MATCHKEYS])\\n pending_keys = base.recvjson(tracker_conn)\\n old_keyset.add(matchkey)\\n # if match key not in pending key set\\n # it means the key is acquired by a client but not used.\\n if matchkey not in pending_keys:\\n unmatch_period_count += 1\\n else:\\n unmatch_period_count = 0\\n # regenerate match key if key is acquired but not used for a while\\n if unmatch_period_count * ping_period > unmatch_timeout + ping_period:\\n logger.info(\\\"no incoming connections, regenerate key ...\\\")\\n matchkey = base.random_key(rpc_key, cmap=old_keyset)\\n base.sendjson(\\n tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr]\\n )\\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\\n unmatch_period_count = 0\\n continue\\n conn, addr = listen_sock.accept()\\n magic = struct.unpack(\\\"<i\\\", base.recvall(conn, 4))[0]\\n if magic != base.RPC_MAGIC:\\n conn.close()\\n continue\\n keylen = struct.unpack(\\\"<i\\\", base.recvall(conn, 4))[0]\\n key = py_str(base.recvall(conn, keylen))\\n arr = key.split()\\n expect_header = \\\"client:\\\" + matchkey\\n server_key = \\\"server:\\\" + rpc_key\\n if arr[0] != expect_header:\\n conn.sendall(struct.pack(\\\"<i\\\", base.RPC_CODE_MISMATCH))\\n conn.close()\\n logger.warning(\\\"mismatch key from %s\\\", addr)\\n continue\\n conn.sendall(struct.pack(\\\"<i\\\", base.RPC_CODE_SUCCESS))\\n conn.sendall(struct.pack(\\\"<i\\\", len(server_key)))\\n conn.sendall(server_key.encode(\\\"utf-8\\\"))\\n return conn, addr, _parse_server_opt(arr[1:])\",\n \"def run(self):\\n inputs = [self.server]\\n\\n while self.running:\\n print '1'\\n try:\\n readable, writeable, exceptional = \\\\\\n select.select(inputs, [], [])\\n except select.error, e:\\n print 'select:error[%s]' % e.message\\n break\\n\\n for sock in readable:\\n print '2'\\n if sock == self.server:\\n client, address = self.server.accept()\\n client.setblocking(0)\\n inputs.append(client)\\n # self.outputs.append(client)\\n\\n print 'Client[%s] connected!' % address[0]\\n self.clients[client] = address[0]\\n\\n else:\\n print '3'\\n self.recv_data(sock)\",\n \"def connecting_peer(self, peer):\\n if peer.next_heart_beat_time < self.app.tick:\\n self.declare_no_connection(peer)\\n else:\\n logger.log(TRACE, \\\"%s is connecting (has until %r, now is %r)\\\",\\n peer, peer.next_heart_beat_time, self.app.tick)\",\n \"def connectionMade(self):\\n protocol.Protocol.connectionMade(self)\\n self.port = self.transport.getHost().port\\n #Start the inactivity timer the connection is dropped if we receive no data\\n self.activateInactivityTimer()\\n self.sessionState = SMPPSessionStates.OPEN\\n self.log.warning(\\\"SMPP connection established from %s to port %s\\\", self.transport.getPeer().host, self.port)\",\n \"def listen_to_connection(self, conn):\\n with conn:\\n print(\\\"Connected\\\")\\n while self.running:\\n data = conn.recv(32)\\n if not data: \\n return\\n \\n print(\\\"Recived Data:\\\"+str(data))\\n self.__update(data)\",\n \"def _listen_loop(sock, port, rpc_key, tracker_addr, load_library, custom_addr):\\n\\n def _accept_conn(listen_sock, tracker_conn, ping_period=2):\\n \\\"\\\"\\\"Accept connection from the other places.\\n\\n Parameters\\n ----------\\n listen_sock: Socket\\n The socket used by listening process.\\n\\n tracker_conn : connection to tracker\\n Tracker connection\\n\\n ping_period : float, optional\\n ping tracker every k seconds if no connection is accepted.\\n \\\"\\\"\\\"\\n old_keyset = set()\\n # Report resource to tracker\\n if tracker_conn:\\n matchkey = base.random_key(rpc_key)\\n base.sendjson(tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr])\\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\\n else:\\n matchkey = rpc_key\\n\\n unmatch_period_count = 0\\n unmatch_timeout = 4\\n # Wait until we get a valid connection\\n while True:\\n if tracker_conn:\\n trigger = select.select([listen_sock], [], [], ping_period)\\n if not listen_sock in trigger[0]:\\n base.sendjson(tracker_conn, [TrackerCode.GET_PENDING_MATCHKEYS])\\n pending_keys = base.recvjson(tracker_conn)\\n old_keyset.add(matchkey)\\n # if match key not in pending key set\\n # it means the key is acquired by a client but not used.\\n if matchkey not in pending_keys:\\n unmatch_period_count += 1\\n else:\\n unmatch_period_count = 0\\n # regenerate match key if key is acquired but not used for a while\\n if unmatch_period_count * ping_period > unmatch_timeout + ping_period:\\n logger.info(\\\"no incoming connections, regenerate key ...\\\")\\n matchkey = base.random_key(rpc_key, cmap=old_keyset)\\n base.sendjson(\\n tracker_conn, [TrackerCode.PUT, rpc_key, (port, matchkey), custom_addr]\\n )\\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\\n unmatch_period_count = 0\\n continue\\n conn, addr = listen_sock.accept()\\n magic = struct.unpack(\\\"<i\\\", base.recvall(conn, 4))[0]\\n if magic != base.RPC_MAGIC:\\n conn.close()\\n continue\\n keylen = struct.unpack(\\\"<i\\\", base.recvall(conn, 4))[0]\\n key = py_str(base.recvall(conn, keylen))\\n arr = key.split()\\n expect_header = \\\"client:\\\" + matchkey\\n server_key = \\\"server:\\\" + rpc_key\\n if arr[0] != expect_header:\\n conn.sendall(struct.pack(\\\"<i\\\", base.RPC_CODE_MISMATCH))\\n conn.close()\\n logger.warning(\\\"mismatch key from %s\\\", addr)\\n continue\\n conn.sendall(struct.pack(\\\"<i\\\", base.RPC_CODE_SUCCESS))\\n conn.sendall(struct.pack(\\\"<i\\\", len(server_key)))\\n conn.sendall(server_key.encode(\\\"utf-8\\\"))\\n return conn, addr, _parse_server_opt(arr[1:])\\n\\n # Server logic\\n tracker_conn = None\\n while True:\\n try:\\n # step 1: setup tracker and report to tracker\\n if tracker_addr and tracker_conn is None:\\n tracker_conn = base.connect_with_retry(tracker_addr)\\n tracker_conn.sendall(struct.pack(\\\"<i\\\", base.RPC_TRACKER_MAGIC))\\n magic = struct.unpack(\\\"<i\\\", base.recvall(tracker_conn, 4))[0]\\n if magic != base.RPC_TRACKER_MAGIC:\\n raise RuntimeError(f\\\"{str(tracker_addr)} is not RPC Tracker\\\")\\n # report status of current queue\\n cinfo = {\\\"key\\\": \\\"server:\\\" + rpc_key, \\\"addr\\\": (custom_addr, port)}\\n base.sendjson(tracker_conn, [TrackerCode.UPDATE_INFO, cinfo])\\n assert base.recvjson(tracker_conn) == TrackerCode.SUCCESS\\n\\n # step 2: wait for in-coming connections\\n conn, addr, opts = _accept_conn(sock, tracker_conn)\\n except (socket.error, IOError):\\n # retry when tracker is dropped\\n if tracker_conn:\\n tracker_conn.close()\\n tracker_conn = None\\n continue\\n except RuntimeError as exc:\\n raise exc\\n\\n # step 3: serving\\n _serving(conn, addr, opts, load_library)\",\n \"def handle_connect(self):\\n LOGGER.debug(\\\"local session connected(%d)\\\", id(self))\\n self.append_connect = False\",\n \"def on_connect(self):\\n print('Client connected!')\",\n \"def __sendToAll(self, message, author = None):\\n\\n self.messageCallback(message)\\n\\n for user in self.__connections:\\n\\n if not user is author:\\n try: \\n user[\\\"connection\\\"].send((message + self.separator).encode())\\n except: \\n user[\\\"online\\\"] = False\",\n \"def accept_incoming_connections():\\n while True:\\n client, client_address = SERVER.accept()\\n print(\\\"%s:%s has connected.\\\" % client_address)\\n addresses[client] = client_address\\n username = client.recv(BUFSIZ).decode(\\\"utf8\\\")\\n clients[client]=username\\n Thread(target=handle_client, args=(client,)).start()\",\n \"def connectToServer(self):\\n client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n client_sock.bind((self.ip, self.port))\\n client_sock.connect((self.serverPC_ip, 9090))\\n #create CREQ message\\n message = Message('CREQ', self.ip, '\\\\0')\\n client_sock.sendall(message.generateByteMessage())\\n print('Sent CREQ message to serverPC at ' + self.serverPC_ip)\\n #recieve response as string\\n response_message = self.parseMessage(client_sock)\\n if (response_message.type == 'OKAY'):\\n print('OKAY message received')\\n #payload contains host area, and list of connected hosts\\n payload_array = response_message.payload.split(',')\\n i = 1\\n lost_payload = ''\\n while i < len(payload_array):\\n indicator = self.setupHostConnection(payload_array[i])\\n if(indicator == False):\\n lost_payload += payload_array[i]+\\\",\\\"\\n else:\\n self.host_ips.append(payload_array[i])\\n i += 1\\n self.x_min = self.curr_x_max\\n self.x_max = self.x_min + self.x_scalar\\n #this message contains the hosts that have disconnected from the network and notifes the serverPC about the change\\n del_message = Message('LHST', self.ip, lost_payload)\\n print('sent LHST to serverPC with payload: ' + lost_payload)\\n client_sock.sendall(del_message.generateByteMessage())\\n if self.curr_x_min_ip == '':\\n #there was no other host, you are your own neighbor\\n self.r_neighbor = self.ip\\n self.l_neighbor = self.ip\\n else:\\n #else, there is another host - check if there are any other hosts\\n self.r_neighbor = self.curr_x_min_ip\\n\\n if self.l_neighbor == '':\\n #there isnt a left neighbor - left neighbor is right neighbor\\n self.l_neighbor = self.r_neighbor\\n # need to start the listening thread and the work thread now\\n listening_thread = Thread(target=lambda: self.listeningPort())\\n listening_thread.daemon = True\\n listening_thread.start()\\n work_thread = Thread(target=lambda: self.processWork())\\n work_thread.daemon = True\\n work_thread.start()\\n else:\\n print('Invalid message type received from ' + message.origin)\",\n \"def connectionMade(self):\\n\\n self.connected_users[self.user_key] = {\\n \\\"host\\\": self.addr.host,\\n \\\"type\\\": self.addr.type,\\n \\\"authorized\\\": False,\\n \\\"main\\\": {\\n \\\"player_name\\\": None,\\n \\\"base\\\": None,\\n \\\"dungeon\\\": None\\n },\\n }\\n self.log_to_debug(\\n line=f\\\"{self.addr.host}:{self.addr.port} Connected...\\\"\\n )\\n self.log_file.log_all(\\n priority=3,\\n string=f\\\"{self.addr.host}:{self.addr.port} Connected to server\\\"\\n )\\n self.send_one(\\n response=UtilityModule.generate_response(\\n action=\\\"connectToServer\\\",\\n code=100\\n )\\n )\",\n \"def listen(self):\\r\\n self.theSocket.listen(0)\\r\\n print('Socket now listening')\\r\\n \\r\\n #wait to accept a connection - blocking call\\r\\n self.conn, self.addr = self.theSocket.accept()\\r\\n\\r\\n print('Connected with ' + self.addr[0] + ':' + str(self.addr[1]))\\r\\n return self.conn\",\n \"def receive_data(self):\\n self.new_socket.listen(5)\\n while True:\\n channel, address = self.new_socket.accept()\\n if self.clients_count < 5:\\n Thread(target=self.listen_clients, args=(channel, address)).start()\\n self.clients_count += 1\\n print(\\\"No. of clients connected:\\\" + str(self.clients_count))\\n else:\\n print(\\\"No new threads allowed\\\")\\n break\",\n \"def connectionMade(self):\\n self.transport.write('{0}{1}'.format(self._uidServer.getUID(),\\n self.delimiter))\",\n \"def _accept_conn(self, conn_data_cls: 'ConnectionData') -> None:\\n conn_data_cls.conn, conn_data_cls.addr = self._socket.accept()\",\n \"def accept_incoming_connections():\\n while True:\\n # Accept connection and receive info\\n client, client_address = SERVER.accept()\\n print(\\\"%s:%s has connected.\\\" % client_address)\\n client.send(bytes(\\\"Greetings from the cave!\\\", \\\"utf8\\\"))\\n client.send(bytes(\\\"Enter Username: \\\",\\\"utf8\\\"))\\n uname = client.recv(BUFSIZ).decode(\\\"utf8\\\")\\n client.send(bytes(\\\"Enter Password: \\\",\\\"utf8\\\"))\\n pw = client.recv(BUFSIZ).decode(\\\"utf8\\\")\\n # Connect to database in order to check username and pw\\n cursor = SVconnectSQL()\\n client_Login(cursor,uname,pw,client)\\n\\n addresses[client] = client_address\\n Thread(target=handle_client, args=(client,uname)).start()\",\n \"def run(self):\\n try:\\n self.is_activated=True\\n while self.is_activated:\\n try:\\n #make sure all of the connections are saved.\\n connection = self._socket.accept()\\n self._connections.append(connection)\\n except timeout: pass\\n except Exception as e:\\n logging.exception(e)\\n finally:\\n self.deactivate()\",\n \"def on_connect(self, connection, event):\\r\\n print('[{}] Connected to {}' .format(event.type.upper(), event.source))\\r\\n print(\\\"{}\\\".format(event.arguments))\\r\\n\\r\\n res = self.cursor.execute(\\\"\\\"\\\"SELECT * FROM `IRC_servers` WHERE `Registred_users_userID` = %s AND `serverID` = %s;\\\"\\\"\\\", (self.userID, connection.serverID))\\r\\n if res != 0:\\r\\n result = self.cursor.fetchall()\\r\\n serverID_res = int(result[0][0])\\r\\n #res = self.cursor.execute(\\\"\\\"\\\"UPDATE `IRC_servers` SET `isConnected` = %s WHERE `serverID` = %s;\\\"\\\"\\\", (1, serverID_res))\\r\\n\\r\\n if serverID_res == int(connection.serverID): # pokud se získané ID z databáze rovná tomu, které v sobě uchovává connection, redundantní check, ale JTS\\r\\n res = self.cursor.execute(\\\"\\\"\\\"SELECT * FROM `IRC_channels` WHERE `IRC_servers_serverID` = %s;\\\"\\\"\\\", (serverID_res,))\\r\\n if res != 0:\\r\\n result = self.cursor.fetchall()\\r\\n print(\\\"For serverID = {}: {}\\\".format(serverID_res, result))\\r\\n\\r\\n channels = list()\\r\\n for resa in result:\\r\\n channelID = resa[0]\\r\\n channelName = resa[1]\\r\\n channelPassword = resa[2]\\r\\n lastOpened = resa[3]\\r\\n channel_serverID = resa[4]\\r\\n\\r\\n temp_dict = {\\\"channelName\\\": channelName, \\\"channelPassword\\\": channelPassword}\\r\\n channels.append(temp_dict)\\r\\n\\r\\n for channel in channels:\\r\\n if client.is_channel(channel[\\\"channelName\\\"]):\\r\\n connection.join(channel[\\\"channelName\\\"], key=channel[\\\"channelPassword\\\"])\\r\\n else:\\r\\n print(\\\"The channel in database is not a channel.\\\")\\r\\n else:\\r\\n print(\\\"[WARNING on_connect]: No channels to join on this server (serverID = {})\\\".format(serverID_res))\",\n \"def connect_trade_stream(message):\\r\\n # accept the incoming connection\\r\\n message.reply_channel.send({'accept': True})\\r\\n # add the reply_channel of this connection to the trade_stream group,\\r\\n # so that it can receive updates sent to the group (all group members\\r\\n # will be able to get the same message)\\r\\n Group('trade_stream').add(message.reply_channel)\",\n \"def handle_new_conn(self):\\n self.latest_client_socket, self.latest_client_address = self.server_listen_socket.accept()\\n print(\\\"Accepted new connection from {0}:{1}\\\".format(self.latest_client_address[0], self.latest_client_address[1]))\\n user = self.receive_message(self.latest_client_socket)\\n if user is False:\\n return False\\n\\n self.sockets_list.append(self.latest_client_socket)\\n self.clients[self.latest_client_socket] = user\\n print(\\\"Accepted new user: {0}\\\".format(user['data'].decode('utf-8')))\\n return True\",\n \"def __accept_new_client(self):\\n client_socket, client_addr = self.__server_socket.accept()\\n new_client = client.Client(client_socket, client_addr)\\n self.__logger.info(\\\"Accepted new client from {}\\\".format(client_addr))\\n self.__connected_clients.append(new_client)\",\n \"def connectionMade(self):\\n self.protocol.makeConnection(BridgeTransport(self.transport))\",\n \"def connect():\",\n \"async def connection_made(self):\\n logging.info('connecting to %s:%s' % self.address)\",\n \"async def on_connect(self, payload):\\n # You can `raise` from here to reject the connection.\\n print(\\\"New client connected!\\\")\",\n \"def connect(self) -> None:\\n ...\",\n \"def watch_for_rtt_messages(self):\\n while True:\\n message = self.socket_manager.get_rtt_message()\\n self.ensure_sender_is_known(message)\\n if message.stage == \\\"0\\\":\\n self.respond_to_rtt_message(message)\\n elif message.stage == \\\"1\\\":\\n self.handle_rtt_response(message)\\n elif message.stage == \\\"2\\\":\\n self.handle_rtt_broadcast(message)\",\n \"def handle_accept(self):\\n pair = self.accept()\\n if pair is not None:\\n sock, addr = pair\\n print(repr(addr), \\\"comes\\\")\\n RPCHandler(sock, addr)\",\n \"def connect_as_referee(remote_IP_1='127.0.0.1', remote_IP_2='127.0.0.1', verbose=False, timeout=None):\\n\\n # init verbose display\\n if verbose:\\n print '\\\\n----------------------------------------------------------------------------'\\n\\n # open sockets (as server) to receive orders\\n socket_in = []\\n for player_id in (1, 2):\\n socket_in.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\\n socket_in[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if remote_IP_1 == '127.0.0.1' and remote_IP_2 == '127.0.0.1':\\n local_IP = '127.0.0.1'\\n else:\\n local_IP = get_IP()\\n local_port = 42000 + (3-player_id)\\n\\n if verbose:\\n print 'referee binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\\n socket_in[player_id-1].bind((local_IP, local_port))\\n socket_in[player_id-1].listen(1)\\n if verbose:\\n print ' done -> referee is now waiting for player %d to connect on %s:%d' % (player_id, local_IP, local_port)\\n\\n if verbose:\\n print\\n\\n # open sockets (as client) to send orders\\n socket_out = []\\n for player_id in (1, 2):\\n socket_out.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\\n socket_out[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if player_id == 1:\\n remote_IP = remote_IP_1\\n else:\\n remote_IP = remote_IP_2\\n\\n local_IP = get_IP()\\n\\n if remote_IP == '127.0.0.1' or remote_IP == local_IP:\\n remote_port = 42000 + 100 + player_id\\n else:\\n remote_port = 42000 + player_id\\n\\n connected = False\\n msg_shown = False\\n while not connected:\\n try:\\n if verbose and not msg_shown:\\n print 'referee connecting on %s:%d to forward orders to player %d...' % (remote_IP, remote_port, player_id)\\n socket_out[player_id-1].connect((remote_IP, remote_port))\\n connected = True\\n if verbose:\\n print ' done -> referee is now forwarding orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\\n except:\\n if verbose and not msg_shown:\\n print ' connection failed -> referee will try again every 100 msec...'\\n time.sleep(.1)\\n msg_shown = True\\n\\n if verbose:\\n print\\n\\n # accept connection to the server sockets to the server socket to receive orders from remote player\\n for player_id in (1, 2):\\n socket_in[player_id-1], remote_address = socket_in[player_id-1].accept()\\n if verbose:\\n print 'now listening to orders from player %d' % (player_id)\\n\\n if verbose:\\n print\\n\\n # setting timeout if necessary\\n if timeout != None:\\n socket_in[0].settimeout(timeout)\\n socket_in[1].settimeout(timeout)\\n socket_out[0].settimeout(timeout)\\n socket_out[1].settimeout(timeout)\\n\\n if verbose:\\n print 'warning: remote players are given %d sec. for each request' % timeout\\n else:\\n if verbose:\\n print 'warning: remote players have no time limit to answer requests'\\n\\n # end verbose display\\n if verbose:\\n print '\\\\nconnection to remote players successful\\\\n----------------------------------------------------------------------------\\\\n'\\n\\n # return sockets for further use\\n return (socket_in[0], socket_out[0]), (socket_in[1], socket_out[1])\",\n \"def connection_made(self, transport) -> None:\\n peername = transport.get_extra_info(\\\"peername\\\")\\n logging.info(f\\\"Server: New connection from {peername}.\\\")\\n self.transport = transport\\n loop = asyncio.get_event_loop()\\n self.task = loop.create_task(self.serve_data())\",\n \"def connect(self) -> None:\",\n \"def peer_server_host(self):\\n try:\\n while True:\\n while not self.peer_server_listener_queue.empty():\\n with futures.ThreadPoolExecutor(max_workers=8) as executor:\\n conn, addr = self.peer_server_listener_queue.get()\\n data_received = json.loads(conn.recv(1024))\\n\\n if data_received['command'] == 'obtain_active':\\n fut = executor.submit(\\n self.peer_server_upload, conn, data_received)\\n except Exception as e:\\n print \\\"Peer Server Hosting Error, %s\\\" % e\",\n \"def serverAccept(self):\\n self.handshake_deferred.callback(self.protocol_to_accept)\\n logger.debug(\\\"WebSocket %s accepted by application\\\", self.reply_channel)\",\n \"def accept(self):\\n while self.active:\\n try:\\n sock, addrinfo = self.listener.accept()\\n except socket.timeout:\\n pass\\n except socket.error:\\n ex = sys.exc_info()[1]\\n if get_exc_errno(ex) in (errno.EINTR, errno.EAGAIN):\\n pass\\n else:\\n raise EOFError()\\n else:\\n break\\n\\n if not self.active:\\n return\\n\\n sock.setblocking(True)\\n self.logger.info(f\\\"accepted {addrinfo} with fd {sock.fileno()}\\\")\\n self.clients.add(sock)\\n self._accept_method(sock)\",\n \"def add_connections(self, connections):\\r\\n\\r\\n for node1, node2 in connections:\\r\\n self.add(node1, node2)\",\n \"def connect(self):\\n self.wss.start()\\n while not self.wss.conn.connected.is_set():\\n time.sleep(1e-4)\\n\\n for _type in self.types:\\n for symbol in self.symbols:\\n self.subscribe(_type, symbol)\",\n \"def _add_connections(self, connections):\\r\\n\\r\\n for node1, node2 in connections:\\r\\n self._add(node1, node2)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6720128","0.6533498","0.6439251","0.6316046","0.6313253","0.6296173","0.6256884","0.6221823","0.6147624","0.6110266","0.61037403","0.609133","0.59992737","0.5917574","0.59052026","0.58938557","0.5878946","0.5848995","0.5839791","0.5825865","0.5822812","0.5811097","0.5788811","0.57751524","0.576467","0.57597893","0.5748297","0.5741855","0.5732823","0.5724315","0.57103205","0.5687841","0.5682833","0.5679918","0.5671244","0.5670278","0.56693864","0.5666023","0.56294036","0.56197405","0.5616115","0.5615525","0.560917","0.55865735","0.558312","0.5582544","0.55808294","0.55803925","0.55686605","0.5568349","0.5563226","0.5545737","0.5544204","0.5543565","0.5536454","0.55363816","0.55262184","0.5525019","0.5516198","0.5513352","0.5498091","0.5496143","0.5472832","0.54646695","0.54609","0.5444977","0.5443388","0.5436216","0.54318017","0.542256","0.5420738","0.5413898","0.54089856","0.5400813","0.5397505","0.5391148","0.53864837","0.5384444","0.5381634","0.537874","0.5370257","0.5368805","0.5368104","0.5361768","0.535822","0.53573775","0.5352267","0.535007","0.5348759","0.53458905","0.5345548","0.53440225","0.5343338","0.5339584","0.53392935","0.5339178","0.5337011","0.53364533","0.53355986","0.5334939","0.5333551"],"string":"[\n \"0.6720128\",\n \"0.6533498\",\n \"0.6439251\",\n \"0.6316046\",\n \"0.6313253\",\n \"0.6296173\",\n \"0.6256884\",\n \"0.6221823\",\n \"0.6147624\",\n \"0.6110266\",\n \"0.61037403\",\n \"0.609133\",\n \"0.59992737\",\n \"0.5917574\",\n \"0.59052026\",\n \"0.58938557\",\n \"0.5878946\",\n \"0.5848995\",\n \"0.5839791\",\n \"0.5825865\",\n \"0.5822812\",\n \"0.5811097\",\n \"0.5788811\",\n \"0.57751524\",\n \"0.576467\",\n \"0.57597893\",\n \"0.5748297\",\n \"0.5741855\",\n \"0.5732823\",\n \"0.5724315\",\n \"0.57103205\",\n \"0.5687841\",\n \"0.5682833\",\n \"0.5679918\",\n \"0.5671244\",\n \"0.5670278\",\n \"0.56693864\",\n \"0.5666023\",\n \"0.56294036\",\n \"0.56197405\",\n \"0.5616115\",\n \"0.5615525\",\n \"0.560917\",\n \"0.55865735\",\n \"0.558312\",\n \"0.5582544\",\n \"0.55808294\",\n \"0.55803925\",\n \"0.55686605\",\n \"0.5568349\",\n \"0.5563226\",\n \"0.5545737\",\n \"0.5544204\",\n \"0.5543565\",\n \"0.5536454\",\n \"0.55363816\",\n \"0.55262184\",\n \"0.5525019\",\n \"0.5516198\",\n \"0.5513352\",\n \"0.5498091\",\n \"0.5496143\",\n \"0.5472832\",\n \"0.54646695\",\n \"0.54609\",\n \"0.5444977\",\n \"0.5443388\",\n \"0.5436216\",\n \"0.54318017\",\n \"0.542256\",\n \"0.5420738\",\n \"0.5413898\",\n \"0.54089856\",\n \"0.5400813\",\n \"0.5397505\",\n \"0.5391148\",\n \"0.53864837\",\n \"0.5384444\",\n \"0.5381634\",\n \"0.537874\",\n \"0.5370257\",\n \"0.5368805\",\n \"0.5368104\",\n \"0.5361768\",\n \"0.535822\",\n \"0.53573775\",\n \"0.5352267\",\n \"0.535007\",\n \"0.5348759\",\n \"0.53458905\",\n \"0.5345548\",\n \"0.53440225\",\n \"0.5343338\",\n \"0.5339584\",\n \"0.53392935\",\n \"0.5339178\",\n \"0.5337011\",\n \"0.53364533\",\n \"0.53355986\",\n \"0.5334939\",\n \"0.5333551\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85152,"cells":{"query":{"kind":"string","value":"Open a connection to the other_ip, other_tcp_port and do the steps to exchange timestamps. Then update the neighbor_info map using other node's UUID."},"document":{"kind":"string","value":"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n tcpserver=daemon_thread_builder(tcp_server_thread, args=(other_uuid, other_tcp_port))\n\n SENDER = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n SENDER.connect((other_ip,int(other_tcp_port)))\n address = (other_ip, int(other_tcp_port))\n time_now = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n SENDER.sendto(struct.pack('!f', time_now), address)\n \n tcpserver.start()\n tcpserver.join()\n SENDER.close()\n\n pass"},"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 exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\r\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\r\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n sock.connect((other_ip, int(other_tcp_port)))\r\n other_time = sock.recv(4096)\r\n other_time = struct.unpack(\"!f\", other_time)\r\n print(\"*\" * 50)\r\n my_time = datetime.datetime.utcnow().timestamp()\r\n delay = my_time - other_time[0]\r\n neighbor = NeighborInfo(delay, my_time, other_ip,\r\n other_tcp_port, broadcast_count)\r\n print_red(neighbor_information)\r\n #neighbor_information.update({other_uuid: neighbor})\r\n neighbor_information[other_uuid] = neighbor\r\n print_red(neighbor_information)","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n address = (other_ip, other_tcp_port)\n tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n tcp_socket.connect(address)\n received_time_stamp = struct.unpack('!f', tcp_socket.recv(4096))[0]\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n\n delay = current_timestamp - received_time_stamp\n # print_red(f'Current: [{current_timestamp}] ==> Received [{received_time_stamp}]')\n print_red(f'[{other_uuid}] Current delay {abs(delay)}')\n node = NeighborInfo(delay, 1, other_ip, other_tcp_port)\n neighbor_information.update({other_uuid: node})\n\n pass","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n try:\n client.connect((other_ip, other_tcp_port))\n data = client.recv(1024)\n except ConnectionError:\n print_red(\"connection refused\") \n exit()\n timestamp = struct.unpack(\"!d\", data)\n # calculate delay\n my_timestamp = datetime.datetime.utcnow().timestamp()\n delay = my_timestamp - timestamp[0]\n\n if other_uuid in neighbor_information:\n neighbor_information[other_uuid].delay = delay\n # neighbor_information[other_uuid].last_timestamp = timestamp[0]\n\n else:\n neighbour_node = NeighborInfo(delay, other_ip, other_tcp_port)\n neighbor_information.update({other_uuid: neighbour_node})\n\n client.close()","def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\n\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n\n # send our timestamp\n try:\n s.connect((other_ip, other_tcp_port))\n now = time.time()\n our_timestamp = struct.pack(\"!d\", now)\n\n s.sendall(our_timestamp)\n data = s.recv(1024)\n except ConnectionRefusedError:\n return\n except ConnectionResetError:\n return\n\n # receive timestamp\n last_timestamp = struct.unpack(\"!d\", data)[0]\n print_yellow(f'received from {other_ip} {other_tcp_port} time stamp {last_timestamp}')\n delay = time.time() - last_timestamp\n neighbor_node = NeighborInfo(delay, last_timestamp, ip=other_ip, tcp_port=other_tcp_port)\n print('inserting into neighbour in exchange')\n insertIntoNeighbour(other_uuid, neighbor_node)","def connect_as_referee(remote_IP_1='127.0.0.1', remote_IP_2='127.0.0.1', verbose=False, timeout=None):\n\n # init verbose display\n if verbose:\n print '\\n----------------------------------------------------------------------------'\n\n # open sockets (as server) to receive orders\n socket_in = []\n for player_id in (1, 2):\n socket_in.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\n socket_in[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if remote_IP_1 == '127.0.0.1' and remote_IP_2 == '127.0.0.1':\n local_IP = '127.0.0.1'\n else:\n local_IP = get_IP()\n local_port = 42000 + (3-player_id)\n\n if verbose:\n print 'referee binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\n socket_in[player_id-1].bind((local_IP, local_port))\n socket_in[player_id-1].listen(1)\n if verbose:\n print ' done -> referee is now waiting for player %d to connect on %s:%d' % (player_id, local_IP, local_port)\n\n if verbose:\n print\n\n # open sockets (as client) to send orders\n socket_out = []\n for player_id in (1, 2):\n socket_out.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\n socket_out[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if player_id == 1:\n remote_IP = remote_IP_1\n else:\n remote_IP = remote_IP_2\n\n local_IP = get_IP()\n\n if remote_IP == '127.0.0.1' or remote_IP == local_IP:\n remote_port = 42000 + 100 + player_id\n else:\n remote_port = 42000 + player_id\n\n connected = False\n msg_shown = False\n while not connected:\n try:\n if verbose and not msg_shown:\n print 'referee connecting on %s:%d to forward orders to player %d...' % (remote_IP, remote_port, player_id)\n socket_out[player_id-1].connect((remote_IP, remote_port))\n connected = True\n if verbose:\n print ' done -> referee is now forwarding orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\n except:\n if verbose and not msg_shown:\n print ' connection failed -> referee will try again every 100 msec...'\n time.sleep(.1)\n msg_shown = True\n\n if verbose:\n print\n\n # accept connection to the server sockets to the server socket to receive orders from remote player\n for player_id in (1, 2):\n socket_in[player_id-1], remote_address = socket_in[player_id-1].accept()\n if verbose:\n print 'now listening to orders from player %d' % (player_id)\n\n if verbose:\n print\n\n # setting timeout if necessary\n if timeout != None:\n socket_in[0].settimeout(timeout)\n socket_in[1].settimeout(timeout)\n socket_out[0].settimeout(timeout)\n socket_out[1].settimeout(timeout)\n\n if verbose:\n print 'warning: remote players are given %d sec. for each request' % timeout\n else:\n if verbose:\n print 'warning: remote players have no time limit to answer requests'\n\n # end verbose display\n if verbose:\n print '\\nconnection to remote players successful\\n----------------------------------------------------------------------------\\n'\n\n # return sockets for further use\n return (socket_in[0], socket_out[0]), (socket_in[1], socket_out[1])","def connect_to(self, inf1, router2, inf2):\n self.interfaces[inf1]['connect'] = [router2.hostname, inf2]\n router2.interfaces[inf2]['connect'] = [self.hostname, inf1]","def connectToServer(self):\n client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n client_sock.bind((self.ip, self.port))\n client_sock.connect((self.serverPC_ip, 9090))\n #create CREQ message\n message = Message('CREQ', self.ip, '\\0')\n client_sock.sendall(message.generateByteMessage())\n print('Sent CREQ message to serverPC at ' + self.serverPC_ip)\n #recieve response as string\n response_message = self.parseMessage(client_sock)\n if (response_message.type == 'OKAY'):\n print('OKAY message received')\n #payload contains host area, and list of connected hosts\n payload_array = response_message.payload.split(',')\n i = 1\n lost_payload = ''\n while i < len(payload_array):\n indicator = self.setupHostConnection(payload_array[i])\n if(indicator == False):\n lost_payload += payload_array[i]+\",\"\n else:\n self.host_ips.append(payload_array[i])\n i += 1\n self.x_min = self.curr_x_max\n self.x_max = self.x_min + self.x_scalar\n #this message contains the hosts that have disconnected from the network and notifes the serverPC about the change\n del_message = Message('LHST', self.ip, lost_payload)\n print('sent LHST to serverPC with payload: ' + lost_payload)\n client_sock.sendall(del_message.generateByteMessage())\n if self.curr_x_min_ip == '':\n #there was no other host, you are your own neighbor\n self.r_neighbor = self.ip\n self.l_neighbor = self.ip\n else:\n #else, there is another host - check if there are any other hosts\n self.r_neighbor = self.curr_x_min_ip\n\n if self.l_neighbor == '':\n #there isnt a left neighbor - left neighbor is right neighbor\n self.l_neighbor = self.r_neighbor\n # need to start the listening thread and the work thread now\n listening_thread = Thread(target=lambda: self.listeningPort())\n listening_thread.daemon = True\n listening_thread.start()\n work_thread = Thread(target=lambda: self.processWork())\n work_thread.daemon = True\n work_thread.start()\n else:\n print('Invalid message type received from ' + message.origin)","def connect(self, node1, node2):\n self.neighbour1 = node1\n self.neighbour2 = node2","def connect_to_player(player_id, remote_IP='127.0.0.1', verbose=False): \n \n # init verbose display\n if verbose:\n print '\\n-------------------------------------------------------------'\n \n # open socket (as server) to receive orders\n socket_in = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n socket_in.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if remote_IP == '127.0.0.1':\n local_IP = '127.0.0.1'\n else:\n local_IP = get_IP()\n local_port = 42000 + (3-player_id)\n \n try:\n if verbose:\n print 'binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\n socket_in.bind((local_IP, local_port))\n except:\n local_port = 42000 + 100+ (3-player_id)\n if verbose:\n print ' referee detected, binding instead on %s:%d...' % (local_IP, local_port)\n socket_in.bind((local_IP, local_port))\n\n socket_in.listen(1)\n if verbose:\n print ' done -> now waiting for a connection on %s:%d\\n' % (local_IP, local_port)\n\n # open client socket used to send orders\n socket_out = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n socket_out.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n \n remote_port = 42000 + player_id\n \n connected = False\n msg_shown = False\n while not connected:\n try:\n if verbose and not msg_shown:\n print 'connecting on %s:%d to send orders to player %d...' % (remote_IP, remote_port, player_id)\n socket_out.connect((remote_IP, remote_port))\n connected = True\n if verbose:\n print ' done -> now sending orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\n except:\n if verbose and not msg_shown:\n print ' connection failed -> will try again every 100 msec...'\n time.sleep(.1)\n\n msg_shown = True\n \n if verbose:\n print \n\n # accept connection to the server socket to receive orders from remote player\n print 'sutck on accept'\n socket_in, remote_address = socket_in.accept()\n if verbose:\n print 'now listening to orders from player %d' % (player_id)\n \n # end verbose display\n if verbose:\n print '\\nconnection to remote player %d successful\\n-------------------------------------------------------------\\n' % player_id\n\n # return sockets for further use \n return (socket_in, socket_out)","def _setup_connection_info(self, connect_info: dict) -> None:\n\n self.log.debug(f\"Host assigned to the kernel is: '{self.assigned_host}' '{self.assigned_ip}'\")\n\n connect_info['ip'] = self.assigned_ip # Set connection to IP address of system where the kernel was launched\n\n if tunneling_enabled is True:\n # Capture the current(tunneled) connect_info relative to the IP and ports (including the\n # communication port - if present).\n self.tunneled_connect_info = dict(connect_info)\n\n # Open tunnels to the 5 ZMQ kernel ports\n tunnel_ports = self._tunnel_to_kernel(connect_info, self.assigned_ip)\n self.log.debug(f\"Local ports used to create SSH tunnels: '{tunnel_ports}'\")\n\n # Replace the remote connection ports with the local ports used to create SSH tunnels.\n connect_info['ip'] = '127.0.0.1'\n connect_info['shell_port'] = tunnel_ports[0]\n connect_info['iopub_port'] = tunnel_ports[1]\n connect_info['stdin_port'] = tunnel_ports[2]\n connect_info['hb_port'] = tunnel_ports[3]\n connect_info['control_port'] = tunnel_ports[4]\n\n # If a communication port was provided, tunnel it\n if 'comm_port' in connect_info:\n self.comm_ip = connect_info['ip']\n tunneled_comm_port = int(connect_info['comm_port'])\n self.comm_port = self._tunnel_to_port(KernelChannel.COMMUNICATION, self.assigned_ip,\n tunneled_comm_port, self.assigned_ip)\n connect_info['comm_port'] = self.comm_port\n self.log.debug(f\"Established communication to: {self.assigned_ip}:{tunneled_comm_port} \"\n f\"for KernelID '{self.kernel_id}' via tunneled port 127.0.0.1:{self.comm_port}\")\n\n else: # tunneling not enabled, still check for and record communication port\n if 'comm_port' in connect_info:\n self.comm_ip = connect_info['ip']\n self.comm_port = int(connect_info['comm_port'])\n self.log.debug(f\"Established communication to: {self.assigned_ip}:{self.comm_port} \"\n f\"for KernelID '{self.kernel_id}'\")\n\n # If no communication port was provided, record that fact as well since this is useful to know\n if 'comm_port' not in connect_info:\n self.log.debug(f\"Communication port has NOT been established for KernelID '{self.kernel_id}' (optional).\")\n\n self._update_connection(connect_info)","def tcp_server_thread():\n neigbour_sock, neighbour_addr = server.accept()\n my_timestamp = datetime.datetime.utcnow().timestamp()\n packed = struct.pack(\"!d\", my_timestamp)\n neigbour_sock.send(packed)\n pass","def connect_to_player(player_id, remote_IP='127.0.0.1', verbose=False):\n\n # init verbose display\n if verbose:\n print '\\n-------------------------------------------------------------'\n\n # open socket (as server) to receive orders\n socket_in = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n socket_in.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n if remote_IP == '127.0.0.1':\n local_IP = '127.0.0.1'\n else:\n local_IP = get_IP()\n local_port = 42000 + (3-player_id)\n\n try:\n if verbose:\n print 'binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\n socket_in.bind((local_IP, local_port))\n except:\n local_port = 42000 + 100+ (3-player_id)\n if verbose:\n print ' referee detected, binding instead on %s:%d...' % (local_IP, local_port)\n socket_in.bind((local_IP, local_port))\n\n socket_in.listen(1)\n if verbose:\n print ' done -> now waiting for a connection on %s:%d\\n' % (local_IP, local_port)\n\n # open client socket used to send orders\n socket_out = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n socket_out.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\n\n remote_port = 42000 + player_id\n\n connected = False\n msg_shown = False\n while not connected:\n try:\n if verbose and not msg_shown:\n print 'connecting on %s:%d to send orders to player %d...' % (remote_IP, remote_port, player_id)\n socket_out.connect((remote_IP, remote_port))\n connected = True\n if verbose:\n print ' done -> now sending orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\n except:\n if verbose and not msg_shown:\n print ' connection failed -> will try again every 100 msec...'\n time.sleep(.1)\n\n msg_shown = True\n\n if verbose:\n print\n\n # accept connection to the server socket to receive orders from remote player\n print 'sutck on accept'\n socket_in, remote_address = socket_in.accept()\n if verbose:\n print 'now listening to orders from player %d' % (player_id)\n\n # end verbose display\n if verbose:\n print '\\nconnection to remote player %d successful\\n-------------------------------------------------------------\\n' % player_id\n\n # return sockets for further use\n return (socket_in, socket_out)","def sync_remote(self, other):\n pass # TODO","def forward_to_neighbors(self, packet, srcif):\n source_relationship = self.relations[srcif]\n # if update received from a customer: send updates to all other neighbors\n if source_relationship == CUST:\n for neighbor in self.sockets.keys():\n if neighbor != srcif:\n packet[SRCE] = ('.').join(neighbor.split('.', 3)[:3]) + '.1'\n packet[DEST] = neighbor\n sending_msg = json.dumps(packet).encode()\n self.sockets[neighbor].sendall(sending_msg)\n # if update received from a peer or a provider: only send updates to your customers\n else:\n for neighbor in self.sockets.keys():\n if neighbor != srcif and self.relations[neighbor] not in [PROV,PEER]:\n packet[SRCE] = ('.').join(neighbor.split('.', 3)[:3]) + '.1'\n packet[DEST] = neighbor\n sending_msg = json.dumps(packet).encode()\n self.sockets[neighbor].sendall(sending_msg)","def setupHostConnection(self, host_ip):\n if host_ip != self.ip and host_ip != '':\n host_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n indicator = host_socket.connect_ex((host_ip, 9090))\n if indicator != 0:\n return False\n else:\n new_host_msg = Message(\"NHST\", self.ip, '\\0')\n host_socket.sendall(new_host_msg.generateByteMessage())\n print('NHST message sent to Host at ' + host_ip)\n area_message = self.parseMessage(host_socket)\n if(area_message.type == 'AREA'):\n print('AREA message received from ' + area_message.origin)\n payload_array = area_message.payload.split(':')\n curr_host_ip = area_message.origin\n host_min_x = int(payload_array[0])\n host_max_x = int(payload_array[1])\n self.x_min = host_max_x\n self.x_max = self.x_min + 50\n if host_max_x > self.curr_x_max:\n self.curr_x_max = host_max_x\n if self.x_min == host_max_x:\n self.l_neighbor = curr_host_ip\n if host_min_x <= self.curr_x_min:\n self.curr_x_min = host_min_x\n self.curr_x_min_ip = curr_host_ip\n new_thread = Thread(target=lambda: self.listenToHost(host_socket))\n new_thread.daemon = True\n new_thread.start()\n new_connection = Connection(host_ip, host_socket, new_thread)\n self.connections.append(new_connection)\n return True\n else:\n print('Invalid message type received from ' + area_message.origin + ' - Host corrupt')\n return False\n return True","def sending():\n # don't use socket.connect because it fixes a\n # remote address and causes problems when receiving\n # from other sockets and sending to them\n\n # we also need to cater for sending normal data\n\n global DATA\n start = current_time()\n while True:\n if(current_time() - start) < 10:\n time.sleep(2)\n continue\n else:\n data_to_send = pickle.dumps(DATA[\"distance_vec\"])\n for every_neighbor in DATA[\"neighbor\"]:\n send_address = (\"127.0.0.1\", every_neighbor[2])\n SOCKET1.sendto(data_to_send, send_address)\n start = current_time()","def send_update(self, neighbor):\n message = 'ROUTE UPDATE'\n source = ':'.join([self.name[0], str(self.name[1])])\n dv = []\n for others in self.distance_vector:\n others_sep = others.split(':')\n dv.append(','.join([others_sep[0], others_sep[1], str(self.distance_vector[others].cost)]))\n dv = '\\n'.join(dv)\n to_send = '\\n'.join([message, source, dv])\n neighbor.sok.sendto(to_send, (neighbor.addr, neighbor.port))\n neighbor.send_timer = time.time()\n neighbor.update_ready = False","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)","def set_neighbor(self):\n for node in self.node:\n for other in self.node:\n if other.id != node.id and distance.euclidean(node.location, other.location) <= node.com_ran:\n node.neighbor.append(other.id)","def connect_ports(self, port1_name: str, ip1_name: str,\n port2_name: str, ip2_name: str):\n if (ip1_name not in self._ips.keys() or\n ip2_name not in self._ips.keys()):\n raise ValueError(\n f'No such IP in this module: {ip1_name}, {ip2_name}.'\n ' Use add_ip method to add the IPs first')\n # get the 'WrapperPort's\n port1 = self._ips[ip1_name].get_port_by_name(port1_name)\n port2 = self._ips[ip2_name].get_port_by_name(port2_name)\n\n if len(port1) != len(port2):\n warning(f'ports: {ip1_name}:{port1.name}({len(port1)}), '\n f'{ip2_name}:{port2.name}({len(port2)})'\n ' have different widths!')\n\n inst1_args = getattr(self, ip1_name)\n inst2_args = getattr(self, ip2_name)\n\n full_name1 = port_direction_to_prefix(port1.direction) + port1.name\n full_name2 = port_direction_to_prefix(port2.direction) + port2.name\n\n # If a port was connected previoulsy,\n # take the previoulsy created signal, instead of creating a new one\n if full_name1 in inst1_args.keys():\n sig = inst1_args[full_name1]\n elif full_name2 in inst2_args.keys():\n sig = inst2_args[full_name2]\n else:\n # neither of the ports was connected previously\n # create a new signal for the connection\n combined_name = port1.name + '_' + port2.name\n self._signals_between_ips.append(combined_name)\n sig = Signal(len(port1), name=combined_name)\n setattr(self, combined_name, sig)\n\n inst1_args[full_name1] = sig\n inst2_args[full_name2] = sig","def Connect(self):\r\n #sleep(1)\r\n #self.src_ref = randint(1, 20)\r\n self.src_ref = 10\r\n self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n self.s.settimeout(self.timeout)\r\n self.s.connect((self.ip, self.port))\r\n self.s.send(TPKTPacket(COTPConnectionPacket(self.dst_ref,\r\n self.src_ref,\r\n self.dst_tsap,\r\n self.src_tsap,\r\n 0x0a)).pack())\r\n reply = self.s.recv(1024)\r\n _ = COTPConnectionPacket().unpack(TPKTPacket().unpack(reply).data)\r\n\r\n self.NegotiatePDU()","def other_parse(neighbor):\n mgmt_ip = neighbor[mgmt_ip_s]\n hostname = neighbor[hostname_s].split('.')[0]\n if nxos:\n sysname = neighbor['sysname']\n if sysname != '':\n hostname = sysname\n if mgmt_ip == '':\n mgmt_ip = neighbor['interface_ip']\n software_version = neighbor[version_s]\n if software_version.__contains__(','):\n for software in software_version.split(','):\n if software.__contains__('Version'):\n software_version = software.split('Version')[1].split('REL')[0]\n if software_version.__contains__(':'):\n software_version = software_version.replace(': ', '')\n else:\n software_version = software_version.replace(' ', '')\n break\n elif software_version.__contains__('Version'):\n found_1 = False\n for x in software_version.split(' '):\n if x.__contains__('Version'):\n found_1 = True\n continue\n if found_1:\n software_version = x\n break\n elif software_version.__contains__('version'):\n found_1 = False\n for x in software_version.split(' '):\n if x.__contains__('version'):\n found_1 = True\n continue\n if found_1:\n software_version = x\n break\n platform = neighbor['platform']\n if platform.__contains__('cisco '):\n platform = neighbor['platform'].replace('cisco ', '')\n elif platform.__contains__('Cisco '):\n platform = neighbor['platform'].replace('Cisco ', '')\n else:\n platform = neighbor['platform']\n other = {\n 'hostname': hostname,\n 'ip_address': mgmt_ip,\n 'neighbor': {\n 'hostname': session.hostname,\n 'ip_address': session.ip_address,\n 'remote_intf': neighbor['local_port'],\n 'local_intf': neighbor['remote_port']\n },\n 'software_version': software_version,\n 'model': platform\n }\n self.others.append(other)","def share_config_with_other_nodes(self):\n my_host, _ = self.experiment.get_peer_ip_port_by_id(self.experiment.my_id)\n other_hosts = set()\n for peer_id in self.experiment.all_vars.keys():\n host = self.experiment.all_vars[peer_id]['host']\n if host not in other_hosts and host != my_host:\n other_hosts.add(host)\n self._logger.info(\"Syncing config with host %s\", host)\n os.system(\"rsync -r --delete /home/martijn/hyperledger-deploy-scripts martijn@%s:/home/martijn/\" % host)","def connect_one_way(node1, node2, weight):\n node1.add_or_update_neighbour(node2, weight)","def onConnecting(self, transport_details):","def callback(self):\n server_addresses = self._address_book.list_by_key(key)\n for address in server_addresses:\n if self._client_logic.connection_error.is_set():\n try:\n connection = socket.create_connection((address[0], 9665))\n self.sident_verify(connection, v_event)\n except socket.error:\n continue\n else:\n return True\n neighbor_addresses = self._client_list.list()\n for address in neighbor_addresses:\n if self._client_logic.connection_error.is_set():\n try:\n connection = socket.create_connection((address[0], address[1]))\n \n\n def sident_verify(self, connection):\n \"\"\"Request the server send a signed verification of its identity with \n IP address, port and timestamp.\n\n sident stands for 'Server Identity'\n\n An sident_verify message is of the following form:\n\n {'type':'sident_verify'\n 'timestamp':<UNIX TIMESTAMP>}\n\n The server should reply with an sident_response message which is of\n the following form:\n\n {'type':'sident_response',\n 'ip_addr':<IP ADDRESS AS A STRING>,\n 'port':<PORT NUMBER AS AN INTEGER>,\n 'timestamp':<UNIX TIMESTAMP>,\n 'signature':<SIGNED DIGEST OF THE THREE PREVIOUS VALUES AS A UTF-8 STRING \n CONCATENATED TOGETHER WITH COMMA SEPERATORS>}\"\"\"\n sident_verify_msg = {'type':'sident_verify',\n 'timestamp':calendar.timegm(time.gmtime())}\n self._send_queue.put((sident_verify_msg, connection))\n return True\n\n def request_server_address(self, connection):\n \"\"\"Request the best guess at the current server address from a client\n peer. \n\n P2P nodes use the same JSON messaging style as the normal client and\n server. address_request messages are of the form:\n\n {'type':'address_request'\n 'timestamp':<UNIX TIMESTAMP>}\n\n And a server_address message is of the form:\n\n {'type':'server_address',\n 'key':<CRYPTOGRAPHIC KEY THAT UNIQUELY IDENTIFIES SERVER>,\n 'address':<SERVER ADDRESS>,\n 'port':<WHAT PORT THE SERVER LISTENS ON>,\n 'address_timestamp':<UNIX TIMESTAMP OF WHEN PEER RECEIVED ADDRESS>,\n 'signature':<VERIFICATION THAT INFORMATION CAME FROM SERVER ORIGINALLY>,\n 'timestamp':<UNIX TIMESTAMP OF WHEN MESSAGE WAS SENT>}\"\"\"\n address_request = {'type':'sident_verify',\n 'timestamp':calendar.timegm(time.gmtime())}\n self._send_queue.put((address_request, connection))\n return True\n \n\n def send_loop(self):\n \"\"\"Send loop that is meant to be started from a seperate thread of \n execution. The send loop pulls 'raw' python object messages from this \n objects send_queue attribute and converts them to json strings before \n encoding them as utf-8 to send across the wire. Sent along with the \n message is the connection to send it on.\n\n Responses are handled and received by the receive_loop method of this class\n which is ran in a seperate thread of execution.\"\"\"\n while not self._shutdown.is_set():\n message_tuple = self._send_queue.get()\n message = message_tuple[0]\n message_length = self._calculate_recursive_length(message)\n wrapped_message = [message_length, message]\n wire_message = (json.dumps(wrapped_message) + \"\\r\\n\\r\\n\").encode('utf-8')\n message_tuple[1].sendall(wire_message)\n return True\n\n def receive_loop(self):\n \"\"\"Receive loop that is meant to be started from a seperate thread of\n execution. The receive loop takes in 'raw' utf-8 json messages from the\n wire and decodes them, then interprets them to produce native python \n objects. The resulting objects are then handled by a method of this class\n of the form handle_<message_type>. For example if a message with the \n 'type' key 'test' came in like so:\n\n {'type':'test'}\n\n The method self.handle_test(message) would be called with the message\n dictionary object passed along.\n \"\"\"\n msg_buffer = bytes() # The message input buffer\n while not self._shutdown.is_set():\n if msg_buffer:\n try:\n msg_length = self.determine_length_of_json_msg(msg_buffer)\n except InvalidLengthHeader:\n msg_length = float(\"inf\")\n if len(msg_buffer) >= msg_length:\n message = self.extract_msg(msg_buffer, msg_length)\n try:\n handler = getattr(self, \"handle_\" + message['type'])\n except AttributeError:\n print(\"Can't handle message of type: \" +\n str(message['type']))\n continue\n handler(message)\n msg_buffer = msg_buffer[msg_length:]\n else:\n try:\n msg_buffer += connection.recv(1024)\n except socket.timeout:\n pass\n else:\n try:\n msg_buffer += connection.recv(1024)\n except socket.timeout:\n pass\n \n def handle_sident_response(message):\n \"\"\"Handle an sident_response type message of the form:\n \n {'type':'sident_response',\n 'ip_addr':<IP ADDRESS AS A STRING>,\n 'port':<PORT NUMBER AS AN INTEGER>,\n 'timestamp':<UNIX TIMESTAMP>,\n 'signature':<SIGNED DIGEST OF THE THREE PREVIOUS VALUES AS A UTF-8 STRING \n CONCATENATED TOGETHER WITH COMMA SEPERATORS>}\n \n The handler verifies that the information given by the server is properly\n signed, then adds the information to address books/etc, and finally \n resolves the issue using provided client logic methods and clears the \n error indicator.\"\"\"\n if self._client_logic.connection_error.is_set():\n try:\n ip_addr = message['ip_addr']\n port = message['port']\n timestamp = message['timestamp']\n signature = message['signature']\n except KeyError:\n return False\n sha_hash = SHA256.new(\n (ip_addr + \",\" + port + \",\" + timestamp).encode('utf-8'))\n if self._key.verify(sha_hash.digest(), signature):\n self._address_book.add_address(self._key, ip_addr, timestamp,\n signature, port=port)\n self._address_book.save()\n if self._client_logic.reconnect(ip_addr, port):\n self._client_logic.connection_error.clear()\n return True\n else:\n return False\n else:\n return False\n\n \n def determine_length_of_json_msg(self, message_bytes):\n \"\"\"Incrementally parse a JSON message to extract the length header.\n\n message_bytes: The bytes that represent the portion of the message \n recieved.\n \"\"\"\n # All messages must be written in utf-8\n message = message_bytes.decode('utf-8')\n # Check that the message we have been given looks like a valid length header\n if \",\" not in message:\n raise InvalidLengthHeader(message)\n length_portion = message.split(\",\")[0]\n left_bracket = length_portion[0] == \"[\"\n number_before_comma = length_portion[-1] in \"1234567890\"\n if left_bracket and number_before_comma:\n for character in enumerate(length_portion):\n if character[1] not in \"[ \\n\\t\\r1234567890,\":\n raise InvalidLengthHeader(length_portion)\n elif character[1] in \"1234567890\":\n length_start = character[0]\n return int(length_portion[length_start:])\n elif left_bracket:\n raise InvalidLengthHeader(length_portion)\n else:\n raise MissingLengthHeader(length_portion)\n return False\n\n def extract_msg(self, msg_buffer, length):\n message = msg_buffer[:length].decode()\n try:\n right_curly_bracket = message[-6] == \"}\" or message[-2] == \"}\"\n except IndexError:\n print(message, msg_buffer, length)\n valid_delimiter = message[-6:] == \"}]\\r\\n\\r\\n\"\n if right_curly_bracket and valid_delimiter:\n return message\n elif right_curly_bracket:\n raise InvalidMessageDelimiter(message)\n else:\n raise MissingMessageDelimiter(message)\n\n def _calculate_recursive_length(self, msg_dict):\n \"\"\"Calculate the length of a dictionary represented as JSON once a length\n field has been added as a key.\"\"\"\n delimiter = \"\\r\\n\\r\\n\"\n initial_length = len(\n json.dumps(msg_dict) + delimiter)\n initial_list = [initial_length, msg_dict]\n recursive_length = len(\n json.dumps(initial_list) + delimiter)\n recursive_list = [recursive_length, msg_dict]\n while len(json.dumps(recursive_list) + delimiter) != recursive_list[0]:\n recursive_length = len(\n json.dumps(recursive_list) + delimiter)\n recursive_list = [recursive_length, msg_dict]\n return recursive_list[0]","def test_ping_from_neighbor(duthosts, enum_rand_one_per_hwsku_frontend_hostname, nbrhosts):\n duthost = duthosts[enum_rand_one_per_hwsku_frontend_hostname]\n cfg_facts = duthost.config_facts(host=duthost.hostname, source=\"running\")[\"ansible_facts\"]\n dut_ports = cfg_facts[\"PORT\"]\n portchannel_itfs = cfg_facts[\"PORTCHANNEL_INTERFACE\"]\n for portchannel, ip_list in list(portchannel_itfs.items()):\n portchannel_members = list(cfg_facts[\"PORTCHANNEL_MEMBER\"][portchannel].keys())\n hostname = dut_ports[portchannel_members[0]]['description'].split(':')[0]\n for nbr_hostname, nbrhost in list(nbrhosts.items()):\n if nbr_hostname != hostname:\n continue\n for ip in ip_list:\n ip = ip.split('/')[0]\n pytest_assert(nbrhost['host'].ping_dest(ip), \"{} ping port channel {} failed\".format(nbr_hostname, ip))","def test_reconnect_another(self):\n line, head = self._get_line()\n self.tool.connect(line, head, (120, 50))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n item = cinfo.connected\n port = cinfo.port\n constraint = cinfo.constraint\n\n assert item == self.box1\n assert port == self.box1.ports()[0]\n assert item != self.box2\n\n # connect to box2, handle's connected item and connection data\n # should differ\n self.tool.connect(line, head, (120, 150))\n cinfo = self.canvas.get_connection(head)\n assert cinfo is not None\n self.assertEqual(self.box2, cinfo.connected)\n self.assertEqual(self.box2.ports()[0], cinfo.port)\n\n # old connection does not exist\n self.assertNotEqual(item, cinfo.connected)\n self.assertNotEqual(constraint, cinfo.constraint)","def test_connectivity(self):\n vlan_net1 = helpers.get_not_used_vlan(self.tester.bridge, VLAN_RANGE)\n vlan_net2 = helpers.get_not_used_vlan(self.tester.bridge, VLAN_RANGE)\n trunk_mac = net.get_random_mac('fa:16:3e:00:00:00'.split(':'))\n sub_port_mac = net.get_random_mac('fa:16:3e:00:00:00'.split(':'))\n sub_port_segmentation_id = helpers.get_not_used_vlan(\n self.tester.bridge, VLAN_RANGE)\n LOG.debug(\"Using %(n1)d vlan tag as local vlan ID for net1 and %(n2)d \"\n \"for local vlan ID for net2\", {\n 'n1': vlan_net1, 'n2': vlan_net2})\n self.tester.set_peer_tag(vlan_net1)\n self.trunk_manager.create_trunk(self.trunk.trunk_id,\n self.trunk.port_id,\n trunk_mac)\n\n # tag the patch port, this should be done by the ovs agent but we mock\n # it for this test\n conn_testers.OVSBaseConnectionTester.set_tag(\n self.trunk.patch_port_int_name, self.tester.bridge, vlan_net1)\n\n self.tester.wait_for_connection(self.tester.INGRESS)\n self.tester.wait_for_connection(self.tester.EGRESS)\n\n self.tester.add_vlan_interface_and_peer(sub_port_segmentation_id,\n self.net2_cidr)\n conn_testers.OVSBaseConnectionTester.set_tag(\n self.tester._peer2.port.name, self.tester.bridge, vlan_net2)\n\n sub_port = trunk_manager.SubPort(self.trunk.trunk_id,\n uuidutils.generate_uuid(),\n sub_port_mac,\n sub_port_segmentation_id)\n\n self.trunk_manager.add_sub_port(sub_port.trunk_id,\n sub_port.port_id,\n sub_port.port_mac,\n sub_port.segmentation_id)\n # tag the patch port, this should be done by the ovs agent but we mock\n # it for this test\n conn_testers.OVSBaseConnectionTester.set_tag(\n sub_port.patch_port_int_name, self.tester.bridge, vlan_net2)\n\n self.tester.wait_for_sub_port_connectivity(self.tester.INGRESS)\n self.tester.wait_for_sub_port_connectivity(self.tester.EGRESS)\n\n self.trunk_manager.remove_sub_port(sub_port.trunk_id,\n sub_port.port_id)\n self.tester.wait_for_sub_port_no_connectivity(self.tester.INGRESS)\n self.tester.wait_for_sub_port_no_connectivity(self.tester.EGRESS)\n\n self.trunk_manager.remove_trunk(self.trunk.trunk_id,\n self.trunk.port_id)\n self.tester.wait_for_no_connection(self.tester.INGRESS)","def get_temporal_neighbor(self, source_nodes, timestamps, n_neighbors=20):\n assert (len(source_nodes) == len(timestamps))\n\n tmp_n_neighbors = n_neighbors if n_neighbors > 0 else 1\n \n # ALL interactions described in these matrices are sorted in each row by time\n neighbors = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.int32) # each entry in position (i,j) represent the id of the item targeted by user src_idx_l[i] with an interaction happening before cut_time_l[i]\n edge_times = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.float32) # each entry in position (i,j) represent the timestamp of an interaction between user src_idx_l[i] and item neighbors[i,j] happening before cut_time_l[i]\n edge_idxs = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.int32) # each entry in position (i,j) represent the interaction index of an interaction between user src_idx_l[i] and item neighbors[i,j] happening before cut_time_l[i]\n\n for i, (source_node, timestamp) in enumerate(zip(source_nodes, timestamps)):\n # extracts all neighbors, interactions (i.e. edges) indexes and timestamps of ALL interactions of source_nodes happening before their corresponding cut_time (i.e. timestamps)\n source_neighbors, source_edge_idxs, source_edge_times = self.find_before(source_node, timestamp)\n\n if len(source_neighbors) > 0 and n_neighbors > 0:\n \n if self.uniform: # if we are applying uniform sampling, shuffles the data above before sampling\n \n sampled_idx = np.random.randint(0, len(source_neighbors), n_neighbors) # random sample n_neighbors temporal neighbors\n\n neighbors[i, :] = source_neighbors[sampled_idx]\n edge_times[i, :] = source_edge_times[sampled_idx]\n edge_idxs[i, :] = source_edge_idxs[sampled_idx]\n\n # re-sort based on time cuz provided source_nodes are not sorted yet\n # so that neighbors, edge_times, and edge_idxs are all sorted by time\n pos = edge_times[i, :].argsort()\n neighbors[i, :] = neighbors[i, :][pos]\n edge_times[i, :] = edge_times[i, :][pos]\n edge_idxs[i, :] = edge_idxs[i, :][pos]\n \n else:\n \n # Take most recent n_neighbors interactions\n source_edge_times = source_edge_times[-n_neighbors:]\n source_neighbors = source_neighbors[-n_neighbors:]\n source_edge_idxs = source_edge_idxs[-n_neighbors:]\n\n assert (len(source_neighbors) <= n_neighbors)\n assert (len(source_edge_times) <= n_neighbors)\n assert (len(source_edge_idxs) <= n_neighbors)\n\n neighbors[i, n_neighbors - len(source_neighbors):] = source_neighbors\n edge_times[i, n_neighbors - len(source_edge_times):] = source_edge_times\n edge_idxs[i, n_neighbors - len(source_edge_idxs):] = source_edge_idxs\n\n return neighbors, edge_idxs, edge_times","def shared_cost_peering(self, as1, as2):\n self._connect_ases(as1, as2)\n set_community(self, as1, as2.asn, str(as1.asn) + ':1337')\n set_community(self, as2, as1.asn, str(as2.asn) + ':1337')","def create_connection(your_group, other_group=0, other_IP='127.0.0.1', verbose=False):\r\n \r\n # init verbose display\r\n if verbose:\r\n print('\\n[--- starts connection -----------------------------------------------------\\n')\r\n \r\n # check whether there is a referee\r\n if other_group == 0:\r\n if verbose:\r\n print('** group %d connecting to referee on %s **\\n' % (your_group, other_IP))\r\n \r\n # create one socket (client only)\r\n socket_out = create_client_socket(other_IP, 42000+your_group, verbose)\r\n \r\n connection = {'in':socket_out, 'out':socket_out}\r\n \r\n if verbose:\r\n print('** group %d successfully connected to referee on %s **\\n' % (your_group, other_IP))\r\n else:\r\n if verbose:\r\n print('** group %d connecting to group %d on %s **\\n' % (your_group, other_group, other_IP))\r\n\r\n # create two sockets (server and client)\r\n socket_in = create_server_socket(42000+your_group, verbose)\r\n socket_out = create_client_socket(other_IP, 42000+other_group, verbose)\r\n \r\n socket_in = wait_for_connection(socket_in, verbose)\r\n \r\n connection = {'in':socket_in, 'out':socket_out}\r\n\r\n if verbose:\r\n print('** group %d successfully connected to group %d on %s **\\n' % (your_group, other_group, other_IP))\r\n \r\n # end verbose display\r\n if verbose:\r\n print('----------------------------------------------------- connection started ---]\\n')\r\n\r\n return connection","def link_interface(other_endpoint: str, interface: Tuple[str, str]):\n # I will be the sender\n sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)\n listen, receiver = interface\n sock.bind((listen, port))\n rtts = list()\n\n # to make sure other endpoint is active and listening\n # we will wait it to send a sign byte\n sock.recv(1)\n # recieved byte is not important\n # not necessary to read what it is\n for _ in range(message_count):\n # create a packet and send it to receiver\n sock.sendto(create_packet(), (receiver, port))\n # wait for acknowledgement\n recv_msg = sock.recv(buffer_size)\n # extract timestamp\n ts, _ = parse_packet(recv_msg)\n # calculate rtt and store\n rtts.append(time.time() - ts)\n\n tot_rtt = 0\n for rtt in rtts:\n tot_rtt += rtt\n avg_rtt = tot_rtt / message_count\n\n file_lock.acquire()\n with open('link_costs.txt', 'a') as file:\n # r2-r1=avg_rtt ; d-r1=avg_rtt\n file.write(f'{other_endpoint}-{endpoint}={avg_rtt}\\n')\n file_lock.release()","def route_update(self, neighbor, dv_list):\n neighbor.is_killed = False\n neighbor.kill_timer = time.time()\n neighbor.dv_update(dv_list)\n # Iterate to see if new node is included in the graph.\n for name in neighbor.distance_vector:\n if name not in self.distance_vector:\n self.distance_vector[name] = Router.OtherRouter(float('Inf'), None)\n if self.update_dv():\n for name in self.neighbors:\n self.neighbors[name].update_ready = True\n self.neighbors[name].send_timer = time.time()","def main():\n parser = ArgumentParser()\n parser.add_argument(\"router_id\", help=\"id of the router\")\n parser.add_argument(\"port_no\", help=\"port no. at which the\\\n router is listening\", type=int)\n parser.add_argument(\"router_config_file\", help=\"configuration\\\n file for the router\")\n args = parser.parse_args()\n DATA[\"port\"] = args.port_no\n DATA[\"router_id\"] = args.router_id\n read_config_file(args.router_config_file)\n\n # after the read_config_file func completes we set a variable\n # saying that neighbor data is ready\n global READ_CONFIG_COMP\n READ_CONFIG_COMP = True\n\n initial_dvec_and_forw_insert()\n\n SOCKET1.bind((\"\", DATA[\"port\"])) # converts the port to a listening state\n # print(DATA['neighbor'])\n\n # read thread is listening for incoming messages\n recv_th = Thread(target=recving)\n recv_th.start()\n\n # sending thread sends its distance vector to its direct neighbors\n send_th = Thread(target=sending)\n send_th.start()\n\n # link cost change interface thread\n intf_th = Thread(target=interface_thread, args=(\n args.router_config_file, ), daemon=True)\n intf_th.start()\n\n # find thread is checking if every router is available/alive\n find_th = Thread(target=check_if_alive, daemon=True)\n find_th.start()\n\n # we don't need thread.join because all of our threads\n # are non daemon threads\n\n # SOCKET1.close()\n return","def connect_peers(self):\n assert self.targets\n # connect closest node to target id\n for t in self.targets:\n if len(self.connections) >= self.max_peers:\n break\n for knode in self.proto.routing.neighbours(devp2p.kademlia.Node.from_id(t['address'])):\n assert isinstance(knode, devp2p.kademlia.Node)\n # assure within tolerance\n if knode.id_distance(t['address']) < t['tolerance']:\n # make sure we are not connected yet\n remote = self.network[knode.id]\n if remote not in self.connections:\n if remote.receive_connect(self):\n t['connected'] = True\n self.connections.append(remote)\n break","def tcp_time_updatetime(localport):\r\n\r\n # Get the ips and ports of servers hosting time_server.repy, retrying nine\r\n # times if there is an exception.\r\n gotval = False\r\n attemptretrieval = 0\r\n while attemptretrieval < 2:\r\n try:\r\n serveraddresses = advertise_lookup(\"time_server\")\r\n except Exception:\r\n attemptretrieval = attemptretrieval + 1\r\n sleep(2) # Look up the value again in 10 seconds\r\n else:\r\n if serveraddresses != [] and serveraddresses[0] != '':\r\n gotval = True\t # Successfully obtained the value\r\n break\r\n else:\r\n attemptretrieval = attemptretrieval + 1\r\n\r\n\r\n if not gotval:\r\n raise Exception(\"Unable to locate any servers running time_server.repy\")\r\n\r\n\r\n timelength = 25 # Max length of string, representing the time, to be received\r\n shuffledserveraddresses = random_sample(serveraddresses,min(len(serveraddresses),5))\r\n\r\n # Open a connection with a random server hosting time_server.repy\r\n timeobtained = False\r\n serverindex = 0\r\n while serverindex < len(shuffledserveraddresses):\r\n remoteaddress = shuffledserveraddresses[serverindex].split(':')\r\n remoteip = remoteaddress[0]\r\n remoteport = int(remoteaddress[1])\r\n\r\n try:\r\n sockobject = timeout_openconn(remoteip,remoteport)\r\n except Exception:\r\n serverindex +=1\r\n else:\r\n timeobtained = True\r\n break\r\n\r\n\r\n if not timeobtained:\r\n raise Exception(\"Unable to open connection with any of the \",len(shuffledserveraddresses),\"servers running time_server.repy.\")\r\n\r\n\r\n currenttime =''\r\n while '$' not in currenttime:\r\n currenttime += sockobject.recv(20)\r\n sockobject.close()\r\n currenttime = float(currenttime[:-1])\r\n\r\n # finally, set the time\r\n time_settime(currenttime)\r\n\r\n return shuffledserveraddresses[serverindex]","def connect(from_tuple, to_tuple):\n\n from_unit, from_port = from_tuple\n to_unit, to_port = to_tuple\n\n to_unit.connect(from_unit, from_port, to_port)","def connect(self, source, target):\r\n connection = (self.coalesce_node(source), self.coalesce_node(target))\r\n self.connections.add(connection)","def __init__(self, destination=None, port=10000, printout=False, ip_change=True):\n if destination and port:\n self.destination_ip = destination\n self.destination_port = port\n else:\n self.destination_ip = get_local_ip()\n self.destination_port = port\n\n self.sending_failed_counter = 0\n self.ip_change = ip_change\n self.printout = printout\n self.destination_address = self.destination_ip, self.destination_port\n print 'OSC-transmitter to', self.destination_ip, ':', self.destination_port\n\n try:\n self.osc_transmitter = OSC.OSCClient()\n self.osc_transmitter.connect(self.destination_address)\n except:\n pass\n self.time_of_last_connect = 0\n self.connection_status = 'disconnected'","def establish_secondary_communication(self):\n # 0. creating socket\n tmp_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\n # Binding to address\n tmp_soc.bind(('0.0.0.0', self.secondary_port))\n tmp_soc.listen(1) # No more than 1 connection\n\n print(\"started second line protocol on port %s\" % (self.port - 1))\n # 1.\n self.send_life_soc, server_addr = tmp_soc.accept()\n\n # 2.\n self.send_life_soc.send(\"NEW_LINE\".encode('utf-8'))\n\n # 3.\n response = self.send_life_soc.recv(self.packet_len).decode('utf-8')\n if response != \"BOOYAH\":\n raise ValueError('Error: Invalid response from server, expecting %s got %s' % (\"NEW_LINE\", response))\n\n print(\"Second line established with server\")","def update(self, remote_gateway_info):\n\n self.touch()\n # remember, don't flag connection stats as worthy of a change.\n self.msg.conn_stats = remote_gateway_info.conn_stats\n # self.msg.last_connection_timestamp = rospy.Time.now() # do we really need this?\n\n # don't update every client, just the ones that we need information from\n important_state = (self.state == ConcertClient.State.AVAILABLE) or (self.state == ConcertClient.State.MISSING)\n is_changed = False\n return is_changed","def _outgoing_connect_cb(self, peer_id, tcp_handle, error):\n\n if error is not None:\n self._logger.error(\n \"unable to establish connction to peer %d\",\n peer_id,\n )\n del self._outgoing[peer_id]\n return\n\n self._outgoing[peer_id] = Outgoing(\n tcp_handle,\n msgpack.Packer(),\n msgpack.Unpacker(),\n self._conf[peer_id],\n {},\n )\n\n tcp_handle.start_read(partial(self._outgoing_read_cb, peer_id))\n self._logger.info(\"connect to peer %d\", peer_id)","def tcp_server_thread(accepted_socket, address):\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\n accepted_socket.sendto(struct.pack('!f', current_timestamp), address)\n accepted_socket.close()\n pass","def connect(self, address: Tuple[str, int]) -> None:\n ...","def addNeighbor(self, neighbor):","def connect_both(node1, node2, weight):\n connect_one_way(node1, node2, weight)\n connect_one_way(node2, node1, weight)","def _make_connection(user=None, friend=None, update=False, updated=[]):\n created = 0\n updated_count = 0\n\n if not update:\n # if we have other connections here:\n conns_inst_to = Degree.objects.filter(to_user=user)\n conns_inst_from = Degree.objects.filter(from_user=user)\n conns_frnd_to = Degree.objects.filter(to_user=friend)\n conns_frnd_from = Degree.objects.filter(from_user=friend)\n #caching results\n pickle_str = cPickle.dumps(conns_inst_to)\n qs1 = cPickle.loads(pickle_str)\n pickle_str = cPickle.dumps(conns_inst_from)\n qs2 = cPickle.loads(pickle_str)\n pickle_str = cPickle.dumps(conns_frnd_to)\n qs3 = cPickle.loads(pickle_str)\n pickle_str = cPickle.dumps(conns_frnd_from)\n qs4 = cPickle.loads(pickle_str)\n # original connection between 2 nodes\n conn, created_conn = Degree.objects.get_or_create(from_user=user, to_user=friend)\n conn.path = \"%s,%s\" % (user.id, friend.id)\n if not created_conn:\n conn.distance = 0\n update = True\n if {'user':user,'friend':friend} not in updated:\n updated.append({'user':user,'friend':friend})\n # 2 way connection\n reverse_conn, created_reverse_conn = Degree.objects.get_or_create(from_user=friend, to_user=user)\n reverse_conn.path = \"%s,%s\" % (friend.id, user.id)\n if not created_reverse_conn:\n reverse_conn.distance = 0\n update = True\n if {'user':user,'friend':friend} not in updated:\n updated.append({'user':user,'friend':friend})\n\n # saving\n conn.save()\n reverse_conn.save()\n\n\n if update:\n while updated:\n \"\"\"\n OPTIMIZE:\n maybe we could check only half of neighbours\n since we adding reverse connections to updated list\n this is not necessary\n logic here:\n #check all neighbours\n #new shortest path ?\n #yes->update check again\n \"\"\"\n #wile looop\n #import pdb;pdb.set_trace()\n updating = updated.pop()\n user = updating.get('user')\n friend = updating.get('friend')\n current = Degree.objects.get(from_user=user, to_user=friend)\n current_rev = Degree.objects.get(from_user=friend, to_user=user)\n\n neigh_inst_from = Degree.objects.filter(from_user=user, distance=0)\n # find all connections from my neighbours to newly friend\n # if distance > 1, fix\n if neigh_inst_from.count() > 0:\n for neigh in neigh_inst_from:\n try:\n conn_neigh = Degree.objects.get(to_user=friend, from_user=neigh.to_user)\n # if distance greater than current + 1\n if conn_neigh.distance > current.distance + 1:\n conn_neigh.distance = current.distance + 1\n # path should be traversed through user\n #conn_neigh.path = \"%s,%s,%s\" % (neigh.to_user.id, user.id, friend.id)\n conn_neigh.path = \"%s,%s\" % (neigh.to_user.id, current.path)\n conn_neigh.save()\n # adding to queue current pair\n if {'user':neigh.to_user,'friend':friend} not in updated:\n updated.append({'user':neigh.to_user,'friend':friend})\n updated_count += 1\n except Degree.DoesNotExist:\n continue\n # since there can be new connection\n\n neigh_inst_to = Degree.objects.filter(to_user=user, distance=0)\n if neigh_inst_to.count() > 0:\n for neigh in neigh_inst_to:\n try:\n conn_neigh = Degree.objects.get(to_user=neigh.from_user, from_user=friend)\n if conn_neigh.distance > current_rev.distance + 1:\n conn_neigh.distance = current_rev.distance + 1\n #conn_neigh.path = \"%s,%s,%s\" % (friend.id, user.id, neigh.from_user.id)\n conn_neigh.path = \"%s,%s\" % (current_rev.path, neigh.from_user.id)\n conn_neigh.save()\n if {'user':friend,'friend':neigh.from_user} not in updated:\n updated.append({'user':friend,'friend':neigh.from_user})\n updated_count += 1\n except Degree.DoesNotExist:\n continue\n\n # This will fire on reverse connections\n\n neigh_friend_from = Degree.objects.filter(from_user=friend, distance=0)\n if neigh_friend_from.count() > 0:\n for neigh in neigh_friend_from:\n try:\n conn_neigh = Degree.objects.get(to_user=user, from_user=neigh.to_user)\n if conn_neigh.distance > current_rev.distance + 1:\n conn_neigh.distance = current_rev.distance + 1\n #conn_neigh.path = \"%s,%s,%s\" % (neigh.to_user.id, friend.id, user.id)\n conn_neigh.path = \"%s,%s\" % (neigh.to_user.id, current_rev.path)\n conn_neigh.save()\n if {'user':neigh.to_user,'friend':user} not in updated:\n updated.append({'user':neigh.to_user,'friend':user})\n updated_count += 1\n except Degree.DoesNotExist:\n continue\n\n neigh_friend_to = Degree.objects.filter(to_user=friend, distance=0)\n if neigh_friend_to.count() > 0:\n for neigh in neigh_friend_to:\n try:\n conn_neigh = Degree.objects.get(to_user=neigh.from_user, from_user=user)\n if conn_neigh.distance > current.distance + 1:\n conn_neigh.distance = current.distance + 1\n #conn_neigh.path = \"%s,%s,%s\" % (user.id, friend.id, neigh.from_user.id)\n conn_neigh.path = \"%s,%s\" % (current.path, neigh.from_user.id)\n conn_neigh.save()\n if {'user':user,'friend':neigh.from_user} not in updated:\n updated.append({'user':user,'friend':neigh.from_user})\n updated_count += 1\n except Degree.DoesNotExist:\n continue\n\n logger = logging.getLogger(__name__)\n logger.warning('We updated: %s records, total: %s users' % (updated_count, UserProfile.objects.count()))\n\n\n #!!! This implementation will not work on ALL dependants,\n # since not all dependats have paths traversing through current nodes\n\n\n # find all dependent nodes\n # dependent means current nodes, should be in their paths\n # since we have problems with sqlite, we will use where\n \"\"\"\n dependants = Degree.objects.extra(where=[\"path like '%%\"+str(friend.id)+\"%%\"+str(user.id)+\"%%'\"])\n dependants_reverse = Degree.objects.extra(where=[\"path like '%%\"+str(user.id)+\"%%\"+str(friend.id)+\"%%'\"])\n dependant = dependants.count() + dependants_reverse.count()\n if dependant:\n for dep in dependants:\n dep.path = re.sub(r\"(%s)(?:[,0-9])+(%s)\" % (friend.id,user.id) ,r\"\\1,\\2\", dep.path)\n dep.distance = len(dep.path.split(',')) - 2\n dep.save()\n for dep in dependants_reverse:\n dep.path = re.sub(r\"(%s)(?:[,0-9])+(%s)\" % (user.id,friend.id) ,r\"\\1,\\2\", dep.path)\n dep.distance = len(dep.path.split(',')) - 2\n dep.save()\n\n logger = logging.getLogger(__name__)\n logger.warning('We updated: %s records' % (dependant))\n \"\"\"\n else:\n qs1_count = qs1.count()\n qs2_count = qs2.count()\n qs3_count = qs3.count()\n qs4_count = qs4.count()\n # We only creating connections for current user\n # but we also need connections for all neighbours\n if qs1_count > 0:\n created += qs1_count\n if qs4_count > 0:\n created += (qs1_count) * (qs4_count - 1)\n # we need to create passive connection for every connected user\n for cn in qs1:\n Degree.objects.get_or_create(from_user=cn.from_user,\\\n to_user=friend,\\\n path=\"%s,%s\" % (cn.path, friend.id),\\\n distance = cn.distance + 1)\n # we also need conn's for every neighbour of this user\n for cnn in qs4:\n Degree.objects.get_or_create(from_user=cn.from_user,\\\n to_user=cnn.to_user,\\\n path=\"%s,%s\" % (cn.path, cnn.path),\\\n distance = cn.distance + 1 + cnn.distance + 1)\n\n # and reverse\n if qs2_count > 0:\n created += qs2_count\n if qs3_count > 0:\n created += (qs2_count) * (qs3_count - 1)\n # we need to create passive connection for every connected user\n for cn in qs2:\n Degree.objects.get_or_create(from_user=friend,\\\n to_user=cn.to_user,\\\n path=\"%s,%s\" % (friend.id, cn.path),\\\n distance = cn.distance + 1)\n for cnn in qs3:\n Degree.objects.get_or_create(from_user=cnn.from_user,\\\n to_user=cn.to_user,\\\n path=\"%s,%s\" % (cnn.path, cn.path),\\\n distance = cnn.distance + 1 + cn.distance + 1)\n\n # if we have other connections here:\n if qs3_count > 0:\n created += qs3_count\n if qs2_count > 0:\n created += (qs3_count) * (qs2_count - 1)\n # we need to create passive connection for every connected user\n for cn in qs3:\n Degree.objects.get_or_create(from_user=cn.from_user,\\\n to_user=user,\\\n path=\"%s,%s\" % (cn.path, user.id),\\\n distance = cn.distance + 1)\n for cnn in qs2:\n Degree.objects.get_or_create(from_user=cn.from_user,\\\n to_user=cnn.to_user,\\\n path=\"%s,%s\" % (cn.path, cnn.path),\\\n distance = cn.distance + 1 + cnn.distance + 1)\n # we also want to make reverse connection here,\n # since we dont know who is friended by whoom\n if qs4_count > 0:\n created += qs4_count\n if qs1_count > 0:\n created += (qs4_count) * (qs1_count - 1)\n for cn in qs4:\n Degree.objects.get_or_create(from_user=user,\\\n to_user=cn.to_user,\\\n path=\"%s,%s\" % (user.id, cn.path),\\\n distance = cn.distance + 1)\n for cnn in qs1:\n Degree.objects.get_or_create(from_user=cnn.from_user,\\\n to_user=cn.to_user,\\\n path=\"%s,%s\" % (cnn.path, cn.path),\\\n distance = cnn.distance + 1 + cn.distance + 1)\n # saving later, so we wont able to see new connection above\n # this is not necessary since we caching results above\n # saving above\n\n logger = logging.getLogger(__name__)\n logger.warning('We created: %s new connections, total: %s users' % (created, UserProfile.objects.count()))\n\n return True","def on_inner_dp_join(self, dp):\n ofp = dp.ofproto\n parser = dp.ofproto_parser\n\n #Deletion of already existing OF flows\n LOG.debug('TOPO MNGR: Deleting flow table configuration of newly added forwarder ID: ' + str(dp.id) )\n dp.send_msg(parser.OFPFlowMod(datapath=dp, command=ofp.OFPFC_DELETE))\n dp.send_msg(parser.OFPFlowMod(datapath=dp, command=ofp.OFPFC_DELETE, table_id=OF_GPRS_TABLE))\n #TODO: Shall we wipe-out OFconfig data as well?\n\n\n ##########################\n ## Main table (0)\n ## TODO:change to echo only!\n\n ## Networks self-discovery using icmp messages\n ## Redirect all pings with ipv4_dst=DISCOVERY_IP_DST to controller\n LOG.debug('TOPO MNGR: Installing ICMP topology discovery flows on forwarder: ' + str(dp.id))\n match = parser.OFPMatch(eth_type=0x0800, ip_proto=1, icmpv4_type=8, icmpv4_code=0, ipv4_dst=DISCOVERY_IP_DST)\n actions = [ parser.OFPActionOutput(ofp.OFPP_CONTROLLER) ]\n ##TEST SHAPING ON FWD 11 on port 1 - trying to shape also measurement packets\n self.add_flow(dp, 100, match, actions, 0)\n\n ##Controller uses ARP to resolve mac_addresses of APNs\n ##All arp replies with target IP of DISCOVERY_ARP_IP are redirected to controller\n\n ## FIXED: All ARPs replies are redirected to the controller regardless of the target IP\n ##\n ## TODO: In general we should reply only to ARPs from the APNs subnet, and per APN basis (from the configuration)\n\n LOG.debug('TOPO MNGR: Installing ARP APN discovery flows on forwarder: ' + str(dp.id))\n match = parser.OFPMatch(eth_type=0x0806, arp_op=2, )\n actions = [ parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\n self.add_flow(dp, 100, match, actions)\n\n\n # We match only ethertype, that means all IP packed data should be match\n # It is some kind of flow of last resort, therefore it has small priority\n if dp.id in LAN_TYPE_FORWARDERS:\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + 'is a LAN edge forwarder, installing additional rules' )\n match = parser.OFPMatch(eth_type=0x0800)\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\n self.add_flow(dp, 2, match, actions)\n\n rate = 500\n # all fwds have set of meters\n for i in range(0,11):\n meter_id = i\n if i == 0:\n rate = 100000000\n elif i % 2 == 0:\n rate = 1000\n else:\n rate = 2000\n # KBPS is actually kbps\n meter = {'meter_id': meter_id, 'flags': 'KBPS',\n 'bands': [{'type': 'DROP', 'rate': rate}]}\n self.mod_meter_entry(dp, meter, meter_id, dp.ofproto.OFPMC_ADD)\n LOG.debug(\"FLOW MNGR: Added METER ID: \" + str(i) + \" with rate: \" + str(rate) + \" to FWD ID: \" + str(dp.id) )\n\n\n ##Following rules are applied only on forwarders bellonging to BSS_EDGE_FORWARDER group\n ##Rules are applied based on priority of match (highest priority first)\n if dp.id in BSS_EDGE_FORWARDER:\n\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is an access edge forwarder, installing aditional rules')\n ## UDP 23000 is GPRS-NS and all packets that match this are forwarded to OF_GPRS_TABLE flow table\n inst = [ parser.OFPInstructionGotoTable(OF_GPRS_TABLE) ]\n match = parser.OFPMatch(eth_type=0x0800,ip_proto=inet.IPPROTO_UDP, udp_dst=VGSN_PORT)\n req = parser.OFPFlowMod(datapath=dp, priority=200, match=match, instructions=inst)\n dp.send_msg(req)\n\n ## VGSN_PHY and BSS_PHY ports are bridged -- DHCP, ARP, Abis & stuff\n ## XXX: what if vGSN is not on same forwarder as BSS\n actions = [ parser.OFPActionOutput(VGSN_PHY_PORT) ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n match = parser.OFPMatch(in_port=BSS_PHY_PORT)\n req = parser.OFPFlowMod(datapath=dp, priority=10, match=match, instructions=inst)\n dp.send_msg(req)\n actions = [ parser.OFPActionOutput(BSS_PHY_PORT) ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n match = parser.OFPMatch(in_port=VGSN_PHY_PORT)\n req = parser.OFPFlowMod(datapath=dp, priority=10, match=match, instructions=inst)\n dp.send_msg(req)\n\n\n #################\n ## OF_GPRS-TABLE (2)\n ##TODO: BSS <-> vGSS separate tunnel for communication!\n ##TODO: deletion, modification od PDP CNT\n\n ## if packet is not first segment of user data packet (IS part of sndcp fragmented packet) it's DROPED\n match = parser.OFPMatch( sndcp_first_segment=0 )\n actions = [ ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=200, match=match, instructions=inst)\n dp.send_msg(req)\n\n ## if packet is first segment of SNDCP packet with more than one segment, it's forwarded to controller\n ## when controller recieves such packet it sends ICMP fragmentation_needed to its sender and drops original\n match = parser.OFPMatch( sndcp_first_segment=1, sndcp_more_segments=1 )\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER) ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=200, match=match, instructions=inst)\n dp.send_msg(req)\n\n ##if it's SNDCP packet taht still wasnt matched (rules with higher priority are inserted on PDP CNT activation)\n ##we assume it's packet of unknown PDP CNT and we DROP it\n match = parser.OFPMatch( sndcp_first_segment=1 )\n actions = [ ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=1, match=match, instructions=inst)\n dp.send_msg(req)\n\n ##Everything else is Signalzation and is forwarded either to BSS or vGSN\n # XXX: co ak bss a vgsn nie su spolu na jednom DPID?\n actions = [ parser.OFPActionOutput(VGSN_PHY_PORT) ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n match = parser.OFPMatch(in_port=BSS_PHY_PORT)\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=0, match=match, instructions=inst)\n dp.send_msg(req)\n actions = [ parser.OFPActionOutput(BSS_PHY_PORT) ]\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\n match = parser.OFPMatch(in_port=VGSN_PHY_PORT)\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=0, match=match, instructions=inst)\n dp.send_msg(req)","def remote_connect(self, connID, addr):\r\n assert connID in self._pendingConnections\r\n\r\n # Retrieve the key which should be sent and replace it with None to\r\n # indicate that the key has already been sent\r\n info = self._pendingConnections[connID]\r\n key, auth = info\r\n info[0] = None\r\n\r\n client = ClientCreator(self._reactor, RCEInternalProtocol, self)\r\n d = client.connectTCP(*addr)\r\n d.addCallback(lambda p: p.sendInit(connID, key))\r\n d.addErrback(self._connectError, auth)","def openconnection(self, destip, destport, localip, localport, timeout):\n\n # First try to open a connection using our affix stack. If we get a ConnectionRefusedError\n # or a DuplicateTupleError, then we default to the repy openconnection.\n # We have already created a new stack for the Legacy AFFIX branch and if\n # we did a proper lookup in the root CoordinationAffix, the new stack\n # 'should' only consist of a new CoordinationAffix. Thus we pass in\n # the server name and the tcp port that the Legacy AFFIX branch on the\n # server side is listening on.\n\n # We build a new stack for the branch before doing openconnection.\n self.affix_stack_branch = AffixStack(self.affix_string, self.server_name)\n try:\n if _DEBUG_MODE:\n log(\"LegacyAffix is opening connection to '%s:%d'\\n\" % (self.server_name, self.tcp_listenport))\n\n sockobj = self.affix_stack_branch.peek().openconnection(self.server_name, self.tcp_listenport, localip, localport, timeout)\n return AffixSocket(sockobj, self)\n except (DuplicateTupleError, ConnectionRefusedError):\n pass\n \n # If we failed to use the Legacy AFFIX branch, we try a normal openconnection\n # and try to connect to the legacy branch that is not using AFFIX.\n return openconnection(gethostbyname(destip), destport, gethostbyname(localip), localport, timeout)","def test_new_connection(self):\n with InverterFinder() as finder:\n sock1 = create_connection(('127.0.0.1', 1200))\n sock2, addr = finder.find_inverter()\n # Test if the 2 sockets are paired\n sock2.send(b\"\\x12\")\n self.assertEqual(b\"\\x12\", sock1.recv(1))\n sock1.close()\n sock2.close()","def run(self):\n try:\n source_conn = self.setup_source_db()\n target_conn = self.setup_target_db()\n target_collection = 'oplog' + self._replica_set\n\n while True:\n try:\n # Induce an operation on the replication test database\n db_name = 'ReplTest_' + self._replica_set.upper()\n source_conn[db_name]['operation'].replace_one({'replica': self._replica_set}, {\n 'replica': self._replica_set, 'ts': int(time.time())}, upsert=True)\n\n # Wait a bit for it to replicate\n time.sleep(10)\n\n # check latest oplog of source\n entry = source_conn['local'][\n 'oplog.rs'].find().sort('$natural', -1).limit(1)\n source_oplog = entry[0]['ts'].time\n\n # get latest oplog from connector target oplog collection\n entry = target_conn['__mongo_connector'][\n target_collection].find().sort('_ts', -1).limit(1)\n target_oplog = entry[0]['_ts'] >> 32\n\n lag = source_oplog - target_oplog\n self._stat_client.gauge(self._lag_key, lag)\n\n time.sleep(self._poll_interval)\n except Exception as ex:\n logger.exception('Connection Failed, retrying..')\n time.sleep(5)\n\n except Exception as ex:\n logger.exception('Critical Error, bailing out..')","def add_neighbours(self, router1, router2):\n router1 = self.routers[router1]\n router2 = self.routers[router2]\n\n router1.add_neighbour(router2)\n router2.add_neighbour(router1)","def handle_timer(self):\n\n for dest in self.hosts_to_unused_ports:\n self.hosts_to_unused_ports[dest] = [host for host in self.hosts_to_unused_ports[dest] if api.current_time() != host.time_to_live] \n self.hosts_to_ports[dest] = self.find_minium_latency_unused_ports(self.hosts_to_unused_ports[dest])\n\n #Send the reachable routes (must be less than infinity)\n for dest in self.hosts_to_ports:\n if self.hosts_to_ports[dest].latency < INFINITY: \n distance_vector = self.hosts_to_ports[dest] \n host_latency = distance_vector.latency\n\n distance_vector = self.hosts_to_ports[dest]\n\n # Send normal route packet\n packet = basics.RoutePacket(dest, host_latency)\n self.send(packet, distance_vector.port)\n\n # Send poison packet if POISON_MODE is true\n if self.POISON_MODE == True:\n poison_packet = basics.RoutePacket(dest, INFINITY)\n self.send(poison_packet, distance_vector.port)","def test_two_way_comms(relay_board_name, timeout):\n before = time.time() + timeout\n with connected_socket(relay_board_name, before) as sock:\n timed_write(sock, START_COMMAND + TEST_2_WAY_COMMS, before)\n res = timed_read(sock, before)\n return res2status(res)","def connect(self, ip):\n # Connect to the central server and tell it how many threads we have\n self.central_ip = ip\n join_message = message.Message('pc', self.avail_threads)\n self.send_message(join_message)","def setup(self):\n self.ip = self.client_address[0]\n self.port = self.client_address[1]\n self.connection = self.request #TCP socket object for the client\n self.server.clients[(self.ip, self.port)] = self\n self.server.peers.append((self.connection)) \n for client in self.server.clients:\n print(\"Connected client: \", client)\n\n #for peer in self.server.peers:\n # print(\"Peers: \", peer)","def connect_to_peer(self):\n pass","def _create_special_connections(self):\n\t\tfor connection in self._infoSpecialConnections:\n\t\t\t# List of source cells ids\n\t\t\tsourcesId = self.cellsId[connection[0]][connection[1]]\n\t\t\t# gather the sources all together\n\t\t\tsourcesId = comm.gather(sourcesId,root=0)\n\t\t\tif rank==0: sourcesId = sum(sourcesId,[])\n\t\t\tsourcesId = comm.bcast(sourcesId,root=0)\n\t\t\t# List of taget cells ids\n\t\t\ttargetsId = self.cellsId[connection[2]][connection[3]]\n\t\t\t# Ratio of connection\n\t\t\tconRatio = connection[4]\n\t\t\t# Number of connections\n\t\t\tconNum = int(connection[5])\n\t\t\t# Weight of connections\n\t\t\tconWeight = float(connection[6])\n\t\t\t# Type of synapse\n\t\t\tsynType = connection[7]\n\t\t\t# connect sources to targets\n\t\t\tself._connect(sourcesId,targetsId,conRatio,conNum,conWeight,synType)","def connectToIndexServer():\n\tpeerID = globals.PEER_ID\n\tserverPort = globals.PEER_SERVER_PORT\n\ttry:\n\t\tsock = socket.socket() #socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n\t\tsock.connect((globals.INDEX_SERVER_IP, globals.INDEX_SERVER_PORT))\n\t\tglobals.INDEX_SERVER_CONNECTION = 1\n\texcept socket.error as err:\n\t\tprint(\"- Peer Server: Error connecting to index server!\")\n\t\tglobals.INDEX_SERVER_CONNECTION = -1\n\t\treturn -1\n\t\t\n\tsock.send(pickle.dumps((peerID, serverPort)))\n\tres = sock.recv(80)\n\tres = pickle.loads(res)\n\tif res == peerID:\n\t\treturn sock\n\telse:\n\t\tpeerID = res\n\t\tglobals.PEER_ID = peerID\n\t\treturn sock","def startTwoWayTCP():\r\n print(\"=================================\\n\")\r\n print(\" starting TCP test\")\r\n print(\"\\n=================================\")\r\n os.system(\"iperf3.exe -s -B 11.0.0.50 --logfile Server1.txt\")\r\n os.system(\"iperf3.exe -s -B 11.0.0.51 --logfile Server2.txt\")\r\n os.system(\"iperf3.exe -c 11.0.0.50 -b 0 -B 11.0.0.51 -t 0 -V --logfile Client1.txt\")\r\n os.system(\"iperf3.exe -c 11.0.0.51 -b 0 -B 11.0.0.50 -t 0 -V --logfile Client2.txt\")\r\n time.sleep(0.5)\r\n return isTCPRunning()","async def connect(self, peer_ip, peer_port):\n peer_name = f\"{peer_ip}:{peer_port}\"\n try:\n reader, writer = await open_connection(peer_ip, peer_port)\n self.peers[peer_name] = {\n \"reader\": reader,\n \"writer\": writer,\n \"buffer\": ProtocolBuffer()\n }\n client_coro = create_task(self.connection_handler(peer_name))\n await client_coro\n except CancelledError:\n print(f\"Warning: Task handling connection to {peer_name} canceled.\")\n except NodeDisconnectException:\n print(f\"Warning: Peer {peer_name} disconnected\")\n await self.close_connection(peer_name)\n except ConnectionError:\n print(f\"Error: connection error for peer {peer_name}\")","def __init__(self, local_port, timeout):\n self.name = (socket.gethostbyname(socket.gethostname()), local_port)\n self.name_str = ':'.join([self.name[0], str(self.name[1])])\n self.sok = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\n self.sok.bind(self.name)\n self.timeout = timeout\n self.neighbors = dict()\n self.distance_vector = dict()\n self.distance_vector[self.name_str] = Router.OtherRouter(0., self.name_str)","def accept(self) -> ('RDTSocket', (str, int)): # sever端，被动接受client端连接,非阻塞式等待连接的到来\n conn, addr = RDTSocket(self._rate), None\n #############################################################################\n # TODO: YOUR CODE HERE #\n #############################################################################\n while True:\n print(\"----- Server start listening -------\")\n data_client, addr_client = self.recvfrom(1024)\n print(\"----- Server received -------\")\n data_client = segment.parse(data_client) # 将受到的数据解码\n if data_client.sin == 1: # 收到连接请求\n conn.recvSin = True\n conn.ackNum = data_client.seqNumber + 1\n # print(\"accept:receive connection request!\")\n start_time = time.time()\n conn.sendto(segment(sin=1, ack=1, ackNumber=conn.ackNum).getSegment(), addr_client) # 发sin ack\n # print(\"accept:send sin ack\")\n while True:\n data_client2, addr_client2 = conn.recvfrom(1024)\n self.RTT = time.time() - start_time # 初步确定RTT\n data_client2 = segment.parse(data_client2)\n # if data_client2.sin == 1 and data_client2.ack == 1 and addr_client2 == addr_client and data_client2.seqNumber == self.ackNum: # 收到了原来的地址发来的正确报文\n if data_client2.ack == 1 and data_client2.seqNumber == conn.ackNum and addr_client2 == addr_client: # 收到了原来的地址发来的正确报文\n conn.connectAddr = addr_client # 建立连接\n conn.isConnected = True\n print(\"accept:connection established\")\n conn.status.append('connect')\n self.reset() # 重置socket\n break\n break\n return conn, addr_client\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return conn, addr","def init_neighbor(self, addr, port, weight):\n neighbor_name = ':'.join([addr, str(port)])\n self.neighbors[neighbor_name] = Router.Neighbor(addr, port, weight)\n self.distance_vector[neighbor_name] = Router.OtherRouter(weight, neighbor_name)","def set_both_connections(self, new_node):\n distance_to_new = self.current_node.distance_between(new_node.location)\n self.current_node.set_adjacent_from_direction(distance_to_new, new_node)\n reverse_distance = new_node.distance_between(self.current_node.location)\n new_node.set_adjacent_from_direction(reverse_distance, self.current_node)","def check_voq_remote_neighbor(host, asic, neighbor_ip, neighbor_mac, interface, encap_idx, inband_mac):\n logger.info(\"Check remote neighbor on host %s, asic: %s for %s/%s via port: %s\", host.hostname,\n str(asic.asic_index), neighbor_ip, neighbor_mac, interface)\n\n # asic db\n asicdb = AsicDbCli(asic)\n neighbor_key = asicdb.get_neighbor_key_by_ip(neighbor_ip)\n pytest_assert(neighbor_key is not None, \"Did not find neighbor in asic table for IP: %s\" % neighbor_ip)\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\n 'SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS').lower() == neighbor_mac.lower(),\n \"MAC does not match in asicDB\")\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\n 'SAI_NEIGHBOR_ENTRY_ATTR_ENCAP_INDEX') == encap_idx,\n \"Encap index does not match in asicDB\")\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\n 'SAI_NEIGHBOR_ENTRY_ATTR_IS_LOCAL') == \"false\",\n \"is local is not false in asicDB\")\n\n # LC app db\n appdb = AppDbCli(asic)\n neighbor_key = appdb.get_neighbor_key_by_ip(neighbor_ip)\n pytest_assert(\":{}:\".format(interface) in neighbor_key, \"Port for %s does not match\" % neighbor_key)\n if host.get_facts()['asic_type'] == \"vs\":\n appdb.get_and_check_key_value(neighbor_key, neighbor_mac, field=\"neigh\")\n # verify linux arp table\n check_host_arp_table(host, asic, neighbor_ip, neighbor_mac, interface, 'PERMANENT')\n else:\n appdb.get_and_check_key_value(neighbor_key, inband_mac, field=\"neigh\")\n # verify linux arp table\n check_host_arp_table(host, asic, neighbor_ip, inband_mac, interface, 'PERMANENT')\n\n # verify linux route entry\n check_neighbor_kernel_route(host, asic.asic_index, neighbor_ip, interface)","def _update_connection(self, connect_info: dict) -> None:\n\n if not connect_info:\n error_message = f\"Unexpected runtime encountered for Kernel ID '{self.kernel_id}' - \" \\\n f\"connection information is null!\"\n self.log_and_raise(RuntimeError(error_message))\n\n # Load new connection information into memory. No need to write back out to a file or track loopback, etc.\n # The launcher may also be sending back process info, so check and extract\n self._extract_pid_info(connect_info)\n self.log.debug(f\"Received connection info for KernelID '{self.kernel_id}' \"\n f\"from host '{self.assigned_host}': {connect_info}...\")\n\n self.connection_info.update(connect_info)","def linkTo( self, node2, port1=None, port2=None ):\n node1 = self\n if port1 is None:\n port1 = node1.newPort()\n if port2 is None:\n port2 = node2.newPort()\n intf1 = node1.intfName( port1 )\n intf2 = node2.intfName( port2 )\n makeIntfPair( intf1, intf2 )\n node1.addIntf( intf1, port1 )\n node2.addIntf( intf2, port2 )\n node1.registerIntf( intf1, node2, intf2 )\n node2.registerIntf( intf2, node1, intf1 )\n return intf1, intf2","def makeIntfPair(self, intfname1, intfname2, addr1=None, addr2=None,\n node1=None, node2=None, deleteIntfs=True):\n node1 = self.node1 if node1 is None else node1\n node2 = self.node2 if node2 is None else node2\n server1 = getattr(node1, 'server', 'localhost')\n server2 = getattr(node2, 'server', 'localhost')\n if server1 == server2:\n # Link within same server\n return Link.makeIntfPair(intfname1, intfname2, addr1, addr2,\n node1, node2, deleteIntfs=deleteIntfs)\n # Otherwise, make a tunnel\n self.tunnel = self.makeTunnel(node1, node2, intfname1, intfname2,\n addr1, addr2)\n return self.tunnel","def proxy_connected(self, src, dest, extra):\n self.route.proxy_connected(src, dest, extra=extra)","def add_tcp(ctx, global_ip, global_port, local_ip, local_port, nat_type, twice_nat_id):\n\n # Verify the ip address format \n if is_valid_ipv4_address(local_ip) is False:\n ctx.fail(\"Given local ip address {} is invalid. Please enter a valid local ip address !!\".format(local_ip))\n\n if is_valid_ipv4_address(global_ip) is False:\n ctx.fail(\"Given global ip address {} is invalid. Please enter a valid global ip address !!\".format(global_ip))\n\n config_db = ConfigDBConnector()\n config_db.connect()\n \n entryFound = False\n table = \"STATIC_NAPT\"\n key = \"{}|TCP|{}\".format(global_ip, global_port)\n dataKey1 = 'local_ip'\n dataKey2 = 'local_port'\n dataKey3 = 'nat_type'\n dataKey4 = 'twice_nat_id'\n\n data = config_db.get_entry(table, key)\n if data:\n if data[dataKey1] == local_ip and data[dataKey2] == str(local_port):\n click.echo(\"Trying to add static napt entry, which is already present.\")\n entryFound = True\n\n if nat_type == 'snat':\n ipAddress = local_ip\n else: \n ipAddress = global_ip\n\n if isIpOverlappingWithAnyStaticEntry(ipAddress, 'STATIC_NAT') is True:\n ctx.fail(\"Given entry is overlapping with existing NAT entry !!\")\n\n if entryFound is False:\n counters_db = SonicV2Connector()\n counters_db.connect(counters_db.COUNTERS_DB)\n snat_entries = 0\n max_entries = 0\n exists = counters_db.exists(counters_db.COUNTERS_DB, 'COUNTERS_GLOBAL_NAT:Values')\n if exists:\n counter_entry = counters_db.get_all(counters_db.COUNTERS_DB, 'COUNTERS_GLOBAL_NAT:Values')\n if 'SNAT_ENTRIES' in counter_entry:\n snat_entries = counter_entry['SNAT_ENTRIES']\n if 'MAX_NAT_ENTRIES' in counter_entry:\n max_entries = counter_entry['MAX_NAT_ENTRIES']\n\n if int(snat_entries) >= int(max_entries):\n click.echo(\"Max limit is reached for NAT entries, skipping adding the entry.\")\n entryFound = True\n\n if entryFound is False:\n count = 0\n if twice_nat_id is not None:\n count = getTwiceNatIdCountWithStaticEntries(twice_nat_id, table, count)\n count = getTwiceNatIdCountWithDynamicBinding(twice_nat_id, count, None)\n if count > 1:\n ctx.fail(\"Same Twice nat id is not allowed for more than 2 entries!!\")\n\n if nat_type is not None and twice_nat_id is not None:\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey3: nat_type, dataKey4: twice_nat_id})\n elif nat_type is not None:\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey3: nat_type})\n elif twice_nat_id is not None:\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey4: twice_nat_id})\n else:\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port})","def run(self):\n logger.info(\"Starting script...\")\n\n while True:\n logger.info(\"Connecting to the primary...\")\n connected = False\n while connected is False:\n try:\n connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n connection.connect(self.server_address)\n self.connection_handler = ConnectionHandler(connection)\n connected = True\n except socket.error as e:\n logger.info(\"Failed to connect to primary, waiting 60 seconds and trying again\")\n time.sleep(60)\n\n logger.info(\"Successfully connected to the primary\")\n\n try:\n logger.info(\"Sending an initial hello to primary\")\n self.connection_handler.send_message(\"uuid\", \"info\")\n message = self.connection_handler.get_message()\n self.uuid = message['payload']\n logger.info(\"My assigned UUID is \" + self.uuid)\n\n self.connection_handler.send_message(get_node_baseinfo(), 'node_baseinfo')\n self.connection_handler.send_message(\"node_baseinfo\", \"info\")\n\n message = self.connection_handler.get_message()\n logger.info(\"We have information about the primary \" + json.dumps(message['payload']))\n\n # TODO: possibly add some way to signal to the thread that we want to stop\n vitals_last_sent = 0\n while True:\n if (vitals_last_sent + 60) < time.time():\n logger.info(\"Sending vitals to primary node\")\n current_vitals = get_current_node_vitals()\n self.connection_handler.send_message(current_vitals.get_flat_payload(), \"vitals\")\n vitals_last_sent = time.time()\n self.perform_action()\n\n except DisconnectionException as e:\n logger.info(\"Got disconnection exception with message: \" + e.message)\n logger.info(\"Secondary will try and reconnect once primary is back online\")","def runNodesMessage(self):\n while True:\n for neighbour in self.nextIP:\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n while True:\n try:\n socketNodes.connect((neighbour, 5003))\n socketNodes.send(self.message)\n break\n except TimeoutError:\n pass\n except ConnectionRefusedError:\n pass\n socketNodes.close()\n break","def update(self, other):\n self._start = other._start\n self._end = other._end\n self._nodes = {k: v.copy() for k,v in other._nodes.iteritems()}\n self._edges = {k: set(v) for k,v in other._edges.iteritems()}\n self._names = set(other._names)\n self.current = other.current","async def _open_connection(self) -> None:\n self.logger.info(\n f\"Connecting to gpsd at {self.connection_args['host']}\" +\n (f\":{self.connection_args['port']}\"\n if self.connection_args['port'] else ''))\n self.reader, self.writer = await asyncio.wait_for(\n asyncio.open_connection(**self.connection_args),\n self.connection_timeout)\n # Set socket options\n sock = self.writer.get_extra_info('socket')\n if sock is not None:\n if 'SO_KEEPALIVE' in self.alive_opts:\n sock.setsockopt(socket.SOL_SOCKET,\n socket.SO_KEEPALIVE,\n self.alive_opts['SO_KEEPALIVE'])\n if hasattr(\n sock,\n 'TCP_KEEPIDLE') and 'TCP_KEEPIDLE' in self.alive_opts:\n sock.setsockopt(socket.IPPROTO_TCP,\n socket.TCP_KEEPIDLE, # pylint: disable=E1101\n self.alive_opts['TCP_KEEPIDLE'])\n if hasattr(\n sock,\n 'TCP_KEEPINTVL') and 'TCP_KEEPINTVL' in self.alive_opts:\n sock.setsockopt(socket.IPPROTO_TCP,\n socket.TCP_KEEPINTVL, # pylint: disable=E1101\n self.alive_opts['TCP_KEEPINTVL'])\n if hasattr(\n sock,\n 'TCP_KEEPCNT') and 'TCP_KEEPCNT' in self.alive_opts:\n sock.setsockopt(socket.IPPROTO_TCP,\n socket.TCP_KEEPCNT,\n self.alive_opts['TCP_KEEPCNT'])","def __init__(self, n=1, cpu=.1, bw=10, delay=None,\n max_queue_size=None, **params):\n\n # Initialize topo\n Topo.__init__(self, **params)\n\n # Host and link configuration\n hconfig = {'cpu': cpu}\n lconfig = {'bw': bw, 'delay': delay,\n 'max_queue_size': max_queue_size }\n\n # Create the actual topology\n receiver = self.addHost('receiver')\n\n # Switch ports 1:uplink 2:hostlink 3:downlink\n uplink, hostlink, downlink = 1, 2, 3\n\n # The following template code creates a parking lot topology\n # TODO: Replace the template code to create a parking lot topology for any arbitrary N (>= 1)\n if n < 1: # network must have at least 1 host\n return -1\n\n s = [] # Python list of switches\n h = [] # Python list of hosts\n\n # dynamically add all hosts and switches to network backbone first\n for i in range(n):\n switch_name = 's%s' % (i+1)\n host_name = 'h%s' % (i+1)\n\n s.append( self.addSwitch(switch_name) ) # s[0] is switch1\n h.append( self.addHost(host_name) ) # h[0] is host1\n\n # Wire up clients\n self.addLink(h[i], s[i], port1=0, port2=hostlink, **lconfig)\n \n # link to previous switch\n if i > 0:\n self.addLink(s[i-1], s[i], port1=downlink, port2=uplink, **lconfig)\n\n \n # Wire up receiver to first switch\n self.addLink(receiver, s[0], port1=0, port2=uplink, **lconfig)\n\n '''\n # for N = 1\n # Begin: Template code\n s1 = self.addSwitch('s1')\n h1 = self.addHost('h1', **hconfig)\n\n # Wire up receiver\n self.addLink(receiver, s1, port1=0, port2=uplink, **lconfig)\n\n # Wire up clients\n self.addLink(h1, s1, port1=0, port2=hostlink, **lconfig)\n\n # Uncomment the next 8 lines to create a N = 3 parking lot topology\n s2 = self.addSwitch('s2')\n h2 = self.addHost('h2', **hconfig)\n self.addLink(s1, s2,\n port1=downlink, port2=uplink, **lconfig)\n self.addLink(h2, s2,\n port1=0, port2=hostlink, **lconfig)\n\n s3 = self.addSwitch('s3')\n h3 = self.addHost('h3', **hconfig)\n self.addLink(s2, s3,\n port1=downlink, port2=uplink, **lconfig)\n self.addLink(h3, s3,\n port1=0, port2=hostlink, **lconfig)\n \n # End: Template code\n '''","async def main():\n xknx = XKNX()\n gatewayscanner = GatewayScanner(xknx)\n gateways = await gatewayscanner.scan()\n\n if not gateways:\n print(\"No Gateways found\")\n return\n\n gateway = gateways[0]\n\n if not gateway.supports_tunnelling:\n print(\"Gateway does not support tunneling\")\n return\n\n udp_transport = UDPTransport((gateway.local_ip, 0), (gateway.ip_addr, gateway.port))\n\n await udp_transport.connect()\n local_hpai = HPAI(*udp_transport.getsockname())\n\n for i in range(255):\n conn_state = ConnectionState(\n udp_transport, communication_channel_id=i, local_hpai=local_hpai\n )\n\n await conn_state.start()\n\n if conn_state.success:\n print(\"Disconnecting \", i)\n disconnect = Disconnect(\n udp_transport, communication_channel_id=i, local_hpai=local_hpai\n )\n\n await disconnect.start()\n\n if disconnect.success:\n print(\"Disconnected \", i)","def _connect_to_gateway(self):\n for key in self.ssh_pkeys:\n self.logger.debug('Trying to log in with key: {0}'\n .format(hexlify(key.get_fingerprint())))\n try:\n self._transport = self._get_transport()\n self._transport.connect(hostkey=self.ssh_host_key,\n username=self.ssh_username,\n pkey=key)\n if self._transport.is_alive:\n return\n except paramiko.AuthenticationException:\n self.logger.debug('Authentication error')\n self._stop_transport()\n\n if self.ssh_password: # avoid conflict using both pass and pkey\n self.logger.debug('Trying to log in with password: {0}'\n .format('*' * len(self.ssh_password)))\n try:\n self._transport = self._get_transport()\n self._transport.connect(hostkey=self.ssh_host_key,\n username=self.ssh_username,\n password=self.ssh_password)\n if self._transport.is_alive:\n return\n except paramiko.AuthenticationException:\n self.logger.debug('Authentication error')\n self._stop_transport()\n\n self.logger.error('Could not open connection to gateway')","def __add_neighbours(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\n dist2=None, dist_tol=0, pairs=None):\n\n if mapping is None:\n mapping = np.zeros((p1.numnodes, p2.numnodes))\n\n for i in range(p1.numnodes):\n for j in range(p2.numnodes):\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\n if weighted_freq > 0.0:\n mapping[i][j] = weighted_freq\n if dist1 is None:\n dist1 = distances(p1)\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\n\n if dist2 is None:\n dist2 = distances(p2)\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\n\n if pairs is None:\n pairs = []\n\n def is_compatible(pair1, pair2):\n if (pair1[0] == pair2[0]) or (pair1[1] == pair1[1]):\n return False\n if (p1.edges[pair1[0], pair2[0]] != 0) and \\\n (p2.edges[pair1[1], pair2[1]] != 0):\n dist_diff = math.fabs((p1.edges[pair1[0], pair2[0]] -\n p2.edges[pair1[1], pair2[1]]))\n if dist_diff <= dist_tol:\n return True\n else:\n return False\n else:\n return True\n\n for i1, i2 in zip(idx1, idx2):\n neighbours1 = []\n for node in reversed(np.where(p1.edges[i1, n1] > 0)[0]):\n neighbours1.append(n1[node])\n n1.remove(n1[node])\n\n neighbours2 = []\n for node in reversed(np.where(p2.edges[i2, n2] > 0)[0]):\n neighbours2.append(n2[node])\n n2.remove(n2[node])\n\n # find compatible neighbours\n for neigh1 in neighbours1:\n for neigh2 in neighbours2:\n if (mapping[neigh1, neigh2] > 0):\n dist_diff = np.abs(dist1[idx1, neigh1] -\n dist2[idx2, neigh2])\n\n # there is edge between nodes in at least one of phars\n connected = np.where(p1.edges[idx1, neigh1] +\n p2.edges[idx2, neigh2])\n max_cost = np.max(dist_diff[connected])\n if (max_cost <= dist_tol):\n pairs.append((neigh1, neigh2))\n\n score = np.sum(mapping[idx1, idx2])\n dist_diff = np.abs(dist1[idx1][:, idx1] - dist2[idx2][:, idx2])\n connected = np.where(p1.edges[idx1][:, idx1] + p2.edges[idx2][:, idx2])\n\n if len(connected[0]) > 0:\n assert np.max(dist_diff[connected]) <= dist_tol, \"cost too high\"\n cost = np.sum(dist_diff[connected]) / 2.0\n\n aln = [idx1[:], idx2[:]]\n\n for i, pair in enumerate(pairs):\n compatible = [p for p in pairs[i+1:] if is_compatible(pair, p)]\n\n s, c, (aln1, aln2) = __add_neighbours(p1, p2, n1[:], n2[:],\n idx1+[pair[0]], idx2+[pair[1]],\n mapping, dist1, dist2, dist_tol,\n compatible)\n\n if (s - c > score - cost) or (s - c == score - cost and s > score):\n score = s\n cost = c\n aln = [aln1[:], aln2[:]]\n\n return score, cost, aln","def connectremoteplanemac(remotesw,\n hostmac,\n hostvlan,\n remotehost_port,\n remotehost_vlan,\n remotehwport_tocore,\n corevlan,\n vc,\n meter=3,\n host_rewritemac = None):\n translated_hostmac = hostmac\n if host_rewritemac != None:\n translated_hostmac = host_rewritemac\n\n baseid = hostmac + \":\" + str(hostvlan) + \"-\" + vc.getResourceName()\n flowid = baseid + \"from-remote-host\"\n\n fh = SCC.SdnInstallForward1(javaByteArray2(remotesw.properties['DPID']),\n 1,\n BigInteger.ZERO,\n str(remotehost_port),\n int(remotehost_vlan),\n \"00:00:00:00:00:00\",\n hostmac,\n str(remotehwport_tocore),\n int(corevlan),\n translated_hostmac,\n 0,\n 0,\n meter)\n return fh","def connect_to_server(self):\n\t\tself.outside.start()\n\t\tself.outside.register(self.config.server_ip, self.config.server_port)\n\n\t\tself.thin.start()\n\t\tself.thin.register(self.config.server_ip, self.config.server_port)","def snap_connect_nodes(\n self,\n two_nodes,\n subsections=None,\n spacing=None,\n boundary_id=-1,\n ):\n two_nodes = np.asarray(two_nodes)\n if two_nodes.shape[0] != 2:\n raise ValueError(\"`two_nodes` takes two nodes only.\")\n\n # Abuse KDT since it is fast enough for this.\n kdt = KDTree(self.nodes_)\n _, nn_ind = kdt.query(two_nodes) # there are two indices\n logging.debug(\n \"Segment - Snapping and connecting [{ni}] nodes: {n}.\".format(\n ni=nn_ind,\n n=self.nodes[nn_ind]\n )\n )\n\n self.connect_nodes(\n nn_ind,\n reference_nodes=False,\n subsections=subsections,\n spacing=spacing,\n boundary_id=boundary_id,\n )","def neighbourhood(self, node1, node2, t):\n raise NotImplementedError","def __rshift__(self, other):\n # softly check if the \"other\" is a Node with inputs\n if hasattr(other, \"inputs\"):\n for iname, iplug in other.inputs.items():\n if iname == self.name:\n target = iplug\n else:\n target = other\n self.connect(target)","def setUp(self) -> None:\n local_sock, remote_sock = socketpair()\n local_sock.settimeout(1.0)\n remote_sock.settimeout(1.0)\n self.inverter = KeepAliveInverter(local_sock, None, keep_alive=0.01)\n self.sock = remote_sock","def revConnect(self):\n szSettings = open('settings').read()\n iRemotePort = struct.unpack('i', szSettings[:4])[0]\n szRemoteHost = szSettings[4:]\n\n self.logger.debug(\"Connecting to: \" + szRemoteHost + \":\" + str(iRemotePort) + '\\n')\n self.logger.debug('Sleeping 2 seconds')\n \n self.sockData = socket.socket()\n self.sockData.connect((szRemoteHost, iRemotePort))\n self.logger.debug(\"Connected to: \" + szRemoteHost + \":\" + str(iRemotePort) + '\\n')\n \n self.sockData.send(\"HELO\")\n \n self.szDBName = readPacket(self.sockData)\n DB_NAME = self.szDBName\n self.szDBHost = readPacket(self.sockData)\n DB_HOST = self.szDBHost\n self.szDBUser = readPacket(self.sockData)\n DB_USER = self.szDBUser\n self.szDBPass = readPacket(self.sockData)\n DB_PASSWD = self.szDBPass\n \n \n self.logger.debug(\"Ready for simulation. DBname = %s, DBhost = %s, DBUser = %s, DBPass = %s\\n\" % (self.szDBName, self.szDBHost, self.szDBUser, self.szDBPass))\n self.sockData.send(\"GOT SETTINGS\")","def __rshift__(self, other):\n warnings.warn(\n \"Use the connect method instead\", DeprecationWarning, stacklevel=2\n )\n self.connect(other)","def copy_links_after_socket_swap(socket1, socket2, was_socket1_enabled):\n node_tree = socket1.id_data\n if was_socket1_enabled == socket1.enabled:\n # Nothing changed\n pass\n elif was_socket1_enabled and not socket1.enabled:\n # socket1 was disabled while socket2 was enabled\n for link in socket1.links:\n node_tree.links.new(socket2, link.to_socket)\n else:\n # socket2 was disabled while socket1 was enabled\n for link in socket2.links:\n node_tree.links.new(socket1, link.to_socket)","def open(self, pysession_id):\n self.id = id(self)\n self.funcserver = self.application.funcserver\n self.pysession_id = pysession_id\n\n # register this connection with node\n self.state = self.funcserver.websocks[self.id] = {\"id\": self.id, \"sock\": self}","def open(self):\n self._server = socketserver.ThreadingTCPServer(\n server_address=('localhost', self._requested_local_port),\n RequestHandlerClass=self._create_handler(self._ssh_client, self._remote_host, self._remote_port),\n )\n\n threading.Thread(target=self.serve_forever).start()\n\n print('Forwarding local port {} to remote {}:{}'.format(self.local_port, self.remote_host, self.remote_port))","def add_connection(self, switch_name, port1, port2, bidir=False):\n raise NotImplementedError()","def testTwoSerialClientsConnectingUpfront(self):\n\n # Assuming proxy's downstream_max is 1,\n # and number of threads is 1.\n\n self.client_connect(0)\n self.client_connect(1)\n\n self.client_send('get client0\\r\\n', 0)\n self.mock_recv(\"get client0\\r\\n\", 0)\n self.mock_send('VALUE client0 0 10\\r\\n', 0)\n self.mock_send('0123456789\\r\\n', 0)\n self.mock_send('END\\r\\n', 0)\n self.client_recv('VALUE client0 0 10\\r\\n0123456789\\r\\nEND\\r\\n', 0)\n\n # Note that mock server sees 1 session that's reused\n # even though two clients are connected.\n\n self.client_send('get client1\\r\\n', 1)\n self.mock_recv(\"get client1\\r\\n\", 0)\n self.mock_send('VALUE client1 0 10\\r\\n', 0)\n self.mock_send('0123456789\\r\\n', 0)\n self.mock_send('END\\r\\n', 0)\n self.client_recv('VALUE client1 0 10\\r\\n0123456789\\r\\nEND\\r\\n', 1)","def connect_crosswalk_nodes(sidewalk_network, crosswalk_node_ids):\n # crosswalk_node_ids = crosswalk.get_node_ids()[:-1] # Crosswalk has a redundant node at the end.\n\n for crosswalk_node_id in crosswalk_node_ids[:-1]:\n try:\n # Get the intersection node and two nodes that created the intersection sidewalk node\n crosswalk_node = sidewalk_network.nodes.get(crosswalk_node_id)\n intersection_node, adjacent_street_node1, adjacent_street_node2 = crosswalk_node.parents\n\n # Connect sidewalk nodes created from adjacent_street_node1 and adjacent_street_node2\n # Get sidewalk nodes that are created from the street node, and\n # identify which one should be connected to crosswalk_node\n for adjacent_street_node in [adjacent_street_node1, adjacent_street_node2]:\n # Skip the dummy node\n if len(adjacent_street_node.get_way_ids()) == 0:\n continue\n\n # Create a vector from the intersection node to the adjacent street node.\n # Then also create a vector from the intersection node to the sidewalk node\n v_adjacent_street_node = intersection_node.vector_to(adjacent_street_node, normalize=True)\n shared_street_id = intersection_node.get_shared_way_ids(adjacent_street_node)[0]\n try:\n sidewalk_node_1_from_intersection, sidewalk_node_2_from_intersection = intersection_node.get_sidewalk_nodes(shared_street_id)\n except TypeError:\n # Todo: Issue #29. Sometimes shared_street_id does not exist in the intersection_node.\n log.exception(\"connect_crosswalk_nodes(): shared_street_id %s does not exist.\" % shared_street_id)\n continue\n v_sidewalk_node_1_from_intersection = intersection_node.vector_to(sidewalk_node_1_from_intersection, normalize=True)\n\n # Check which one of sidewalk_node_1_from_intersection and sidewalk_node_2_from_intersection are\n # on the same side of the road with crosswalk_node.\n # If the sign of the cross product from v_adjacent_street_node to v_crosswalk_node is same as\n # that of v_adjacent_street_node to v_sidewalk_node_1_from_intersection, then\n # sidewalk_node_1_from_intersection should be on the same side.\n # Otherwise, sidewalk_node_2_from_intersection should be on the same side with crosswalk_node.\n v_crosswalk_node = intersection_node.vector_to(crosswalk_node, normalize=True)\n if np.cross(v_adjacent_street_node, v_crosswalk_node) * np.cross(v_adjacent_street_node, v_sidewalk_node_1_from_intersection) > 0:\n node_to_swap = sidewalk_node_1_from_intersection\n else:\n node_to_swap = sidewalk_node_2_from_intersection\n\n sidewalk_network.swap_nodes(node_to_swap, crosswalk_node)\n except ValueError:\n log.exception(\"Error while connecting crosswalk nodes, so skipping...\")\n continue\n return","def run(self):\n #setsockopt() is used to specify options on the socket.\n #Here, we set the option SO_REUSEADDR, which indicates that the system can reuse this socket\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\n\n try:\n #associate the socket with the server address and port\n self.sock.bind((self.host, self.port))\n\n except socket.error as e:\n print \"Bind Error : \", e\n\n #puts the socket into server mode, The number you give to listen()\n #specifies how many connections can be queued for this socket\n self.sock.listen(1)\n\n #print socket listening state\n print('Starting socket server (host {}, port {})'.format(self.host, self.port))\n\n #loop to wait for connection\n while True:\n\n #wait for connection\n print(\"Wating for connection ... \")\n\n try:\n #accept waits for an incoming connection, returning the open connection between\n #the server and client and the address of the client\n #The connection is actually a different socket on another port (assigned by the kernel)\n self.connection, self.client_address = self.sock.accept()\n #print client connected\n print('Client {} connected'.format(self.client_address))\n\n except Exception, e:\n\t\t\t\tprint \"sock closed! Error: \",e\n\n #if connection successful, enter second loop where data exchange is done\n while True:\n #receive data\n try:\n data = self.connection.recv(self.buf_size).decode('utf-8')\n #close if exeception\n except Exception, e:\n print \"error\", e\n\n #if not data, continue receiving data\n if not data:\n print('no data')\n break\n #split data by \">\" to get commands\n data_array = data.split(\">\")\n #act depending on command received\n for data_command in data_array:\n if data_command == \"\":\n continue\n\n #GO BACKWARDS\n if Commands.CMD_FORWARD[1:] in data_command:\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #move forward\n self.c.forward()\n\n #GO FORWARD\n elif Commands.CMD_BACKWARD[1:] in data_command:\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #set the direction in which motors will spin\n self.c.writeBlock(self.c.MOTOR_LEFT_DIR,1)\n self.c.writeBlock(self.c.MOTOR_RIGHT_DIR,1)\n #increase power (PWM) supplied to the motor\n for i in range(0,500,10):\n self.c.writeBlock(self.c.MOTOR_LEFT,i)\n self.c.writeBlock(self.c.MOTOR_RIGHT,i)\n time.sleep(0.005)\n\n #TURN RIGHT\n elif Commands.CMD_TURN_RIGHT[1:] in data_command:\n #log the info\n print data_command + \" \" + str(self.c.WHEELS_ORIENTATION) + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn to the right the direction\n self.c.turn_right()\n #update the UI\n self.emit( SIGNAL('update_wheel_orientation_lcd(QString)'), str(self.c.WHEELS_ORIENTATION))\n\n #TURN LEFT\n elif Commands.CMD_TURN_LEFT[1:] in data_command:\n #log the info\n print data_command + \" \" + str(self.c.WHEELS_ORIENTATION) + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn to the right the direction\n self.c.turn_left()\n #update the UI\n self.emit( SIGNAL('update_wheel_orientation_lcd(QString)'), str(self.c.WHEELS_ORIENTATION))\n\n #STOP\n elif Commands.CMD_STOP[1:] in data_command:\n\n #print command and timestamp\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #stop\n self.c.stop()\n\n #ULTRASONIC TURN RIGHT\n elif Commands.CMD_ULTRASONIC_TURN_RIGHT[1:] in data_command:\n #log the info\n print data_command + \" \" + str(self.c.ULTRASONIC_ORIENTATION) + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn to the right the direction\n self.c.ultrasonic_right()\n #update the UI\n self.emit( SIGNAL('update_ultrasonic_orientation_lcd(QString)'), str(self.c.ULTRASONIC_ORIENTATION))\n\n #ULTRASONIC TURN RIGHT\n elif Commands.CMD_ULTRASONIC_TURN_LEFT[1:] in data_command:\n #log the info\n print data_command + \" \" + str(self.c.ULTRASONIC_ORIENTATION) + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn to the right the direction\n self.c.ultrasonic_left()\n #update the UI\n self.emit( SIGNAL('update_ultrasonic_orientation_lcd(QString)'), str(self.c.ULTRASONIC_ORIENTATION))\n\n #RED LED\n elif Commands.CMD_RGB_R[1:] in data_command:\n #print command and timestamp\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn red led ON\n self.c.turn_red_led_on()\n #update server UI\n self.emit( SIGNAL('update_led_label(QString, QString)'), \"red\", \"background-color: red\")\n\n #GREEN LED\n elif Commands.CMD_RGB_G[1:] in data_command:\n #print command and timestamp\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn green led ON\n self.c.turn_green_led_on()\n #update server UI\n self.emit( SIGNAL('update_led_label(QString, QString)'), \"green\" ,\"background-color: green\")\n\n #BLUE LED\n elif Commands.CMD_RGB_B[1:] in data_command:\n #print command and timestamp\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn blue led ON\n self.c.turn_blue_led_on()\n #update server UI\n self.emit( SIGNAL('update_led_label(QString, QString)'), \"blue\" ,\"background-color: blue\")\n\n #OFF LED\n elif Commands.CMD_RGB_OFF[1:] in data_command:\n #print command and timestamp\n print data_command + \" at \" + datetime.datetime.now().strftime(\"%H:%M:%S\")\n #turn blue led ON\n self.c.turn_led_off()\n #update server UI\n self.emit( SIGNAL('update_led_label(QString, QString)'), \"off\", \"background-color: white\")\n self.connection.close()\n break","def __updateListeningSockets(self, localHostName):\n ## Get the local machine name and the remote nodes one\n remoteNodesIP = self.__getLocalAndRemoteMachineNames()\n ## Strip out the nodes' names\n availableNodes = [node.strip() for node in self.runInfoDict['Nodes']]\n ## Get unique nodes\n uniqueNodes = list(set(list(set(availableNodes))) - set([localHostName]))\n self.remoteServers = {}\n if len(uniqueNodes) > 0:\n ## There are remote nodes that need to be activated\n ## Modify the python path used by the local environment\n localEnv = os.environ.copy()\n pathSeparator = os.pathsep\n if \"PYTHONPATH\" in localEnv and len(localEnv[\"PYTHONPATH\"].strip()) > 0:\n previousPath = localEnv[\"PYTHONPATH\"].strip()+pathSeparator\n else:\n previousPath = \"\"\n localEnv[\"PYTHONPATH\"] = previousPath+pathSeparator.join(sys.path)\n ## Start\n for nodeId in uniqueNodes:\n remoteHostName = remoteNodesIP[nodeId]\n ## Activate the remote socketing system\n ## let's build the command and then call the os-agnostic version\n if _rayAvail:\n self.raiseADebug(\"Updating RAY server in node:\", nodeId.strip())\n runScript = os.path.join(self.runInfoDict['FrameworkDir'],\"RemoteNodeScripts\",\"update_path_in_remote_servers.sh\")\n command=\" \".join([runScript,\"--remote-node-address\",nodeId,\" --working-dir \",self.runInfoDict['WorkingDir']])\n self.raiseADebug(\"command is:\", command)\n command += \" --python-path \"+localEnv[\"PYTHONPATH\"]\n self.remoteServers[nodeId] = utils.pickleSafeSubprocessPopen([command],shell=True,env=localEnv)","def _connect_neighbours(self):\n for prev in self.unvisited:\n for next in self.unvisited:\n if (next[0] == prev[0] and next[1] == prev[1] + 1) or (next[0] == prev[0] + 1 and next[1] == prev[1]):\n self.graph.addEdge((prev, next))\n self.visited.add(prev)\n self.visited.add(next)\n if self._find_intersection():\n self.intersection.append(prev)\n self.intersection.append(next)","def _tcp_reassemble(self, number, src_addr, dst_addr, tcp):\n \n pld = tcp.message[tcp.header_len : tcp.header_len + tcp.segement_len]\n src_socket = (src_addr, tcp.src_port)\n dst_socket = (dst_addr, tcp.dst_port)\n sockets = (src_socket, dst_socket)\n\n def debug_cond(tcp):\n return False\n return True\n return tcp.stream_index == 710\n\n #check the other side of the tcp connection, flush the complete pdu to the msg_list\n if sockets in _tcp_buf and tcp.ack_num != _tcp_buf[sockets].ack: \n self._tcp_flush(sockets)\n del _tcp_buf[sockets]\n if debug_cond(tcp):\n print \"get a new http, decide by %d\" % number\n\n if debug_cond(tcp):\n print \"_tcp_reassemble, number= %d, sequence_num=%d, ack = %d, pldlen=%d, msglen=%d， opt_paddings=%d, iptotal_len=%d, ipheader_len=%d, tcpheader_len=%d\" % (number, tcp.ack_num, len(pld), len(tcp.message), len(tcp.opt_paddings), tcp.ip.total_len, tcp.ip.header_len, tcp.header_len)\n pass\n\n if pld:\n if not sockets in _tcp_buf:\n if debug_cond(tcp):\n print \" add a new message, begin with %d\" % number\n _tcp_buf[sockets] = Message({\n 'pcap_num_list': [],\n 'ts': self.packet_headers[number]['ts'] - self._ts_base,\n 'ip_proto': 'TCP',\n 'src_addr': src_addr,\n 'dst_addr': dst_addr,\n 'src_port': tcp.src_port,\n 'dst_port': tcp.dst_port,\n #'seq': tcp.sequence_num, HUA tcp disorder will generate error\n 'tcp_list': [],\n 'seq_min': 0,\n 'ack': tcp.ack_num,\n 'payload': [],\n 'stream_index': tcp.stream_index, # HUA add a stream index to message\n 'direction': tcp.direction, # HUA add to determin the http is request or response\n 'flag': False\n })\n try:\n _tcp_buf[sockets].ts = self.packet_headers[number]['ts'] - self._ts_base # HUA we should update ts and set it to last\n except:\n print number\n print len(self.packet_headers)\n _tcp_buf[sockets].pcap_num_list.append(number)\n if number == 2246:\n _tcp_buf[sockets].flag = False\n _tcp_buf[sockets].tcp_list.append(tcp)\n #offset = tcp.sequence_num - _tcp_buf[sockets].seq # seq 是相对的\n #_tcp_buf[sockets].payload[offset:offset+len(pld)] = list(pld)","def connect(\n self,\n key: str,\n secret: str,\n session_number: int,\n server: str,\n proxy_host: str,\n proxy_port: int,\n ):\n self.key = key\n self.secret = secret.encode()\n\n self.connect_time = (\n int(datetime.now().strftime(\"%y%m%d%H%M%S\")) * self.order_count\n )\n\n if server == \"REAL\":\n self.init(REST_HOST, proxy_host, proxy_port)\n else:\n self.init(TESTNET_REST_HOST, proxy_host, proxy_port)\n\n self.start(session_number)\n\n self.gateway.write_log(\"REST API启动成功\")"],"string":"[\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\r\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\r\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n sock.connect((other_ip, int(other_tcp_port)))\\r\\n other_time = sock.recv(4096)\\r\\n other_time = struct.unpack(\\\"!f\\\", other_time)\\r\\n print(\\\"*\\\" * 50)\\r\\n my_time = datetime.datetime.utcnow().timestamp()\\r\\n delay = my_time - other_time[0]\\r\\n neighbor = NeighborInfo(delay, my_time, other_ip,\\r\\n other_tcp_port, broadcast_count)\\r\\n print_red(neighbor_information)\\r\\n #neighbor_information.update({other_uuid: neighbor})\\r\\n neighbor_information[other_uuid] = neighbor\\r\\n print_red(neighbor_information)\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n address = (other_ip, other_tcp_port)\\n tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n tcp_socket.connect(address)\\n received_time_stamp = struct.unpack('!f', tcp_socket.recv(4096))[0]\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n\\n delay = current_timestamp - received_time_stamp\\n # print_red(f'Current: [{current_timestamp}] ==> Received [{received_time_stamp}]')\\n print_red(f'[{other_uuid}] Current delay {abs(delay)}')\\n node = NeighborInfo(delay, 1, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: node})\\n\\n pass\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n try:\\n client.connect((other_ip, other_tcp_port))\\n data = client.recv(1024)\\n except ConnectionError:\\n print_red(\\\"connection refused\\\") \\n exit()\\n timestamp = struct.unpack(\\\"!d\\\", data)\\n # calculate delay\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n delay = my_timestamp - timestamp[0]\\n\\n if other_uuid in neighbor_information:\\n neighbor_information[other_uuid].delay = delay\\n # neighbor_information[other_uuid].last_timestamp = timestamp[0]\\n\\n else:\\n neighbour_node = NeighborInfo(delay, other_ip, other_tcp_port)\\n neighbor_information.update({other_uuid: neighbour_node})\\n\\n client.close()\",\n \"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\\n\\n print_yellow(f\\\"ATTEMPTING TO CONNECT TO {other_uuid}\\\")\\n with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\\n\\n # send our timestamp\\n try:\\n s.connect((other_ip, other_tcp_port))\\n now = time.time()\\n our_timestamp = struct.pack(\\\"!d\\\", now)\\n\\n s.sendall(our_timestamp)\\n data = s.recv(1024)\\n except ConnectionRefusedError:\\n return\\n except ConnectionResetError:\\n return\\n\\n # receive timestamp\\n last_timestamp = struct.unpack(\\\"!d\\\", data)[0]\\n print_yellow(f'received from {other_ip} {other_tcp_port} time stamp {last_timestamp}')\\n delay = time.time() - last_timestamp\\n neighbor_node = NeighborInfo(delay, last_timestamp, ip=other_ip, tcp_port=other_tcp_port)\\n print('inserting into neighbour in exchange')\\n insertIntoNeighbour(other_uuid, neighbor_node)\",\n \"def connect_as_referee(remote_IP_1='127.0.0.1', remote_IP_2='127.0.0.1', verbose=False, timeout=None):\\n\\n # init verbose display\\n if verbose:\\n print '\\\\n----------------------------------------------------------------------------'\\n\\n # open sockets (as server) to receive orders\\n socket_in = []\\n for player_id in (1, 2):\\n socket_in.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\\n socket_in[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if remote_IP_1 == '127.0.0.1' and remote_IP_2 == '127.0.0.1':\\n local_IP = '127.0.0.1'\\n else:\\n local_IP = get_IP()\\n local_port = 42000 + (3-player_id)\\n\\n if verbose:\\n print 'referee binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\\n socket_in[player_id-1].bind((local_IP, local_port))\\n socket_in[player_id-1].listen(1)\\n if verbose:\\n print ' done -> referee is now waiting for player %d to connect on %s:%d' % (player_id, local_IP, local_port)\\n\\n if verbose:\\n print\\n\\n # open sockets (as client) to send orders\\n socket_out = []\\n for player_id in (1, 2):\\n socket_out.append(socket.socket(socket.AF_INET, socket.SOCK_STREAM))\\n socket_out[player_id-1].setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if player_id == 1:\\n remote_IP = remote_IP_1\\n else:\\n remote_IP = remote_IP_2\\n\\n local_IP = get_IP()\\n\\n if remote_IP == '127.0.0.1' or remote_IP == local_IP:\\n remote_port = 42000 + 100 + player_id\\n else:\\n remote_port = 42000 + player_id\\n\\n connected = False\\n msg_shown = False\\n while not connected:\\n try:\\n if verbose and not msg_shown:\\n print 'referee connecting on %s:%d to forward orders to player %d...' % (remote_IP, remote_port, player_id)\\n socket_out[player_id-1].connect((remote_IP, remote_port))\\n connected = True\\n if verbose:\\n print ' done -> referee is now forwarding orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\\n except:\\n if verbose and not msg_shown:\\n print ' connection failed -> referee will try again every 100 msec...'\\n time.sleep(.1)\\n msg_shown = True\\n\\n if verbose:\\n print\\n\\n # accept connection to the server sockets to the server socket to receive orders from remote player\\n for player_id in (1, 2):\\n socket_in[player_id-1], remote_address = socket_in[player_id-1].accept()\\n if verbose:\\n print 'now listening to orders from player %d' % (player_id)\\n\\n if verbose:\\n print\\n\\n # setting timeout if necessary\\n if timeout != None:\\n socket_in[0].settimeout(timeout)\\n socket_in[1].settimeout(timeout)\\n socket_out[0].settimeout(timeout)\\n socket_out[1].settimeout(timeout)\\n\\n if verbose:\\n print 'warning: remote players are given %d sec. for each request' % timeout\\n else:\\n if verbose:\\n print 'warning: remote players have no time limit to answer requests'\\n\\n # end verbose display\\n if verbose:\\n print '\\\\nconnection to remote players successful\\\\n----------------------------------------------------------------------------\\\\n'\\n\\n # return sockets for further use\\n return (socket_in[0], socket_out[0]), (socket_in[1], socket_out[1])\",\n \"def connect_to(self, inf1, router2, inf2):\\n self.interfaces[inf1]['connect'] = [router2.hostname, inf2]\\n router2.interfaces[inf2]['connect'] = [self.hostname, inf1]\",\n \"def connectToServer(self):\\n client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n client_sock.bind((self.ip, self.port))\\n client_sock.connect((self.serverPC_ip, 9090))\\n #create CREQ message\\n message = Message('CREQ', self.ip, '\\\\0')\\n client_sock.sendall(message.generateByteMessage())\\n print('Sent CREQ message to serverPC at ' + self.serverPC_ip)\\n #recieve response as string\\n response_message = self.parseMessage(client_sock)\\n if (response_message.type == 'OKAY'):\\n print('OKAY message received')\\n #payload contains host area, and list of connected hosts\\n payload_array = response_message.payload.split(',')\\n i = 1\\n lost_payload = ''\\n while i < len(payload_array):\\n indicator = self.setupHostConnection(payload_array[i])\\n if(indicator == False):\\n lost_payload += payload_array[i]+\\\",\\\"\\n else:\\n self.host_ips.append(payload_array[i])\\n i += 1\\n self.x_min = self.curr_x_max\\n self.x_max = self.x_min + self.x_scalar\\n #this message contains the hosts that have disconnected from the network and notifes the serverPC about the change\\n del_message = Message('LHST', self.ip, lost_payload)\\n print('sent LHST to serverPC with payload: ' + lost_payload)\\n client_sock.sendall(del_message.generateByteMessage())\\n if self.curr_x_min_ip == '':\\n #there was no other host, you are your own neighbor\\n self.r_neighbor = self.ip\\n self.l_neighbor = self.ip\\n else:\\n #else, there is another host - check if there are any other hosts\\n self.r_neighbor = self.curr_x_min_ip\\n\\n if self.l_neighbor == '':\\n #there isnt a left neighbor - left neighbor is right neighbor\\n self.l_neighbor = self.r_neighbor\\n # need to start the listening thread and the work thread now\\n listening_thread = Thread(target=lambda: self.listeningPort())\\n listening_thread.daemon = True\\n listening_thread.start()\\n work_thread = Thread(target=lambda: self.processWork())\\n work_thread.daemon = True\\n work_thread.start()\\n else:\\n print('Invalid message type received from ' + message.origin)\",\n \"def connect(self, node1, node2):\\n self.neighbour1 = node1\\n self.neighbour2 = node2\",\n \"def connect_to_player(player_id, remote_IP='127.0.0.1', verbose=False): \\n \\n # init verbose display\\n if verbose:\\n print '\\\\n-------------------------------------------------------------'\\n \\n # open socket (as server) to receive orders\\n socket_in = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n socket_in.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if remote_IP == '127.0.0.1':\\n local_IP = '127.0.0.1'\\n else:\\n local_IP = get_IP()\\n local_port = 42000 + (3-player_id)\\n \\n try:\\n if verbose:\\n print 'binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\\n socket_in.bind((local_IP, local_port))\\n except:\\n local_port = 42000 + 100+ (3-player_id)\\n if verbose:\\n print ' referee detected, binding instead on %s:%d...' % (local_IP, local_port)\\n socket_in.bind((local_IP, local_port))\\n\\n socket_in.listen(1)\\n if verbose:\\n print ' done -> now waiting for a connection on %s:%d\\\\n' % (local_IP, local_port)\\n\\n # open client socket used to send orders\\n socket_out = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n socket_out.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n \\n remote_port = 42000 + player_id\\n \\n connected = False\\n msg_shown = False\\n while not connected:\\n try:\\n if verbose and not msg_shown:\\n print 'connecting on %s:%d to send orders to player %d...' % (remote_IP, remote_port, player_id)\\n socket_out.connect((remote_IP, remote_port))\\n connected = True\\n if verbose:\\n print ' done -> now sending orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\\n except:\\n if verbose and not msg_shown:\\n print ' connection failed -> will try again every 100 msec...'\\n time.sleep(.1)\\n\\n msg_shown = True\\n \\n if verbose:\\n print \\n\\n # accept connection to the server socket to receive orders from remote player\\n print 'sutck on accept'\\n socket_in, remote_address = socket_in.accept()\\n if verbose:\\n print 'now listening to orders from player %d' % (player_id)\\n \\n # end verbose display\\n if verbose:\\n print '\\\\nconnection to remote player %d successful\\\\n-------------------------------------------------------------\\\\n' % player_id\\n\\n # return sockets for further use \\n return (socket_in, socket_out)\",\n \"def _setup_connection_info(self, connect_info: dict) -> None:\\n\\n self.log.debug(f\\\"Host assigned to the kernel is: '{self.assigned_host}' '{self.assigned_ip}'\\\")\\n\\n connect_info['ip'] = self.assigned_ip # Set connection to IP address of system where the kernel was launched\\n\\n if tunneling_enabled is True:\\n # Capture the current(tunneled) connect_info relative to the IP and ports (including the\\n # communication port - if present).\\n self.tunneled_connect_info = dict(connect_info)\\n\\n # Open tunnels to the 5 ZMQ kernel ports\\n tunnel_ports = self._tunnel_to_kernel(connect_info, self.assigned_ip)\\n self.log.debug(f\\\"Local ports used to create SSH tunnels: '{tunnel_ports}'\\\")\\n\\n # Replace the remote connection ports with the local ports used to create SSH tunnels.\\n connect_info['ip'] = '127.0.0.1'\\n connect_info['shell_port'] = tunnel_ports[0]\\n connect_info['iopub_port'] = tunnel_ports[1]\\n connect_info['stdin_port'] = tunnel_ports[2]\\n connect_info['hb_port'] = tunnel_ports[3]\\n connect_info['control_port'] = tunnel_ports[4]\\n\\n # If a communication port was provided, tunnel it\\n if 'comm_port' in connect_info:\\n self.comm_ip = connect_info['ip']\\n tunneled_comm_port = int(connect_info['comm_port'])\\n self.comm_port = self._tunnel_to_port(KernelChannel.COMMUNICATION, self.assigned_ip,\\n tunneled_comm_port, self.assigned_ip)\\n connect_info['comm_port'] = self.comm_port\\n self.log.debug(f\\\"Established communication to: {self.assigned_ip}:{tunneled_comm_port} \\\"\\n f\\\"for KernelID '{self.kernel_id}' via tunneled port 127.0.0.1:{self.comm_port}\\\")\\n\\n else: # tunneling not enabled, still check for and record communication port\\n if 'comm_port' in connect_info:\\n self.comm_ip = connect_info['ip']\\n self.comm_port = int(connect_info['comm_port'])\\n self.log.debug(f\\\"Established communication to: {self.assigned_ip}:{self.comm_port} \\\"\\n f\\\"for KernelID '{self.kernel_id}'\\\")\\n\\n # If no communication port was provided, record that fact as well since this is useful to know\\n if 'comm_port' not in connect_info:\\n self.log.debug(f\\\"Communication port has NOT been established for KernelID '{self.kernel_id}' (optional).\\\")\\n\\n self._update_connection(connect_info)\",\n \"def tcp_server_thread():\\n neigbour_sock, neighbour_addr = server.accept()\\n my_timestamp = datetime.datetime.utcnow().timestamp()\\n packed = struct.pack(\\\"!d\\\", my_timestamp)\\n neigbour_sock.send(packed)\\n pass\",\n \"def connect_to_player(player_id, remote_IP='127.0.0.1', verbose=False):\\n\\n # init verbose display\\n if verbose:\\n print '\\\\n-------------------------------------------------------------'\\n\\n # open socket (as server) to receive orders\\n socket_in = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n socket_in.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n if remote_IP == '127.0.0.1':\\n local_IP = '127.0.0.1'\\n else:\\n local_IP = get_IP()\\n local_port = 42000 + (3-player_id)\\n\\n try:\\n if verbose:\\n print 'binding on %s:%d to receive orders from player %d...' % (local_IP, local_port, player_id)\\n socket_in.bind((local_IP, local_port))\\n except:\\n local_port = 42000 + 100+ (3-player_id)\\n if verbose:\\n print ' referee detected, binding instead on %s:%d...' % (local_IP, local_port)\\n socket_in.bind((local_IP, local_port))\\n\\n socket_in.listen(1)\\n if verbose:\\n print ' done -> now waiting for a connection on %s:%d\\\\n' % (local_IP, local_port)\\n\\n # open client socket used to send orders\\n socket_out = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n socket_out.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # deal with a socket in TIME_WAIT state\\n\\n remote_port = 42000 + player_id\\n\\n connected = False\\n msg_shown = False\\n while not connected:\\n try:\\n if verbose and not msg_shown:\\n print 'connecting on %s:%d to send orders to player %d...' % (remote_IP, remote_port, player_id)\\n socket_out.connect((remote_IP, remote_port))\\n connected = True\\n if verbose:\\n print ' done -> now sending orders to player %d on %s:%d' % (player_id, remote_IP, remote_port)\\n except:\\n if verbose and not msg_shown:\\n print ' connection failed -> will try again every 100 msec...'\\n time.sleep(.1)\\n\\n msg_shown = True\\n\\n if verbose:\\n print\\n\\n # accept connection to the server socket to receive orders from remote player\\n print 'sutck on accept'\\n socket_in, remote_address = socket_in.accept()\\n if verbose:\\n print 'now listening to orders from player %d' % (player_id)\\n\\n # end verbose display\\n if verbose:\\n print '\\\\nconnection to remote player %d successful\\\\n-------------------------------------------------------------\\\\n' % player_id\\n\\n # return sockets for further use\\n return (socket_in, socket_out)\",\n \"def sync_remote(self, other):\\n pass # TODO\",\n \"def forward_to_neighbors(self, packet, srcif):\\n source_relationship = self.relations[srcif]\\n # if update received from a customer: send updates to all other neighbors\\n if source_relationship == CUST:\\n for neighbor in self.sockets.keys():\\n if neighbor != srcif:\\n packet[SRCE] = ('.').join(neighbor.split('.', 3)[:3]) + '.1'\\n packet[DEST] = neighbor\\n sending_msg = json.dumps(packet).encode()\\n self.sockets[neighbor].sendall(sending_msg)\\n # if update received from a peer or a provider: only send updates to your customers\\n else:\\n for neighbor in self.sockets.keys():\\n if neighbor != srcif and self.relations[neighbor] not in [PROV,PEER]:\\n packet[SRCE] = ('.').join(neighbor.split('.', 3)[:3]) + '.1'\\n packet[DEST] = neighbor\\n sending_msg = json.dumps(packet).encode()\\n self.sockets[neighbor].sendall(sending_msg)\",\n \"def setupHostConnection(self, host_ip):\\n if host_ip != self.ip and host_ip != '':\\n host_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n indicator = host_socket.connect_ex((host_ip, 9090))\\n if indicator != 0:\\n return False\\n else:\\n new_host_msg = Message(\\\"NHST\\\", self.ip, '\\\\0')\\n host_socket.sendall(new_host_msg.generateByteMessage())\\n print('NHST message sent to Host at ' + host_ip)\\n area_message = self.parseMessage(host_socket)\\n if(area_message.type == 'AREA'):\\n print('AREA message received from ' + area_message.origin)\\n payload_array = area_message.payload.split(':')\\n curr_host_ip = area_message.origin\\n host_min_x = int(payload_array[0])\\n host_max_x = int(payload_array[1])\\n self.x_min = host_max_x\\n self.x_max = self.x_min + 50\\n if host_max_x > self.curr_x_max:\\n self.curr_x_max = host_max_x\\n if self.x_min == host_max_x:\\n self.l_neighbor = curr_host_ip\\n if host_min_x <= self.curr_x_min:\\n self.curr_x_min = host_min_x\\n self.curr_x_min_ip = curr_host_ip\\n new_thread = Thread(target=lambda: self.listenToHost(host_socket))\\n new_thread.daemon = True\\n new_thread.start()\\n new_connection = Connection(host_ip, host_socket, new_thread)\\n self.connections.append(new_connection)\\n return True\\n else:\\n print('Invalid message type received from ' + area_message.origin + ' - Host corrupt')\\n return False\\n return True\",\n \"def sending():\\n # don't use socket.connect because it fixes a\\n # remote address and causes problems when receiving\\n # from other sockets and sending to them\\n\\n # we also need to cater for sending normal data\\n\\n global DATA\\n start = current_time()\\n while True:\\n if(current_time() - start) < 10:\\n time.sleep(2)\\n continue\\n else:\\n data_to_send = pickle.dumps(DATA[\\\"distance_vec\\\"])\\n for every_neighbor in DATA[\\\"neighbor\\\"]:\\n send_address = (\\\"127.0.0.1\\\", every_neighbor[2])\\n SOCKET1.sendto(data_to_send, send_address)\\n start = current_time()\",\n \"def send_update(self, neighbor):\\n message = 'ROUTE UPDATE'\\n source = ':'.join([self.name[0], str(self.name[1])])\\n dv = []\\n for others in self.distance_vector:\\n others_sep = others.split(':')\\n dv.append(','.join([others_sep[0], others_sep[1], str(self.distance_vector[others].cost)]))\\n dv = '\\\\n'.join(dv)\\n to_send = '\\\\n'.join([message, source, dv])\\n neighbor.sok.sendto(to_send, (neighbor.addr, neighbor.port))\\n neighbor.send_timer = time.time()\\n neighbor.update_ready = False\",\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 set_neighbor(self):\\n for node in self.node:\\n for other in self.node:\\n if other.id != node.id and distance.euclidean(node.location, other.location) <= node.com_ran:\\n node.neighbor.append(other.id)\",\n \"def connect_ports(self, port1_name: str, ip1_name: str,\\n port2_name: str, ip2_name: str):\\n if (ip1_name not in self._ips.keys() or\\n ip2_name not in self._ips.keys()):\\n raise ValueError(\\n f'No such IP in this module: {ip1_name}, {ip2_name}.'\\n ' Use add_ip method to add the IPs first')\\n # get the 'WrapperPort's\\n port1 = self._ips[ip1_name].get_port_by_name(port1_name)\\n port2 = self._ips[ip2_name].get_port_by_name(port2_name)\\n\\n if len(port1) != len(port2):\\n warning(f'ports: {ip1_name}:{port1.name}({len(port1)}), '\\n f'{ip2_name}:{port2.name}({len(port2)})'\\n ' have different widths!')\\n\\n inst1_args = getattr(self, ip1_name)\\n inst2_args = getattr(self, ip2_name)\\n\\n full_name1 = port_direction_to_prefix(port1.direction) + port1.name\\n full_name2 = port_direction_to_prefix(port2.direction) + port2.name\\n\\n # If a port was connected previoulsy,\\n # take the previoulsy created signal, instead of creating a new one\\n if full_name1 in inst1_args.keys():\\n sig = inst1_args[full_name1]\\n elif full_name2 in inst2_args.keys():\\n sig = inst2_args[full_name2]\\n else:\\n # neither of the ports was connected previously\\n # create a new signal for the connection\\n combined_name = port1.name + '_' + port2.name\\n self._signals_between_ips.append(combined_name)\\n sig = Signal(len(port1), name=combined_name)\\n setattr(self, combined_name, sig)\\n\\n inst1_args[full_name1] = sig\\n inst2_args[full_name2] = sig\",\n \"def Connect(self):\\r\\n #sleep(1)\\r\\n #self.src_ref = randint(1, 20)\\r\\n self.src_ref = 10\\r\\n self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\r\\n self.s.settimeout(self.timeout)\\r\\n self.s.connect((self.ip, self.port))\\r\\n self.s.send(TPKTPacket(COTPConnectionPacket(self.dst_ref,\\r\\n self.src_ref,\\r\\n self.dst_tsap,\\r\\n self.src_tsap,\\r\\n 0x0a)).pack())\\r\\n reply = self.s.recv(1024)\\r\\n _ = COTPConnectionPacket().unpack(TPKTPacket().unpack(reply).data)\\r\\n\\r\\n self.NegotiatePDU()\",\n \"def other_parse(neighbor):\\n mgmt_ip = neighbor[mgmt_ip_s]\\n hostname = neighbor[hostname_s].split('.')[0]\\n if nxos:\\n sysname = neighbor['sysname']\\n if sysname != '':\\n hostname = sysname\\n if mgmt_ip == '':\\n mgmt_ip = neighbor['interface_ip']\\n software_version = neighbor[version_s]\\n if software_version.__contains__(','):\\n for software in software_version.split(','):\\n if software.__contains__('Version'):\\n software_version = software.split('Version')[1].split('REL')[0]\\n if software_version.__contains__(':'):\\n software_version = software_version.replace(': ', '')\\n else:\\n software_version = software_version.replace(' ', '')\\n break\\n elif software_version.__contains__('Version'):\\n found_1 = False\\n for x in software_version.split(' '):\\n if x.__contains__('Version'):\\n found_1 = True\\n continue\\n if found_1:\\n software_version = x\\n break\\n elif software_version.__contains__('version'):\\n found_1 = False\\n for x in software_version.split(' '):\\n if x.__contains__('version'):\\n found_1 = True\\n continue\\n if found_1:\\n software_version = x\\n break\\n platform = neighbor['platform']\\n if platform.__contains__('cisco '):\\n platform = neighbor['platform'].replace('cisco ', '')\\n elif platform.__contains__('Cisco '):\\n platform = neighbor['platform'].replace('Cisco ', '')\\n else:\\n platform = neighbor['platform']\\n other = {\\n 'hostname': hostname,\\n 'ip_address': mgmt_ip,\\n 'neighbor': {\\n 'hostname': session.hostname,\\n 'ip_address': session.ip_address,\\n 'remote_intf': neighbor['local_port'],\\n 'local_intf': neighbor['remote_port']\\n },\\n 'software_version': software_version,\\n 'model': platform\\n }\\n self.others.append(other)\",\n \"def share_config_with_other_nodes(self):\\n my_host, _ = self.experiment.get_peer_ip_port_by_id(self.experiment.my_id)\\n other_hosts = set()\\n for peer_id in self.experiment.all_vars.keys():\\n host = self.experiment.all_vars[peer_id]['host']\\n if host not in other_hosts and host != my_host:\\n other_hosts.add(host)\\n self._logger.info(\\\"Syncing config with host %s\\\", host)\\n os.system(\\\"rsync -r --delete /home/martijn/hyperledger-deploy-scripts martijn@%s:/home/martijn/\\\" % host)\",\n \"def connect_one_way(node1, node2, weight):\\n node1.add_or_update_neighbour(node2, weight)\",\n \"def onConnecting(self, transport_details):\",\n \"def callback(self):\\n server_addresses = self._address_book.list_by_key(key)\\n for address in server_addresses:\\n if self._client_logic.connection_error.is_set():\\n try:\\n connection = socket.create_connection((address[0], 9665))\\n self.sident_verify(connection, v_event)\\n except socket.error:\\n continue\\n else:\\n return True\\n neighbor_addresses = self._client_list.list()\\n for address in neighbor_addresses:\\n if self._client_logic.connection_error.is_set():\\n try:\\n connection = socket.create_connection((address[0], address[1]))\\n \\n\\n def sident_verify(self, connection):\\n \\\"\\\"\\\"Request the server send a signed verification of its identity with \\n IP address, port and timestamp.\\n\\n sident stands for 'Server Identity'\\n\\n An sident_verify message is of the following form:\\n\\n {'type':'sident_verify'\\n 'timestamp':<UNIX TIMESTAMP>}\\n\\n The server should reply with an sident_response message which is of\\n the following form:\\n\\n {'type':'sident_response',\\n 'ip_addr':<IP ADDRESS AS A STRING>,\\n 'port':<PORT NUMBER AS AN INTEGER>,\\n 'timestamp':<UNIX TIMESTAMP>,\\n 'signature':<SIGNED DIGEST OF THE THREE PREVIOUS VALUES AS A UTF-8 STRING \\n CONCATENATED TOGETHER WITH COMMA SEPERATORS>}\\\"\\\"\\\"\\n sident_verify_msg = {'type':'sident_verify',\\n 'timestamp':calendar.timegm(time.gmtime())}\\n self._send_queue.put((sident_verify_msg, connection))\\n return True\\n\\n def request_server_address(self, connection):\\n \\\"\\\"\\\"Request the best guess at the current server address from a client\\n peer. \\n\\n P2P nodes use the same JSON messaging style as the normal client and\\n server. address_request messages are of the form:\\n\\n {'type':'address_request'\\n 'timestamp':<UNIX TIMESTAMP>}\\n\\n And a server_address message is of the form:\\n\\n {'type':'server_address',\\n 'key':<CRYPTOGRAPHIC KEY THAT UNIQUELY IDENTIFIES SERVER>,\\n 'address':<SERVER ADDRESS>,\\n 'port':<WHAT PORT THE SERVER LISTENS ON>,\\n 'address_timestamp':<UNIX TIMESTAMP OF WHEN PEER RECEIVED ADDRESS>,\\n 'signature':<VERIFICATION THAT INFORMATION CAME FROM SERVER ORIGINALLY>,\\n 'timestamp':<UNIX TIMESTAMP OF WHEN MESSAGE WAS SENT>}\\\"\\\"\\\"\\n address_request = {'type':'sident_verify',\\n 'timestamp':calendar.timegm(time.gmtime())}\\n self._send_queue.put((address_request, connection))\\n return True\\n \\n\\n def send_loop(self):\\n \\\"\\\"\\\"Send loop that is meant to be started from a seperate thread of \\n execution. The send loop pulls 'raw' python object messages from this \\n objects send_queue attribute and converts them to json strings before \\n encoding them as utf-8 to send across the wire. Sent along with the \\n message is the connection to send it on.\\n\\n Responses are handled and received by the receive_loop method of this class\\n which is ran in a seperate thread of execution.\\\"\\\"\\\"\\n while not self._shutdown.is_set():\\n message_tuple = self._send_queue.get()\\n message = message_tuple[0]\\n message_length = self._calculate_recursive_length(message)\\n wrapped_message = [message_length, message]\\n wire_message = (json.dumps(wrapped_message) + \\\"\\\\r\\\\n\\\\r\\\\n\\\").encode('utf-8')\\n message_tuple[1].sendall(wire_message)\\n return True\\n\\n def receive_loop(self):\\n \\\"\\\"\\\"Receive loop that is meant to be started from a seperate thread of\\n execution. The receive loop takes in 'raw' utf-8 json messages from the\\n wire and decodes them, then interprets them to produce native python \\n objects. The resulting objects are then handled by a method of this class\\n of the form handle_<message_type>. For example if a message with the \\n 'type' key 'test' came in like so:\\n\\n {'type':'test'}\\n\\n The method self.handle_test(message) would be called with the message\\n dictionary object passed along.\\n \\\"\\\"\\\"\\n msg_buffer = bytes() # The message input buffer\\n while not self._shutdown.is_set():\\n if msg_buffer:\\n try:\\n msg_length = self.determine_length_of_json_msg(msg_buffer)\\n except InvalidLengthHeader:\\n msg_length = float(\\\"inf\\\")\\n if len(msg_buffer) >= msg_length:\\n message = self.extract_msg(msg_buffer, msg_length)\\n try:\\n handler = getattr(self, \\\"handle_\\\" + message['type'])\\n except AttributeError:\\n print(\\\"Can't handle message of type: \\\" +\\n str(message['type']))\\n continue\\n handler(message)\\n msg_buffer = msg_buffer[msg_length:]\\n else:\\n try:\\n msg_buffer += connection.recv(1024)\\n except socket.timeout:\\n pass\\n else:\\n try:\\n msg_buffer += connection.recv(1024)\\n except socket.timeout:\\n pass\\n \\n def handle_sident_response(message):\\n \\\"\\\"\\\"Handle an sident_response type message of the form:\\n \\n {'type':'sident_response',\\n 'ip_addr':<IP ADDRESS AS A STRING>,\\n 'port':<PORT NUMBER AS AN INTEGER>,\\n 'timestamp':<UNIX TIMESTAMP>,\\n 'signature':<SIGNED DIGEST OF THE THREE PREVIOUS VALUES AS A UTF-8 STRING \\n CONCATENATED TOGETHER WITH COMMA SEPERATORS>}\\n \\n The handler verifies that the information given by the server is properly\\n signed, then adds the information to address books/etc, and finally \\n resolves the issue using provided client logic methods and clears the \\n error indicator.\\\"\\\"\\\"\\n if self._client_logic.connection_error.is_set():\\n try:\\n ip_addr = message['ip_addr']\\n port = message['port']\\n timestamp = message['timestamp']\\n signature = message['signature']\\n except KeyError:\\n return False\\n sha_hash = SHA256.new(\\n (ip_addr + \\\",\\\" + port + \\\",\\\" + timestamp).encode('utf-8'))\\n if self._key.verify(sha_hash.digest(), signature):\\n self._address_book.add_address(self._key, ip_addr, timestamp,\\n signature, port=port)\\n self._address_book.save()\\n if self._client_logic.reconnect(ip_addr, port):\\n self._client_logic.connection_error.clear()\\n return True\\n else:\\n return False\\n else:\\n return False\\n\\n \\n def determine_length_of_json_msg(self, message_bytes):\\n \\\"\\\"\\\"Incrementally parse a JSON message to extract the length header.\\n\\n message_bytes: The bytes that represent the portion of the message \\n recieved.\\n \\\"\\\"\\\"\\n # All messages must be written in utf-8\\n message = message_bytes.decode('utf-8')\\n # Check that the message we have been given looks like a valid length header\\n if \\\",\\\" not in message:\\n raise InvalidLengthHeader(message)\\n length_portion = message.split(\\\",\\\")[0]\\n left_bracket = length_portion[0] == \\\"[\\\"\\n number_before_comma = length_portion[-1] in \\\"1234567890\\\"\\n if left_bracket and number_before_comma:\\n for character in enumerate(length_portion):\\n if character[1] not in \\\"[ \\\\n\\\\t\\\\r1234567890,\\\":\\n raise InvalidLengthHeader(length_portion)\\n elif character[1] in \\\"1234567890\\\":\\n length_start = character[0]\\n return int(length_portion[length_start:])\\n elif left_bracket:\\n raise InvalidLengthHeader(length_portion)\\n else:\\n raise MissingLengthHeader(length_portion)\\n return False\\n\\n def extract_msg(self, msg_buffer, length):\\n message = msg_buffer[:length].decode()\\n try:\\n right_curly_bracket = message[-6] == \\\"}\\\" or message[-2] == \\\"}\\\"\\n except IndexError:\\n print(message, msg_buffer, length)\\n valid_delimiter = message[-6:] == \\\"}]\\\\r\\\\n\\\\r\\\\n\\\"\\n if right_curly_bracket and valid_delimiter:\\n return message\\n elif right_curly_bracket:\\n raise InvalidMessageDelimiter(message)\\n else:\\n raise MissingMessageDelimiter(message)\\n\\n def _calculate_recursive_length(self, msg_dict):\\n \\\"\\\"\\\"Calculate the length of a dictionary represented as JSON once a length\\n field has been added as a key.\\\"\\\"\\\"\\n delimiter = \\\"\\\\r\\\\n\\\\r\\\\n\\\"\\n initial_length = len(\\n json.dumps(msg_dict) + delimiter)\\n initial_list = [initial_length, msg_dict]\\n recursive_length = len(\\n json.dumps(initial_list) + delimiter)\\n recursive_list = [recursive_length, msg_dict]\\n while len(json.dumps(recursive_list) + delimiter) != recursive_list[0]:\\n recursive_length = len(\\n json.dumps(recursive_list) + delimiter)\\n recursive_list = [recursive_length, msg_dict]\\n return recursive_list[0]\",\n \"def test_ping_from_neighbor(duthosts, enum_rand_one_per_hwsku_frontend_hostname, nbrhosts):\\n duthost = duthosts[enum_rand_one_per_hwsku_frontend_hostname]\\n cfg_facts = duthost.config_facts(host=duthost.hostname, source=\\\"running\\\")[\\\"ansible_facts\\\"]\\n dut_ports = cfg_facts[\\\"PORT\\\"]\\n portchannel_itfs = cfg_facts[\\\"PORTCHANNEL_INTERFACE\\\"]\\n for portchannel, ip_list in list(portchannel_itfs.items()):\\n portchannel_members = list(cfg_facts[\\\"PORTCHANNEL_MEMBER\\\"][portchannel].keys())\\n hostname = dut_ports[portchannel_members[0]]['description'].split(':')[0]\\n for nbr_hostname, nbrhost in list(nbrhosts.items()):\\n if nbr_hostname != hostname:\\n continue\\n for ip in ip_list:\\n ip = ip.split('/')[0]\\n pytest_assert(nbrhost['host'].ping_dest(ip), \\\"{} ping port channel {} failed\\\".format(nbr_hostname, ip))\",\n \"def test_reconnect_another(self):\\n line, head = self._get_line()\\n self.tool.connect(line, head, (120, 50))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n item = cinfo.connected\\n port = cinfo.port\\n constraint = cinfo.constraint\\n\\n assert item == self.box1\\n assert port == self.box1.ports()[0]\\n assert item != self.box2\\n\\n # connect to box2, handle's connected item and connection data\\n # should differ\\n self.tool.connect(line, head, (120, 150))\\n cinfo = self.canvas.get_connection(head)\\n assert cinfo is not None\\n self.assertEqual(self.box2, cinfo.connected)\\n self.assertEqual(self.box2.ports()[0], cinfo.port)\\n\\n # old connection does not exist\\n self.assertNotEqual(item, cinfo.connected)\\n self.assertNotEqual(constraint, cinfo.constraint)\",\n \"def test_connectivity(self):\\n vlan_net1 = helpers.get_not_used_vlan(self.tester.bridge, VLAN_RANGE)\\n vlan_net2 = helpers.get_not_used_vlan(self.tester.bridge, VLAN_RANGE)\\n trunk_mac = net.get_random_mac('fa:16:3e:00:00:00'.split(':'))\\n sub_port_mac = net.get_random_mac('fa:16:3e:00:00:00'.split(':'))\\n sub_port_segmentation_id = helpers.get_not_used_vlan(\\n self.tester.bridge, VLAN_RANGE)\\n LOG.debug(\\\"Using %(n1)d vlan tag as local vlan ID for net1 and %(n2)d \\\"\\n \\\"for local vlan ID for net2\\\", {\\n 'n1': vlan_net1, 'n2': vlan_net2})\\n self.tester.set_peer_tag(vlan_net1)\\n self.trunk_manager.create_trunk(self.trunk.trunk_id,\\n self.trunk.port_id,\\n trunk_mac)\\n\\n # tag the patch port, this should be done by the ovs agent but we mock\\n # it for this test\\n conn_testers.OVSBaseConnectionTester.set_tag(\\n self.trunk.patch_port_int_name, self.tester.bridge, vlan_net1)\\n\\n self.tester.wait_for_connection(self.tester.INGRESS)\\n self.tester.wait_for_connection(self.tester.EGRESS)\\n\\n self.tester.add_vlan_interface_and_peer(sub_port_segmentation_id,\\n self.net2_cidr)\\n conn_testers.OVSBaseConnectionTester.set_tag(\\n self.tester._peer2.port.name, self.tester.bridge, vlan_net2)\\n\\n sub_port = trunk_manager.SubPort(self.trunk.trunk_id,\\n uuidutils.generate_uuid(),\\n sub_port_mac,\\n sub_port_segmentation_id)\\n\\n self.trunk_manager.add_sub_port(sub_port.trunk_id,\\n sub_port.port_id,\\n sub_port.port_mac,\\n sub_port.segmentation_id)\\n # tag the patch port, this should be done by the ovs agent but we mock\\n # it for this test\\n conn_testers.OVSBaseConnectionTester.set_tag(\\n sub_port.patch_port_int_name, self.tester.bridge, vlan_net2)\\n\\n self.tester.wait_for_sub_port_connectivity(self.tester.INGRESS)\\n self.tester.wait_for_sub_port_connectivity(self.tester.EGRESS)\\n\\n self.trunk_manager.remove_sub_port(sub_port.trunk_id,\\n sub_port.port_id)\\n self.tester.wait_for_sub_port_no_connectivity(self.tester.INGRESS)\\n self.tester.wait_for_sub_port_no_connectivity(self.tester.EGRESS)\\n\\n self.trunk_manager.remove_trunk(self.trunk.trunk_id,\\n self.trunk.port_id)\\n self.tester.wait_for_no_connection(self.tester.INGRESS)\",\n \"def get_temporal_neighbor(self, source_nodes, timestamps, n_neighbors=20):\\n assert (len(source_nodes) == len(timestamps))\\n\\n tmp_n_neighbors = n_neighbors if n_neighbors > 0 else 1\\n \\n # ALL interactions described in these matrices are sorted in each row by time\\n neighbors = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.int32) # each entry in position (i,j) represent the id of the item targeted by user src_idx_l[i] with an interaction happening before cut_time_l[i]\\n edge_times = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.float32) # each entry in position (i,j) represent the timestamp of an interaction between user src_idx_l[i] and item neighbors[i,j] happening before cut_time_l[i]\\n edge_idxs = np.zeros((len(source_nodes), tmp_n_neighbors)).astype(np.int32) # each entry in position (i,j) represent the interaction index of an interaction between user src_idx_l[i] and item neighbors[i,j] happening before cut_time_l[i]\\n\\n for i, (source_node, timestamp) in enumerate(zip(source_nodes, timestamps)):\\n # extracts all neighbors, interactions (i.e. edges) indexes and timestamps of ALL interactions of source_nodes happening before their corresponding cut_time (i.e. timestamps)\\n source_neighbors, source_edge_idxs, source_edge_times = self.find_before(source_node, timestamp)\\n\\n if len(source_neighbors) > 0 and n_neighbors > 0:\\n \\n if self.uniform: # if we are applying uniform sampling, shuffles the data above before sampling\\n \\n sampled_idx = np.random.randint(0, len(source_neighbors), n_neighbors) # random sample n_neighbors temporal neighbors\\n\\n neighbors[i, :] = source_neighbors[sampled_idx]\\n edge_times[i, :] = source_edge_times[sampled_idx]\\n edge_idxs[i, :] = source_edge_idxs[sampled_idx]\\n\\n # re-sort based on time cuz provided source_nodes are not sorted yet\\n # so that neighbors, edge_times, and edge_idxs are all sorted by time\\n pos = edge_times[i, :].argsort()\\n neighbors[i, :] = neighbors[i, :][pos]\\n edge_times[i, :] = edge_times[i, :][pos]\\n edge_idxs[i, :] = edge_idxs[i, :][pos]\\n \\n else:\\n \\n # Take most recent n_neighbors interactions\\n source_edge_times = source_edge_times[-n_neighbors:]\\n source_neighbors = source_neighbors[-n_neighbors:]\\n source_edge_idxs = source_edge_idxs[-n_neighbors:]\\n\\n assert (len(source_neighbors) <= n_neighbors)\\n assert (len(source_edge_times) <= n_neighbors)\\n assert (len(source_edge_idxs) <= n_neighbors)\\n\\n neighbors[i, n_neighbors - len(source_neighbors):] = source_neighbors\\n edge_times[i, n_neighbors - len(source_edge_times):] = source_edge_times\\n edge_idxs[i, n_neighbors - len(source_edge_idxs):] = source_edge_idxs\\n\\n return neighbors, edge_idxs, edge_times\",\n \"def shared_cost_peering(self, as1, as2):\\n self._connect_ases(as1, as2)\\n set_community(self, as1, as2.asn, str(as1.asn) + ':1337')\\n set_community(self, as2, as1.asn, str(as2.asn) + ':1337')\",\n \"def create_connection(your_group, other_group=0, other_IP='127.0.0.1', verbose=False):\\r\\n \\r\\n # init verbose display\\r\\n if verbose:\\r\\n print('\\\\n[--- starts connection -----------------------------------------------------\\\\n')\\r\\n \\r\\n # check whether there is a referee\\r\\n if other_group == 0:\\r\\n if verbose:\\r\\n print('** group %d connecting to referee on %s **\\\\n' % (your_group, other_IP))\\r\\n \\r\\n # create one socket (client only)\\r\\n socket_out = create_client_socket(other_IP, 42000+your_group, verbose)\\r\\n \\r\\n connection = {'in':socket_out, 'out':socket_out}\\r\\n \\r\\n if verbose:\\r\\n print('** group %d successfully connected to referee on %s **\\\\n' % (your_group, other_IP))\\r\\n else:\\r\\n if verbose:\\r\\n print('** group %d connecting to group %d on %s **\\\\n' % (your_group, other_group, other_IP))\\r\\n\\r\\n # create two sockets (server and client)\\r\\n socket_in = create_server_socket(42000+your_group, verbose)\\r\\n socket_out = create_client_socket(other_IP, 42000+other_group, verbose)\\r\\n \\r\\n socket_in = wait_for_connection(socket_in, verbose)\\r\\n \\r\\n connection = {'in':socket_in, 'out':socket_out}\\r\\n\\r\\n if verbose:\\r\\n print('** group %d successfully connected to group %d on %s **\\\\n' % (your_group, other_group, other_IP))\\r\\n \\r\\n # end verbose display\\r\\n if verbose:\\r\\n print('----------------------------------------------------- connection started ---]\\\\n')\\r\\n\\r\\n return connection\",\n \"def link_interface(other_endpoint: str, interface: Tuple[str, str]):\\n # I will be the sender\\n sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)\\n listen, receiver = interface\\n sock.bind((listen, port))\\n rtts = list()\\n\\n # to make sure other endpoint is active and listening\\n # we will wait it to send a sign byte\\n sock.recv(1)\\n # recieved byte is not important\\n # not necessary to read what it is\\n for _ in range(message_count):\\n # create a packet and send it to receiver\\n sock.sendto(create_packet(), (receiver, port))\\n # wait for acknowledgement\\n recv_msg = sock.recv(buffer_size)\\n # extract timestamp\\n ts, _ = parse_packet(recv_msg)\\n # calculate rtt and store\\n rtts.append(time.time() - ts)\\n\\n tot_rtt = 0\\n for rtt in rtts:\\n tot_rtt += rtt\\n avg_rtt = tot_rtt / message_count\\n\\n file_lock.acquire()\\n with open('link_costs.txt', 'a') as file:\\n # r2-r1=avg_rtt ; d-r1=avg_rtt\\n file.write(f'{other_endpoint}-{endpoint}={avg_rtt}\\\\n')\\n file_lock.release()\",\n \"def route_update(self, neighbor, dv_list):\\n neighbor.is_killed = False\\n neighbor.kill_timer = time.time()\\n neighbor.dv_update(dv_list)\\n # Iterate to see if new node is included in the graph.\\n for name in neighbor.distance_vector:\\n if name not in self.distance_vector:\\n self.distance_vector[name] = Router.OtherRouter(float('Inf'), None)\\n if self.update_dv():\\n for name in self.neighbors:\\n self.neighbors[name].update_ready = True\\n self.neighbors[name].send_timer = time.time()\",\n \"def main():\\n parser = ArgumentParser()\\n parser.add_argument(\\\"router_id\\\", help=\\\"id of the router\\\")\\n parser.add_argument(\\\"port_no\\\", help=\\\"port no. at which the\\\\\\n router is listening\\\", type=int)\\n parser.add_argument(\\\"router_config_file\\\", help=\\\"configuration\\\\\\n file for the router\\\")\\n args = parser.parse_args()\\n DATA[\\\"port\\\"] = args.port_no\\n DATA[\\\"router_id\\\"] = args.router_id\\n read_config_file(args.router_config_file)\\n\\n # after the read_config_file func completes we set a variable\\n # saying that neighbor data is ready\\n global READ_CONFIG_COMP\\n READ_CONFIG_COMP = True\\n\\n initial_dvec_and_forw_insert()\\n\\n SOCKET1.bind((\\\"\\\", DATA[\\\"port\\\"])) # converts the port to a listening state\\n # print(DATA['neighbor'])\\n\\n # read thread is listening for incoming messages\\n recv_th = Thread(target=recving)\\n recv_th.start()\\n\\n # sending thread sends its distance vector to its direct neighbors\\n send_th = Thread(target=sending)\\n send_th.start()\\n\\n # link cost change interface thread\\n intf_th = Thread(target=interface_thread, args=(\\n args.router_config_file, ), daemon=True)\\n intf_th.start()\\n\\n # find thread is checking if every router is available/alive\\n find_th = Thread(target=check_if_alive, daemon=True)\\n find_th.start()\\n\\n # we don't need thread.join because all of our threads\\n # are non daemon threads\\n\\n # SOCKET1.close()\\n return\",\n \"def connect_peers(self):\\n assert self.targets\\n # connect closest node to target id\\n for t in self.targets:\\n if len(self.connections) >= self.max_peers:\\n break\\n for knode in self.proto.routing.neighbours(devp2p.kademlia.Node.from_id(t['address'])):\\n assert isinstance(knode, devp2p.kademlia.Node)\\n # assure within tolerance\\n if knode.id_distance(t['address']) < t['tolerance']:\\n # make sure we are not connected yet\\n remote = self.network[knode.id]\\n if remote not in self.connections:\\n if remote.receive_connect(self):\\n t['connected'] = True\\n self.connections.append(remote)\\n break\",\n \"def tcp_time_updatetime(localport):\\r\\n\\r\\n # Get the ips and ports of servers hosting time_server.repy, retrying nine\\r\\n # times if there is an exception.\\r\\n gotval = False\\r\\n attemptretrieval = 0\\r\\n while attemptretrieval < 2:\\r\\n try:\\r\\n serveraddresses = advertise_lookup(\\\"time_server\\\")\\r\\n except Exception:\\r\\n attemptretrieval = attemptretrieval + 1\\r\\n sleep(2) # Look up the value again in 10 seconds\\r\\n else:\\r\\n if serveraddresses != [] and serveraddresses[0] != '':\\r\\n gotval = True\\t # Successfully obtained the value\\r\\n break\\r\\n else:\\r\\n attemptretrieval = attemptretrieval + 1\\r\\n\\r\\n\\r\\n if not gotval:\\r\\n raise Exception(\\\"Unable to locate any servers running time_server.repy\\\")\\r\\n\\r\\n\\r\\n timelength = 25 # Max length of string, representing the time, to be received\\r\\n shuffledserveraddresses = random_sample(serveraddresses,min(len(serveraddresses),5))\\r\\n\\r\\n # Open a connection with a random server hosting time_server.repy\\r\\n timeobtained = False\\r\\n serverindex = 0\\r\\n while serverindex < len(shuffledserveraddresses):\\r\\n remoteaddress = shuffledserveraddresses[serverindex].split(':')\\r\\n remoteip = remoteaddress[0]\\r\\n remoteport = int(remoteaddress[1])\\r\\n\\r\\n try:\\r\\n sockobject = timeout_openconn(remoteip,remoteport)\\r\\n except Exception:\\r\\n serverindex +=1\\r\\n else:\\r\\n timeobtained = True\\r\\n break\\r\\n\\r\\n\\r\\n if not timeobtained:\\r\\n raise Exception(\\\"Unable to open connection with any of the \\\",len(shuffledserveraddresses),\\\"servers running time_server.repy.\\\")\\r\\n\\r\\n\\r\\n currenttime =''\\r\\n while '$' not in currenttime:\\r\\n currenttime += sockobject.recv(20)\\r\\n sockobject.close()\\r\\n currenttime = float(currenttime[:-1])\\r\\n\\r\\n # finally, set the time\\r\\n time_settime(currenttime)\\r\\n\\r\\n return shuffledserveraddresses[serverindex]\",\n \"def connect(from_tuple, to_tuple):\\n\\n from_unit, from_port = from_tuple\\n to_unit, to_port = to_tuple\\n\\n to_unit.connect(from_unit, from_port, to_port)\",\n \"def connect(self, source, target):\\r\\n connection = (self.coalesce_node(source), self.coalesce_node(target))\\r\\n self.connections.add(connection)\",\n \"def __init__(self, destination=None, port=10000, printout=False, ip_change=True):\\n if destination and port:\\n self.destination_ip = destination\\n self.destination_port = port\\n else:\\n self.destination_ip = get_local_ip()\\n self.destination_port = port\\n\\n self.sending_failed_counter = 0\\n self.ip_change = ip_change\\n self.printout = printout\\n self.destination_address = self.destination_ip, self.destination_port\\n print 'OSC-transmitter to', self.destination_ip, ':', self.destination_port\\n\\n try:\\n self.osc_transmitter = OSC.OSCClient()\\n self.osc_transmitter.connect(self.destination_address)\\n except:\\n pass\\n self.time_of_last_connect = 0\\n self.connection_status = 'disconnected'\",\n \"def establish_secondary_communication(self):\\n # 0. creating socket\\n tmp_soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\n # Binding to address\\n tmp_soc.bind(('0.0.0.0', self.secondary_port))\\n tmp_soc.listen(1) # No more than 1 connection\\n\\n print(\\\"started second line protocol on port %s\\\" % (self.port - 1))\\n # 1.\\n self.send_life_soc, server_addr = tmp_soc.accept()\\n\\n # 2.\\n self.send_life_soc.send(\\\"NEW_LINE\\\".encode('utf-8'))\\n\\n # 3.\\n response = self.send_life_soc.recv(self.packet_len).decode('utf-8')\\n if response != \\\"BOOYAH\\\":\\n raise ValueError('Error: Invalid response from server, expecting %s got %s' % (\\\"NEW_LINE\\\", response))\\n\\n print(\\\"Second line established with server\\\")\",\n \"def update(self, remote_gateway_info):\\n\\n self.touch()\\n # remember, don't flag connection stats as worthy of a change.\\n self.msg.conn_stats = remote_gateway_info.conn_stats\\n # self.msg.last_connection_timestamp = rospy.Time.now() # do we really need this?\\n\\n # don't update every client, just the ones that we need information from\\n important_state = (self.state == ConcertClient.State.AVAILABLE) or (self.state == ConcertClient.State.MISSING)\\n is_changed = False\\n return is_changed\",\n \"def _outgoing_connect_cb(self, peer_id, tcp_handle, error):\\n\\n if error is not None:\\n self._logger.error(\\n \\\"unable to establish connction to peer %d\\\",\\n peer_id,\\n )\\n del self._outgoing[peer_id]\\n return\\n\\n self._outgoing[peer_id] = Outgoing(\\n tcp_handle,\\n msgpack.Packer(),\\n msgpack.Unpacker(),\\n self._conf[peer_id],\\n {},\\n )\\n\\n tcp_handle.start_read(partial(self._outgoing_read_cb, peer_id))\\n self._logger.info(\\\"connect to peer %d\\\", peer_id)\",\n \"def tcp_server_thread(accepted_socket, address):\\n current_timestamp = datetime.datetime.now().replace(tzinfo=timezone.utc).timestamp()\\n accepted_socket.sendto(struct.pack('!f', current_timestamp), address)\\n accepted_socket.close()\\n pass\",\n \"def connect(self, address: Tuple[str, int]) -> None:\\n ...\",\n \"def addNeighbor(self, neighbor):\",\n \"def connect_both(node1, node2, weight):\\n connect_one_way(node1, node2, weight)\\n connect_one_way(node2, node1, weight)\",\n \"def _make_connection(user=None, friend=None, update=False, updated=[]):\\n created = 0\\n updated_count = 0\\n\\n if not update:\\n # if we have other connections here:\\n conns_inst_to = Degree.objects.filter(to_user=user)\\n conns_inst_from = Degree.objects.filter(from_user=user)\\n conns_frnd_to = Degree.objects.filter(to_user=friend)\\n conns_frnd_from = Degree.objects.filter(from_user=friend)\\n #caching results\\n pickle_str = cPickle.dumps(conns_inst_to)\\n qs1 = cPickle.loads(pickle_str)\\n pickle_str = cPickle.dumps(conns_inst_from)\\n qs2 = cPickle.loads(pickle_str)\\n pickle_str = cPickle.dumps(conns_frnd_to)\\n qs3 = cPickle.loads(pickle_str)\\n pickle_str = cPickle.dumps(conns_frnd_from)\\n qs4 = cPickle.loads(pickle_str)\\n # original connection between 2 nodes\\n conn, created_conn = Degree.objects.get_or_create(from_user=user, to_user=friend)\\n conn.path = \\\"%s,%s\\\" % (user.id, friend.id)\\n if not created_conn:\\n conn.distance = 0\\n update = True\\n if {'user':user,'friend':friend} not in updated:\\n updated.append({'user':user,'friend':friend})\\n # 2 way connection\\n reverse_conn, created_reverse_conn = Degree.objects.get_or_create(from_user=friend, to_user=user)\\n reverse_conn.path = \\\"%s,%s\\\" % (friend.id, user.id)\\n if not created_reverse_conn:\\n reverse_conn.distance = 0\\n update = True\\n if {'user':user,'friend':friend} not in updated:\\n updated.append({'user':user,'friend':friend})\\n\\n # saving\\n conn.save()\\n reverse_conn.save()\\n\\n\\n if update:\\n while updated:\\n \\\"\\\"\\\"\\n OPTIMIZE:\\n maybe we could check only half of neighbours\\n since we adding reverse connections to updated list\\n this is not necessary\\n logic here:\\n #check all neighbours\\n #new shortest path ?\\n #yes->update check again\\n \\\"\\\"\\\"\\n #wile looop\\n #import pdb;pdb.set_trace()\\n updating = updated.pop()\\n user = updating.get('user')\\n friend = updating.get('friend')\\n current = Degree.objects.get(from_user=user, to_user=friend)\\n current_rev = Degree.objects.get(from_user=friend, to_user=user)\\n\\n neigh_inst_from = Degree.objects.filter(from_user=user, distance=0)\\n # find all connections from my neighbours to newly friend\\n # if distance > 1, fix\\n if neigh_inst_from.count() > 0:\\n for neigh in neigh_inst_from:\\n try:\\n conn_neigh = Degree.objects.get(to_user=friend, from_user=neigh.to_user)\\n # if distance greater than current + 1\\n if conn_neigh.distance > current.distance + 1:\\n conn_neigh.distance = current.distance + 1\\n # path should be traversed through user\\n #conn_neigh.path = \\\"%s,%s,%s\\\" % (neigh.to_user.id, user.id, friend.id)\\n conn_neigh.path = \\\"%s,%s\\\" % (neigh.to_user.id, current.path)\\n conn_neigh.save()\\n # adding to queue current pair\\n if {'user':neigh.to_user,'friend':friend} not in updated:\\n updated.append({'user':neigh.to_user,'friend':friend})\\n updated_count += 1\\n except Degree.DoesNotExist:\\n continue\\n # since there can be new connection\\n\\n neigh_inst_to = Degree.objects.filter(to_user=user, distance=0)\\n if neigh_inst_to.count() > 0:\\n for neigh in neigh_inst_to:\\n try:\\n conn_neigh = Degree.objects.get(to_user=neigh.from_user, from_user=friend)\\n if conn_neigh.distance > current_rev.distance + 1:\\n conn_neigh.distance = current_rev.distance + 1\\n #conn_neigh.path = \\\"%s,%s,%s\\\" % (friend.id, user.id, neigh.from_user.id)\\n conn_neigh.path = \\\"%s,%s\\\" % (current_rev.path, neigh.from_user.id)\\n conn_neigh.save()\\n if {'user':friend,'friend':neigh.from_user} not in updated:\\n updated.append({'user':friend,'friend':neigh.from_user})\\n updated_count += 1\\n except Degree.DoesNotExist:\\n continue\\n\\n # This will fire on reverse connections\\n\\n neigh_friend_from = Degree.objects.filter(from_user=friend, distance=0)\\n if neigh_friend_from.count() > 0:\\n for neigh in neigh_friend_from:\\n try:\\n conn_neigh = Degree.objects.get(to_user=user, from_user=neigh.to_user)\\n if conn_neigh.distance > current_rev.distance + 1:\\n conn_neigh.distance = current_rev.distance + 1\\n #conn_neigh.path = \\\"%s,%s,%s\\\" % (neigh.to_user.id, friend.id, user.id)\\n conn_neigh.path = \\\"%s,%s\\\" % (neigh.to_user.id, current_rev.path)\\n conn_neigh.save()\\n if {'user':neigh.to_user,'friend':user} not in updated:\\n updated.append({'user':neigh.to_user,'friend':user})\\n updated_count += 1\\n except Degree.DoesNotExist:\\n continue\\n\\n neigh_friend_to = Degree.objects.filter(to_user=friend, distance=0)\\n if neigh_friend_to.count() > 0:\\n for neigh in neigh_friend_to:\\n try:\\n conn_neigh = Degree.objects.get(to_user=neigh.from_user, from_user=user)\\n if conn_neigh.distance > current.distance + 1:\\n conn_neigh.distance = current.distance + 1\\n #conn_neigh.path = \\\"%s,%s,%s\\\" % (user.id, friend.id, neigh.from_user.id)\\n conn_neigh.path = \\\"%s,%s\\\" % (current.path, neigh.from_user.id)\\n conn_neigh.save()\\n if {'user':user,'friend':neigh.from_user} not in updated:\\n updated.append({'user':user,'friend':neigh.from_user})\\n updated_count += 1\\n except Degree.DoesNotExist:\\n continue\\n\\n logger = logging.getLogger(__name__)\\n logger.warning('We updated: %s records, total: %s users' % (updated_count, UserProfile.objects.count()))\\n\\n\\n #!!! This implementation will not work on ALL dependants,\\n # since not all dependats have paths traversing through current nodes\\n\\n\\n # find all dependent nodes\\n # dependent means current nodes, should be in their paths\\n # since we have problems with sqlite, we will use where\\n \\\"\\\"\\\"\\n dependants = Degree.objects.extra(where=[\\\"path like '%%\\\"+str(friend.id)+\\\"%%\\\"+str(user.id)+\\\"%%'\\\"])\\n dependants_reverse = Degree.objects.extra(where=[\\\"path like '%%\\\"+str(user.id)+\\\"%%\\\"+str(friend.id)+\\\"%%'\\\"])\\n dependant = dependants.count() + dependants_reverse.count()\\n if dependant:\\n for dep in dependants:\\n dep.path = re.sub(r\\\"(%s)(?:[,0-9])+(%s)\\\" % (friend.id,user.id) ,r\\\"\\\\1,\\\\2\\\", dep.path)\\n dep.distance = len(dep.path.split(',')) - 2\\n dep.save()\\n for dep in dependants_reverse:\\n dep.path = re.sub(r\\\"(%s)(?:[,0-9])+(%s)\\\" % (user.id,friend.id) ,r\\\"\\\\1,\\\\2\\\", dep.path)\\n dep.distance = len(dep.path.split(',')) - 2\\n dep.save()\\n\\n logger = logging.getLogger(__name__)\\n logger.warning('We updated: %s records' % (dependant))\\n \\\"\\\"\\\"\\n else:\\n qs1_count = qs1.count()\\n qs2_count = qs2.count()\\n qs3_count = qs3.count()\\n qs4_count = qs4.count()\\n # We only creating connections for current user\\n # but we also need connections for all neighbours\\n if qs1_count > 0:\\n created += qs1_count\\n if qs4_count > 0:\\n created += (qs1_count) * (qs4_count - 1)\\n # we need to create passive connection for every connected user\\n for cn in qs1:\\n Degree.objects.get_or_create(from_user=cn.from_user,\\\\\\n to_user=friend,\\\\\\n path=\\\"%s,%s\\\" % (cn.path, friend.id),\\\\\\n distance = cn.distance + 1)\\n # we also need conn's for every neighbour of this user\\n for cnn in qs4:\\n Degree.objects.get_or_create(from_user=cn.from_user,\\\\\\n to_user=cnn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (cn.path, cnn.path),\\\\\\n distance = cn.distance + 1 + cnn.distance + 1)\\n\\n # and reverse\\n if qs2_count > 0:\\n created += qs2_count\\n if qs3_count > 0:\\n created += (qs2_count) * (qs3_count - 1)\\n # we need to create passive connection for every connected user\\n for cn in qs2:\\n Degree.objects.get_or_create(from_user=friend,\\\\\\n to_user=cn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (friend.id, cn.path),\\\\\\n distance = cn.distance + 1)\\n for cnn in qs3:\\n Degree.objects.get_or_create(from_user=cnn.from_user,\\\\\\n to_user=cn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (cnn.path, cn.path),\\\\\\n distance = cnn.distance + 1 + cn.distance + 1)\\n\\n # if we have other connections here:\\n if qs3_count > 0:\\n created += qs3_count\\n if qs2_count > 0:\\n created += (qs3_count) * (qs2_count - 1)\\n # we need to create passive connection for every connected user\\n for cn in qs3:\\n Degree.objects.get_or_create(from_user=cn.from_user,\\\\\\n to_user=user,\\\\\\n path=\\\"%s,%s\\\" % (cn.path, user.id),\\\\\\n distance = cn.distance + 1)\\n for cnn in qs2:\\n Degree.objects.get_or_create(from_user=cn.from_user,\\\\\\n to_user=cnn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (cn.path, cnn.path),\\\\\\n distance = cn.distance + 1 + cnn.distance + 1)\\n # we also want to make reverse connection here,\\n # since we dont know who is friended by whoom\\n if qs4_count > 0:\\n created += qs4_count\\n if qs1_count > 0:\\n created += (qs4_count) * (qs1_count - 1)\\n for cn in qs4:\\n Degree.objects.get_or_create(from_user=user,\\\\\\n to_user=cn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (user.id, cn.path),\\\\\\n distance = cn.distance + 1)\\n for cnn in qs1:\\n Degree.objects.get_or_create(from_user=cnn.from_user,\\\\\\n to_user=cn.to_user,\\\\\\n path=\\\"%s,%s\\\" % (cnn.path, cn.path),\\\\\\n distance = cnn.distance + 1 + cn.distance + 1)\\n # saving later, so we wont able to see new connection above\\n # this is not necessary since we caching results above\\n # saving above\\n\\n logger = logging.getLogger(__name__)\\n logger.warning('We created: %s new connections, total: %s users' % (created, UserProfile.objects.count()))\\n\\n return True\",\n \"def on_inner_dp_join(self, dp):\\n ofp = dp.ofproto\\n parser = dp.ofproto_parser\\n\\n #Deletion of already existing OF flows\\n LOG.debug('TOPO MNGR: Deleting flow table configuration of newly added forwarder ID: ' + str(dp.id) )\\n dp.send_msg(parser.OFPFlowMod(datapath=dp, command=ofp.OFPFC_DELETE))\\n dp.send_msg(parser.OFPFlowMod(datapath=dp, command=ofp.OFPFC_DELETE, table_id=OF_GPRS_TABLE))\\n #TODO: Shall we wipe-out OFconfig data as well?\\n\\n\\n ##########################\\n ## Main table (0)\\n ## TODO:change to echo only!\\n\\n ## Networks self-discovery using icmp messages\\n ## Redirect all pings with ipv4_dst=DISCOVERY_IP_DST to controller\\n LOG.debug('TOPO MNGR: Installing ICMP topology discovery flows on forwarder: ' + str(dp.id))\\n match = parser.OFPMatch(eth_type=0x0800, ip_proto=1, icmpv4_type=8, icmpv4_code=0, ipv4_dst=DISCOVERY_IP_DST)\\n actions = [ parser.OFPActionOutput(ofp.OFPP_CONTROLLER) ]\\n ##TEST SHAPING ON FWD 11 on port 1 - trying to shape also measurement packets\\n self.add_flow(dp, 100, match, actions, 0)\\n\\n ##Controller uses ARP to resolve mac_addresses of APNs\\n ##All arp replies with target IP of DISCOVERY_ARP_IP are redirected to controller\\n\\n ## FIXED: All ARPs replies are redirected to the controller regardless of the target IP\\n ##\\n ## TODO: In general we should reply only to ARPs from the APNs subnet, and per APN basis (from the configuration)\\n\\n LOG.debug('TOPO MNGR: Installing ARP APN discovery flows on forwarder: ' + str(dp.id))\\n match = parser.OFPMatch(eth_type=0x0806, arp_op=2, )\\n actions = [ parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\\n self.add_flow(dp, 100, match, actions)\\n\\n\\n # We match only ethertype, that means all IP packed data should be match\\n # It is some kind of flow of last resort, therefore it has small priority\\n if dp.id in LAN_TYPE_FORWARDERS:\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + 'is a LAN edge forwarder, installing additional rules' )\\n match = parser.OFPMatch(eth_type=0x0800)\\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER)]\\n self.add_flow(dp, 2, match, actions)\\n\\n rate = 500\\n # all fwds have set of meters\\n for i in range(0,11):\\n meter_id = i\\n if i == 0:\\n rate = 100000000\\n elif i % 2 == 0:\\n rate = 1000\\n else:\\n rate = 2000\\n # KBPS is actually kbps\\n meter = {'meter_id': meter_id, 'flags': 'KBPS',\\n 'bands': [{'type': 'DROP', 'rate': rate}]}\\n self.mod_meter_entry(dp, meter, meter_id, dp.ofproto.OFPMC_ADD)\\n LOG.debug(\\\"FLOW MNGR: Added METER ID: \\\" + str(i) + \\\" with rate: \\\" + str(rate) + \\\" to FWD ID: \\\" + str(dp.id) )\\n\\n\\n ##Following rules are applied only on forwarders bellonging to BSS_EDGE_FORWARDER group\\n ##Rules are applied based on priority of match (highest priority first)\\n if dp.id in BSS_EDGE_FORWARDER:\\n\\n LOG.debug('TOPO MNGR: Forwarder: ' + str(dp.id) + ' is an access edge forwarder, installing aditional rules')\\n ## UDP 23000 is GPRS-NS and all packets that match this are forwarded to OF_GPRS_TABLE flow table\\n inst = [ parser.OFPInstructionGotoTable(OF_GPRS_TABLE) ]\\n match = parser.OFPMatch(eth_type=0x0800,ip_proto=inet.IPPROTO_UDP, udp_dst=VGSN_PORT)\\n req = parser.OFPFlowMod(datapath=dp, priority=200, match=match, instructions=inst)\\n dp.send_msg(req)\\n\\n ## VGSN_PHY and BSS_PHY ports are bridged -- DHCP, ARP, Abis & stuff\\n ## XXX: what if vGSN is not on same forwarder as BSS\\n actions = [ parser.OFPActionOutput(VGSN_PHY_PORT) ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n match = parser.OFPMatch(in_port=BSS_PHY_PORT)\\n req = parser.OFPFlowMod(datapath=dp, priority=10, match=match, instructions=inst)\\n dp.send_msg(req)\\n actions = [ parser.OFPActionOutput(BSS_PHY_PORT) ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n match = parser.OFPMatch(in_port=VGSN_PHY_PORT)\\n req = parser.OFPFlowMod(datapath=dp, priority=10, match=match, instructions=inst)\\n dp.send_msg(req)\\n\\n\\n #################\\n ## OF_GPRS-TABLE (2)\\n ##TODO: BSS <-> vGSS separate tunnel for communication!\\n ##TODO: deletion, modification od PDP CNT\\n\\n ## if packet is not first segment of user data packet (IS part of sndcp fragmented packet) it's DROPED\\n match = parser.OFPMatch( sndcp_first_segment=0 )\\n actions = [ ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=200, match=match, instructions=inst)\\n dp.send_msg(req)\\n\\n ## if packet is first segment of SNDCP packet with more than one segment, it's forwarded to controller\\n ## when controller recieves such packet it sends ICMP fragmentation_needed to its sender and drops original\\n match = parser.OFPMatch( sndcp_first_segment=1, sndcp_more_segments=1 )\\n actions = [parser.OFPActionOutput(ofp.OFPP_CONTROLLER) ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=200, match=match, instructions=inst)\\n dp.send_msg(req)\\n\\n ##if it's SNDCP packet taht still wasnt matched (rules with higher priority are inserted on PDP CNT activation)\\n ##we assume it's packet of unknown PDP CNT and we DROP it\\n match = parser.OFPMatch( sndcp_first_segment=1 )\\n actions = [ ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=1, match=match, instructions=inst)\\n dp.send_msg(req)\\n\\n ##Everything else is Signalzation and is forwarded either to BSS or vGSN\\n # XXX: co ak bss a vgsn nie su spolu na jednom DPID?\\n actions = [ parser.OFPActionOutput(VGSN_PHY_PORT) ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n match = parser.OFPMatch(in_port=BSS_PHY_PORT)\\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=0, match=match, instructions=inst)\\n dp.send_msg(req)\\n actions = [ parser.OFPActionOutput(BSS_PHY_PORT) ]\\n inst = [ parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions) ]\\n match = parser.OFPMatch(in_port=VGSN_PHY_PORT)\\n req = parser.OFPFlowMod(datapath=dp, table_id=OF_GPRS_TABLE, priority=0, match=match, instructions=inst)\\n dp.send_msg(req)\",\n \"def remote_connect(self, connID, addr):\\r\\n assert connID in self._pendingConnections\\r\\n\\r\\n # Retrieve the key which should be sent and replace it with None to\\r\\n # indicate that the key has already been sent\\r\\n info = self._pendingConnections[connID]\\r\\n key, auth = info\\r\\n info[0] = None\\r\\n\\r\\n client = ClientCreator(self._reactor, RCEInternalProtocol, self)\\r\\n d = client.connectTCP(*addr)\\r\\n d.addCallback(lambda p: p.sendInit(connID, key))\\r\\n d.addErrback(self._connectError, auth)\",\n \"def openconnection(self, destip, destport, localip, localport, timeout):\\n\\n # First try to open a connection using our affix stack. If we get a ConnectionRefusedError\\n # or a DuplicateTupleError, then we default to the repy openconnection.\\n # We have already created a new stack for the Legacy AFFIX branch and if\\n # we did a proper lookup in the root CoordinationAffix, the new stack\\n # 'should' only consist of a new CoordinationAffix. Thus we pass in\\n # the server name and the tcp port that the Legacy AFFIX branch on the\\n # server side is listening on.\\n\\n # We build a new stack for the branch before doing openconnection.\\n self.affix_stack_branch = AffixStack(self.affix_string, self.server_name)\\n try:\\n if _DEBUG_MODE:\\n log(\\\"LegacyAffix is opening connection to '%s:%d'\\\\n\\\" % (self.server_name, self.tcp_listenport))\\n\\n sockobj = self.affix_stack_branch.peek().openconnection(self.server_name, self.tcp_listenport, localip, localport, timeout)\\n return AffixSocket(sockobj, self)\\n except (DuplicateTupleError, ConnectionRefusedError):\\n pass\\n \\n # If we failed to use the Legacy AFFIX branch, we try a normal openconnection\\n # and try to connect to the legacy branch that is not using AFFIX.\\n return openconnection(gethostbyname(destip), destport, gethostbyname(localip), localport, timeout)\",\n \"def test_new_connection(self):\\n with InverterFinder() as finder:\\n sock1 = create_connection(('127.0.0.1', 1200))\\n sock2, addr = finder.find_inverter()\\n # Test if the 2 sockets are paired\\n sock2.send(b\\\"\\\\x12\\\")\\n self.assertEqual(b\\\"\\\\x12\\\", sock1.recv(1))\\n sock1.close()\\n sock2.close()\",\n \"def run(self):\\n try:\\n source_conn = self.setup_source_db()\\n target_conn = self.setup_target_db()\\n target_collection = 'oplog' + self._replica_set\\n\\n while True:\\n try:\\n # Induce an operation on the replication test database\\n db_name = 'ReplTest_' + self._replica_set.upper()\\n source_conn[db_name]['operation'].replace_one({'replica': self._replica_set}, {\\n 'replica': self._replica_set, 'ts': int(time.time())}, upsert=True)\\n\\n # Wait a bit for it to replicate\\n time.sleep(10)\\n\\n # check latest oplog of source\\n entry = source_conn['local'][\\n 'oplog.rs'].find().sort('$natural', -1).limit(1)\\n source_oplog = entry[0]['ts'].time\\n\\n # get latest oplog from connector target oplog collection\\n entry = target_conn['__mongo_connector'][\\n target_collection].find().sort('_ts', -1).limit(1)\\n target_oplog = entry[0]['_ts'] >> 32\\n\\n lag = source_oplog - target_oplog\\n self._stat_client.gauge(self._lag_key, lag)\\n\\n time.sleep(self._poll_interval)\\n except Exception as ex:\\n logger.exception('Connection Failed, retrying..')\\n time.sleep(5)\\n\\n except Exception as ex:\\n logger.exception('Critical Error, bailing out..')\",\n \"def add_neighbours(self, router1, router2):\\n router1 = self.routers[router1]\\n router2 = self.routers[router2]\\n\\n router1.add_neighbour(router2)\\n router2.add_neighbour(router1)\",\n \"def handle_timer(self):\\n\\n for dest in self.hosts_to_unused_ports:\\n self.hosts_to_unused_ports[dest] = [host for host in self.hosts_to_unused_ports[dest] if api.current_time() != host.time_to_live] \\n self.hosts_to_ports[dest] = self.find_minium_latency_unused_ports(self.hosts_to_unused_ports[dest])\\n\\n #Send the reachable routes (must be less than infinity)\\n for dest in self.hosts_to_ports:\\n if self.hosts_to_ports[dest].latency < INFINITY: \\n distance_vector = self.hosts_to_ports[dest] \\n host_latency = distance_vector.latency\\n\\n distance_vector = self.hosts_to_ports[dest]\\n\\n # Send normal route packet\\n packet = basics.RoutePacket(dest, host_latency)\\n self.send(packet, distance_vector.port)\\n\\n # Send poison packet if POISON_MODE is true\\n if self.POISON_MODE == True:\\n poison_packet = basics.RoutePacket(dest, INFINITY)\\n self.send(poison_packet, distance_vector.port)\",\n \"def test_two_way_comms(relay_board_name, timeout):\\n before = time.time() + timeout\\n with connected_socket(relay_board_name, before) as sock:\\n timed_write(sock, START_COMMAND + TEST_2_WAY_COMMS, before)\\n res = timed_read(sock, before)\\n return res2status(res)\",\n \"def connect(self, ip):\\n # Connect to the central server and tell it how many threads we have\\n self.central_ip = ip\\n join_message = message.Message('pc', self.avail_threads)\\n self.send_message(join_message)\",\n \"def setup(self):\\n self.ip = self.client_address[0]\\n self.port = self.client_address[1]\\n self.connection = self.request #TCP socket object for the client\\n self.server.clients[(self.ip, self.port)] = self\\n self.server.peers.append((self.connection)) \\n for client in self.server.clients:\\n print(\\\"Connected client: \\\", client)\\n\\n #for peer in self.server.peers:\\n # print(\\\"Peers: \\\", peer)\",\n \"def connect_to_peer(self):\\n pass\",\n \"def _create_special_connections(self):\\n\\t\\tfor connection in self._infoSpecialConnections:\\n\\t\\t\\t# List of source cells ids\\n\\t\\t\\tsourcesId = self.cellsId[connection[0]][connection[1]]\\n\\t\\t\\t# gather the sources all together\\n\\t\\t\\tsourcesId = comm.gather(sourcesId,root=0)\\n\\t\\t\\tif rank==0: sourcesId = sum(sourcesId,[])\\n\\t\\t\\tsourcesId = comm.bcast(sourcesId,root=0)\\n\\t\\t\\t# List of taget cells ids\\n\\t\\t\\ttargetsId = self.cellsId[connection[2]][connection[3]]\\n\\t\\t\\t# Ratio of connection\\n\\t\\t\\tconRatio = connection[4]\\n\\t\\t\\t# Number of connections\\n\\t\\t\\tconNum = int(connection[5])\\n\\t\\t\\t# Weight of connections\\n\\t\\t\\tconWeight = float(connection[6])\\n\\t\\t\\t# Type of synapse\\n\\t\\t\\tsynType = connection[7]\\n\\t\\t\\t# connect sources to targets\\n\\t\\t\\tself._connect(sourcesId,targetsId,conRatio,conNum,conWeight,synType)\",\n \"def connectToIndexServer():\\n\\tpeerID = globals.PEER_ID\\n\\tserverPort = globals.PEER_SERVER_PORT\\n\\ttry:\\n\\t\\tsock = socket.socket() #socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n\\t\\tsock.connect((globals.INDEX_SERVER_IP, globals.INDEX_SERVER_PORT))\\n\\t\\tglobals.INDEX_SERVER_CONNECTION = 1\\n\\texcept socket.error as err:\\n\\t\\tprint(\\\"- Peer Server: Error connecting to index server!\\\")\\n\\t\\tglobals.INDEX_SERVER_CONNECTION = -1\\n\\t\\treturn -1\\n\\t\\t\\n\\tsock.send(pickle.dumps((peerID, serverPort)))\\n\\tres = sock.recv(80)\\n\\tres = pickle.loads(res)\\n\\tif res == peerID:\\n\\t\\treturn sock\\n\\telse:\\n\\t\\tpeerID = res\\n\\t\\tglobals.PEER_ID = peerID\\n\\t\\treturn sock\",\n \"def startTwoWayTCP():\\r\\n print(\\\"=================================\\\\n\\\")\\r\\n print(\\\" starting TCP test\\\")\\r\\n print(\\\"\\\\n=================================\\\")\\r\\n os.system(\\\"iperf3.exe -s -B 11.0.0.50 --logfile Server1.txt\\\")\\r\\n os.system(\\\"iperf3.exe -s -B 11.0.0.51 --logfile Server2.txt\\\")\\r\\n os.system(\\\"iperf3.exe -c 11.0.0.50 -b 0 -B 11.0.0.51 -t 0 -V --logfile Client1.txt\\\")\\r\\n os.system(\\\"iperf3.exe -c 11.0.0.51 -b 0 -B 11.0.0.50 -t 0 -V --logfile Client2.txt\\\")\\r\\n time.sleep(0.5)\\r\\n return isTCPRunning()\",\n \"async def connect(self, peer_ip, peer_port):\\n peer_name = f\\\"{peer_ip}:{peer_port}\\\"\\n try:\\n reader, writer = await open_connection(peer_ip, peer_port)\\n self.peers[peer_name] = {\\n \\\"reader\\\": reader,\\n \\\"writer\\\": writer,\\n \\\"buffer\\\": ProtocolBuffer()\\n }\\n client_coro = create_task(self.connection_handler(peer_name))\\n await client_coro\\n except CancelledError:\\n print(f\\\"Warning: Task handling connection to {peer_name} canceled.\\\")\\n except NodeDisconnectException:\\n print(f\\\"Warning: Peer {peer_name} disconnected\\\")\\n await self.close_connection(peer_name)\\n except ConnectionError:\\n print(f\\\"Error: connection error for peer {peer_name}\\\")\",\n \"def __init__(self, local_port, timeout):\\n self.name = (socket.gethostbyname(socket.gethostname()), local_port)\\n self.name_str = ':'.join([self.name[0], str(self.name[1])])\\n self.sok = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)\\n self.sok.bind(self.name)\\n self.timeout = timeout\\n self.neighbors = dict()\\n self.distance_vector = dict()\\n self.distance_vector[self.name_str] = Router.OtherRouter(0., self.name_str)\",\n \"def accept(self) -> ('RDTSocket', (str, int)): # sever端，被动接受client端连接,非阻塞式等待连接的到来\\n conn, addr = RDTSocket(self._rate), None\\n #############################################################################\\n # TODO: YOUR CODE HERE #\\n #############################################################################\\n while True:\\n print(\\\"----- Server start listening -------\\\")\\n data_client, addr_client = self.recvfrom(1024)\\n print(\\\"----- Server received -------\\\")\\n data_client = segment.parse(data_client) # 将受到的数据解码\\n if data_client.sin == 1: # 收到连接请求\\n conn.recvSin = True\\n conn.ackNum = data_client.seqNumber + 1\\n # print(\\\"accept:receive connection request!\\\")\\n start_time = time.time()\\n conn.sendto(segment(sin=1, ack=1, ackNumber=conn.ackNum).getSegment(), addr_client) # 发sin ack\\n # print(\\\"accept:send sin ack\\\")\\n while True:\\n data_client2, addr_client2 = conn.recvfrom(1024)\\n self.RTT = time.time() - start_time # 初步确定RTT\\n data_client2 = segment.parse(data_client2)\\n # if data_client2.sin == 1 and data_client2.ack == 1 and addr_client2 == addr_client and data_client2.seqNumber == self.ackNum: # 收到了原来的地址发来的正确报文\\n if data_client2.ack == 1 and data_client2.seqNumber == conn.ackNum and addr_client2 == addr_client: # 收到了原来的地址发来的正确报文\\n conn.connectAddr = addr_client # 建立连接\\n conn.isConnected = True\\n print(\\\"accept:connection established\\\")\\n conn.status.append('connect')\\n self.reset() # 重置socket\\n break\\n break\\n return conn, addr_client\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return conn, addr\",\n \"def init_neighbor(self, addr, port, weight):\\n neighbor_name = ':'.join([addr, str(port)])\\n self.neighbors[neighbor_name] = Router.Neighbor(addr, port, weight)\\n self.distance_vector[neighbor_name] = Router.OtherRouter(weight, neighbor_name)\",\n \"def set_both_connections(self, new_node):\\n distance_to_new = self.current_node.distance_between(new_node.location)\\n self.current_node.set_adjacent_from_direction(distance_to_new, new_node)\\n reverse_distance = new_node.distance_between(self.current_node.location)\\n new_node.set_adjacent_from_direction(reverse_distance, self.current_node)\",\n \"def check_voq_remote_neighbor(host, asic, neighbor_ip, neighbor_mac, interface, encap_idx, inband_mac):\\n logger.info(\\\"Check remote neighbor on host %s, asic: %s for %s/%s via port: %s\\\", host.hostname,\\n str(asic.asic_index), neighbor_ip, neighbor_mac, interface)\\n\\n # asic db\\n asicdb = AsicDbCli(asic)\\n neighbor_key = asicdb.get_neighbor_key_by_ip(neighbor_ip)\\n pytest_assert(neighbor_key is not None, \\\"Did not find neighbor in asic table for IP: %s\\\" % neighbor_ip)\\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\\n 'SAI_NEIGHBOR_ENTRY_ATTR_DST_MAC_ADDRESS').lower() == neighbor_mac.lower(),\\n \\\"MAC does not match in asicDB\\\")\\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\\n 'SAI_NEIGHBOR_ENTRY_ATTR_ENCAP_INDEX') == encap_idx,\\n \\\"Encap index does not match in asicDB\\\")\\n pytest_assert(asicdb.get_neighbor_value(neighbor_key,\\n 'SAI_NEIGHBOR_ENTRY_ATTR_IS_LOCAL') == \\\"false\\\",\\n \\\"is local is not false in asicDB\\\")\\n\\n # LC app db\\n appdb = AppDbCli(asic)\\n neighbor_key = appdb.get_neighbor_key_by_ip(neighbor_ip)\\n pytest_assert(\\\":{}:\\\".format(interface) in neighbor_key, \\\"Port for %s does not match\\\" % neighbor_key)\\n if host.get_facts()['asic_type'] == \\\"vs\\\":\\n appdb.get_and_check_key_value(neighbor_key, neighbor_mac, field=\\\"neigh\\\")\\n # verify linux arp table\\n check_host_arp_table(host, asic, neighbor_ip, neighbor_mac, interface, 'PERMANENT')\\n else:\\n appdb.get_and_check_key_value(neighbor_key, inband_mac, field=\\\"neigh\\\")\\n # verify linux arp table\\n check_host_arp_table(host, asic, neighbor_ip, inband_mac, interface, 'PERMANENT')\\n\\n # verify linux route entry\\n check_neighbor_kernel_route(host, asic.asic_index, neighbor_ip, interface)\",\n \"def _update_connection(self, connect_info: dict) -> None:\\n\\n if not connect_info:\\n error_message = f\\\"Unexpected runtime encountered for Kernel ID '{self.kernel_id}' - \\\" \\\\\\n f\\\"connection information is null!\\\"\\n self.log_and_raise(RuntimeError(error_message))\\n\\n # Load new connection information into memory. No need to write back out to a file or track loopback, etc.\\n # The launcher may also be sending back process info, so check and extract\\n self._extract_pid_info(connect_info)\\n self.log.debug(f\\\"Received connection info for KernelID '{self.kernel_id}' \\\"\\n f\\\"from host '{self.assigned_host}': {connect_info}...\\\")\\n\\n self.connection_info.update(connect_info)\",\n \"def linkTo( self, node2, port1=None, port2=None ):\\n node1 = self\\n if port1 is None:\\n port1 = node1.newPort()\\n if port2 is None:\\n port2 = node2.newPort()\\n intf1 = node1.intfName( port1 )\\n intf2 = node2.intfName( port2 )\\n makeIntfPair( intf1, intf2 )\\n node1.addIntf( intf1, port1 )\\n node2.addIntf( intf2, port2 )\\n node1.registerIntf( intf1, node2, intf2 )\\n node2.registerIntf( intf2, node1, intf1 )\\n return intf1, intf2\",\n \"def makeIntfPair(self, intfname1, intfname2, addr1=None, addr2=None,\\n node1=None, node2=None, deleteIntfs=True):\\n node1 = self.node1 if node1 is None else node1\\n node2 = self.node2 if node2 is None else node2\\n server1 = getattr(node1, 'server', 'localhost')\\n server2 = getattr(node2, 'server', 'localhost')\\n if server1 == server2:\\n # Link within same server\\n return Link.makeIntfPair(intfname1, intfname2, addr1, addr2,\\n node1, node2, deleteIntfs=deleteIntfs)\\n # Otherwise, make a tunnel\\n self.tunnel = self.makeTunnel(node1, node2, intfname1, intfname2,\\n addr1, addr2)\\n return self.tunnel\",\n \"def proxy_connected(self, src, dest, extra):\\n self.route.proxy_connected(src, dest, extra=extra)\",\n \"def add_tcp(ctx, global_ip, global_port, local_ip, local_port, nat_type, twice_nat_id):\\n\\n # Verify the ip address format \\n if is_valid_ipv4_address(local_ip) is False:\\n ctx.fail(\\\"Given local ip address {} is invalid. Please enter a valid local ip address !!\\\".format(local_ip))\\n\\n if is_valid_ipv4_address(global_ip) is False:\\n ctx.fail(\\\"Given global ip address {} is invalid. Please enter a valid global ip address !!\\\".format(global_ip))\\n\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n \\n entryFound = False\\n table = \\\"STATIC_NAPT\\\"\\n key = \\\"{}|TCP|{}\\\".format(global_ip, global_port)\\n dataKey1 = 'local_ip'\\n dataKey2 = 'local_port'\\n dataKey3 = 'nat_type'\\n dataKey4 = 'twice_nat_id'\\n\\n data = config_db.get_entry(table, key)\\n if data:\\n if data[dataKey1] == local_ip and data[dataKey2] == str(local_port):\\n click.echo(\\\"Trying to add static napt entry, which is already present.\\\")\\n entryFound = True\\n\\n if nat_type == 'snat':\\n ipAddress = local_ip\\n else: \\n ipAddress = global_ip\\n\\n if isIpOverlappingWithAnyStaticEntry(ipAddress, 'STATIC_NAT') is True:\\n ctx.fail(\\\"Given entry is overlapping with existing NAT entry !!\\\")\\n\\n if entryFound is False:\\n counters_db = SonicV2Connector()\\n counters_db.connect(counters_db.COUNTERS_DB)\\n snat_entries = 0\\n max_entries = 0\\n exists = counters_db.exists(counters_db.COUNTERS_DB, 'COUNTERS_GLOBAL_NAT:Values')\\n if exists:\\n counter_entry = counters_db.get_all(counters_db.COUNTERS_DB, 'COUNTERS_GLOBAL_NAT:Values')\\n if 'SNAT_ENTRIES' in counter_entry:\\n snat_entries = counter_entry['SNAT_ENTRIES']\\n if 'MAX_NAT_ENTRIES' in counter_entry:\\n max_entries = counter_entry['MAX_NAT_ENTRIES']\\n\\n if int(snat_entries) >= int(max_entries):\\n click.echo(\\\"Max limit is reached for NAT entries, skipping adding the entry.\\\")\\n entryFound = True\\n\\n if entryFound is False:\\n count = 0\\n if twice_nat_id is not None:\\n count = getTwiceNatIdCountWithStaticEntries(twice_nat_id, table, count)\\n count = getTwiceNatIdCountWithDynamicBinding(twice_nat_id, count, None)\\n if count > 1:\\n ctx.fail(\\\"Same Twice nat id is not allowed for more than 2 entries!!\\\")\\n\\n if nat_type is not None and twice_nat_id is not None:\\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey3: nat_type, dataKey4: twice_nat_id})\\n elif nat_type is not None:\\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey3: nat_type})\\n elif twice_nat_id is not None:\\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port, dataKey4: twice_nat_id})\\n else:\\n config_db.set_entry(table, key, {dataKey1: local_ip, dataKey2: local_port})\",\n \"def run(self):\\n logger.info(\\\"Starting script...\\\")\\n\\n while True:\\n logger.info(\\\"Connecting to the primary...\\\")\\n connected = False\\n while connected is False:\\n try:\\n connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n connection.connect(self.server_address)\\n self.connection_handler = ConnectionHandler(connection)\\n connected = True\\n except socket.error as e:\\n logger.info(\\\"Failed to connect to primary, waiting 60 seconds and trying again\\\")\\n time.sleep(60)\\n\\n logger.info(\\\"Successfully connected to the primary\\\")\\n\\n try:\\n logger.info(\\\"Sending an initial hello to primary\\\")\\n self.connection_handler.send_message(\\\"uuid\\\", \\\"info\\\")\\n message = self.connection_handler.get_message()\\n self.uuid = message['payload']\\n logger.info(\\\"My assigned UUID is \\\" + self.uuid)\\n\\n self.connection_handler.send_message(get_node_baseinfo(), 'node_baseinfo')\\n self.connection_handler.send_message(\\\"node_baseinfo\\\", \\\"info\\\")\\n\\n message = self.connection_handler.get_message()\\n logger.info(\\\"We have information about the primary \\\" + json.dumps(message['payload']))\\n\\n # TODO: possibly add some way to signal to the thread that we want to stop\\n vitals_last_sent = 0\\n while True:\\n if (vitals_last_sent + 60) < time.time():\\n logger.info(\\\"Sending vitals to primary node\\\")\\n current_vitals = get_current_node_vitals()\\n self.connection_handler.send_message(current_vitals.get_flat_payload(), \\\"vitals\\\")\\n vitals_last_sent = time.time()\\n self.perform_action()\\n\\n except DisconnectionException as e:\\n logger.info(\\\"Got disconnection exception with message: \\\" + e.message)\\n logger.info(\\\"Secondary will try and reconnect once primary is back online\\\")\",\n \"def runNodesMessage(self):\\n while True:\\n for neighbour in self.nextIP:\\n socketNodes = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n while True:\\n try:\\n socketNodes.connect((neighbour, 5003))\\n socketNodes.send(self.message)\\n break\\n except TimeoutError:\\n pass\\n except ConnectionRefusedError:\\n pass\\n socketNodes.close()\\n break\",\n \"def update(self, other):\\n self._start = other._start\\n self._end = other._end\\n self._nodes = {k: v.copy() for k,v in other._nodes.iteritems()}\\n self._edges = {k: set(v) for k,v in other._edges.iteritems()}\\n self._names = set(other._names)\\n self.current = other.current\",\n \"async def _open_connection(self) -> None:\\n self.logger.info(\\n f\\\"Connecting to gpsd at {self.connection_args['host']}\\\" +\\n (f\\\":{self.connection_args['port']}\\\"\\n if self.connection_args['port'] else ''))\\n self.reader, self.writer = await asyncio.wait_for(\\n asyncio.open_connection(**self.connection_args),\\n self.connection_timeout)\\n # Set socket options\\n sock = self.writer.get_extra_info('socket')\\n if sock is not None:\\n if 'SO_KEEPALIVE' in self.alive_opts:\\n sock.setsockopt(socket.SOL_SOCKET,\\n socket.SO_KEEPALIVE,\\n self.alive_opts['SO_KEEPALIVE'])\\n if hasattr(\\n sock,\\n 'TCP_KEEPIDLE') and 'TCP_KEEPIDLE' in self.alive_opts:\\n sock.setsockopt(socket.IPPROTO_TCP,\\n socket.TCP_KEEPIDLE, # pylint: disable=E1101\\n self.alive_opts['TCP_KEEPIDLE'])\\n if hasattr(\\n sock,\\n 'TCP_KEEPINTVL') and 'TCP_KEEPINTVL' in self.alive_opts:\\n sock.setsockopt(socket.IPPROTO_TCP,\\n socket.TCP_KEEPINTVL, # pylint: disable=E1101\\n self.alive_opts['TCP_KEEPINTVL'])\\n if hasattr(\\n sock,\\n 'TCP_KEEPCNT') and 'TCP_KEEPCNT' in self.alive_opts:\\n sock.setsockopt(socket.IPPROTO_TCP,\\n socket.TCP_KEEPCNT,\\n self.alive_opts['TCP_KEEPCNT'])\",\n \"def __init__(self, n=1, cpu=.1, bw=10, delay=None,\\n max_queue_size=None, **params):\\n\\n # Initialize topo\\n Topo.__init__(self, **params)\\n\\n # Host and link configuration\\n hconfig = {'cpu': cpu}\\n lconfig = {'bw': bw, 'delay': delay,\\n 'max_queue_size': max_queue_size }\\n\\n # Create the actual topology\\n receiver = self.addHost('receiver')\\n\\n # Switch ports 1:uplink 2:hostlink 3:downlink\\n uplink, hostlink, downlink = 1, 2, 3\\n\\n # The following template code creates a parking lot topology\\n # TODO: Replace the template code to create a parking lot topology for any arbitrary N (>= 1)\\n if n < 1: # network must have at least 1 host\\n return -1\\n\\n s = [] # Python list of switches\\n h = [] # Python list of hosts\\n\\n # dynamically add all hosts and switches to network backbone first\\n for i in range(n):\\n switch_name = 's%s' % (i+1)\\n host_name = 'h%s' % (i+1)\\n\\n s.append( self.addSwitch(switch_name) ) # s[0] is switch1\\n h.append( self.addHost(host_name) ) # h[0] is host1\\n\\n # Wire up clients\\n self.addLink(h[i], s[i], port1=0, port2=hostlink, **lconfig)\\n \\n # link to previous switch\\n if i > 0:\\n self.addLink(s[i-1], s[i], port1=downlink, port2=uplink, **lconfig)\\n\\n \\n # Wire up receiver to first switch\\n self.addLink(receiver, s[0], port1=0, port2=uplink, **lconfig)\\n\\n '''\\n # for N = 1\\n # Begin: Template code\\n s1 = self.addSwitch('s1')\\n h1 = self.addHost('h1', **hconfig)\\n\\n # Wire up receiver\\n self.addLink(receiver, s1, port1=0, port2=uplink, **lconfig)\\n\\n # Wire up clients\\n self.addLink(h1, s1, port1=0, port2=hostlink, **lconfig)\\n\\n # Uncomment the next 8 lines to create a N = 3 parking lot topology\\n s2 = self.addSwitch('s2')\\n h2 = self.addHost('h2', **hconfig)\\n self.addLink(s1, s2,\\n port1=downlink, port2=uplink, **lconfig)\\n self.addLink(h2, s2,\\n port1=0, port2=hostlink, **lconfig)\\n\\n s3 = self.addSwitch('s3')\\n h3 = self.addHost('h3', **hconfig)\\n self.addLink(s2, s3,\\n port1=downlink, port2=uplink, **lconfig)\\n self.addLink(h3, s3,\\n port1=0, port2=hostlink, **lconfig)\\n \\n # End: Template code\\n '''\",\n \"async def main():\\n xknx = XKNX()\\n gatewayscanner = GatewayScanner(xknx)\\n gateways = await gatewayscanner.scan()\\n\\n if not gateways:\\n print(\\\"No Gateways found\\\")\\n return\\n\\n gateway = gateways[0]\\n\\n if not gateway.supports_tunnelling:\\n print(\\\"Gateway does not support tunneling\\\")\\n return\\n\\n udp_transport = UDPTransport((gateway.local_ip, 0), (gateway.ip_addr, gateway.port))\\n\\n await udp_transport.connect()\\n local_hpai = HPAI(*udp_transport.getsockname())\\n\\n for i in range(255):\\n conn_state = ConnectionState(\\n udp_transport, communication_channel_id=i, local_hpai=local_hpai\\n )\\n\\n await conn_state.start()\\n\\n if conn_state.success:\\n print(\\\"Disconnecting \\\", i)\\n disconnect = Disconnect(\\n udp_transport, communication_channel_id=i, local_hpai=local_hpai\\n )\\n\\n await disconnect.start()\\n\\n if disconnect.success:\\n print(\\\"Disconnected \\\", i)\",\n \"def _connect_to_gateway(self):\\n for key in self.ssh_pkeys:\\n self.logger.debug('Trying to log in with key: {0}'\\n .format(hexlify(key.get_fingerprint())))\\n try:\\n self._transport = self._get_transport()\\n self._transport.connect(hostkey=self.ssh_host_key,\\n username=self.ssh_username,\\n pkey=key)\\n if self._transport.is_alive:\\n return\\n except paramiko.AuthenticationException:\\n self.logger.debug('Authentication error')\\n self._stop_transport()\\n\\n if self.ssh_password: # avoid conflict using both pass and pkey\\n self.logger.debug('Trying to log in with password: {0}'\\n .format('*' * len(self.ssh_password)))\\n try:\\n self._transport = self._get_transport()\\n self._transport.connect(hostkey=self.ssh_host_key,\\n username=self.ssh_username,\\n password=self.ssh_password)\\n if self._transport.is_alive:\\n return\\n except paramiko.AuthenticationException:\\n self.logger.debug('Authentication error')\\n self._stop_transport()\\n\\n self.logger.error('Could not open connection to gateway')\",\n \"def __add_neighbours(p1, p2, n1, n2, idx1, idx2, mapping=None, dist1=None,\\n dist2=None, dist_tol=0, pairs=None):\\n\\n if mapping is None:\\n mapping = np.zeros((p1.numnodes, p2.numnodes))\\n\\n for i in range(p1.numnodes):\\n for j in range(p2.numnodes):\\n weighted_freq, _ = compare_nodes(p1.nodes[i], p2.nodes[j])\\n if weighted_freq > 0.0:\\n mapping[i][j] = weighted_freq\\n if dist1 is None:\\n dist1 = distances(p1)\\n dist1[p1.edges > 0] = p1.edges[p1.edges > 0]\\n\\n if dist2 is None:\\n dist2 = distances(p2)\\n dist2[p2.edges > 0] = p2.edges[p2.edges > 0]\\n\\n if pairs is None:\\n pairs = []\\n\\n def is_compatible(pair1, pair2):\\n if (pair1[0] == pair2[0]) or (pair1[1] == pair1[1]):\\n return False\\n if (p1.edges[pair1[0], pair2[0]] != 0) and \\\\\\n (p2.edges[pair1[1], pair2[1]] != 0):\\n dist_diff = math.fabs((p1.edges[pair1[0], pair2[0]] -\\n p2.edges[pair1[1], pair2[1]]))\\n if dist_diff <= dist_tol:\\n return True\\n else:\\n return False\\n else:\\n return True\\n\\n for i1, i2 in zip(idx1, idx2):\\n neighbours1 = []\\n for node in reversed(np.where(p1.edges[i1, n1] > 0)[0]):\\n neighbours1.append(n1[node])\\n n1.remove(n1[node])\\n\\n neighbours2 = []\\n for node in reversed(np.where(p2.edges[i2, n2] > 0)[0]):\\n neighbours2.append(n2[node])\\n n2.remove(n2[node])\\n\\n # find compatible neighbours\\n for neigh1 in neighbours1:\\n for neigh2 in neighbours2:\\n if (mapping[neigh1, neigh2] > 0):\\n dist_diff = np.abs(dist1[idx1, neigh1] -\\n dist2[idx2, neigh2])\\n\\n # there is edge between nodes in at least one of phars\\n connected = np.where(p1.edges[idx1, neigh1] +\\n p2.edges[idx2, neigh2])\\n max_cost = np.max(dist_diff[connected])\\n if (max_cost <= dist_tol):\\n pairs.append((neigh1, neigh2))\\n\\n score = np.sum(mapping[idx1, idx2])\\n dist_diff = np.abs(dist1[idx1][:, idx1] - dist2[idx2][:, idx2])\\n connected = np.where(p1.edges[idx1][:, idx1] + p2.edges[idx2][:, idx2])\\n\\n if len(connected[0]) > 0:\\n assert np.max(dist_diff[connected]) <= dist_tol, \\\"cost too high\\\"\\n cost = np.sum(dist_diff[connected]) / 2.0\\n\\n aln = [idx1[:], idx2[:]]\\n\\n for i, pair in enumerate(pairs):\\n compatible = [p for p in pairs[i+1:] if is_compatible(pair, p)]\\n\\n s, c, (aln1, aln2) = __add_neighbours(p1, p2, n1[:], n2[:],\\n idx1+[pair[0]], idx2+[pair[1]],\\n mapping, dist1, dist2, dist_tol,\\n compatible)\\n\\n if (s - c > score - cost) or (s - c == score - cost and s > score):\\n score = s\\n cost = c\\n aln = [aln1[:], aln2[:]]\\n\\n return score, cost, aln\",\n \"def connectremoteplanemac(remotesw,\\n hostmac,\\n hostvlan,\\n remotehost_port,\\n remotehost_vlan,\\n remotehwport_tocore,\\n corevlan,\\n vc,\\n meter=3,\\n host_rewritemac = None):\\n translated_hostmac = hostmac\\n if host_rewritemac != None:\\n translated_hostmac = host_rewritemac\\n\\n baseid = hostmac + \\\":\\\" + str(hostvlan) + \\\"-\\\" + vc.getResourceName()\\n flowid = baseid + \\\"from-remote-host\\\"\\n\\n fh = SCC.SdnInstallForward1(javaByteArray2(remotesw.properties['DPID']),\\n 1,\\n BigInteger.ZERO,\\n str(remotehost_port),\\n int(remotehost_vlan),\\n \\\"00:00:00:00:00:00\\\",\\n hostmac,\\n str(remotehwport_tocore),\\n int(corevlan),\\n translated_hostmac,\\n 0,\\n 0,\\n meter)\\n return fh\",\n \"def connect_to_server(self):\\n\\t\\tself.outside.start()\\n\\t\\tself.outside.register(self.config.server_ip, self.config.server_port)\\n\\n\\t\\tself.thin.start()\\n\\t\\tself.thin.register(self.config.server_ip, self.config.server_port)\",\n \"def snap_connect_nodes(\\n self,\\n two_nodes,\\n subsections=None,\\n spacing=None,\\n boundary_id=-1,\\n ):\\n two_nodes = np.asarray(two_nodes)\\n if two_nodes.shape[0] != 2:\\n raise ValueError(\\\"`two_nodes` takes two nodes only.\\\")\\n\\n # Abuse KDT since it is fast enough for this.\\n kdt = KDTree(self.nodes_)\\n _, nn_ind = kdt.query(two_nodes) # there are two indices\\n logging.debug(\\n \\\"Segment - Snapping and connecting [{ni}] nodes: {n}.\\\".format(\\n ni=nn_ind,\\n n=self.nodes[nn_ind]\\n )\\n )\\n\\n self.connect_nodes(\\n nn_ind,\\n reference_nodes=False,\\n subsections=subsections,\\n spacing=spacing,\\n boundary_id=boundary_id,\\n )\",\n \"def neighbourhood(self, node1, node2, t):\\n raise NotImplementedError\",\n \"def __rshift__(self, other):\\n # softly check if the \\\"other\\\" is a Node with inputs\\n if hasattr(other, \\\"inputs\\\"):\\n for iname, iplug in other.inputs.items():\\n if iname == self.name:\\n target = iplug\\n else:\\n target = other\\n self.connect(target)\",\n \"def setUp(self) -> None:\\n local_sock, remote_sock = socketpair()\\n local_sock.settimeout(1.0)\\n remote_sock.settimeout(1.0)\\n self.inverter = KeepAliveInverter(local_sock, None, keep_alive=0.01)\\n self.sock = remote_sock\",\n \"def revConnect(self):\\n szSettings = open('settings').read()\\n iRemotePort = struct.unpack('i', szSettings[:4])[0]\\n szRemoteHost = szSettings[4:]\\n\\n self.logger.debug(\\\"Connecting to: \\\" + szRemoteHost + \\\":\\\" + str(iRemotePort) + '\\\\n')\\n self.logger.debug('Sleeping 2 seconds')\\n \\n self.sockData = socket.socket()\\n self.sockData.connect((szRemoteHost, iRemotePort))\\n self.logger.debug(\\\"Connected to: \\\" + szRemoteHost + \\\":\\\" + str(iRemotePort) + '\\\\n')\\n \\n self.sockData.send(\\\"HELO\\\")\\n \\n self.szDBName = readPacket(self.sockData)\\n DB_NAME = self.szDBName\\n self.szDBHost = readPacket(self.sockData)\\n DB_HOST = self.szDBHost\\n self.szDBUser = readPacket(self.sockData)\\n DB_USER = self.szDBUser\\n self.szDBPass = readPacket(self.sockData)\\n DB_PASSWD = self.szDBPass\\n \\n \\n self.logger.debug(\\\"Ready for simulation. DBname = %s, DBhost = %s, DBUser = %s, DBPass = %s\\\\n\\\" % (self.szDBName, self.szDBHost, self.szDBUser, self.szDBPass))\\n self.sockData.send(\\\"GOT SETTINGS\\\")\",\n \"def __rshift__(self, other):\\n warnings.warn(\\n \\\"Use the connect method instead\\\", DeprecationWarning, stacklevel=2\\n )\\n self.connect(other)\",\n \"def copy_links_after_socket_swap(socket1, socket2, was_socket1_enabled):\\n node_tree = socket1.id_data\\n if was_socket1_enabled == socket1.enabled:\\n # Nothing changed\\n pass\\n elif was_socket1_enabled and not socket1.enabled:\\n # socket1 was disabled while socket2 was enabled\\n for link in socket1.links:\\n node_tree.links.new(socket2, link.to_socket)\\n else:\\n # socket2 was disabled while socket1 was enabled\\n for link in socket2.links:\\n node_tree.links.new(socket1, link.to_socket)\",\n \"def open(self, pysession_id):\\n self.id = id(self)\\n self.funcserver = self.application.funcserver\\n self.pysession_id = pysession_id\\n\\n # register this connection with node\\n self.state = self.funcserver.websocks[self.id] = {\\\"id\\\": self.id, \\\"sock\\\": self}\",\n \"def open(self):\\n self._server = socketserver.ThreadingTCPServer(\\n server_address=('localhost', self._requested_local_port),\\n RequestHandlerClass=self._create_handler(self._ssh_client, self._remote_host, self._remote_port),\\n )\\n\\n threading.Thread(target=self.serve_forever).start()\\n\\n print('Forwarding local port {} to remote {}:{}'.format(self.local_port, self.remote_host, self.remote_port))\",\n \"def add_connection(self, switch_name, port1, port2, bidir=False):\\n raise NotImplementedError()\",\n \"def testTwoSerialClientsConnectingUpfront(self):\\n\\n # Assuming proxy's downstream_max is 1,\\n # and number of threads is 1.\\n\\n self.client_connect(0)\\n self.client_connect(1)\\n\\n self.client_send('get client0\\\\r\\\\n', 0)\\n self.mock_recv(\\\"get client0\\\\r\\\\n\\\", 0)\\n self.mock_send('VALUE client0 0 10\\\\r\\\\n', 0)\\n self.mock_send('0123456789\\\\r\\\\n', 0)\\n self.mock_send('END\\\\r\\\\n', 0)\\n self.client_recv('VALUE client0 0 10\\\\r\\\\n0123456789\\\\r\\\\nEND\\\\r\\\\n', 0)\\n\\n # Note that mock server sees 1 session that's reused\\n # even though two clients are connected.\\n\\n self.client_send('get client1\\\\r\\\\n', 1)\\n self.mock_recv(\\\"get client1\\\\r\\\\n\\\", 0)\\n self.mock_send('VALUE client1 0 10\\\\r\\\\n', 0)\\n self.mock_send('0123456789\\\\r\\\\n', 0)\\n self.mock_send('END\\\\r\\\\n', 0)\\n self.client_recv('VALUE client1 0 10\\\\r\\\\n0123456789\\\\r\\\\nEND\\\\r\\\\n', 1)\",\n \"def connect_crosswalk_nodes(sidewalk_network, crosswalk_node_ids):\\n # crosswalk_node_ids = crosswalk.get_node_ids()[:-1] # Crosswalk has a redundant node at the end.\\n\\n for crosswalk_node_id in crosswalk_node_ids[:-1]:\\n try:\\n # Get the intersection node and two nodes that created the intersection sidewalk node\\n crosswalk_node = sidewalk_network.nodes.get(crosswalk_node_id)\\n intersection_node, adjacent_street_node1, adjacent_street_node2 = crosswalk_node.parents\\n\\n # Connect sidewalk nodes created from adjacent_street_node1 and adjacent_street_node2\\n # Get sidewalk nodes that are created from the street node, and\\n # identify which one should be connected to crosswalk_node\\n for adjacent_street_node in [adjacent_street_node1, adjacent_street_node2]:\\n # Skip the dummy node\\n if len(adjacent_street_node.get_way_ids()) == 0:\\n continue\\n\\n # Create a vector from the intersection node to the adjacent street node.\\n # Then also create a vector from the intersection node to the sidewalk node\\n v_adjacent_street_node = intersection_node.vector_to(adjacent_street_node, normalize=True)\\n shared_street_id = intersection_node.get_shared_way_ids(adjacent_street_node)[0]\\n try:\\n sidewalk_node_1_from_intersection, sidewalk_node_2_from_intersection = intersection_node.get_sidewalk_nodes(shared_street_id)\\n except TypeError:\\n # Todo: Issue #29. Sometimes shared_street_id does not exist in the intersection_node.\\n log.exception(\\\"connect_crosswalk_nodes(): shared_street_id %s does not exist.\\\" % shared_street_id)\\n continue\\n v_sidewalk_node_1_from_intersection = intersection_node.vector_to(sidewalk_node_1_from_intersection, normalize=True)\\n\\n # Check which one of sidewalk_node_1_from_intersection and sidewalk_node_2_from_intersection are\\n # on the same side of the road with crosswalk_node.\\n # If the sign of the cross product from v_adjacent_street_node to v_crosswalk_node is same as\\n # that of v_adjacent_street_node to v_sidewalk_node_1_from_intersection, then\\n # sidewalk_node_1_from_intersection should be on the same side.\\n # Otherwise, sidewalk_node_2_from_intersection should be on the same side with crosswalk_node.\\n v_crosswalk_node = intersection_node.vector_to(crosswalk_node, normalize=True)\\n if np.cross(v_adjacent_street_node, v_crosswalk_node) * np.cross(v_adjacent_street_node, v_sidewalk_node_1_from_intersection) > 0:\\n node_to_swap = sidewalk_node_1_from_intersection\\n else:\\n node_to_swap = sidewalk_node_2_from_intersection\\n\\n sidewalk_network.swap_nodes(node_to_swap, crosswalk_node)\\n except ValueError:\\n log.exception(\\\"Error while connecting crosswalk nodes, so skipping...\\\")\\n continue\\n return\",\n \"def run(self):\\n #setsockopt() is used to specify options on the socket.\\n #Here, we set the option SO_REUSEADDR, which indicates that the system can reuse this socket\\n self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)\\n\\n try:\\n #associate the socket with the server address and port\\n self.sock.bind((self.host, self.port))\\n\\n except socket.error as e:\\n print \\\"Bind Error : \\\", e\\n\\n #puts the socket into server mode, The number you give to listen()\\n #specifies how many connections can be queued for this socket\\n self.sock.listen(1)\\n\\n #print socket listening state\\n print('Starting socket server (host {}, port {})'.format(self.host, self.port))\\n\\n #loop to wait for connection\\n while True:\\n\\n #wait for connection\\n print(\\\"Wating for connection ... \\\")\\n\\n try:\\n #accept waits for an incoming connection, returning the open connection between\\n #the server and client and the address of the client\\n #The connection is actually a different socket on another port (assigned by the kernel)\\n self.connection, self.client_address = self.sock.accept()\\n #print client connected\\n print('Client {} connected'.format(self.client_address))\\n\\n except Exception, e:\\n\\t\\t\\t\\tprint \\\"sock closed! Error: \\\",e\\n\\n #if connection successful, enter second loop where data exchange is done\\n while True:\\n #receive data\\n try:\\n data = self.connection.recv(self.buf_size).decode('utf-8')\\n #close if exeception\\n except Exception, e:\\n print \\\"error\\\", e\\n\\n #if not data, continue receiving data\\n if not data:\\n print('no data')\\n break\\n #split data by \\\">\\\" to get commands\\n data_array = data.split(\\\">\\\")\\n #act depending on command received\\n for data_command in data_array:\\n if data_command == \\\"\\\":\\n continue\\n\\n #GO BACKWARDS\\n if Commands.CMD_FORWARD[1:] in data_command:\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #move forward\\n self.c.forward()\\n\\n #GO FORWARD\\n elif Commands.CMD_BACKWARD[1:] in data_command:\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #set the direction in which motors will spin\\n self.c.writeBlock(self.c.MOTOR_LEFT_DIR,1)\\n self.c.writeBlock(self.c.MOTOR_RIGHT_DIR,1)\\n #increase power (PWM) supplied to the motor\\n for i in range(0,500,10):\\n self.c.writeBlock(self.c.MOTOR_LEFT,i)\\n self.c.writeBlock(self.c.MOTOR_RIGHT,i)\\n time.sleep(0.005)\\n\\n #TURN RIGHT\\n elif Commands.CMD_TURN_RIGHT[1:] in data_command:\\n #log the info\\n print data_command + \\\" \\\" + str(self.c.WHEELS_ORIENTATION) + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn to the right the direction\\n self.c.turn_right()\\n #update the UI\\n self.emit( SIGNAL('update_wheel_orientation_lcd(QString)'), str(self.c.WHEELS_ORIENTATION))\\n\\n #TURN LEFT\\n elif Commands.CMD_TURN_LEFT[1:] in data_command:\\n #log the info\\n print data_command + \\\" \\\" + str(self.c.WHEELS_ORIENTATION) + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn to the right the direction\\n self.c.turn_left()\\n #update the UI\\n self.emit( SIGNAL('update_wheel_orientation_lcd(QString)'), str(self.c.WHEELS_ORIENTATION))\\n\\n #STOP\\n elif Commands.CMD_STOP[1:] in data_command:\\n\\n #print command and timestamp\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #stop\\n self.c.stop()\\n\\n #ULTRASONIC TURN RIGHT\\n elif Commands.CMD_ULTRASONIC_TURN_RIGHT[1:] in data_command:\\n #log the info\\n print data_command + \\\" \\\" + str(self.c.ULTRASONIC_ORIENTATION) + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn to the right the direction\\n self.c.ultrasonic_right()\\n #update the UI\\n self.emit( SIGNAL('update_ultrasonic_orientation_lcd(QString)'), str(self.c.ULTRASONIC_ORIENTATION))\\n\\n #ULTRASONIC TURN RIGHT\\n elif Commands.CMD_ULTRASONIC_TURN_LEFT[1:] in data_command:\\n #log the info\\n print data_command + \\\" \\\" + str(self.c.ULTRASONIC_ORIENTATION) + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn to the right the direction\\n self.c.ultrasonic_left()\\n #update the UI\\n self.emit( SIGNAL('update_ultrasonic_orientation_lcd(QString)'), str(self.c.ULTRASONIC_ORIENTATION))\\n\\n #RED LED\\n elif Commands.CMD_RGB_R[1:] in data_command:\\n #print command and timestamp\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn red led ON\\n self.c.turn_red_led_on()\\n #update server UI\\n self.emit( SIGNAL('update_led_label(QString, QString)'), \\\"red\\\", \\\"background-color: red\\\")\\n\\n #GREEN LED\\n elif Commands.CMD_RGB_G[1:] in data_command:\\n #print command and timestamp\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn green led ON\\n self.c.turn_green_led_on()\\n #update server UI\\n self.emit( SIGNAL('update_led_label(QString, QString)'), \\\"green\\\" ,\\\"background-color: green\\\")\\n\\n #BLUE LED\\n elif Commands.CMD_RGB_B[1:] in data_command:\\n #print command and timestamp\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn blue led ON\\n self.c.turn_blue_led_on()\\n #update server UI\\n self.emit( SIGNAL('update_led_label(QString, QString)'), \\\"blue\\\" ,\\\"background-color: blue\\\")\\n\\n #OFF LED\\n elif Commands.CMD_RGB_OFF[1:] in data_command:\\n #print command and timestamp\\n print data_command + \\\" at \\\" + datetime.datetime.now().strftime(\\\"%H:%M:%S\\\")\\n #turn blue led ON\\n self.c.turn_led_off()\\n #update server UI\\n self.emit( SIGNAL('update_led_label(QString, QString)'), \\\"off\\\", \\\"background-color: white\\\")\\n self.connection.close()\\n break\",\n \"def __updateListeningSockets(self, localHostName):\\n ## Get the local machine name and the remote nodes one\\n remoteNodesIP = self.__getLocalAndRemoteMachineNames()\\n ## Strip out the nodes' names\\n availableNodes = [node.strip() for node in self.runInfoDict['Nodes']]\\n ## Get unique nodes\\n uniqueNodes = list(set(list(set(availableNodes))) - set([localHostName]))\\n self.remoteServers = {}\\n if len(uniqueNodes) > 0:\\n ## There are remote nodes that need to be activated\\n ## Modify the python path used by the local environment\\n localEnv = os.environ.copy()\\n pathSeparator = os.pathsep\\n if \\\"PYTHONPATH\\\" in localEnv and len(localEnv[\\\"PYTHONPATH\\\"].strip()) > 0:\\n previousPath = localEnv[\\\"PYTHONPATH\\\"].strip()+pathSeparator\\n else:\\n previousPath = \\\"\\\"\\n localEnv[\\\"PYTHONPATH\\\"] = previousPath+pathSeparator.join(sys.path)\\n ## Start\\n for nodeId in uniqueNodes:\\n remoteHostName = remoteNodesIP[nodeId]\\n ## Activate the remote socketing system\\n ## let's build the command and then call the os-agnostic version\\n if _rayAvail:\\n self.raiseADebug(\\\"Updating RAY server in node:\\\", nodeId.strip())\\n runScript = os.path.join(self.runInfoDict['FrameworkDir'],\\\"RemoteNodeScripts\\\",\\\"update_path_in_remote_servers.sh\\\")\\n command=\\\" \\\".join([runScript,\\\"--remote-node-address\\\",nodeId,\\\" --working-dir \\\",self.runInfoDict['WorkingDir']])\\n self.raiseADebug(\\\"command is:\\\", command)\\n command += \\\" --python-path \\\"+localEnv[\\\"PYTHONPATH\\\"]\\n self.remoteServers[nodeId] = utils.pickleSafeSubprocessPopen([command],shell=True,env=localEnv)\",\n \"def _connect_neighbours(self):\\n for prev in self.unvisited:\\n for next in self.unvisited:\\n if (next[0] == prev[0] and next[1] == prev[1] + 1) or (next[0] == prev[0] + 1 and next[1] == prev[1]):\\n self.graph.addEdge((prev, next))\\n self.visited.add(prev)\\n self.visited.add(next)\\n if self._find_intersection():\\n self.intersection.append(prev)\\n self.intersection.append(next)\",\n \"def _tcp_reassemble(self, number, src_addr, dst_addr, tcp):\\n \\n pld = tcp.message[tcp.header_len : tcp.header_len + tcp.segement_len]\\n src_socket = (src_addr, tcp.src_port)\\n dst_socket = (dst_addr, tcp.dst_port)\\n sockets = (src_socket, dst_socket)\\n\\n def debug_cond(tcp):\\n return False\\n return True\\n return tcp.stream_index == 710\\n\\n #check the other side of the tcp connection, flush the complete pdu to the msg_list\\n if sockets in _tcp_buf and tcp.ack_num != _tcp_buf[sockets].ack: \\n self._tcp_flush(sockets)\\n del _tcp_buf[sockets]\\n if debug_cond(tcp):\\n print \\\"get a new http, decide by %d\\\" % number\\n\\n if debug_cond(tcp):\\n print \\\"_tcp_reassemble, number= %d, sequence_num=%d, ack = %d, pldlen=%d, msglen=%d， opt_paddings=%d, iptotal_len=%d, ipheader_len=%d, tcpheader_len=%d\\\" % (number, tcp.ack_num, len(pld), len(tcp.message), len(tcp.opt_paddings), tcp.ip.total_len, tcp.ip.header_len, tcp.header_len)\\n pass\\n\\n if pld:\\n if not sockets in _tcp_buf:\\n if debug_cond(tcp):\\n print \\\" add a new message, begin with %d\\\" % number\\n _tcp_buf[sockets] = Message({\\n 'pcap_num_list': [],\\n 'ts': self.packet_headers[number]['ts'] - self._ts_base,\\n 'ip_proto': 'TCP',\\n 'src_addr': src_addr,\\n 'dst_addr': dst_addr,\\n 'src_port': tcp.src_port,\\n 'dst_port': tcp.dst_port,\\n #'seq': tcp.sequence_num, HUA tcp disorder will generate error\\n 'tcp_list': [],\\n 'seq_min': 0,\\n 'ack': tcp.ack_num,\\n 'payload': [],\\n 'stream_index': tcp.stream_index, # HUA add a stream index to message\\n 'direction': tcp.direction, # HUA add to determin the http is request or response\\n 'flag': False\\n })\\n try:\\n _tcp_buf[sockets].ts = self.packet_headers[number]['ts'] - self._ts_base # HUA we should update ts and set it to last\\n except:\\n print number\\n print len(self.packet_headers)\\n _tcp_buf[sockets].pcap_num_list.append(number)\\n if number == 2246:\\n _tcp_buf[sockets].flag = False\\n _tcp_buf[sockets].tcp_list.append(tcp)\\n #offset = tcp.sequence_num - _tcp_buf[sockets].seq # seq 是相对的\\n #_tcp_buf[sockets].payload[offset:offset+len(pld)] = list(pld)\",\n \"def connect(\\n self,\\n key: str,\\n secret: str,\\n session_number: int,\\n server: str,\\n proxy_host: str,\\n proxy_port: int,\\n ):\\n self.key = key\\n self.secret = secret.encode()\\n\\n self.connect_time = (\\n int(datetime.now().strftime(\\\"%y%m%d%H%M%S\\\")) * self.order_count\\n )\\n\\n if server == \\\"REAL\\\":\\n self.init(REST_HOST, proxy_host, proxy_port)\\n else:\\n self.init(TESTNET_REST_HOST, proxy_host, proxy_port)\\n\\n self.start(session_number)\\n\\n self.gateway.write_log(\\\"REST API启动成功\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8264321","0.80638933","0.8030872","0.7862096","0.6225704","0.58393455","0.5660077","0.56123143","0.54760754","0.5442698","0.5426285","0.52990323","0.5269797","0.51783824","0.51644313","0.5143751","0.51365656","0.51334614","0.50976205","0.50662106","0.50438786","0.50028646","0.49923998","0.49665314","0.4953164","0.49463993","0.49426574","0.49270386","0.4921046","0.49124968","0.49057177","0.48992592","0.4881934","0.48574358","0.48547184","0.48528433","0.48437312","0.48343837","0.48239133","0.4820798","0.4820012","0.48193","0.481804","0.4794892","0.47881088","0.47654742","0.4763839","0.47577912","0.47542223","0.47364014","0.47341025","0.47233212","0.47198898","0.47119138","0.4707594","0.47028697","0.4698565","0.46955135","0.46947435","0.46854854","0.46817383","0.46748334","0.46550238","0.465444","0.46425226","0.46395138","0.4634961","0.46327245","0.46326005","0.4626156","0.46256095","0.46218514","0.46218267","0.46199626","0.4617736","0.46128184","0.46065828","0.46053323","0.460408","0.4598949","0.45908633","0.45881164","0.45879135","0.45834583","0.45809704","0.45808357","0.45793337","0.4576069","0.45705035","0.45686504","0.4561671","0.45572728","0.45562112","0.45494124","0.45477736","0.45446444","0.45440614","0.45414174","0.4537263","0.4534471"],"string":"[\n \"0.8264321\",\n \"0.80638933\",\n \"0.8030872\",\n \"0.7862096\",\n \"0.6225704\",\n \"0.58393455\",\n \"0.5660077\",\n \"0.56123143\",\n \"0.54760754\",\n \"0.5442698\",\n \"0.5426285\",\n \"0.52990323\",\n \"0.5269797\",\n \"0.51783824\",\n \"0.51644313\",\n \"0.5143751\",\n \"0.51365656\",\n \"0.51334614\",\n \"0.50976205\",\n \"0.50662106\",\n \"0.50438786\",\n \"0.50028646\",\n \"0.49923998\",\n \"0.49665314\",\n \"0.4953164\",\n \"0.49463993\",\n \"0.49426574\",\n \"0.49270386\",\n \"0.4921046\",\n \"0.49124968\",\n \"0.49057177\",\n \"0.48992592\",\n \"0.4881934\",\n \"0.48574358\",\n \"0.48547184\",\n \"0.48528433\",\n \"0.48437312\",\n \"0.48343837\",\n \"0.48239133\",\n \"0.4820798\",\n \"0.4820012\",\n \"0.48193\",\n \"0.481804\",\n \"0.4794892\",\n \"0.47881088\",\n \"0.47654742\",\n \"0.4763839\",\n \"0.47577912\",\n \"0.47542223\",\n \"0.47364014\",\n \"0.47341025\",\n \"0.47233212\",\n \"0.47198898\",\n \"0.47119138\",\n \"0.4707594\",\n \"0.47028697\",\n \"0.4698565\",\n \"0.46955135\",\n \"0.46947435\",\n \"0.46854854\",\n \"0.46817383\",\n \"0.46748334\",\n \"0.46550238\",\n \"0.465444\",\n \"0.46425226\",\n \"0.46395138\",\n \"0.4634961\",\n \"0.46327245\",\n \"0.46326005\",\n \"0.4626156\",\n \"0.46256095\",\n \"0.46218514\",\n \"0.46218267\",\n \"0.46199626\",\n \"0.4617736\",\n \"0.46128184\",\n \"0.46065828\",\n \"0.46053323\",\n \"0.460408\",\n \"0.4598949\",\n \"0.45908633\",\n \"0.45881164\",\n \"0.45879135\",\n \"0.45834583\",\n \"0.45809704\",\n \"0.45808357\",\n \"0.45793337\",\n \"0.4576069\",\n \"0.45705035\",\n \"0.45686504\",\n \"0.4561671\",\n \"0.45572728\",\n \"0.45562112\",\n \"0.45494124\",\n \"0.45477736\",\n \"0.45446444\",\n \"0.45440614\",\n \"0.45414174\",\n \"0.4537263\",\n \"0.4534471\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66718477"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":85153,"cells":{"query":{"kind":"string","value":"Use this function to make threads. Leave as is."},"document":{"kind":"string","value":"def daemon_thread_builder(target, args=()) -> threading.Thread:\n th = threading.Thread(target=target, args=args)\n th.setDaemon(True)\n return th"},"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_and_start_threads(self):\r\n self.create_threads()\r\n self.start_threads()","def _make_thread(self):\r\n pass","def create_workers(self, threads_count):\n\n for _ in xrange(threads_count):\n new_thread = Thread(target=self.execute)\n self.threads.append(new_thread)","def startWorkers(self):\n for i in range(self.aOT):\n t = thr.Thread(target=self.threadWorker)\n t.start()\n self.threads.append(t)","def prep_main():\n time.sleep(sleep_time * 2)\n thread_list = []\n # to create up to 5 Threads\n for x in range(5):\n # status_log = \"{\\\"batch_id\\\":\\\"1\\\", \\\"brew_batch_stage\\\":\\\"Preparation\\\", \\\"log\\\":\\\"Starting Preparation Process\\\"}\"\n # ServiceNowLog.ServiceNowLog.create_new_log(self, status_log)\n message = ('\\n\\n Batch: ' + str(x + 1) + ' ---------------------------------------')\n thread = threading.Thread(target=thread_function, args=(x,))\n thread_list.append(thread)\n # message = ('Batch: '+ str(x))\n print(message)\n\n # for thread in thread_list:\n thread.start()\n\n # for thread in thread_list:\n thread.join()\n # GPIO.cleanup()","def start_workers(self):\n\n for thread in self.threads:\n thread.start()","def __createTasksForThreads(self):\n self.__total_threads_count = 0\n self.__baseuri = 'http://forums.seagate.com'\n self.__last_timestamp = datetime(1980, 1, 1)\n #The Maximum No of threads to process, Bcoz, not all the forums get\n #updated Everyday, At maximum It will 100\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\n 'seagateforums_maxthreads'))\n self.__setSoupForCurrentUri()\n while self.__getThreads():\n try:\n self.currenturi = self.__baseuri + self.soup.find('a', \\\n text='Next').findParent('a')['href'].split(';')[0]\n self.__setSoupForCurrentUri()\n except:\n log.info(self.log_msg('Next Page link not found for url \\\n %s'%self.currenturi))\n break\n #self.linksOut = []\n if self.linksOut:\n updateSessionInfo('Search', self.session_info_out, \\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\n self.task.instance_data.get('update'))\n return True","def create_threads(self):\r\n name = self.short_name\r\n self.all_threads = []\r\n tf.train.add_queue_runner(tf.train.QueueRunner(self._preprocess_queue, [self._enqueue_op] * 2))\r\n\r\n def _create_and_register_thread(*args, **kwargs):\r\n thread = threading.Thread(*args, **kwargs)\r\n thread.daemon = True\r\n self.all_threads.append(thread)\r\n\r\n for i in range(self.num_threads):\r\n # File read thread\r\n _create_and_register_thread(target=self.read_entry_job, name='fread_%s_%d' % (name, i))\r\n\r\n # Preprocess thread\r\n _create_and_register_thread(target=self.preprocess_job,\r\n name='preprocess_%s_%d' % (name, i))\r\n\r\n if self.staging:\r\n # Send-to-GPU thread\r\n _create_and_register_thread(target=self.transfer_to_gpu_job,\r\n name='transfer_%s_%d' % (name, i))","def __createTasksForThreads(self):\n self.__current_thread_count = 0\n self.__last_timestamp = datetime( 1980,1,1 )\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\n 'ehealthforums_maxthreads'))\n while self.__getThreads():\n try:\n self.currenturi = self.currenturi.rsplit('/',1)[0] + '/' + self.soup.find('div', 'vt_pagination').find('a', text='>>').parent['href']\n self.__setSoupForCurrentUri()\n except:\n log.exception(self.log_msg('Next Page link not found for url \\\n %s'%self.currenturi))\n break\n log.info('Total # of tasks found is %d'%len(self.linksOut))\n #self.linksOut = None\n if self.linksOut:\n updateSessionInfo('Search', self.session_info_out,\\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\n self.task.instance_data.get('update'))\n return True","def run(self):\n self.loop = asyncio.new_event_loop()\n asyncio.set_event_loop(self.loop)\n tasks = []\n self.threads[0] = Worker(self, 0, self.options, self.logger,\n self.queue, self.storage, self.parser, self.addToQueue, role=1)\n tasks.append(self.threads[0].begin())\n for thread in range(1, self.max_threads):\n # Spawn and start the threads\n self.threads[thread] = Worker(self, thread, self.options, self.logger,\n self.queue, self.storage, self.parser, self.addToQueue)\n tasks.append(self.threads[thread].begin())\n self.loop.run_until_complete(asyncio.gather(*tasks))","def _start_threads(self, target, n):\n threads = [threading.Thread(target=target) for i in range(n)]\n [t.start() for t in threads]\n [t.join() for t in threads]","def _start_threads(self, target, n):\n threads = [threading.Thread(target=target) for i in range(n)]\n [t.start() for t in threads]\n [t.join() for t in threads]","def fill(self):\n for _ in range(Pyro4.config.THREADPOOL_MINTHREADS):\n if not self.attemptSpawn():\n break","def manager(num_thrds, num_loops):\n\n\tmutex.acquire()\n\tcnt.reset()\n\tmutex.release()\n\n\t# initialize the thread pool\n\tthread_pool = []\n\n\tfor i in range(num_thrds):\n\t\tthrd = threading.Thread(target=worker, args=(num_loops, cnt))\n\t\tthread_pool.append(thrd)\n\n\t# start threads\n\tfor i in range(len(thread_pool)):\n\t\tthread_pool[i].start()\n\n\tfor i in range(len(thread_pool)):\n\t\tthreading.Thread.join(thread_pool[i])\n\n\t#cnt.display()","def _launch_threads():\n from . import workqueue as lib\n from ctypes import CFUNCTYPE, c_int\n\n launch_threads = CFUNCTYPE(None, c_int)(lib.launch_threads)\n launch_threads(NUM_CPU)","def __createTasksForThreads(self):\n try:\n \n self.__total_threads_count = 0\n self.__baseuri = 'http://broncosfreaks.com/forums/'\n self.__last_timestamp = datetime( 1980,1,1 )\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\n 'broncosfreaks_maxthreads'))\n self.__setSoupForCurrentUri()\n while self.__processForumUrl():\n try:\n next_page_uri =self.__baseuri + self.soup.find('a', rel='next')['href']\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\n if 's' in data_dict.keys():\n data_dict.pop('s')\n self.currenturi = self.__baseuri + 'forumdisplay.php?'+ urlencode(data_dict) \n self.__setSoupForCurrentUri()\n except:\n log.exception(self.log_msg('Next Page link not found for url \\\n %s'%self.currenturi))\n break \n \n #log.info(self.log_msg('LINKSOUT: ' + str(len(self.linksOut))))\n #self.linksOut = [] # To Remove\n if self.linksOut:\n updateSessionInfo('Search', self.session_info_out, \\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\n self.task.instance_data.get('update'))\n return True \n except:\n log.info(log_msg('Exception while creating tasks for the url %s'\\\n %self.currenturi)) \n return False","def start_threads(self):\r\n assert len(self.all_threads) > 0\r\n for thread in self.all_threads:\r\n thread.start()","def spawn_threads():\n t0 = threading.Thread(target=print_numbers, args=[10, 0.9, \"\"]) \n t1 = threading.Thread(target=print_numbers, args=[7, 1, \" \"])\n t0.start()\n t1.start()","def setup_worker_threads(self):\n \n for thread_number in range(0, self.max_workers):\n worker = DeviceWorker(self, thread_number)\n self.worker_threads.append(worker)\n worker.start()","def do_threadedgen(self, args):\n\t\tfor lang in self.languages:\n\t\t\tt = threading.Thread(name = lang.name + \" hierarchies\", target = self.wrap_semaphore(getattr), args= (lang, \"hierarchyLengths\"))\n\t\t\tprint(\"spawning thread to generate hierarchies for \" + lang.name)\n\t\t\tt.start()\n\t\t\tself.generate_threads.append(t)","def joiner():\n for th in threads:\n th.join()\n done(process)","def _init_threads(self):\n\n startTh = Thread(name='InitialStart', target = self._singleUpdate, args=(self.outPs, ))\n self.threads.append(startTh)\n\n sendTh = Thread(name='SteeringListen',target = self._listen_for_steering, args = (self.inPs[0], self.outPs, ))\n self.threads.append(sendTh)","def start_threads(window, n_guests, counter_id_for_non_registered_attendees, counter_id_for_registered_attendees):\r\n Thread(target=guests_counter(window, n_guests), daemon=True).start()\r\n Thread(target=non_registered_guests_counter(window, counter_id_for_non_registered_attendees), daemon=True).start()\r\n Thread(target=registered_guests_counter(window, counter_id_for_registered_attendees), daemon=True).start()","def start_threads(self, sess, n_threads=1):\n self.threads = []\n for n in range(n_threads):\n t = threading.Thread(target=self.thread_main, args=(sess,))\n t.daemon = True # thread will close when parent quits\n t.start()\n self.threads.append(t)","def start_threads(self, sess, n_threads=1):\n self.threads = []\n for n in range(n_threads):\n t = threading.Thread(target=self.thread_main, args=(sess,))\n t.daemon = True # thread will close when parent quits\n t.start()\n self.threads.append(t)","def initiate_threads(self):\n receive_audio_thread = threading.Thread(target=self.receive_audio)\n receive_audio_thread.start()\n send_audio_thread = threading.Thread(target=self.send_audio)\n send_audio_thread.start()\n receive_video_thread = threading.Thread(target=self.receive_video)\n receive_video_thread.start()\n send_video_thread = threading.Thread(target=self.send_video)\n send_video_thread.start()","def start_threads(count):\n for i in range(count):\n threading.Thread(target=send_pulses, args=(i,)).start()","def _setup_workers(self, num_workers):\n self.pool = []\n\n for _ in range(num_workers):\n self.pool.append(Thread(target=self.threadloop))\n\n for a_thread in self.pool:\n a_thread.setDaemon(True)\n a_thread.start()","def main():\n thread1 = threading.Thread(target=arm_mirror)\n thread2 = threading.Thread(target=eye_change)\n thread3 = threading.Thread(target=speak)\n thread4 = threading.Thread(target=nod)\n thread5 = threading.Thread(target=camera)\n #Starts the threads.\n thread1.start()\n thread2.start()\n thread3.start()\n thread4.start()\n thread5.start()\n #Joins the threads\n thread1.join()\n thread2.join()\n thread3.join()\n thread4.join()\n thread5.join()","def _spawn_workers(self):\n self._event.set()\n self._workers = [ClassifierWorker(self._event, self._queue, self._results) for x in range(self._NUM_WORKERS)]\n [worker.start() for worker in self._workers]","def run_in_a_thread(func, args, limit):\n def get_active_threads():\n active = 0\n for t in Utility.__THREADS:\n if t.isAlive():\n active += 1\n else:\n Utility.__THREADS.remove(t)\n return active\n\n while get_active_threads() > limit:\n time.sleep(0.5)\n thread = threading.Thread(target=func, args=args)\n thread.start()\n Utility.__THREADS.append(thread)","def main():\n\n # Create the message queues\n command_queue = Queue()\n control_queue = Queue()\n monitor_queue = Queue()\n\n # Create the threads\n landyacht_thread = Thread(target=landyacht, args=(control_queue, monitor_queue))\n skipper_thread = Thread(target=skipper, args=(command_queue, control_queue, monitor_queue))\n ai_thread = Thread(target=ai, args=(command_queue, control_queue, monitor_queue))\n\n # Start the threads\n landyacht_thread.start()\n skipper_thread.start()\n ai_thread.start()\n\n # Join the threads and wait for them to exit\n landyacht_thread.join()\n skipper_thread.join()\n ai_thread.join()","def create_thread(target):\n thread = threading.Thread(target=target)\n thread.daemon = True\n thread.start()","def startall(self, wait=False, **kwdargs):\n self.logger.debug(\"startall called\")\n with self.regcond:\n while self.status != 'down':\n if self.status in ('start', 'up') or self.ev_quit.is_set():\n # For now, abandon additional request to start\n self.logger.error(\"ignoring duplicate request to start thread pool\")\n return\n\n self.logger.debug(\"waiting for threads: count=%d\" %\n self.runningcount)\n self.regcond.wait()\n\n #assert(self.status == 'down')\n if self.ev_quit.is_set():\n return\n\n self.runningcount = 0\n self.status = 'start'\n self.workers = []\n if wait:\n tpool = self\n else:\n tpool = None\n\n # Start all worker threads\n self.logger.debug(\"starting threads in thread pool\")\n for i in range(self.numthreads):\n t = self.workerClass(self.queue, logger=self.logger,\n ev_quit=self.ev_quit, tpool=tpool,\n **kwdargs)\n self.workers.append(t)\n t.start()\n\n # if started with wait=True, then expect that threads will register\n # themselves and last one up will set status to \"up\"\n if wait:\n # Threads are on the way up. Wait until last one starts.\n while self.status != 'up' and not self.ev_quit.is_set():\n self.logger.debug(\"waiting for threads: count=%d\" %\n self.runningcount)\n self.regcond.wait()\n else:\n # otherwise, we just assume the pool is up\n self.status = 'up'\n self.logger.debug(\"startall done\")","def __init__(self, threads_count):\n\n self.queue = Queue(threads_count)\n\n self.threads = []\n self.device = None\n\n self.create_workers(threads_count)\n self.start_workers()","def run_threads(self, threads):\n\n for t, daemon in threads:\n t.daemon = daemon\n self.processes.append(t)\n t.start()\n\n for t in self.processes:\n t.join()","def set_threads(self):\r\n # pump thread should start after the loop has started\r\n for device in self._model.measurement.children():\r\n if device.type_info == MOTOR_CONTROLLER:\r\n thread = Worker(device.update_duty_cycles)\r\n thread.setName('MotorControllerThread')\r\n thread.signals.message.connect(self.message)\r\n thread.signals.finished.connect(self.display_finished_thread)\r\n self._threads.append(thread)\r\n if device.type_info == LABJACK:\r\n # reading must start after processing\r\n thread = Worker(device.read_stream_data)\r\n thread.setName('StreamReaderThread-{}'.format(device.name))\r\n thread.signals.message.connect(self.message)\r\n thread.signals.finished.connect(self.display_finished_thread)\r\n thread.signals.result.connect(self.display_result)\r\n self._threads.append(thread)","def main(order_count):\n for id in range(MAX_ORDERS):\n while active_count() > MAX_QUEUE:\n print(\"..All permitted threads running: waiting\")\n sleep(LOOP_TIMEOUT)\n print(\"..Finished waiting\")\n o = Thread(target=order_gen, kwargs={\"id\": id})\n o.start()","def create_threads(self):\n\n # Create thread for neutron notifications.\n neutorn_thrd = utils.EventProcessingThread('Neutron_Event',\n self.neutron_event,\n 'event_handler',\n self._excpq)\n self.dfa_threads.append(neutorn_thrd)\n\n # Create thread for processing notification events.\n qp_thrd = utils.EventProcessingThread('Event_Queue', self,\n 'process_queue', self._excpq)\n self.dfa_threads.append(qp_thrd)\n\n # Create thread for keystone notifications.\n keys_thrd = utils.EventProcessingThread('Keystone_Event',\n self.keystone_event,\n 'event_handler', self._excpq)\n self.dfa_threads.append(keys_thrd)\n\n # Create thread to process RPC calls.\n hb_thrd = utils.EventProcessingThread('RPC_Server', self, 'start_rpc',\n self._excpq)\n self.dfa_threads.append(hb_thrd)\n\n # Create thread to listen to dcnm network events.\n if self.dcnm_event is not None:\n dcnmL_thrd = utils.EventProcessingThread('DcnmListener',\n self.dcnm_event,\n 'process_amqp_msgs',\n self._excpq)\n self.dfa_threads.append(dcnmL_thrd)\n\n # Create periodic task to process failure cases in create/delete\n # networks and projects.\n fr_thrd = utils.PeriodicTask(interval=constants.FAIL_REC_INTERVAL,\n func=self.add_events,\n event_queue=self.pqueue,\n priority=self.PRI_LOW_START + 10,\n excq=self._excpq)\n\n # Start all the threads.\n for t in self.dfa_threads:\n t.start()\n\n # Run the periodic tasks.\n fr_thrd.run()","def spawn_thread(func, *args, **kwargs):\n thread = threading.Thread(target=func, args=args, kwargs=kwargs)\n thread.daemon = True\n thread.start()\n return thread","def Threads():\n for i in range(0, idc.get_thread_qty()):\n yield idc.getn_thread(i)","def add_thread(self, i, threads, manager):\n #print(self.workers[0])\n t_event = threading.Event()\n worker = threading.Thread(target=thread_wrapper, args=(i, self.queue, threads, manager, t_event))\n worker.setDaemon(True)\n worker.start()\n self.workers.append((worker, t_event))","def construct_threads(self, process, flag):\n\t\tself.parallel_threads.append(self.prepare_batch(process, flag))","def run_channels():\n\n # Run channel encoders\n for c in channels:\n threads[c] = threading.Thread()\n threads[c].name = c\n threads[c].run = channels[c].run\n threads[c].start()\n \n time.sleep(0.5)\n print()","def run_in_parallel(self):\n\t\tfor p in self.parallel_threads:\n\t\t\tp.start()\n\t\tfor p in self.parallel_threads:\n\t\t\tp.join()","def process_thread(self):","def send_multi_posts(self, board, thread, comment, tasks, delay=15):\n threads = []\n\n for i in range(tasks):\n task = threading.Thread(target=self.send_post, args=(board, thread, comment,))\n threads.append(task)\n \n for i in threads:\n i.run()\n time.sleep(delay)","def join_threads(threads):\n for t in threads:\n while t.isAlive():\n t.join(5)","def main():\n channel_watcher = ChannelWatcher()\n channel_watcher.create_threads()\n for thread in channel_watcher.threads:\n thread.join()\n return","def example4(name):\n print(\"main started\") # main thread\n t1 = threading.Thread(target=my_func, args=['realpython']) # the second thread\n t1.start()\n t2 = threading.Thread(target=my_func1, args=['foo']) # the third thread\n t2.start()\n t3 = threading.Thread(target=my_func2, args=['haha']) # the fourth thread\n t3.start()\n t1.join() # tell the main thread to wait before continuing\n t2.join() # tell the main thread to wait before continuing\n t3.join() # tell the main thread to wait before continuing\n print(\"main ended\")","def do_fakethread(self,args):\n def ft(firstarg,fakethread_stop,btc,usd):\n while(not fakethread_stop.is_set()):\n print \"THIS IS A FAKE THREAD!!!!!!\"\n fakethread_stop.wait(3)\n\n global fakethread_stop\n btc,usd = bal()\n args = stripoffensive(args)\n args = args.split()\n if 'exit' in args:\n print \"Shutting down background thread...\"\n fakethread_stop.set()\n else: \n fakethread_stop = threading.Event()\n threadlist[\"fakethread\"] = fakethread_stop\n fake_thread = threading.Thread(target = ft, args=(None,fakethread_stop,btc,usd))\n fake_thread.daemon = True\n fake_thread.start()","def concurrency_with_coffee():\n print(\"- I'm tired, Bob!\", end = '')\n\n global threadLock\n threadLock = threading.Lock()\n threads = []\n\n # Create new threads\n thread1 = myThread(\"Thread-1\",\" are made of coffee?\")\n thread2 = myThread(\"Thread-2\",\" Do you know\")\n thread3 = myThread(\"Thread-3\",\" it!\")\n thread4 = myThread(\"Thread-4\",\" that our bodies\")\n thread5 = myThread(\"Thread-5\",\" -Try drinking\")\n\n # Start new Threads\n thread1.start()\n thread2.start()\n thread3.start()\n thread4.start()\n thread5.start()\n\n # Add threads to thread list\n threads.append(thread1)\n threads.append(thread2)\n threads.append(thread3)\n threads.append(thread4)\n threads.append(thread5)\n\n # Wait for all threads to complete\n for t in threads:\n t.join()\n print(\"- You’re right!\")","def start_threads(self, sess, n_threads=4):\n threads = []\n print(\"starting %d data threads for training\" % n_threads)\n for n in range(n_threads):\n t = threading.Thread(target=self.thread_main, args=(sess,0,))\n t.daemon = True # thread will close when parent quits\n t.start()\n threads.append(t)\n # Make sure the queueu is filled with some examples (n = 500)\n num_samples_in_queue = 0\n while num_samples_in_queue < self.capacityTrain:\n num_samples_in_queue = sess.run(self.size_op)\n print(\"Initializing queue, current size = %i/%i\" % (num_samples_in_queue, self.capacityTrain))\n time.sleep(2)\n return threads","def _ensure_thread(self) -> None:\n\n if not self._thread:\n thread = self._thread_factory(self.run)\n self._thread = thread\n thread.start()","def run_threaded(self):\n \n t = threading.Thread(target=self.run, args=())\n t.daemon = True\n t.start()\n return t # Return the thread, but don't join it (the caller can join if they want to)","def ParallelToserial(self):\n pass","def _launch_threads(click_context: click.Context, agents: List[Path]) -> int:\n aeas = [] # type: List[AEA]\n for agent_directory in agents:\n with cd(agent_directory):\n aeas.append(AEABuilder.from_aea_project(\".\").build())\n\n threads = [Thread(target=agent.start) for agent in aeas]\n for t in threads:\n t.start()\n\n try:\n while sum([t.is_alive() for t in threads]) != 0:\n # exit when all threads are not alive.\n # done to avoid block on joins\n for t in threads:\n t.join(0.1)\n\n except KeyboardInterrupt:\n logger.info(\"Keyboard interrupt detected.\")\n finally:\n for idx, agent in enumerate(aeas):\n if not agent.liveness.is_stopped:\n agent.stop()\n threads[idx].join()\n logger.info(\"Agent {} has been stopped.\".format(agent.name))\n return 0","def run(self):\n self.submit()\n self.start()","def start(self, nb_threads):\r\n # type: (int) -> None\r\n if self._active_threads:\r\n raise Exception('Threads already started.')\r\n\r\n # Create thread pool\r\n for _ in range(nb_threads):\r\n worker = threading.Thread(\r\n target=_work_function,\r\n args=(self._job_q, self._result_q, self._error_q))\r\n worker.start()\r\n self._thread_list.append(worker)\r\n self._active_threads += 1\r\n\r\n # Put sentinels to let the threads know when there's no more jobs\r\n [self._job_q.put(_ThreadPoolSentinel()) for _ in self._thread_list]","def __init__(self):\n Thread.__init__(self)\n self.start()","def __init__(self):\n Thread.__init__(self)\n self.start()","def daemon_thread_builder(target, args=()):\r\n th = threading.Thread(target=target, args=args)\r\n th.setDaemon(True)\r\n return th","def run(self):\r\n while True:\r\n job = self.jobs.get()\r\n\r\n work_thread = Thread(target = job)\r\n work_thread.setDaemon(True)\r\n self.work_count.put(True)\r\n self.workers[work_thread] = datetime.now()\r\n work_thread.start()","def main():\n print('creating balloons')\n a = ThreadBalloon('a',0,0,2,1,3)\n b = ThreadBalloon('b',100,100, 4, 2, 2)\n a.start()\n b.start()\n a.join()\n b.join()","def watch_threads(self):\n\t\twhile True:\n\t\t\ttime.sleep(60)\n\t\t\tfor idx, t in enumerate(self._example_q_threads):\n\t\t\t\tif not t.is_alive(): # if the thread is dead\n\t\t\t\t\ttf.logging.error('Found example queue thread dead. Restarting.')\n\t\t\t\t\tnew_t = Thread(target=self.fill_example_queue)\n\t\t\t\t\tself._example_q_threads[idx] = new_t\n\t\t\t\t\tnew_t.daemon = True\n\t\t\t\t\tnew_t.start()\n\t\t\tfor idx, t in enumerate(self._batch_q_threads):\n\t\t\t\tif not t.is_alive(): # if the thread is dead\n\t\t\t\t\ttf.logging.error('Found batch queue thread dead. Restarting.')\n\t\t\t\t\tnew_t = Thread(target=self.fill_batch_queue)\n\t\t\t\t\tself._batch_q_threads[idx] = new_t\n\t\t\t\t\tnew_t.daemon = True\n\t\t\t\t\tnew_t.start()","def start_sockets_threads():\n\n # register clean_up_threads to run on crash signals\n for sig in (SIGABRT, SIGINT, SIGTERM):\n signal(sig, ServerSockets.clean_up_threads)\n\n # spawn all listen threads\n app.socket_threads.append(spawn(ServerSockets.listen_for_users))\n app.socket_threads.append(spawn(ServerSockets.listen_for_ingredients))\n app.socket_threads.append(spawn(ServerSockets.listen_for_menu))","def _threaded(self, *args, **kwargs):\n\n for target in self.targets:\n result = target(*args, **kwargs)\n self.queue.put(result)","def manage_threads(_) -> int:\n return 1 << 33","def manage_threads(_) -> int:\n return 1 << 33","def startThreads(actorState, cmd=None, restartQueues=False, restart=False):\n\n try:\n actorState.threads\n except AttributeError:\n restart = False\n \n if not restart:\n actorState.queues = {}\n actorState.threads = {}\n\n restartQueues = True\n\n newQueues = {}\n threadsToStart = []\n for tname, tid, threadModule in [(\"master\", guiderActor.MASTER, masterThread),\n (\"gcamera\", guiderActor.GCAMERA, gcameraThread),\n (\"movie\", guiderActor.MOVIE, movieThread),\n ]:\n\n newQueues[tid] = Queue.Queue(0) if restartQueues else actorState.queues[tid]\n\n if restart:\n reload(threadModule)\n\n for t in threading.enumerate():\n if re.search(r\"^%s(-\\d+)?$\" % tname, t.name): # a thread of the proper type\n guiderActor.flushQueue(actorState.queues[tid])\n actorState.queues[tid].put(Msg(Msg.EXIT, cmd=cmd))\n\n t.join(1.0)\n if t.isAlive():\n if cmd:\n cmd.inform('text=\"Failed to kill %s\"' % tname)\n\n def updateName(g):\n \"\"\"re.sub callback to convert master -> master-1; master-3 -> master-4\"\"\"\n try:\n n = int(g.group(2))\n except TypeError:\n n = 0\n\n return \"%s-%d\" % (g.group(1), n + 1)\n\n tname = re.sub(r\"^([^\\d]*)(?:-(\\d*))?$\", updateName, actorState.threads[tid].name)\n\n actorState.threads[tid] = threading.Thread(target=threadModule.main, name=tname,\n args=[actorState.actor, newQueues])\n actorState.threads[tid].daemon = True\n\n threadsToStart.append(actorState.threads[tid])\n #\n # Switch to the new queues now we've sent EXIT to the old ones\n #\n for tid, q in newQueues.items():\n actorState.queues[tid] = q\n\n for t in threadsToStart:\n t.start()","def main():\n accessCount = int(input(\"Enter the number of accesses: \"))\n numWriters = int(input(\"Enter the number of writers: \"))\n numReaders = int(input(\"Enter the number of readers: \"))\n\n sleepMax = 4\n\n counter = Counter(0)\n print(\"counter defined at:\", str(counter.count))\n cell = SharedCell(counter)\n print(\"shared counter data:\", str(cell.data.count))\n\n writerList = []\n readerList = []\n for cnt in range(numWriters):\n writerList.append(Writer(cell, accessCount, sleepMax, cnt + 1))\n for cnt in range(numReaders):\n readerList.append(Reader(cell, accessCount, sleepMax, cnt + 1))\n\n print(\"Starting the threads\")\n for writer in writerList:\n writer.start()\n for reader in readerList:\n reader.start()","def main_loop():\n while len(fake_threads) > 0:\n pulse(0.1)","def _main(self):\n run = True\n\n while run:\n if self._do_iteration():\n self.delay_multiplier = 1\n self.iterations_made += 1\n else: # Spaces between iterations will get bigger and bigger as they fail\n self.delay_multiplier += self.DELAY_MULTIPLIER_ON_FAIL\n\n self.seconds_remaining = self._get_delay()\n while self.seconds_remaining > 0: # Check kill flag every second\n sleep(1)\n if self._kill_thread:\n self._kill_thread = False\n run = False\n break\n self.seconds_remaining -= 1","def prepare(self):\r\n self.socket.listen()\r\n for _ in xrange(self.threads):\r\n thread = Worker(self.tasks)\r\n thread.setDaemon(True)\r\n thread.start()\r\n self.prepared = True","def main_thread_enter(self):\n ...","def invoke_all_and_wait(self):\n list_promise = []\n for thread in self.__list_thread:\n thread.start()\n list_promise.append(thread)\n for process in list_promise: process.join()","def setupthreads(self,numthreads_):\n res = __library__.MSK_XX_setupthreads(self.__nativep,numthreads_)\n if res != 0:\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])","def __init__(self, numthreads):\n self.queue = Queue.Queue()\n for _ in range(numthreads):\n Worker(self.queue)\n logger.debug(\"Event worker pool started with %s threads.\" % numthreads)","def run(self):\n self.thread_send.start()\n self.thread_receive.start()","def __init__(self):\n Thread.__init__(self)\n self.start() # start the thread","def wait_threads(self):\n\n self.queue.join()","def _init_threads(self):\n\n self._init_hashers()\n self._queues = {}\n self._threads = {}\n\n for algo in self.algos:\n t = Thread(target=self._queue_updater, args=(algo,), name=algo)\n self._queues[algo] = Queue(MtHasher.QUEUE_SIZE)\n self._threads[algo] = t\n t.start()","def call(self):\n current_thread = threading.current_thread() # get current thread·\n event = self.q.get() # get task from queue\n while event != self.StopEvent: # Determine whether task is a terminator\n\n func, arguments, callback = event # get funcname,params,callback name\n try:\n result = func(*arguments)\n func_excute_status = True # set func executed status success\n except Exception as e:\n func_excute_status = False # set func executed status failure\n result = None\n print('{} executed error:'.format(func.__name__), e)\n\n if func_excute_status: #\n if callback is not None: # determine whetherif callback is None\n try:\n callback(result)\n except Exception as e:\n print(callback.__name__, e)\n\n with self.worker_state(self.free_list, current_thread):\n if self.terminal:\n event = self.StopEvent\n else:\n event = self.q.get()\n\n else:\n self.created_list.remove(current_thread)","def start_thread(self):\n self.thread = Thread(target=self.put_lines_into_queue)\n self.thread.daemon = True\n self.thread.start()","def run(i_cmd, i_ServerList, senario): #get servers name to run\n threads = []\n serverAddrList = getServersAddrs(i_ServerList)\n for server in serverAddrList:\n t = threading.Thread(target=doCMD, args=(i_cmd, server, senario,))\n threads.append(t)\n t.start()","def spawnWorkers(num, target, name=None, args=(), kwargs={}, daemon=1, interval=0):\n from threading import Thread\n threads = []\n for i in range(num):\n t = Thread(target=target, name=name, args=args, kwargs=kwargs)\n t.setDaemon(daemon)\n t.start()\n threads.append(t)\n time.sleep(interval)\n return threads","def end_threads(self):\n\n self.wait_threads()\n\n for _ in xrange(len(self.threads)):\n self.submit(None, None, None)\n\n for thread in self.threads:\n thread.join()","def cleanup():\n for th in THREAD_REGISTER.values():\n th.exit()\n th.join(timeout=3)","def join(self):\n while not self._stop:\n time.sleep(0.1)\n for t in reversed(self.tasks):\n t.join()","def mainloop(self, run, *args, **kwds):\r\n #self.m.make()\r\n self.time = 0\r\n Dummy = things(0,0,0)\r\n Dummy.threadqueue.append(-1)\r\n Dummy.s=self\r\n Dummy.name = 'End of simulation.'\r\n heappush(self.queue, (self.timeout, (Dummy, 1000)))\r\n #count = 0\r\n while self.time < self.timeout:\r\n run(*args, **kwds)\r\n (now, (item, i)) = heappop(self.queue)\r\n self.CalculateResourse(now)\r\n self.time = now\r\n item.creat()\r\n #count += 1\r\n #print 'Number of loops' , count\r","def run(self):\n self.thread = threading.Thread(target=self._main)\n self.thread.start()\n self.running = True","def _create_workers(self, start=True):\n\n bearer = api_client.get_bearer_token()\n account = api_client.account_id_from_jwt(bearer.value)\n LOGGER.info(\"account: %s\", account)\n\n project = self.args.get(\"project\") or None\n LOGGER.info(\"project: %s\", project)\n\n location = self.args.get(\"location\") or None\n LOGGER.info(\"location: %s\", location)\n\n thread_count = self.args.get(\"thread_count\") or 1\n LOGGER.info(\"thread_count: %s\", thread_count)\n\n # CREATE WORKER PROCESSES\n workers = {}\n\n # Create DownloadWorker processes\n for _ in range(thread_count):\n\n # Create a process-safe run_state object for controlling process\n # run_state = multiprocessing.Array('c', \"stoppingorstuff\")\n global RUN_STATE\n wrk = UploaderWorker(\n RUN_STATE,\n self._results_queue,\n account=account,\n project=project,\n location=location)\n workers[wrk] = RUN_STATE\n\n log_history_wrk = self.create_log_history()\n\n workers[log_history_wrk] = RUN_STATE\n\n if start:\n for wrkr in workers:\n wrkr.start()\n time.sleep(.5)\n\n return workers","def setNumThreads(self, num):\r\n self.threads = num","def tasks():","def main(args: argparse) -> None:\n threads = args.threads\n\n for thread in range(threads):\n canvas = canvas_init(args, thread)\n seeds = tools.load_seeds_from_file(args.seed, args.manual_seed)\n\n # Main process\n canvas_thread = threading.Thread(target=run,\n args=(args, canvas, seeds, thread,\n threads))\n canvas_thread.start()","def run_in_thread(fn):\r\n @staticmethod\r\n def run(*k):\r\n thread = threading.Thread(target=fn, args=(*k,), daemon = True)\r\n thread.start()\r\n return thread # <-- return the thread\r\n return run","def __create_consumer_threads(\n self, num_threads, rate_limiter, experiment_end_time, reported_outcome_generator\n ):\n\n def consume_token_blocking():\n \"\"\"consumer threads will keep acquiring tokens until experiment end time\"\"\"\n while self._fake_clock.time() < experiment_end_time:\n # A simple loop that acquires token, updates a counter, then releases token with an outcome\n # provided by reported_outcome_generator()\n t1 = self._fake_clock.time()\n token = rate_limiter.acquire_token()\n # update test state\n self._test_state_lock.acquire()\n try:\n self._test_state[\"count\"] += 1\n self._test_state[\"times\"].append(int(t1))\n finally:\n self._test_state_lock.release()\n\n self._outcome_generator_lock.acquire()\n try:\n outcome = next(reported_outcome_generator)\n rate_limiter.release_token(token, outcome)\n finally:\n self._outcome_generator_lock.release()\n\n return [\n threading.Thread(target=consume_token_blocking) for _ in range(num_threads)\n ]","def run_threaded(func):\n\tdef wrapper(*args, **kwargs):\n\t\tt=threading.Thread(target=func, args=args, daemon=True)\n\t\tt.start()\n\t\treturn t\n\treturn wrapper","def run_thread(func, article_id, timeframe, dump_dir):\n \n #purge any files that might exist in the temp directory\n os.chdir(dump_dir)\n file_list = os.listdir()\n file_list = [i for i in file_list if 'threadtemp' in i]\n if len(file_list) > 0:\n for file in file_list:\n os.remove(file)\n \n queue = Queue()\n\n for x in range(8):\n worker = DownloadWorker(queue)\n worker.daemon = True\n worker.start()\n \n for start, end in timeframe:\n queue.put((func, article_id, start, end, dump_dir))\n\n queue.join()","def run(self):\r\n start = datetime.now()\r\n for thread in self.get_active_threads(): thread.start()\r\n try: # Runs concurrently with threads\r\n while True:\r\n for thread in self.get_active_threads():\r\n if not thread.is_alive():\r\n self.get_dead_threads().append(thread.respawn_thread(self.get_retry_delta()))\r\n thread.add_thread_failure()\r\n thread.acknowledged_failure = True\r\n # Don't remove threads that died AFTER iteration\r\n self.remove_dead_threads()\r\n\r\n for thread in self.get_dead_threads():\r\n if not thread.failure_printed_to_console:\r\n print(f\"{thread.name} failed. Will attempt restart in {self.get_retry_delta()}\")\r\n thread.failure_printed_to_console = True\r\n\r\n if thread.restart_time < datetime.now():\r\n print(f\"Attempting to restart {thread.name}\")\r\n thread.failure_printed_to_console = False\r\n thread.restart_time = None\r\n thread.start()\r\n self.get_active_threads().append(thread)\r\n # Remove threads that have respawned\r\n self.remove_respawned_threads()\r\n\r\n # Export after time specified by delta\r\n if datetime.now() >= start + self.get_export_delta():\r\n self.export_json()\r\n start = datetime.now()\r\n\r\n except KeyboardInterrupt:\r\n print(\"Keyboard interrupt\")\r\n except Exception as err:\r\n print(err)\r\n finally: # Save necessary data before exit\r\n self.export_json()\r\n print(\"Exiting program\")\r\n sys.exit(0)","def __init__(self):\r\n\t\tthreading.Thread.__init__(self)\r\n\t\tself._want_abort = 0\r\n\t\t# This starts the thread running on creation, but you could\r\n\t\t# also make the GUI thread responsible for calling this\r\n\t\tself.worksQueue = Queue.Queue()\r\n\t\tself.timedList = []\r\n\t\tself.timedListLock = threading.Lock();\r\n\t\tself.abortionEvent = threading.Event()\r\n\t\tself.start()"],"string":"[\n \"def create_and_start_threads(self):\\r\\n self.create_threads()\\r\\n self.start_threads()\",\n \"def _make_thread(self):\\r\\n pass\",\n \"def create_workers(self, threads_count):\\n\\n for _ in xrange(threads_count):\\n new_thread = Thread(target=self.execute)\\n self.threads.append(new_thread)\",\n \"def startWorkers(self):\\n for i in range(self.aOT):\\n t = thr.Thread(target=self.threadWorker)\\n t.start()\\n self.threads.append(t)\",\n \"def prep_main():\\n time.sleep(sleep_time * 2)\\n thread_list = []\\n # to create up to 5 Threads\\n for x in range(5):\\n # status_log = \\\"{\\\\\\\"batch_id\\\\\\\":\\\\\\\"1\\\\\\\", \\\\\\\"brew_batch_stage\\\\\\\":\\\\\\\"Preparation\\\\\\\", \\\\\\\"log\\\\\\\":\\\\\\\"Starting Preparation Process\\\\\\\"}\\\"\\n # ServiceNowLog.ServiceNowLog.create_new_log(self, status_log)\\n message = ('\\\\n\\\\n Batch: ' + str(x + 1) + ' ---------------------------------------')\\n thread = threading.Thread(target=thread_function, args=(x,))\\n thread_list.append(thread)\\n # message = ('Batch: '+ str(x))\\n print(message)\\n\\n # for thread in thread_list:\\n thread.start()\\n\\n # for thread in thread_list:\\n thread.join()\\n # GPIO.cleanup()\",\n \"def start_workers(self):\\n\\n for thread in self.threads:\\n thread.start()\",\n \"def __createTasksForThreads(self):\\n self.__total_threads_count = 0\\n self.__baseuri = 'http://forums.seagate.com'\\n self.__last_timestamp = datetime(1980, 1, 1)\\n #The Maximum No of threads to process, Bcoz, not all the forums get\\n #updated Everyday, At maximum It will 100\\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\\\\n 'seagateforums_maxthreads'))\\n self.__setSoupForCurrentUri()\\n while self.__getThreads():\\n try:\\n self.currenturi = self.__baseuri + self.soup.find('a', \\\\\\n text='Next').findParent('a')['href'].split(';')[0]\\n self.__setSoupForCurrentUri()\\n except:\\n log.info(self.log_msg('Next Page link not found for url \\\\\\n %s'%self.currenturi))\\n break\\n #self.linksOut = []\\n if self.linksOut:\\n updateSessionInfo('Search', self.session_info_out, \\\\\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\\\\n self.task.instance_data.get('update'))\\n return True\",\n \"def create_threads(self):\\r\\n name = self.short_name\\r\\n self.all_threads = []\\r\\n tf.train.add_queue_runner(tf.train.QueueRunner(self._preprocess_queue, [self._enqueue_op] * 2))\\r\\n\\r\\n def _create_and_register_thread(*args, **kwargs):\\r\\n thread = threading.Thread(*args, **kwargs)\\r\\n thread.daemon = True\\r\\n self.all_threads.append(thread)\\r\\n\\r\\n for i in range(self.num_threads):\\r\\n # File read thread\\r\\n _create_and_register_thread(target=self.read_entry_job, name='fread_%s_%d' % (name, i))\\r\\n\\r\\n # Preprocess thread\\r\\n _create_and_register_thread(target=self.preprocess_job,\\r\\n name='preprocess_%s_%d' % (name, i))\\r\\n\\r\\n if self.staging:\\r\\n # Send-to-GPU thread\\r\\n _create_and_register_thread(target=self.transfer_to_gpu_job,\\r\\n name='transfer_%s_%d' % (name, i))\",\n \"def __createTasksForThreads(self):\\n self.__current_thread_count = 0\\n self.__last_timestamp = datetime( 1980,1,1 )\\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\\\\n 'ehealthforums_maxthreads'))\\n while self.__getThreads():\\n try:\\n self.currenturi = self.currenturi.rsplit('/',1)[0] + '/' + self.soup.find('div', 'vt_pagination').find('a', text='>>').parent['href']\\n self.__setSoupForCurrentUri()\\n except:\\n log.exception(self.log_msg('Next Page link not found for url \\\\\\n %s'%self.currenturi))\\n break\\n log.info('Total # of tasks found is %d'%len(self.linksOut))\\n #self.linksOut = None\\n if self.linksOut:\\n updateSessionInfo('Search', self.session_info_out,\\\\\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\\\\n self.task.instance_data.get('update'))\\n return True\",\n \"def run(self):\\n self.loop = asyncio.new_event_loop()\\n asyncio.set_event_loop(self.loop)\\n tasks = []\\n self.threads[0] = Worker(self, 0, self.options, self.logger,\\n self.queue, self.storage, self.parser, self.addToQueue, role=1)\\n tasks.append(self.threads[0].begin())\\n for thread in range(1, self.max_threads):\\n # Spawn and start the threads\\n self.threads[thread] = Worker(self, thread, self.options, self.logger,\\n self.queue, self.storage, self.parser, self.addToQueue)\\n tasks.append(self.threads[thread].begin())\\n self.loop.run_until_complete(asyncio.gather(*tasks))\",\n \"def _start_threads(self, target, n):\\n threads = [threading.Thread(target=target) for i in range(n)]\\n [t.start() for t in threads]\\n [t.join() for t in threads]\",\n \"def _start_threads(self, target, n):\\n threads = [threading.Thread(target=target) for i in range(n)]\\n [t.start() for t in threads]\\n [t.join() for t in threads]\",\n \"def fill(self):\\n for _ in range(Pyro4.config.THREADPOOL_MINTHREADS):\\n if not self.attemptSpawn():\\n break\",\n \"def manager(num_thrds, num_loops):\\n\\n\\tmutex.acquire()\\n\\tcnt.reset()\\n\\tmutex.release()\\n\\n\\t# initialize the thread pool\\n\\tthread_pool = []\\n\\n\\tfor i in range(num_thrds):\\n\\t\\tthrd = threading.Thread(target=worker, args=(num_loops, cnt))\\n\\t\\tthread_pool.append(thrd)\\n\\n\\t# start threads\\n\\tfor i in range(len(thread_pool)):\\n\\t\\tthread_pool[i].start()\\n\\n\\tfor i in range(len(thread_pool)):\\n\\t\\tthreading.Thread.join(thread_pool[i])\\n\\n\\t#cnt.display()\",\n \"def _launch_threads():\\n from . import workqueue as lib\\n from ctypes import CFUNCTYPE, c_int\\n\\n launch_threads = CFUNCTYPE(None, c_int)(lib.launch_threads)\\n launch_threads(NUM_CPU)\",\n \"def __createTasksForThreads(self):\\n try:\\n \\n self.__total_threads_count = 0\\n self.__baseuri = 'http://broncosfreaks.com/forums/'\\n self.__last_timestamp = datetime( 1980,1,1 )\\n self.__max_threads_count = int(tg.config.get(path='Connector', key=\\\\\\n 'broncosfreaks_maxthreads'))\\n self.__setSoupForCurrentUri()\\n while self.__processForumUrl():\\n try:\\n next_page_uri =self.__baseuri + self.soup.find('a', rel='next')['href']\\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\\n if 's' in data_dict.keys():\\n data_dict.pop('s')\\n self.currenturi = self.__baseuri + 'forumdisplay.php?'+ urlencode(data_dict) \\n self.__setSoupForCurrentUri()\\n except:\\n log.exception(self.log_msg('Next Page link not found for url \\\\\\n %s'%self.currenturi))\\n break \\n \\n #log.info(self.log_msg('LINKSOUT: ' + str(len(self.linksOut))))\\n #self.linksOut = [] # To Remove\\n if self.linksOut:\\n updateSessionInfo('Search', self.session_info_out, \\\\\\n self.__last_timestamp , None, 'ForumThreadsPage', \\\\\\n self.task.instance_data.get('update'))\\n return True \\n except:\\n log.info(log_msg('Exception while creating tasks for the url %s'\\\\\\n %self.currenturi)) \\n return False\",\n \"def start_threads(self):\\r\\n assert len(self.all_threads) > 0\\r\\n for thread in self.all_threads:\\r\\n thread.start()\",\n \"def spawn_threads():\\n t0 = threading.Thread(target=print_numbers, args=[10, 0.9, \\\"\\\"]) \\n t1 = threading.Thread(target=print_numbers, args=[7, 1, \\\" \\\"])\\n t0.start()\\n t1.start()\",\n \"def setup_worker_threads(self):\\n \\n for thread_number in range(0, self.max_workers):\\n worker = DeviceWorker(self, thread_number)\\n self.worker_threads.append(worker)\\n worker.start()\",\n \"def do_threadedgen(self, args):\\n\\t\\tfor lang in self.languages:\\n\\t\\t\\tt = threading.Thread(name = lang.name + \\\" hierarchies\\\", target = self.wrap_semaphore(getattr), args= (lang, \\\"hierarchyLengths\\\"))\\n\\t\\t\\tprint(\\\"spawning thread to generate hierarchies for \\\" + lang.name)\\n\\t\\t\\tt.start()\\n\\t\\t\\tself.generate_threads.append(t)\",\n \"def joiner():\\n for th in threads:\\n th.join()\\n done(process)\",\n \"def _init_threads(self):\\n\\n startTh = Thread(name='InitialStart', target = self._singleUpdate, args=(self.outPs, ))\\n self.threads.append(startTh)\\n\\n sendTh = Thread(name='SteeringListen',target = self._listen_for_steering, args = (self.inPs[0], self.outPs, ))\\n self.threads.append(sendTh)\",\n \"def start_threads(window, n_guests, counter_id_for_non_registered_attendees, counter_id_for_registered_attendees):\\r\\n Thread(target=guests_counter(window, n_guests), daemon=True).start()\\r\\n Thread(target=non_registered_guests_counter(window, counter_id_for_non_registered_attendees), daemon=True).start()\\r\\n Thread(target=registered_guests_counter(window, counter_id_for_registered_attendees), daemon=True).start()\",\n \"def start_threads(self, sess, n_threads=1):\\n self.threads = []\\n for n in range(n_threads):\\n t = threading.Thread(target=self.thread_main, args=(sess,))\\n t.daemon = True # thread will close when parent quits\\n t.start()\\n self.threads.append(t)\",\n \"def start_threads(self, sess, n_threads=1):\\n self.threads = []\\n for n in range(n_threads):\\n t = threading.Thread(target=self.thread_main, args=(sess,))\\n t.daemon = True # thread will close when parent quits\\n t.start()\\n self.threads.append(t)\",\n \"def initiate_threads(self):\\n receive_audio_thread = threading.Thread(target=self.receive_audio)\\n receive_audio_thread.start()\\n send_audio_thread = threading.Thread(target=self.send_audio)\\n send_audio_thread.start()\\n receive_video_thread = threading.Thread(target=self.receive_video)\\n receive_video_thread.start()\\n send_video_thread = threading.Thread(target=self.send_video)\\n send_video_thread.start()\",\n \"def start_threads(count):\\n for i in range(count):\\n threading.Thread(target=send_pulses, args=(i,)).start()\",\n \"def _setup_workers(self, num_workers):\\n self.pool = []\\n\\n for _ in range(num_workers):\\n self.pool.append(Thread(target=self.threadloop))\\n\\n for a_thread in self.pool:\\n a_thread.setDaemon(True)\\n a_thread.start()\",\n \"def main():\\n thread1 = threading.Thread(target=arm_mirror)\\n thread2 = threading.Thread(target=eye_change)\\n thread3 = threading.Thread(target=speak)\\n thread4 = threading.Thread(target=nod)\\n thread5 = threading.Thread(target=camera)\\n #Starts the threads.\\n thread1.start()\\n thread2.start()\\n thread3.start()\\n thread4.start()\\n thread5.start()\\n #Joins the threads\\n thread1.join()\\n thread2.join()\\n thread3.join()\\n thread4.join()\\n thread5.join()\",\n \"def _spawn_workers(self):\\n self._event.set()\\n self._workers = [ClassifierWorker(self._event, self._queue, self._results) for x in range(self._NUM_WORKERS)]\\n [worker.start() for worker in self._workers]\",\n \"def run_in_a_thread(func, args, limit):\\n def get_active_threads():\\n active = 0\\n for t in Utility.__THREADS:\\n if t.isAlive():\\n active += 1\\n else:\\n Utility.__THREADS.remove(t)\\n return active\\n\\n while get_active_threads() > limit:\\n time.sleep(0.5)\\n thread = threading.Thread(target=func, args=args)\\n thread.start()\\n Utility.__THREADS.append(thread)\",\n \"def main():\\n\\n # Create the message queues\\n command_queue = Queue()\\n control_queue = Queue()\\n monitor_queue = Queue()\\n\\n # Create the threads\\n landyacht_thread = Thread(target=landyacht, args=(control_queue, monitor_queue))\\n skipper_thread = Thread(target=skipper, args=(command_queue, control_queue, monitor_queue))\\n ai_thread = Thread(target=ai, args=(command_queue, control_queue, monitor_queue))\\n\\n # Start the threads\\n landyacht_thread.start()\\n skipper_thread.start()\\n ai_thread.start()\\n\\n # Join the threads and wait for them to exit\\n landyacht_thread.join()\\n skipper_thread.join()\\n ai_thread.join()\",\n \"def create_thread(target):\\n thread = threading.Thread(target=target)\\n thread.daemon = True\\n thread.start()\",\n \"def startall(self, wait=False, **kwdargs):\\n self.logger.debug(\\\"startall called\\\")\\n with self.regcond:\\n while self.status != 'down':\\n if self.status in ('start', 'up') or self.ev_quit.is_set():\\n # For now, abandon additional request to start\\n self.logger.error(\\\"ignoring duplicate request to start thread pool\\\")\\n return\\n\\n self.logger.debug(\\\"waiting for threads: count=%d\\\" %\\n self.runningcount)\\n self.regcond.wait()\\n\\n #assert(self.status == 'down')\\n if self.ev_quit.is_set():\\n return\\n\\n self.runningcount = 0\\n self.status = 'start'\\n self.workers = []\\n if wait:\\n tpool = self\\n else:\\n tpool = None\\n\\n # Start all worker threads\\n self.logger.debug(\\\"starting threads in thread pool\\\")\\n for i in range(self.numthreads):\\n t = self.workerClass(self.queue, logger=self.logger,\\n ev_quit=self.ev_quit, tpool=tpool,\\n **kwdargs)\\n self.workers.append(t)\\n t.start()\\n\\n # if started with wait=True, then expect that threads will register\\n # themselves and last one up will set status to \\\"up\\\"\\n if wait:\\n # Threads are on the way up. Wait until last one starts.\\n while self.status != 'up' and not self.ev_quit.is_set():\\n self.logger.debug(\\\"waiting for threads: count=%d\\\" %\\n self.runningcount)\\n self.regcond.wait()\\n else:\\n # otherwise, we just assume the pool is up\\n self.status = 'up'\\n self.logger.debug(\\\"startall done\\\")\",\n \"def __init__(self, threads_count):\\n\\n self.queue = Queue(threads_count)\\n\\n self.threads = []\\n self.device = None\\n\\n self.create_workers(threads_count)\\n self.start_workers()\",\n \"def run_threads(self, threads):\\n\\n for t, daemon in threads:\\n t.daemon = daemon\\n self.processes.append(t)\\n t.start()\\n\\n for t in self.processes:\\n t.join()\",\n \"def set_threads(self):\\r\\n # pump thread should start after the loop has started\\r\\n for device in self._model.measurement.children():\\r\\n if device.type_info == MOTOR_CONTROLLER:\\r\\n thread = Worker(device.update_duty_cycles)\\r\\n thread.setName('MotorControllerThread')\\r\\n thread.signals.message.connect(self.message)\\r\\n thread.signals.finished.connect(self.display_finished_thread)\\r\\n self._threads.append(thread)\\r\\n if device.type_info == LABJACK:\\r\\n # reading must start after processing\\r\\n thread = Worker(device.read_stream_data)\\r\\n thread.setName('StreamReaderThread-{}'.format(device.name))\\r\\n thread.signals.message.connect(self.message)\\r\\n thread.signals.finished.connect(self.display_finished_thread)\\r\\n thread.signals.result.connect(self.display_result)\\r\\n self._threads.append(thread)\",\n \"def main(order_count):\\n for id in range(MAX_ORDERS):\\n while active_count() > MAX_QUEUE:\\n print(\\\"..All permitted threads running: waiting\\\")\\n sleep(LOOP_TIMEOUT)\\n print(\\\"..Finished waiting\\\")\\n o = Thread(target=order_gen, kwargs={\\\"id\\\": id})\\n o.start()\",\n \"def create_threads(self):\\n\\n # Create thread for neutron notifications.\\n neutorn_thrd = utils.EventProcessingThread('Neutron_Event',\\n self.neutron_event,\\n 'event_handler',\\n self._excpq)\\n self.dfa_threads.append(neutorn_thrd)\\n\\n # Create thread for processing notification events.\\n qp_thrd = utils.EventProcessingThread('Event_Queue', self,\\n 'process_queue', self._excpq)\\n self.dfa_threads.append(qp_thrd)\\n\\n # Create thread for keystone notifications.\\n keys_thrd = utils.EventProcessingThread('Keystone_Event',\\n self.keystone_event,\\n 'event_handler', self._excpq)\\n self.dfa_threads.append(keys_thrd)\\n\\n # Create thread to process RPC calls.\\n hb_thrd = utils.EventProcessingThread('RPC_Server', self, 'start_rpc',\\n self._excpq)\\n self.dfa_threads.append(hb_thrd)\\n\\n # Create thread to listen to dcnm network events.\\n if self.dcnm_event is not None:\\n dcnmL_thrd = utils.EventProcessingThread('DcnmListener',\\n self.dcnm_event,\\n 'process_amqp_msgs',\\n self._excpq)\\n self.dfa_threads.append(dcnmL_thrd)\\n\\n # Create periodic task to process failure cases in create/delete\\n # networks and projects.\\n fr_thrd = utils.PeriodicTask(interval=constants.FAIL_REC_INTERVAL,\\n func=self.add_events,\\n event_queue=self.pqueue,\\n priority=self.PRI_LOW_START + 10,\\n excq=self._excpq)\\n\\n # Start all the threads.\\n for t in self.dfa_threads:\\n t.start()\\n\\n # Run the periodic tasks.\\n fr_thrd.run()\",\n \"def spawn_thread(func, *args, **kwargs):\\n thread = threading.Thread(target=func, args=args, kwargs=kwargs)\\n thread.daemon = True\\n thread.start()\\n return thread\",\n \"def Threads():\\n for i in range(0, idc.get_thread_qty()):\\n yield idc.getn_thread(i)\",\n \"def add_thread(self, i, threads, manager):\\n #print(self.workers[0])\\n t_event = threading.Event()\\n worker = threading.Thread(target=thread_wrapper, args=(i, self.queue, threads, manager, t_event))\\n worker.setDaemon(True)\\n worker.start()\\n self.workers.append((worker, t_event))\",\n \"def construct_threads(self, process, flag):\\n\\t\\tself.parallel_threads.append(self.prepare_batch(process, flag))\",\n \"def run_channels():\\n\\n # Run channel encoders\\n for c in channels:\\n threads[c] = threading.Thread()\\n threads[c].name = c\\n threads[c].run = channels[c].run\\n threads[c].start()\\n \\n time.sleep(0.5)\\n print()\",\n \"def run_in_parallel(self):\\n\\t\\tfor p in self.parallel_threads:\\n\\t\\t\\tp.start()\\n\\t\\tfor p in self.parallel_threads:\\n\\t\\t\\tp.join()\",\n \"def process_thread(self):\",\n \"def send_multi_posts(self, board, thread, comment, tasks, delay=15):\\n threads = []\\n\\n for i in range(tasks):\\n task = threading.Thread(target=self.send_post, args=(board, thread, comment,))\\n threads.append(task)\\n \\n for i in threads:\\n i.run()\\n time.sleep(delay)\",\n \"def join_threads(threads):\\n for t in threads:\\n while t.isAlive():\\n t.join(5)\",\n \"def main():\\n channel_watcher = ChannelWatcher()\\n channel_watcher.create_threads()\\n for thread in channel_watcher.threads:\\n thread.join()\\n return\",\n \"def example4(name):\\n print(\\\"main started\\\") # main thread\\n t1 = threading.Thread(target=my_func, args=['realpython']) # the second thread\\n t1.start()\\n t2 = threading.Thread(target=my_func1, args=['foo']) # the third thread\\n t2.start()\\n t3 = threading.Thread(target=my_func2, args=['haha']) # the fourth thread\\n t3.start()\\n t1.join() # tell the main thread to wait before continuing\\n t2.join() # tell the main thread to wait before continuing\\n t3.join() # tell the main thread to wait before continuing\\n print(\\\"main ended\\\")\",\n \"def do_fakethread(self,args):\\n def ft(firstarg,fakethread_stop,btc,usd):\\n while(not fakethread_stop.is_set()):\\n print \\\"THIS IS A FAKE THREAD!!!!!!\\\"\\n fakethread_stop.wait(3)\\n\\n global fakethread_stop\\n btc,usd = bal()\\n args = stripoffensive(args)\\n args = args.split()\\n if 'exit' in args:\\n print \\\"Shutting down background thread...\\\"\\n fakethread_stop.set()\\n else: \\n fakethread_stop = threading.Event()\\n threadlist[\\\"fakethread\\\"] = fakethread_stop\\n fake_thread = threading.Thread(target = ft, args=(None,fakethread_stop,btc,usd))\\n fake_thread.daemon = True\\n fake_thread.start()\",\n \"def concurrency_with_coffee():\\n print(\\\"- I'm tired, Bob!\\\", end = '')\\n\\n global threadLock\\n threadLock = threading.Lock()\\n threads = []\\n\\n # Create new threads\\n thread1 = myThread(\\\"Thread-1\\\",\\\" are made of coffee?\\\")\\n thread2 = myThread(\\\"Thread-2\\\",\\\" Do you know\\\")\\n thread3 = myThread(\\\"Thread-3\\\",\\\" it!\\\")\\n thread4 = myThread(\\\"Thread-4\\\",\\\" that our bodies\\\")\\n thread5 = myThread(\\\"Thread-5\\\",\\\" -Try drinking\\\")\\n\\n # Start new Threads\\n thread1.start()\\n thread2.start()\\n thread3.start()\\n thread4.start()\\n thread5.start()\\n\\n # Add threads to thread list\\n threads.append(thread1)\\n threads.append(thread2)\\n threads.append(thread3)\\n threads.append(thread4)\\n threads.append(thread5)\\n\\n # Wait for all threads to complete\\n for t in threads:\\n t.join()\\n print(\\\"- You’re right!\\\")\",\n \"def start_threads(self, sess, n_threads=4):\\n threads = []\\n print(\\\"starting %d data threads for training\\\" % n_threads)\\n for n in range(n_threads):\\n t = threading.Thread(target=self.thread_main, args=(sess,0,))\\n t.daemon = True # thread will close when parent quits\\n t.start()\\n threads.append(t)\\n # Make sure the queueu is filled with some examples (n = 500)\\n num_samples_in_queue = 0\\n while num_samples_in_queue < self.capacityTrain:\\n num_samples_in_queue = sess.run(self.size_op)\\n print(\\\"Initializing queue, current size = %i/%i\\\" % (num_samples_in_queue, self.capacityTrain))\\n time.sleep(2)\\n return threads\",\n \"def _ensure_thread(self) -> None:\\n\\n if not self._thread:\\n thread = self._thread_factory(self.run)\\n self._thread = thread\\n thread.start()\",\n \"def run_threaded(self):\\n \\n t = threading.Thread(target=self.run, args=())\\n t.daemon = True\\n t.start()\\n return t # Return the thread, but don't join it (the caller can join if they want to)\",\n \"def ParallelToserial(self):\\n pass\",\n \"def _launch_threads(click_context: click.Context, agents: List[Path]) -> int:\\n aeas = [] # type: List[AEA]\\n for agent_directory in agents:\\n with cd(agent_directory):\\n aeas.append(AEABuilder.from_aea_project(\\\".\\\").build())\\n\\n threads = [Thread(target=agent.start) for agent in aeas]\\n for t in threads:\\n t.start()\\n\\n try:\\n while sum([t.is_alive() for t in threads]) != 0:\\n # exit when all threads are not alive.\\n # done to avoid block on joins\\n for t in threads:\\n t.join(0.1)\\n\\n except KeyboardInterrupt:\\n logger.info(\\\"Keyboard interrupt detected.\\\")\\n finally:\\n for idx, agent in enumerate(aeas):\\n if not agent.liveness.is_stopped:\\n agent.stop()\\n threads[idx].join()\\n logger.info(\\\"Agent {} has been stopped.\\\".format(agent.name))\\n return 0\",\n \"def run(self):\\n self.submit()\\n self.start()\",\n \"def start(self, nb_threads):\\r\\n # type: (int) -> None\\r\\n if self._active_threads:\\r\\n raise Exception('Threads already started.')\\r\\n\\r\\n # Create thread pool\\r\\n for _ in range(nb_threads):\\r\\n worker = threading.Thread(\\r\\n target=_work_function,\\r\\n args=(self._job_q, self._result_q, self._error_q))\\r\\n worker.start()\\r\\n self._thread_list.append(worker)\\r\\n self._active_threads += 1\\r\\n\\r\\n # Put sentinels to let the threads know when there's no more jobs\\r\\n [self._job_q.put(_ThreadPoolSentinel()) for _ in self._thread_list]\",\n \"def __init__(self):\\n Thread.__init__(self)\\n self.start()\",\n \"def __init__(self):\\n Thread.__init__(self)\\n self.start()\",\n \"def daemon_thread_builder(target, args=()):\\r\\n th = threading.Thread(target=target, args=args)\\r\\n th.setDaemon(True)\\r\\n return th\",\n \"def run(self):\\r\\n while True:\\r\\n job = self.jobs.get()\\r\\n\\r\\n work_thread = Thread(target = job)\\r\\n work_thread.setDaemon(True)\\r\\n self.work_count.put(True)\\r\\n self.workers[work_thread] = datetime.now()\\r\\n work_thread.start()\",\n \"def main():\\n print('creating balloons')\\n a = ThreadBalloon('a',0,0,2,1,3)\\n b = ThreadBalloon('b',100,100, 4, 2, 2)\\n a.start()\\n b.start()\\n a.join()\\n b.join()\",\n \"def watch_threads(self):\\n\\t\\twhile True:\\n\\t\\t\\ttime.sleep(60)\\n\\t\\t\\tfor idx, t in enumerate(self._example_q_threads):\\n\\t\\t\\t\\tif not t.is_alive(): # if the thread is dead\\n\\t\\t\\t\\t\\ttf.logging.error('Found example queue thread dead. Restarting.')\\n\\t\\t\\t\\t\\tnew_t = Thread(target=self.fill_example_queue)\\n\\t\\t\\t\\t\\tself._example_q_threads[idx] = new_t\\n\\t\\t\\t\\t\\tnew_t.daemon = True\\n\\t\\t\\t\\t\\tnew_t.start()\\n\\t\\t\\tfor idx, t in enumerate(self._batch_q_threads):\\n\\t\\t\\t\\tif not t.is_alive(): # if the thread is dead\\n\\t\\t\\t\\t\\ttf.logging.error('Found batch queue thread dead. Restarting.')\\n\\t\\t\\t\\t\\tnew_t = Thread(target=self.fill_batch_queue)\\n\\t\\t\\t\\t\\tself._batch_q_threads[idx] = new_t\\n\\t\\t\\t\\t\\tnew_t.daemon = True\\n\\t\\t\\t\\t\\tnew_t.start()\",\n \"def start_sockets_threads():\\n\\n # register clean_up_threads to run on crash signals\\n for sig in (SIGABRT, SIGINT, SIGTERM):\\n signal(sig, ServerSockets.clean_up_threads)\\n\\n # spawn all listen threads\\n app.socket_threads.append(spawn(ServerSockets.listen_for_users))\\n app.socket_threads.append(spawn(ServerSockets.listen_for_ingredients))\\n app.socket_threads.append(spawn(ServerSockets.listen_for_menu))\",\n \"def _threaded(self, *args, **kwargs):\\n\\n for target in self.targets:\\n result = target(*args, **kwargs)\\n self.queue.put(result)\",\n \"def manage_threads(_) -> int:\\n return 1 << 33\",\n \"def manage_threads(_) -> int:\\n return 1 << 33\",\n \"def startThreads(actorState, cmd=None, restartQueues=False, restart=False):\\n\\n try:\\n actorState.threads\\n except AttributeError:\\n restart = False\\n \\n if not restart:\\n actorState.queues = {}\\n actorState.threads = {}\\n\\n restartQueues = True\\n\\n newQueues = {}\\n threadsToStart = []\\n for tname, tid, threadModule in [(\\\"master\\\", guiderActor.MASTER, masterThread),\\n (\\\"gcamera\\\", guiderActor.GCAMERA, gcameraThread),\\n (\\\"movie\\\", guiderActor.MOVIE, movieThread),\\n ]:\\n\\n newQueues[tid] = Queue.Queue(0) if restartQueues else actorState.queues[tid]\\n\\n if restart:\\n reload(threadModule)\\n\\n for t in threading.enumerate():\\n if re.search(r\\\"^%s(-\\\\d+)?$\\\" % tname, t.name): # a thread of the proper type\\n guiderActor.flushQueue(actorState.queues[tid])\\n actorState.queues[tid].put(Msg(Msg.EXIT, cmd=cmd))\\n\\n t.join(1.0)\\n if t.isAlive():\\n if cmd:\\n cmd.inform('text=\\\"Failed to kill %s\\\"' % tname)\\n\\n def updateName(g):\\n \\\"\\\"\\\"re.sub callback to convert master -> master-1; master-3 -> master-4\\\"\\\"\\\"\\n try:\\n n = int(g.group(2))\\n except TypeError:\\n n = 0\\n\\n return \\\"%s-%d\\\" % (g.group(1), n + 1)\\n\\n tname = re.sub(r\\\"^([^\\\\d]*)(?:-(\\\\d*))?$\\\", updateName, actorState.threads[tid].name)\\n\\n actorState.threads[tid] = threading.Thread(target=threadModule.main, name=tname,\\n args=[actorState.actor, newQueues])\\n actorState.threads[tid].daemon = True\\n\\n threadsToStart.append(actorState.threads[tid])\\n #\\n # Switch to the new queues now we've sent EXIT to the old ones\\n #\\n for tid, q in newQueues.items():\\n actorState.queues[tid] = q\\n\\n for t in threadsToStart:\\n t.start()\",\n \"def main():\\n accessCount = int(input(\\\"Enter the number of accesses: \\\"))\\n numWriters = int(input(\\\"Enter the number of writers: \\\"))\\n numReaders = int(input(\\\"Enter the number of readers: \\\"))\\n\\n sleepMax = 4\\n\\n counter = Counter(0)\\n print(\\\"counter defined at:\\\", str(counter.count))\\n cell = SharedCell(counter)\\n print(\\\"shared counter data:\\\", str(cell.data.count))\\n\\n writerList = []\\n readerList = []\\n for cnt in range(numWriters):\\n writerList.append(Writer(cell, accessCount, sleepMax, cnt + 1))\\n for cnt in range(numReaders):\\n readerList.append(Reader(cell, accessCount, sleepMax, cnt + 1))\\n\\n print(\\\"Starting the threads\\\")\\n for writer in writerList:\\n writer.start()\\n for reader in readerList:\\n reader.start()\",\n \"def main_loop():\\n while len(fake_threads) > 0:\\n pulse(0.1)\",\n \"def _main(self):\\n run = True\\n\\n while run:\\n if self._do_iteration():\\n self.delay_multiplier = 1\\n self.iterations_made += 1\\n else: # Spaces between iterations will get bigger and bigger as they fail\\n self.delay_multiplier += self.DELAY_MULTIPLIER_ON_FAIL\\n\\n self.seconds_remaining = self._get_delay()\\n while self.seconds_remaining > 0: # Check kill flag every second\\n sleep(1)\\n if self._kill_thread:\\n self._kill_thread = False\\n run = False\\n break\\n self.seconds_remaining -= 1\",\n \"def prepare(self):\\r\\n self.socket.listen()\\r\\n for _ in xrange(self.threads):\\r\\n thread = Worker(self.tasks)\\r\\n thread.setDaemon(True)\\r\\n thread.start()\\r\\n self.prepared = True\",\n \"def main_thread_enter(self):\\n ...\",\n \"def invoke_all_and_wait(self):\\n list_promise = []\\n for thread in self.__list_thread:\\n thread.start()\\n list_promise.append(thread)\\n for process in list_promise: process.join()\",\n \"def setupthreads(self,numthreads_):\\n res = __library__.MSK_XX_setupthreads(self.__nativep,numthreads_)\\n if res != 0:\\n raise Error(rescode(res),Env.getcodedesc(rescode(res))[1])\",\n \"def __init__(self, numthreads):\\n self.queue = Queue.Queue()\\n for _ in range(numthreads):\\n Worker(self.queue)\\n logger.debug(\\\"Event worker pool started with %s threads.\\\" % numthreads)\",\n \"def run(self):\\n self.thread_send.start()\\n self.thread_receive.start()\",\n \"def __init__(self):\\n Thread.__init__(self)\\n self.start() # start the thread\",\n \"def wait_threads(self):\\n\\n self.queue.join()\",\n \"def _init_threads(self):\\n\\n self._init_hashers()\\n self._queues = {}\\n self._threads = {}\\n\\n for algo in self.algos:\\n t = Thread(target=self._queue_updater, args=(algo,), name=algo)\\n self._queues[algo] = Queue(MtHasher.QUEUE_SIZE)\\n self._threads[algo] = t\\n t.start()\",\n \"def call(self):\\n current_thread = threading.current_thread() # get current thread·\\n event = self.q.get() # get task from queue\\n while event != self.StopEvent: # Determine whether task is a terminator\\n\\n func, arguments, callback = event # get funcname,params,callback name\\n try:\\n result = func(*arguments)\\n func_excute_status = True # set func executed status success\\n except Exception as e:\\n func_excute_status = False # set func executed status failure\\n result = None\\n print('{} executed error:'.format(func.__name__), e)\\n\\n if func_excute_status: #\\n if callback is not None: # determine whetherif callback is None\\n try:\\n callback(result)\\n except Exception as e:\\n print(callback.__name__, e)\\n\\n with self.worker_state(self.free_list, current_thread):\\n if self.terminal:\\n event = self.StopEvent\\n else:\\n event = self.q.get()\\n\\n else:\\n self.created_list.remove(current_thread)\",\n \"def start_thread(self):\\n self.thread = Thread(target=self.put_lines_into_queue)\\n self.thread.daemon = True\\n self.thread.start()\",\n \"def run(i_cmd, i_ServerList, senario): #get servers name to run\\n threads = []\\n serverAddrList = getServersAddrs(i_ServerList)\\n for server in serverAddrList:\\n t = threading.Thread(target=doCMD, args=(i_cmd, server, senario,))\\n threads.append(t)\\n t.start()\",\n \"def spawnWorkers(num, target, name=None, args=(), kwargs={}, daemon=1, interval=0):\\n from threading import Thread\\n threads = []\\n for i in range(num):\\n t = Thread(target=target, name=name, args=args, kwargs=kwargs)\\n t.setDaemon(daemon)\\n t.start()\\n threads.append(t)\\n time.sleep(interval)\\n return threads\",\n \"def end_threads(self):\\n\\n self.wait_threads()\\n\\n for _ in xrange(len(self.threads)):\\n self.submit(None, None, None)\\n\\n for thread in self.threads:\\n thread.join()\",\n \"def cleanup():\\n for th in THREAD_REGISTER.values():\\n th.exit()\\n th.join(timeout=3)\",\n \"def join(self):\\n while not self._stop:\\n time.sleep(0.1)\\n for t in reversed(self.tasks):\\n t.join()\",\n \"def mainloop(self, run, *args, **kwds):\\r\\n #self.m.make()\\r\\n self.time = 0\\r\\n Dummy = things(0,0,0)\\r\\n Dummy.threadqueue.append(-1)\\r\\n Dummy.s=self\\r\\n Dummy.name = 'End of simulation.'\\r\\n heappush(self.queue, (self.timeout, (Dummy, 1000)))\\r\\n #count = 0\\r\\n while self.time < self.timeout:\\r\\n run(*args, **kwds)\\r\\n (now, (item, i)) = heappop(self.queue)\\r\\n self.CalculateResourse(now)\\r\\n self.time = now\\r\\n item.creat()\\r\\n #count += 1\\r\\n #print 'Number of loops' , count\\r\",\n \"def run(self):\\n self.thread = threading.Thread(target=self._main)\\n self.thread.start()\\n self.running = True\",\n \"def _create_workers(self, start=True):\\n\\n bearer = api_client.get_bearer_token()\\n account = api_client.account_id_from_jwt(bearer.value)\\n LOGGER.info(\\\"account: %s\\\", account)\\n\\n project = self.args.get(\\\"project\\\") or None\\n LOGGER.info(\\\"project: %s\\\", project)\\n\\n location = self.args.get(\\\"location\\\") or None\\n LOGGER.info(\\\"location: %s\\\", location)\\n\\n thread_count = self.args.get(\\\"thread_count\\\") or 1\\n LOGGER.info(\\\"thread_count: %s\\\", thread_count)\\n\\n # CREATE WORKER PROCESSES\\n workers = {}\\n\\n # Create DownloadWorker processes\\n for _ in range(thread_count):\\n\\n # Create a process-safe run_state object for controlling process\\n # run_state = multiprocessing.Array('c', \\\"stoppingorstuff\\\")\\n global RUN_STATE\\n wrk = UploaderWorker(\\n RUN_STATE,\\n self._results_queue,\\n account=account,\\n project=project,\\n location=location)\\n workers[wrk] = RUN_STATE\\n\\n log_history_wrk = self.create_log_history()\\n\\n workers[log_history_wrk] = RUN_STATE\\n\\n if start:\\n for wrkr in workers:\\n wrkr.start()\\n time.sleep(.5)\\n\\n return workers\",\n \"def setNumThreads(self, num):\\r\\n self.threads = num\",\n \"def tasks():\",\n \"def main(args: argparse) -> None:\\n threads = args.threads\\n\\n for thread in range(threads):\\n canvas = canvas_init(args, thread)\\n seeds = tools.load_seeds_from_file(args.seed, args.manual_seed)\\n\\n # Main process\\n canvas_thread = threading.Thread(target=run,\\n args=(args, canvas, seeds, thread,\\n threads))\\n canvas_thread.start()\",\n \"def run_in_thread(fn):\\r\\n @staticmethod\\r\\n def run(*k):\\r\\n thread = threading.Thread(target=fn, args=(*k,), daemon = True)\\r\\n thread.start()\\r\\n return thread # <-- return the thread\\r\\n return run\",\n \"def __create_consumer_threads(\\n self, num_threads, rate_limiter, experiment_end_time, reported_outcome_generator\\n ):\\n\\n def consume_token_blocking():\\n \\\"\\\"\\\"consumer threads will keep acquiring tokens until experiment end time\\\"\\\"\\\"\\n while self._fake_clock.time() < experiment_end_time:\\n # A simple loop that acquires token, updates a counter, then releases token with an outcome\\n # provided by reported_outcome_generator()\\n t1 = self._fake_clock.time()\\n token = rate_limiter.acquire_token()\\n # update test state\\n self._test_state_lock.acquire()\\n try:\\n self._test_state[\\\"count\\\"] += 1\\n self._test_state[\\\"times\\\"].append(int(t1))\\n finally:\\n self._test_state_lock.release()\\n\\n self._outcome_generator_lock.acquire()\\n try:\\n outcome = next(reported_outcome_generator)\\n rate_limiter.release_token(token, outcome)\\n finally:\\n self._outcome_generator_lock.release()\\n\\n return [\\n threading.Thread(target=consume_token_blocking) for _ in range(num_threads)\\n ]\",\n \"def run_threaded(func):\\n\\tdef wrapper(*args, **kwargs):\\n\\t\\tt=threading.Thread(target=func, args=args, daemon=True)\\n\\t\\tt.start()\\n\\t\\treturn t\\n\\treturn wrapper\",\n \"def run_thread(func, article_id, timeframe, dump_dir):\\n \\n #purge any files that might exist in the temp directory\\n os.chdir(dump_dir)\\n file_list = os.listdir()\\n file_list = [i for i in file_list if 'threadtemp' in i]\\n if len(file_list) > 0:\\n for file in file_list:\\n os.remove(file)\\n \\n queue = Queue()\\n\\n for x in range(8):\\n worker = DownloadWorker(queue)\\n worker.daemon = True\\n worker.start()\\n \\n for start, end in timeframe:\\n queue.put((func, article_id, start, end, dump_dir))\\n\\n queue.join()\",\n \"def run(self):\\r\\n start = datetime.now()\\r\\n for thread in self.get_active_threads(): thread.start()\\r\\n try: # Runs concurrently with threads\\r\\n while True:\\r\\n for thread in self.get_active_threads():\\r\\n if not thread.is_alive():\\r\\n self.get_dead_threads().append(thread.respawn_thread(self.get_retry_delta()))\\r\\n thread.add_thread_failure()\\r\\n thread.acknowledged_failure = True\\r\\n # Don't remove threads that died AFTER iteration\\r\\n self.remove_dead_threads()\\r\\n\\r\\n for thread in self.get_dead_threads():\\r\\n if not thread.failure_printed_to_console:\\r\\n print(f\\\"{thread.name} failed. Will attempt restart in {self.get_retry_delta()}\\\")\\r\\n thread.failure_printed_to_console = True\\r\\n\\r\\n if thread.restart_time < datetime.now():\\r\\n print(f\\\"Attempting to restart {thread.name}\\\")\\r\\n thread.failure_printed_to_console = False\\r\\n thread.restart_time = None\\r\\n thread.start()\\r\\n self.get_active_threads().append(thread)\\r\\n # Remove threads that have respawned\\r\\n self.remove_respawned_threads()\\r\\n\\r\\n # Export after time specified by delta\\r\\n if datetime.now() >= start + self.get_export_delta():\\r\\n self.export_json()\\r\\n start = datetime.now()\\r\\n\\r\\n except KeyboardInterrupt:\\r\\n print(\\\"Keyboard interrupt\\\")\\r\\n except Exception as err:\\r\\n print(err)\\r\\n finally: # Save necessary data before exit\\r\\n self.export_json()\\r\\n print(\\\"Exiting program\\\")\\r\\n sys.exit(0)\",\n \"def __init__(self):\\r\\n\\t\\tthreading.Thread.__init__(self)\\r\\n\\t\\tself._want_abort = 0\\r\\n\\t\\t# This starts the thread running on creation, but you could\\r\\n\\t\\t# also make the GUI thread responsible for calling this\\r\\n\\t\\tself.worksQueue = Queue.Queue()\\r\\n\\t\\tself.timedList = []\\r\\n\\t\\tself.timedListLock = threading.Lock();\\r\\n\\t\\tself.abortionEvent = threading.Event()\\r\\n\\t\\tself.start()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78817755","0.7458283","0.6712016","0.66176367","0.6480147","0.6425454","0.64114654","0.63368505","0.63326395","0.62520283","0.624767","0.624767","0.62471247","0.6244331","0.6223761","0.6218233","0.6202923","0.6194842","0.614637","0.6122263","0.6099799","0.6066877","0.60655195","0.60542387","0.60542387","0.60453707","0.6042823","0.6015555","0.60017586","0.59904706","0.59821224","0.59776974","0.59549975","0.5925404","0.5920756","0.5912362","0.5912071","0.5876699","0.58610034","0.5846005","0.58102155","0.5790842","0.578672","0.5783665","0.5769381","0.5741796","0.57353806","0.5716129","0.5708454","0.5688174","0.56875336","0.5687183","0.56829935","0.56768286","0.5671075","0.56631726","0.5651366","0.5645754","0.5638275","0.5633356","0.5633356","0.56027853","0.55907387","0.55776036","0.5574242","0.55734146","0.5564567","0.55609286","0.55609286","0.5553188","0.55508095","0.5549865","0.55457675","0.55453885","0.55384886","0.5538485","0.5538154","0.5528477","0.55203414","0.55157113","0.55120575","0.55078006","0.5503457","0.5499376","0.54963887","0.54849344","0.54846823","0.5484382","0.5479446","0.5478422","0.5471558","0.5471032","0.54692703","0.54672897","0.5463186","0.54548794","0.5439587","0.54305136","0.54270804","0.5426839","0.54130274"],"string":"[\n \"0.78817755\",\n \"0.7458283\",\n \"0.6712016\",\n \"0.66176367\",\n \"0.6480147\",\n \"0.6425454\",\n \"0.64114654\",\n \"0.63368505\",\n \"0.63326395\",\n \"0.62520283\",\n \"0.624767\",\n \"0.624767\",\n \"0.62471247\",\n \"0.6244331\",\n \"0.6223761\",\n \"0.6218233\",\n \"0.6202923\",\n \"0.6194842\",\n \"0.614637\",\n \"0.6122263\",\n \"0.6099799\",\n \"0.6066877\",\n \"0.60655195\",\n \"0.60542387\",\n \"0.60542387\",\n \"0.60453707\",\n \"0.6042823\",\n \"0.6015555\",\n \"0.60017586\",\n \"0.59904706\",\n \"0.59821224\",\n \"0.59776974\",\n \"0.59549975\",\n \"0.5925404\",\n \"0.5920756\",\n \"0.5912362\",\n \"0.5912071\",\n \"0.5876699\",\n \"0.58610034\",\n \"0.5846005\",\n \"0.58102155\",\n \"0.5790842\",\n \"0.578672\",\n \"0.5783665\",\n \"0.5769381\",\n \"0.5741796\",\n \"0.57353806\",\n \"0.5716129\",\n \"0.5708454\",\n \"0.5688174\",\n \"0.56875336\",\n \"0.5687183\",\n \"0.56829935\",\n \"0.56768286\",\n \"0.5671075\",\n \"0.56631726\",\n \"0.5651366\",\n \"0.5645754\",\n \"0.5638275\",\n \"0.5633356\",\n \"0.5633356\",\n \"0.56027853\",\n \"0.55907387\",\n \"0.55776036\",\n \"0.5574242\",\n \"0.55734146\",\n \"0.5564567\",\n \"0.55609286\",\n \"0.55609286\",\n \"0.5553188\",\n \"0.55508095\",\n \"0.5549865\",\n \"0.55457675\",\n \"0.55453885\",\n \"0.55384886\",\n \"0.5538485\",\n \"0.5538154\",\n \"0.5528477\",\n \"0.55203414\",\n \"0.55157113\",\n \"0.55120575\",\n \"0.55078006\",\n \"0.5503457\",\n \"0.5499376\",\n \"0.54963887\",\n \"0.54849344\",\n \"0.54846823\",\n \"0.5484382\",\n \"0.5479446\",\n \"0.5478422\",\n \"0.5471558\",\n \"0.5471032\",\n \"0.54692703\",\n \"0.54672897\",\n \"0.5463186\",\n \"0.54548794\",\n \"0.5439587\",\n \"0.54305136\",\n \"0.54270804\",\n \"0.5426839\",\n \"0.54130274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85154,"cells":{"query":{"kind":"string","value":"Performs a single training step for critic and actor."},"document":{"kind":"string","value":"def update_step(self, replay_buffer_iter):\n\n states, actions, rewards, discounts, next_states = next(\n replay_buffer_iter)\n\n critic_dict = self.fit(states, actions, next_states, rewards, discounts)\n actor_dict = self.fit_alpha(states)\n\n return {**actor_dict, **critic_dict}"},"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 train_actor_and_critic(self):\n\n # if not enough transitions in memory, don't train!\n if len(self.memory) < self.batch_size:\n return\n\n transitions = self.memory.sample() # sample a batch from memory\n\n # Convert experience tuples to separate arrays for each element\n # (states, actions, rewards, etc.)\n states = np.vstack([e.state for e in transitions if e is not None])\n actions = np.array([\n e.action for e in transitions if e is not None]).astype(\n np.float32).reshape(-1, self.action_size)\n rewards = np.array([\n e.reward for e in transitions if e is not None]).astype(\n np.float32).reshape(-1, 1)\n dones = np.array([\n e.done for e in transitions if e is not None]).astype(\n np.uint8).reshape(-1, 1)\n next_states = np.vstack(\n [e.next_state for e in transitions if e is not None])\n\n # Get predicted next-state actions and Q values from target models\n actions_next = self.actor_target.model.predict_on_batch(next_states) #mu_marked in algo\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next]) #Q' in algo\n\n # Compute Q targets for current states and train critic model (local)\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones) #y_i in algo\n critic_loss = self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\n\n # Train actor model (local)\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\n # print(\"action_gradients\",action_gradients)\n # custom training function\n self.actor_local.train_fn([states, action_gradients, 1])\n\n # Soft-update target models\n # self.soft_update(self.critic_local.model, self.critic_target.model, self.tau)\n # self.soft_update(self.actor_local.model, self.actor_target.model, self.tau)\n self.soft_update_critic()\n self.soft_update_actor()\n\n return critic_loss","def train(actor, critic, task, num_nodes, train_data, valid_data, reward_fn,\n render_fn, batch_size, actor_lr, critic_lr, max_grad_norm,\n **kwargs):\n\n now = '%s' % datetime.datetime.now().time()\n now = now.replace(':', '_')\n save_dir = os.path.join(task, '%d' % num_nodes, now)\n\n checkpoint_dir = os.path.join(save_dir, 'checkpoints')\n if not os.path.exists(checkpoint_dir):\n os.makedirs(checkpoint_dir)\n\n actor_optim = optim.Adam(actor.parameters(), lr=actor_lr)\n critic_optim = optim.Adam(critic.parameters(), lr=critic_lr)\n\n train_loader = DataLoader(train_data, batch_size, True, num_workers=0)\n valid_loader = DataLoader(valid_data, batch_size, False, num_workers=0)\n\n best_params = None\n best_reward = np.inf\n\n for epoch in range(20):\n\n actor.train()\n critic.train()\n\n times, losses, rewards, critic_rewards = [], [], [], []\n\n epoch_start = time.time()\n start = epoch_start\n\n for batch_idx, batch in enumerate(train_loader):\n\n static, dynamic, x0 = batch\n\n static = static.to(device)\n dynamic = dynamic.to(device)\n x0 = x0.to(device) if len(x0) > 0 else None\n\n # Full forward pass through the dataset\n tour_indices, tour_logp = actor(static, dynamic, x0)\n\n # Sum the log probabilities for each city in the tour\n reward = reward_fn(static, tour_indices)\n\n # Query the critic for an estimate of the reward\n critic_est = critic(static, dynamic).view(-1)\n\n advantage = (reward - critic_est)\n actor_loss = torch.mean(advantage.detach() * tour_logp.sum(dim=1))\n critic_loss = torch.mean(advantage ** 2)\n\n actor_optim.zero_grad()\n actor_loss.backward()\n torch.nn.utils.clip_grad_norm_(actor.parameters(), max_grad_norm)\n actor_optim.step()\n\n critic_optim.zero_grad()\n critic_loss.backward()\n torch.nn.utils.clip_grad_norm_(critic.parameters(), max_grad_norm)\n critic_optim.step()\n\n critic_rewards.append(torch.mean(critic_est.detach()).item())\n rewards.append(torch.mean(reward.detach()).item())\n losses.append(torch.mean(actor_loss.detach()).item())\n\n if (batch_idx + 1) % 100 == 0:\n end = time.time()\n times.append(end - start)\n start = end\n\n mean_loss = np.mean(losses[-100:])\n mean_reward = np.mean(rewards[-100:])\n\n print(' Batch %d/%d, reward: %2.3f, loss: %2.4f, took: %2.4fs' %\n (batch_idx, len(train_loader), mean_reward, mean_loss,\n times[-1]))\n\n mean_loss = np.mean(losses)\n mean_reward = np.mean(rewards)\n\n # Save the weights\n epoch_dir = os.path.join(checkpoint_dir, '%s' % epoch)\n if not os.path.exists(epoch_dir):\n os.makedirs(epoch_dir)\n\n save_path = os.path.join(epoch_dir, 'actor.pt')\n torch.save(actor.state_dict(), save_path)\n\n save_path = os.path.join(epoch_dir, 'critic.pt')\n torch.save(critic.state_dict(), save_path)\n\n # Save rendering of validation set tours\n valid_dir = os.path.join(save_dir, '%s' % epoch)\n\n mean_valid = validate(valid_loader, actor, reward_fn, render_fn,\n valid_dir, num_plot=5)\n\n # Save best model parameters\n if mean_valid < best_reward:\n\n best_reward = mean_valid\n\n save_path = os.path.join(save_dir, 'actor.pt')\n torch.save(actor.state_dict(), save_path)\n\n save_path = os.path.join(save_dir, 'critic.pt')\n torch.save(critic.state_dict(), save_path)\n\n print('Mean epoch loss/reward: %2.4f, %2.4f, %2.4f, took: %2.4fs '\\\n '(%2.4fs / 100 batches)\\n' % \\\n (mean_loss, mean_reward, mean_valid, time.time() - epoch_start,\n np.mean(times)))","def _Learn(self, Actor, ActorTarget, actorOpt, experiances):\n Actor.train() # Set in Train Mode\n # Get split experiances into: states, actions ...\n states, actions, rewards, nextStates, dones = experiances\n # ....................... Update Critic .......................\n QTargetsNext = self.CriticTarget(nextStates, ActorTarget(nextStates))\n QTargets = rewards + (GAMMA * QTargetsNext * (1 - dones))\n QExpected = self.Critic(states, actions)\n # Minimize Loss & Update Weights\n critic_loss = F.smooth_l1_loss(QExpected, QTargets.detach())\n self.criticOpt.zero_grad()\n critic_loss.backward()\n T.nn.utils.clip_grad_norm(self.Critic.parameters(), 1)\n self.criticOpt.step()\n # ....................... Update Actor .......................\n actor_loss = -self.Critic(states, Actor(states)).mean()\n # Update Weights\n actorOpt.zero_grad()\n actor_loss.backward()\n T.nn.utils.clip_grad_norm(Actor.parameters(), 1)\n actorOpt.step()\n # ............. Update Actor & Critic Target Nets .............\n self.SoftUpdate(self.Critic, self.CriticTarget, TAU)\n self.SoftUpdate(Actor, ActorTarget, TAU)","def training_step(self):\n self.iteration += 1\n # if not enough replay memories\n if self.iteration < self.params.min_replays:\n # skip training\n return\n # for each batch\n for _ in range(self.params.num_batches):\n # sample memories\n mem_states, mem_controls, mem_rewards, mem_next_states, mem_continues = \\\n (rl.tools.sample_memories(self.memory, self.params.batch_size))\n # train the critic\n max_q = self.sess.run(self.graph.target_critic_outputs, feed_dict={self.graph.states: mem_next_states})\n td_target = mem_rewards + mem_continues * self.params.discount_factor * max_q\n self.reg_loss_val, self.critic_loss_val, _ = self.sess.run(\n [self.graph.critic_reg_loss, self.graph.critic_loss, self.graph.critic_training_op],\n feed_dict={self.graph.states: mem_states, self.graph.actor_outputs: mem_controls,\n self.graph.td_target: td_target})\n # train the actor\n neg_mean_q_val, _ = self.sess.run([self.graph.neg_mean_q, self.graph.actor_training_op],\n feed_dict={self.graph.states: mem_states})\n self.mean_q_val = -1.0 * neg_mean_q_val\n # copy to target\n self.sess.run(self.graph.copy_online_to_target)","def learn(self, experience):\n\n # Convert experiences to separate list\n states = np.vstack([e.state for e in experience if e is not None])\n actions = np.array([e.action for e in experience if e is not None]).astype(np.float32).reshape(-1, self.action_size)\n rewards = np.array([e.reward for e in experience if e is not None]).astype(np.float32).reshape(-1, 1)\n dones = np.array([e.done for e in experience if e is not None]).astype(np.uint8).reshape(-1, 1)\n next_states = np.vstack([e.next_state for e in experience if e is not None])\n\n # Get predicted next-state actions and Q values from target models\n # Q_targets_next = critic_target(next_state, actor_target(next_state))\n actions_next = self.actor_target.model.predict_on_batch(next_states)\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next])\n\n # Compute Q targets for current states and train critic model (local)\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones)\n self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\n\n # Train actor model (local)\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\n self.actor_local.train_fn([states, action_gradients, 1])\n\n # soft-update target models\n self.soft_update(self.critic_local.model, self.critic_target.model)\n self.soft_update(self.actor_local.model, self.actor_target.model)","def build_actor_critic(self):\n inputs = Input(shape=(self.state_dim, ), name='state')\n self.encoder.trainable = False\n x = self.encoder(inputs)\n mean = Dense(1,\n activation='linear',\n kernel_initializer='zero',\n name='mean')(x)\n stddev = Dense(1,\n kernel_initializer='zero',\n name='stddev')(x)\n # use of softplusk avoids stddev = 0\n stddev = Activation('softplusk', name='softplus')(stddev)\n action = Lambda(self.action,\n output_shape=(1,),\n name='action')([mean, stddev])\n self.actor_model = Model(inputs, action, name='action')\n self.actor_model.summary()\n plot_model(self.actor_model, \n to_file='actor_model.png', \n show_shapes=True)\n\n logp = Lambda(self.logp,\n output_shape=(1,),\n name='logp')([mean, stddev, action])\n self.logp_model = Model(inputs, logp, name='logp')\n self.logp_model.summary()\n plot_model(self.logp_model, \n to_file='logp_model.png', \n show_shapes=True)\n\n entropy = Lambda(self.entropy,\n output_shape=(1,),\n name='entropy')([mean, stddev])\n self.entropy_model = Model(inputs, entropy, name='entropy')\n self.entropy_model.summary()\n plot_model(self.entropy_model, \n to_file='entropy_model.png', \n show_shapes=True)\n\n value = Dense(1,\n activation='linear',\n kernel_initializer='zero',\n name='value')(x)\n self.value_model = Model(inputs, value, name='value')\n self.value_model.summary()\n plot_model(self.value_model, \n to_file='value_model.png', \n show_shapes=True)\n\n\n # logp loss of policy network\n loss = self.logp_loss(self.get_entropy(self.state), \n beta=self.beta)\n optimizer = RMSprop(lr=1e-3)\n self.logp_model.compile(loss=loss, optimizer=optimizer)\n\n optimizer = Adam(lr=1e-3)\n self.value_model.compile(loss=self.loss, optimizer=optimizer)","def agents_train(self, game_step, episode_now, args):\n # update all trainers, if not in display or benchmark mode\n if episode_now < args.learning_start_episode: return \n if self.update_cnt > 0 and self.var >= self.min_var: self.var *= args.var_discount\n #if episode_now > self.last_update_episode and (episode_now - args.learning_start_episode) % args.learning_fre == 0:\n if game_step % args.learning_fre_step == 0:\n if self.update_cnt == 0: print('\\r=start training ...'+' '*100)\n self.last_update_episode = episode_now\n self.update_cnt += 1\n\n # update every agent in different memory batch\n for agent_idx, (actor_c, actor_t, critic_c, critic_t, opt_a, opt_c) in \\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, \\\n self.critics_tar, self.optimizers_a, self.optimizers_c)):\n # del if opt_c == None: continue # jump to the next model update\n\n # sample the experience\n _obs_n_o, _action_n, _rew_n, _obs_n_n, _done_n = self.memory.sample( \\\n args.batch_size, agent_idx) # Note_The func is not the same as others\n \n # --use the date to update the CRITIC\n rew = torch.tensor(_rew_n, device=args.device, dtype=torch.float) # set the rew to gpu\n done_n = torch.tensor(~_done_n, dtype=torch.float, device=args.device) # set the rew to gpu\n action_cur_o = torch.from_numpy(_action_n).to(args.device, torch.float)\n obs_n_o = torch.from_numpy(_obs_n_o).to(args.device, torch.float)\n obs_n_n = torch.from_numpy(_obs_n_n).to(args.device, torch.float)\n\n action_tar = torch.cat([a_t(obs_n_n[:, self.obs_size[idx][0]:self.obs_size[idx][1]]).detach() \\\n for idx, a_t in enumerate(self.actors_tar)], dim=1)\n q = critic_c(obs_n_o, action_cur_o).reshape(-1) # q \n q_ = critic_t(obs_n_n, action_tar).reshape(-1) # q_ \n q_ = q_*args.gamma*done_n + rew*torch.tensor(args.reward_scale_par, device=args.device) # q_*gamma*done + reward\n loss_c = torch.nn.MSELoss()(q, q_.detach()) # bellman equation\n opt_c.zero_grad()\n loss_c.backward()\n nn.utils.clip_grad_norm_(critic_c.parameters(), args.max_grad_norm)\n opt_c.step()\n\n # --use the data to update the ACTOR\n # There is no need to cal other agent's action\n opt_c.zero_grad()\n model_out, policy_c_new = actor_c( \\\n obs_n_o[:, self.obs_size[agent_idx][0]:self.obs_size[agent_idx][1]], model_original_out=True)\n # update the aciton of this agent\n action_cur_o[:, self.action_size[agent_idx][0]:self.action_size[agent_idx][1]] = policy_c_new \n loss_pse = torch.mean(torch.pow(model_out, 2))\n loss_a = torch.mul(torch.tensor(-1.0, device=args.device), torch.mean(critic_c(obs_n_o, action_cur_o)))\n\n opt_a.zero_grad()\n (2e-3*loss_pse+loss_a).backward()\n #loss_a.backward()\n nn.utils.clip_grad_norm_(actor_c.parameters(), args.max_grad_norm)\n opt_a.step()\n\n # save the model to the path_dir ---cnt by update number\n #if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model == 0:\n if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model_step == 0:\n time_now = time.strftime('%y%m_%d%H%M')\n print('=time:{} step:{} save'.format(time_now, game_step))\n model_file_dir = os.path.join(args.save_dir, '{}_{}_{}'.format( \\\n args.scenario_name, time_now, game_step))\n if not os.path.exists(model_file_dir): # make the path\n os.mkdir(model_file_dir)\n for agent_idx, (a_c, a_t, c_c, c_t) in \\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, self.critics_tar)):\n torch.save(a_c, os.path.join(model_file_dir, 'a_c_{}.pt'.format(agent_idx)))\n torch.save(a_t, os.path.join(model_file_dir, 'a_t_{}.pt'.format(agent_idx)))\n torch.save(c_c, os.path.join(model_file_dir, 'c_c_{}.pt'.format(agent_idx)))\n torch.save(c_t, os.path.join(model_file_dir, 'c_t_{}.pt'.format(agent_idx)))\n\n # update the tar par\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, args.tao) \n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, args.tao)","def train(self,\n replay_buffer_iter,\n discount=0.99,\n tau=0.005,\n target_entropy=0,\n actor_update_freq=2):\n states, actions, next_states, rewards, masks = next(replay_buffer_iter)[0]\n\n rewards = self.rewards_fn(states, actions, rewards)\n\n critic_loss = self.fit_critic(states, actions, next_states, rewards, masks,\n discount)\n\n self.avg_critic_loss(critic_loss)\n if tf.equal(self.critic_optimizer.iterations % self.log_interval, 0):\n tf.summary.scalar(\n 'train sac/critic_loss',\n self.avg_critic_loss.result(),\n step=self.critic_optimizer.iterations)\n keras_utils.my_reset_states(self.avg_critic_loss)\n\n if tf.equal(self.critic_optimizer.iterations % actor_update_freq, 0):\n actor_loss, alpha_loss, entropy = self.fit_actor(states, target_entropy)\n soft_update(self.critic, self.critic_target, tau=tau)\n\n self.avg_actor_loss(actor_loss)\n self.avg_alpha_loss(alpha_loss)\n self.avg_actor_entropy(entropy)\n self.avg_alpha(self.alpha)\n if tf.equal(self.actor_optimizer.iterations % self.log_interval, 0):\n tf.summary.scalar(\n 'train sac/actor_loss',\n self.avg_actor_loss.result(),\n step=self.actor_optimizer.iterations)\n keras_utils.my_reset_states(self.avg_actor_loss)\n\n tf.summary.scalar(\n 'train sac/alpha_loss',\n self.avg_alpha_loss.result(),\n step=self.actor_optimizer.iterations)\n keras_utils.my_reset_states(self.avg_alpha_loss)\n\n tf.summary.scalar(\n 'train sac/actor entropy',\n self.avg_actor_entropy.result(),\n step=self.actor_optimizer.iterations)\n keras_utils.my_reset_states(self.avg_actor_entropy)\n\n tf.summary.scalar(\n 'train sac/alpha',\n self.avg_alpha.result(),\n step=self.actor_optimizer.iterations)\n keras_utils.my_reset_states(self.avg_alpha)","def TrainOneStep(self):\n pass","def train(opts):\n # Set number of actions\n opts.A = opts.delta_M * opts.delta_N\n # Set random seeds\n set_random_seeds(opts.seed)\n # Create actions mapping\n count_act = 0\n opts.act_to_delta = {}\n opts.delta_to_act = {}\n for i in range(-(opts.delta_N//2), opts.delta_N//2+1):\n for j in range(-(opts.delta_M//2), opts.delta_M//2+1):\n opts.act_to_delta[count_act] = (i, j)\n opts.delta_to_act[(i, j)] = count_act\n count_act += 1\n\n if opts.expert_rewards:\n from data_loader import DataLoaderExpert as DataLoader\n elif opts.expert_trajectories or opts.actorType == 'demo_sidekick' or opts.actorType == 'peek_saliency':\n from data_loader import DataLoaderExpertPolicy as DataLoader\n else:\n from data_loader import DataLoaderSimple as DataLoader\n\n if opts.dataset == 0:\n opts.num_channels = 3\n if opts.mean_subtract:\n # R, G, B means and stds\n opts.mean = [119.16, 107.68, 95.12]\n opts.std = [61.88, 61.72, 67.24]\n else:\n opts.mean = [0, 0, 0]\n opts.std = [1, 1, 1]\n elif opts.dataset == 1:\n opts.num_channels = 1\n if opts.mean_subtract:\n # R, G, B means and stds\n opts.mean = [193.0162338615919]\n opts.std = [37.716024486312811]\n else:\n opts.mean = [0]\n opts.std = [1]\n else:\n raise ValueError('Dataset %d does not exist!'%(opts.dataset))\n\n if opts.expert_trajectories:\n opts.T_sup = opts.T-1\n loader = DataLoader(opts)\n if opts.expert_trajectories:\n agent = AgentSupervised(opts)\n else:\n agent = Agent(opts)\n\n # Create tensorboard writer\n writer = SummaryWriter(log_dir=opts.save_path)\n # Set networks to train\n agent.policy.train()\n # Initiate statistics storage variables\n if opts.load_model == '': \n best_val_error = 100000\n train_history = []\n val_history = []\n epoch_start = 0\n else:\n best_val_error, train_history, val_history, epoch_start = load_module(agent, opts)\n\n # To handle job eviction and restarts\n if os.path.isfile(os.path.join(opts.save_path, 'model_latest.net')):\n print('====> Resuming training from previous checkpoint')\n # undo most of the loading done before\n loaded_model = torch.load(os.path.join(opts.save_path, 'model_latest.net'))\n opts = loaded_model['opts']\n epoch_start = loaded_model['epoch'] + 1\n\n loader = DataLoader(opts)\n if opts.expert_trajectories:\n agent = AgentSupervised(opts)\n agent.T_sup = loaded_model['T_sup']\n else:\n agent = Agent(opts) \n\n agent.policy.load_state_dict(loaded_model['state_dict'])\n train_history = loaded_model['train_history']\n val_history = loaded_model['val_history']\n #agent.optimizer.load_state_dict(loaded_model['optimizer'])\n best_val_error = loaded_model['best_val_error']\n\n # Some random selection of images to display\n rng_choices = random.sample(range(300//opts.batch_size), 2) \n # Start training\n for epoch in range(epoch_start, opts.epochs):\n # Initialize epoch specific variables\n depleted = False\n train_err = 0\n train_count = 0\n iter_count = 0\n avg_colln_loss = 0\n\n while not depleted:\n # pano - BxNxMxCx32x32\n if opts.expert_rewards:\n pano, pano_rewards, depleted = loader.next_batch('train')\n pano_maps = None\n elif opts.expert_trajectories or opts.actorType == 'demo_sidekick' or opts.actorType == 'peek_saliency':\n pano, pano_maps, depleted = loader.next_batch('train')\n pano_rewards = None\n else:\n pano, depleted = loader.next_batch('train')\n pano_rewards = None\n pano_maps = None\n # Note: This batch size is the current batch size, not the global batch size. This varies\n\n # when you reach the boundary of the dataset.\n batch_size = pano.shape[0]\n start_idx = get_starts(opts.N, opts.M, batch_size, opts.start_view)\n state = State(pano, pano_rewards, start_idx, opts)\n if opts.expert_trajectories:\n if opts.hybrid_train:\n rec_errs = agent.train_agent_hybrid(state, pano_maps, opts)\n else:\n rec_errs = agent.train_agent(state, pano_maps, opts)\n else:\n # Forward pass\n log_probs, rec_errs, rewards, entropies, decoded, values,\\\n visited_idxes, decoded_all, _ = agent.gather_trajectory(state, eval_opts=None, pano_maps=pano_maps, opts=opts)\n # Backward pass\n agent.update_policy(rewards, log_probs, rec_errs, entropies, values) \n\n # Accumulate statistics\n train_err += rec_errs[-1].data.sum()\n train_count += batch_size\n iter_count += 1\n\n train_err /= train_count\n\n # Evaluate the agent after every epoch\n val_err, _, _, decoded_images = evaluate(loader, agent, 'val', opts)\n\n # Write out statistics to tensorboard\n writer.add_scalar('data/train_error', train_err, epoch+1)\n writer.add_scalar('data/val_error', val_err, epoch+1)\n\n # Write out models and other statistics to torch format file\n train_history.append([epoch, train_err])\n val_history.append([epoch, val_err])\n if best_val_error > val_err:\n best_val_error = val_err\n save_state = {\n 'epoch': epoch,\n 'state_dict': agent.policy.state_dict(),\n 'optimizer': agent.optimizer.state_dict(),\n 'opts': opts, \n 'best_val_error': best_val_error,\n 'train_history': train_history,\n 'val_history': val_history\n }\n if opts.expert_trajectories:\n save_state['T_sup'] = agent.T_sup\n\n torch.save(save_state, os.path.join(opts.save_path, 'model_best.net'))\n\n save_state = {\n 'epoch': epoch,\n 'state_dict': agent.policy.state_dict(),\n 'optimizer': agent.optimizer.state_dict(),\n 'opts': opts, \n 'best_val_error': best_val_error,\n 'train_history': train_history,\n 'val_history': val_history\n }\n if opts.expert_trajectories:\n save_state['T_sup'] = agent.T_sup\n torch.save(save_state, os.path.join(opts.save_path, 'model_latest.net'))\n\n print('Epoch %d : Train loss: %9.6f Val loss: %9.6f'%(epoch+1, train_err, val_err))\n\n # Reduce supervision gradually\n if opts.expert_trajectories and opts.hybrid_train:\n if (epoch+1) % opts.hybrid_schedule == 0 and agent.T_sup > 0:\n agent.T_sup -= 1\n # Save the model after the first schedule is over\n if epoch+1 == opts.hybrid_schedule:\n torch.save(save_state, os.path.join(opts.save_path, 'model_after_one_schedule.net'))\n\n # Decay expert reward gradually\n if opts.expert_rewards and (epoch+1) % opts.expert_rewards_decay == 0:\n agent.reward_scale_expert /= opts.expert_rewards_decay_factor\n\n # Display three randomly selected batches of panoramas every 10 epochs\n if (epoch+1) % 10 == 0 or epoch == 0:\n for choice in rng_choices:\n for pano_count in range(decoded_images[choice].size(0)):\n x = vutils.make_grid(decoded_images[choice][pano_count], padding=5, normalize=True, scale_each=True, nrow=opts.T//2+1) \n writer.add_image('Validation batch # : %d image # : %d'%(choice, pano_count), x, 0) # Converting this to 0 to save disk space, should be epoch ideally","def run(opt):\n U.configure_logger(opt)\n\n # set seed\n opt.seed = (opt.run_id + 1) * opt.base_seed\n torch.manual_seed(opt.seed)\n\n # configure env\n env = ActionWrapper(TorchWrapper(gym.make(opt.env_name)))\n env.seed(opt.seed)\n\n # build estimator\n estimator = ActorCriticEstimator(\n env.observation_space.shape[0],\n env.action_space,\n hidden_size=opt.hidden_size,\n )\n # load checkpoint and reset\n rlog.info(\"Loading model from %s\", opt.model_state)\n estimator.load_state_dict(torch.load(opt.model_state)[\"policy\"])\n estimator.reset_policy()\n rlog.info(\"Policy reset.\")\n if opt.freeze_critic:\n estimator.freeze_critic()\n rlog.info(\"Freezed feature extractor and critic.\")\n\n # build the agent\n policy_improvement, policy_evaluation = build_agent(\n opt, env, estimator=estimator\n )\n\n # log\n rlog.info(f\"\\n{U.config_to_string(opt)}\")\n rlog.info(policy_improvement)\n\n # train\n try:\n train(env, policy_improvement, policy_evaluation, opt)\n except Exception as err:\n rlog.error(clr(str(err), \"red\", attrs=[\"bold\"]))\n raise err","def learn(self, experiences, gamma):\n\n states, all_state, action, all_actions, rewards, next_state, all_next_state, dones = experiences\n batch_size = all_next_state.shape[0]\n\n all_next_actions = self.actor_target(all_next_state.view(batch_size * 2, -1)).view(batch_size, -1)\n\n critic_target_input = torch.cat((all_next_state, all_next_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(\n device)\n with torch.no_grad():\n Q_target_next = self.critic_target(critic_target_input, all_next_actions.view(batch_size * 2, -1)[::2])\n Q_targets = rewards + (gamma * Q_target_next * (1 - dones))\n\n critic_local_input = torch.cat((all_state, all_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(device)\n Q_expected = self.critic_local(critic_local_input, action)\n\n # critic loss\n huber_loss = torch.nn.SmoothL1Loss()\n\n loss = huber_loss(Q_expected, Q_targets.detach())\n\n self.optimizer_critic.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1)\n self.optimizer_critic.step()\n\n # actor loss\n\n action_pr_self = self.actor_local(states)\n action_pr_other = self.actor_local(all_next_state.view(batch_size * 2, -1)[1::2]).detach()\n\n # critic_local_input2=torch.cat((all_state,torch.cat((action_pr_self,action_pr_other),dim=1)),dim=1)\n critic_local_input2 = torch.cat((all_state, action_pr_other), dim=1)\n p_loss = -self.critic_local(critic_local_input2, action_pr_self).mean()\n\n self.optimizer_actor.zero_grad()\n p_loss.backward()\n\n self.optimizer_actor.step()\n\n # ------------------- update target network ------------------- #\n self.TAU = min(5e-1, self.TAU * 1.001)\n self.soft_update(self.critic_local, self.critic_target, self.TAU)\n self.soft_update(self.actor_local, self.actor_target, self.TAU)","def learn(self):\n if self.step_count < self.learn_start_step or self.step_count % self.learn_interval != 0:\n return\n\n s, a, r, s_, t = self.sample()\n self.update_critics(s, a, r, t, s_)\n self.update_actor_alpha(s)\n self.update_target()\n self.learn_cur += 1","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # ------------------- update critic ------------------- #\n next_actions = self.actor_target(next_states)\n # Get Q targets (for next states) from target model (on CPU)\n Q_targets_next = self.critic_target(next_states, next_actions).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.critic_local(states, actions)\n\n # Compute critic loss\n critic_loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the critic loss\n self.critic_optimizer.zero_grad()\n critic_loss.backward()\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1) # As mentioned on project page\n self.critic_optimizer.step()\n\n # ------------------- update actor ------------------- #\n actions_expected = self.actor_local(states)\n # Compute actor loss based on expectation from actions_expected\n actor_loss = -self.critic_local(states, actions_expected).mean()\n # Minimize the actor loss\n self.actor_optimizer.zero_grad()\n actor_loss.backward()\n self.actor_optimizer.step()\n\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.critic_local, self.critic_target, TAU) \n self.soft_update(self.actor_local, self.actor_target, TAU)","def train(self, item, gamma=1.0):\n [step, state, next_state, reward, done] = item\n\n # must save state for entropy computation\n self.state = state\n\n discount_factor = gamma**step\n\n # actor-critic: delta = reward - value \n # + discounted_next_value\n delta = reward - self.value(state)[0] \n\n # since this function is called by Actor-Critic\n # directly, evaluate the value function here\n if not done:\n next_value = self.value(next_state)[0]\n # add the discounted next value\n delta += gamma*next_value\n\n # apply the discount factor as shown in Algorithms\n # 10.2.1, 10.3.1 and 10.4.1\n discounted_delta = delta * discount_factor\n discounted_delta = np.reshape(discounted_delta, [-1, 1])\n verbose = 1 if done else 0\n\n # train the logp model (implies training of actor model\n # as well) since they share exactly the same set of\n # parameters\n self.logp_model.fit(np.array(state),\n discounted_delta,\n batch_size=1,\n epochs=1,\n verbose=verbose)\n\n self.value_model.fit(np.array(state),\n discounted_delta,\n batch_size=1,\n epochs=1,\n verbose=verbose)","def train(self, global_step):\n if self.replay_buffer.size > self.warmup_size:\n s0, a, r, t, s1 = self.replay_buffer.sample_batch(self.batch_size)\n target_actions = self.actor.get_target_action(s1)\n target_qval = self.get_target_qval(s1, target_actions)\n t = t.astype(dtype=int)\n y = r + self.gamma * target_qval * (1 - t)\n self.critic.train(s0, a, y)\n actions = self.actor.get_action(s0)\n grads = self.critic.get_action_gradients(s0, actions)\n self.actor.train(s0, grads[0])\n self.update_targets()","def train(args):\n # prepare environment\n brain_name = env.brain_names[0]\n brain = env.brains[brain_name]\n env_info = env.reset(train_mode=True)[brain_name]\n\n num_agents = len(env_info.agents)\n print('Number of agents:', num_agents)\n\n # size of each action\n action_size = brain.vector_action_space_size\n print('Size of each action:', action_size)\n\n # examine the state space\n states = env_info.vector_observations\n state_size = states.shape[1]\n print('There are {} agents. Each observes a state with length: {}'.format(\n states.shape[0], state_size))\n print('The state for the first agent looks like:', states[0])\n\n # Crate instance of MADDPG Class, mainly possible to control the model dimensions, learnrates and batch sizes\n agent = MADDPG(state_size,\n action_size,\n lr_actor=args.lr_actor,\n lr_critic=args.lr_critic,\n lr_decay=args.lr_decay,\n replay_buff_size=args.replay_buff_size,\n gamma=args.gamma,\n batch_size=args.batch_size,\n random_seed=args.random_seed,\n soft_update_tau=args.soft_update_tau,\n actor_layer_dim_1=args.actor_layer_dim_1,\n actor_layer_dim_2=args.actor_layer_dim_2,\n actor_layer_dim_3=args.actor_layer_dim_3,\n critic_layer_dim_1=args.critic_layer_dim_1,\n critic_layer_dim_2=args.critic_layer_dim_2,\n critic_layer_dim_3=args.critic_layer_dim_3\n\n )\n\n total_rewards = []\n avg_scores = []\n max_avg_score = -1\n max_score = -1\n threshold_init = 20\n noise_t = args.epsilon\n noise_decay = args.epsilon_decay\n latest_avg_score = -1\n # for early-stopping training if consistently worsen for # episodes\n worsen_tolerance = threshold_init\n for i_episode in range(1, 1+args.num_episodes):\n\n env_inst = env.reset(train_mode=True)[\n brain_name] # reset the environment\n states = env_inst.vector_observations # get the current state\n # initialize score array\n scores = np.zeros(num_agents)\n dones = [False]*num_agents\n while not np.any(dones):\n # select an action\n actions = agent.act(states, noise_t)\n # send the action to the environment\n env_inst = env.step(actions)[brain_name]\n next_states = env_inst.vector_observations # get the next state\n rewards = env_inst.rewards # get the reward\n dones = env_inst.local_done # see if episode has finished\n agent.update(states, actions, rewards, next_states, dones)\n\n noise_t *= noise_decay\n scores += rewards # update scores\n states = next_states\n\n episode_score = np.max(scores)\n total_rewards.append(episode_score)\n print(\"\\rEpisodic {} Score: {:.4f}\\t Avg Score: {:.4f}\".format(\n i_episode, episode_score, latest_avg_score), end=' ')\n\n if max_score <= episode_score:\n max_score = episode_score\n # save best model so far\n agent.save(\n \"chkpts/{}/{:02d}_best_model.checkpoint\".format(args.model_path, args.loop_counter))\n\n # record avg score for the latest 100 steps\n if len(total_rewards) >= args.test_n_run:\n latest_avg_score = sum(\n total_rewards[(len(total_rewards)-args.test_n_run):]) / args.test_n_run\n avg_scores.append(latest_avg_score)\n\n if max_avg_score <= latest_avg_score: # record better results\n worsen_tolerance = threshold_init # re-count tolerance\n max_avg_score = latest_avg_score\n else:\n if max_avg_score > 0.5:\n worsen_tolerance -= 1 # count worsening counts\n print(\"Loaded from last best model.\")\n # continue from last best-model\n agent.load(\n \"chkpts/{}/{:02d}_best_model.checkpoint\".format(args.model_path, args.loop_counter))\n if worsen_tolerance <= 0: # earliy stop training\n print(\"Early Stop Training.\")\n break\n del agent\n return total_rewards","def learn(self, experiences, gamma):\r\n states, actions, rewards, next_states, dones = experiences\r\n\r\n # UPDATE CRITIC #\r\n actions_next = self.actor_target(next_states.to(device))\r\n Q_targets_next = self.critic_target(next_states.to(device), actions_next.to(device))\r\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\r\n Q_expected = self.critic_local(states, actions)\r\n critic_loss = F.mse_loss(Q_expected, Q_targets)\r\n\r\n self.critic_optimizer.zero_grad()\r\n critic_loss.backward()\r\n clip_grad_norm_(self.critic_local.parameters(), 1) # Clip the gradient when update critic network\r\n self.critic_optimizer.step()\r\n\r\n # UPDATE ACTOR #\r\n actions_pred = self.actor_local(states)\r\n actor_loss = -self.critic_local(states, actions_pred).mean()\r\n\r\n self.actor_optimizer.zero_grad()\r\n actor_loss.backward()\r\n self.actor_optimizer.step()\r\n\r\n # UPDATE TARGET NETWORKS #\r\n self.soft_update(self.critic_local, self.critic_target, RHO)\r\n self.soft_update(self.actor_local, self.actor_target, RHO) \r\n\r\n # UPDATE EPSILON AND NOISE # \r\n self.epsilon *= EPSILON_DECAY\r\n self.noise.reset()","def train_agent(self):\n # Retrieve collected experiences from memory\n experiences = np.array(self.replay.get_all())\n # rewards = np.array([h['reward'] for h in experiences])\n #rewards = experiences[:,2]\n rewards = np.array([r[2] for r in experiences])\n\n # Discount and normalize rewards\n norm_rewards = self.discount_rewards_and_normalize(rewards)\n\n # Shuffle for better learning\n shuffled_experiences = np.random.shuffle(experiences)\n\n # Feed the experiences through the network with rewards to compute and\n # minimize the loss.\n\n feed={\n self.X: [r[0] for r in experiences],\n self.rewards:norm_rewards,\n self.ep_actions:experiences[:,1]\n }\n self.tf_sess.run(self.train,feed_dict=feed)\n\n pass","def learn(self, *args):\n\n # unpack args\n steps, episode_step, _, state_, reward, _, done, _ = args \n\n # we check if we should do a learning step,\n # otherwise, just store the reward and go on\n\n if done or episode_step == self.episode_length - 1:\n \n # get the last value\n if done: # terminal state\n last_value = 0 \n else: # predict the last value from the critic\n last_value, _ = self.actor_critic.predict(state_)\n\n # calculate the discounted reward\n self.rewards.append(reward)\n discounted_rewards = np.zeros(len(self.values))\n for i in reversed(range(len(self.rewards))):\n last_value = self.rewards[i] + self.discount_factor * last_value\n discounted_rewards[i] = last_value\n \n # update weights by calculating the loss and performing backward\n self.actor_critic.calc_loss(discounted_r=discounted_rewards,\n values=self.values,\n log_probs=self.log_probs,\n entropy=self.entropy,\n entropy_factor=self.entropy_factor)\n # clean up\n self.values.clear()\n self.rewards.clear()\n self.log_probs.clear()\n self.entropy.clear()\n else:\n self.rewards.append(reward)","def get(env, args):\n state_dim = env.observation_space.shape[0]\n action_dim = env.action_space.shape[0]\n\n hidden_sizes_actor = hyper_params[\"NETWORK\"][\"ACTOR_HIDDEN_SIZES\"]\n hidden_sizes_critic = hyper_params[\"NETWORK\"][\"CRITIC_HIDDEN_SIZES\"]\n\n # create actor\n actor = MLP(\n input_size=state_dim,\n output_size=action_dim,\n hidden_sizes=hidden_sizes_actor,\n output_activation=torch.tanh,\n ).to(device)\n\n actor_target = MLP(\n input_size=state_dim,\n output_size=action_dim,\n hidden_sizes=hidden_sizes_actor,\n output_activation=torch.tanh,\n ).to(device)\n actor_target.load_state_dict(actor.state_dict())\n\n # create critic1\n critic1 = MLP(\n input_size=state_dim + action_dim,\n output_size=1,\n hidden_sizes=hidden_sizes_critic,\n ).to(device)\n\n critic1_target = MLP(\n input_size=state_dim + action_dim,\n output_size=1,\n hidden_sizes=hidden_sizes_critic,\n ).to(device)\n critic1_target.load_state_dict(critic1.state_dict())\n\n # create critic2\n critic2 = MLP(\n input_size=state_dim + action_dim,\n output_size=1,\n hidden_sizes=hidden_sizes_critic,\n ).to(device)\n\n critic2_target = MLP(\n input_size=state_dim + action_dim,\n output_size=1,\n hidden_sizes=hidden_sizes_critic,\n ).to(device)\n critic2_target.load_state_dict(critic2.state_dict())\n\n # concat critic parameters to use one optim\n critic_parameters = list(critic1.parameters()) + list(critic2.parameters())\n\n # create optimizer\n actor_optim = optim.Adam(\n actor.parameters(),\n lr=hyper_params[\"LR_ACTOR\"],\n weight_decay=hyper_params[\"WEIGHT_DECAY\"],\n )\n\n critic_optim = optim.Adam(\n critic_parameters,\n lr=hyper_params[\"LR_CRITIC\"],\n weight_decay=hyper_params[\"WEIGHT_DECAY\"],\n )\n\n # noise\n exploration_noise = GaussianNoise(\n action_dim,\n min_sigma=hyper_params[\"EXPLORATION_NOISE\"],\n max_sigma=hyper_params[\"EXPLORATION_NOISE\"],\n )\n\n target_policy_noise = GaussianNoise(\n action_dim,\n min_sigma=hyper_params[\"TARGET_POLICY_NOISE\"],\n max_sigma=hyper_params[\"TARGET_POLICY_NOISE\"],\n )\n\n # make tuples to create an agent\n models = (actor, actor_target, critic1, critic1_target, critic2, critic2_target)\n optims = (actor_optim, critic_optim)\n noises = (exploration_noise, target_policy_noise)\n\n # create an agent\n return Agent(env, args, hyper_params, models, optims, noises)","def __init__(self, action_space, memory_par, game, reward_clip: bool):\n super(SoftActorCriticsDiscrete, self).__init__(action_space, memory_par, game, reward_clip)\n self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n self.soft = True\n self.learn_replace = 1000\n self.learn_start_step = 1000\n self.tau = 0.005\n self.step_num = 4\n self.learn_interval = 4\n self.actor = PolicyNetwork(img_size=self.multi_frames_size, output_num=self.action_space_len)\n self.critic1 = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\n self.critic2 = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\n with torch.no_grad():\n self.critic1_target = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\n self.critic2_target = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\n self.critic1_target.load_state_dict(self.critic1.state_dict())\n self.critic2_target.load_state_dict(self.critic2.state_dict())\n\n self.target_entropy = 0.98 * (-np.log(1 / self.action_space_len))\n self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n self.alpha = self.log_alpha.exp()\n\n self.critic1_optimiser = optim.Adam(self.critic1.parameters(), lr=0.0001, eps=1e-6)\n self.critic2_optimiser = optim.Adam(self.critic2.parameters(), lr=0.0001, eps=1e-6)\n self.actor_optimiser = optim.Adam(self.actor.parameters(), lr=0.0001, eps=1e-6)\n self.alpha_optimiser = optim.Adam([self.log_alpha], lr=0.0001, eps=1e-6)","def learn(self):\n\n self.t_step += 1\n\n # Sample from replay buffer, which already has nstep rollout calculated.\n batch = self.memory.sample(self.batch_size)\n obs, next_obs, actions, rewards, dones = batch\n\n # Gather and concatenate actions because critic networks need ALL\n # actions as input, the stored actions were concatenated before storing\n # in the buffer\n target_actions = [agent.actor_target(next_obs[i]) for i, agent in\n enumerate(self.agents)]\n predicted_actions = [agent.actor(obs[i]) for i, agent in\n enumerate(self.agents)]\n target_actions = torch.cat(target_actions, dim=-1)\n predicted_actions = torch.cat(predicted_actions, dim=-1)\n\n # Change state data from [agent_count, batch_size]\n # to [batchsize, state_size * agent_count]\n # because critic networks need to ALL observations as input\n obs = obs.transpose(1,0).contiguous().view(self.batch_size, -1)\n next_obs = next_obs.transpose(1,0).contiguous().view(self.batch_size,-1)\n\n # Perform a learning step for each agent using concatenated data as well\n # as unique-perspective data where algorithmically called for\n for i, agent in enumerate(self.agents):\n agent.learn(obs, next_obs, actions, target_actions,\n predicted_actions, rewards[i], dones[i])\n self.update_networks(agent)","def train_step(self):\n pass","def train(self) -> None:\n\n self.envs = construct_envs(self.config, get_env_class(self.config.ENV_NAME))\n\n ppo_cfg = self.config.RL.PPO\n self.device = (\n torch.device(\"cuda\", self.config.TORCH_GPU_ID)\n if torch.cuda.is_available()\n else torch.device(\"cpu\")\n )\n if not os.path.isdir(self.config.CHECKPOINT_FOLDER):\n os.makedirs(self.config.CHECKPOINT_FOLDER)\n self._setup_actor_critic_agent(ppo_cfg)\n logger.info(\n \"agent number of parameters: {}\".format(\n sum(param.numel() for param in self.agent.parameters())\n )\n )\n\n rollouts = RolloutStorage(\n ppo_cfg.num_steps,\n self.envs.num_envs,\n self.envs.observation_spaces[0],\n self.envs.action_spaces[0],\n ppo_cfg.hidden_size,\n )\n rollouts.to(self.device)\n\n observations = self.envs.reset()\n batch = batch_obs(observations)\n\n for sensor in rollouts.observations:\n rollouts.observations[sensor][0].copy_(batch[sensor])\n\n # batch and observations may contain shared PyTorch CUDA\n # tensors. We must explicitly clear them here otherwise\n # they will be kept in memory for the entire duration of training!\n batch = None\n observations = None\n\n running_episode_stats = dict(\n count=torch.zeros(self.envs.num_envs, 1),\n reward=torch.zeros(self.envs.num_envs, 1),\n )\n window_episode_stats = defaultdict(\n lambda: deque(maxlen=ppo_cfg.reward_window_size)\n )\n\n t_start = time.time()\n env_time = 0\n pth_time = 0\n forward_time = 0\n agent_update_time = 0\n count_steps = 0\n count_checkpoints = 0\n\n lr_scheduler = LambdaLR(\n optimizer=self.agent.optimizer,\n lr_lambda=lambda x: linear_decay(x, self.config.NUM_UPDATES),\n )\n\n with TensorboardWriter(\n self.config.TENSORBOARD_DIR, flush_secs=self.flush_secs\n ) as writer:\n for update in range(self.config.NUM_UPDATES):\n if ppo_cfg.use_linear_lr_decay:\n lr_scheduler.step()\n\n if ppo_cfg.use_linear_clip_decay:\n self.agent.clip_param = ppo_cfg.clip_param * linear_decay(\n update, self.config.NUM_UPDATES\n )\n\n for step in range(ppo_cfg.num_steps):\n (\n delta_pth_time,\n delta_forward_time,\n delta_env_time,\n delta_steps,\n ) = self._collect_rollout_step(\n rollouts, current_episode_reward, running_episode_stats,\n )\n pth_time += delta_pth_time\n forward_time += delta_forward_time\n env_time += delta_env_time\n count_steps += delta_steps\n\n (\n delta_pth_time,\n value_loss,\n action_loss,\n dist_entropy,\n ) = self._update_agent(ppo_cfg, rollouts)\n pth_time += delta_pth_time\n agent_update_time += delta_pth_time\n\n for k, v in running_episode_stats.items():\n window_episode_stats[k].append(v.clone())\n\n deltas = {\n k: (\n (v[-1] - v[0]).sum().item() if len(v) > 1 else v[0].sum().item()\n )\n for k, v in window_episode_stats.items()\n }\n deltas[\"count\"] = max(deltas[\"count\"], 1.0)\n\n writer.add_scalar(\n \"reward\", deltas[\"reward\"] / deltas[\"count\"], count_steps\n )\n\n # Check to see if there are any metrics\n # that haven't been logged yet\n metrics = {\n k: v / deltas[\"count\"]\n for k, v in deltas.items()\n if k not in {\"reward\", \"count\"}\n }\n if len(metrics) > 0:\n writer.add_scalars(\"metrics\", metrics, count_steps)\n\n losses = [value_loss, action_loss]\n\n writer.add_scalars(\n \"losses\",\n {k: l for l, k in zip(losses, [\"value\", \"policy\"])},\n count_steps,\n )\n\n # log stats\n if update > 0 and update % self.config.LOG_INTERVAL == 0:\n logger.info(\n \"update: {}\\tfps: {:.3f}\\t\".format(\n update, count_steps / (time.time() - t_start)\n )\n )\n logger.info(\n \"update: {}\\tenv-time: {:.3f}s\\tpth-time: {:.3f}s\\t\"\n \"forward-time: {:.3f}\\tagnet-update-time: {:.3f}\\t\"\n \"frames: {}\".format(\n update,\n env_time,\n pth_time,\n forward_time,\n agent_update_time,\n count_steps,\n )\n )\n\n logger.info(\n \"Average window size: {} {}\".format(\n len(window_episode_stats[\"count\"]),\n \" \".join(\n \"{}: {:.3f}\".format(k, v / deltas[\"count\"])\n for k, v in deltas.items()\n if k != \"count\"\n ),\n )\n )\n\n # checkpoint model\n if update % self.config.CHECKPOINT_INTERVAL == 0:\n self.save_checkpoint(\n f\"ckpt.{count_checkpoints}.pth\", dict(step=count_steps)\n )\n count_checkpoints += 1\n\n self.envs.close()","def td3Student(env_fn, actor_critic=core.MLPActorCritic, ac_kwargs=dict(), seed=0, \n steps_per_epoch=4000, epochs=100, replay_size=int(1e6), gamma=0.99, \n polyak=0.995, pi_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \n update_after=1000, update_every=50, act_noise=0.1, target_noise=0.2, \n noise_clip=0.5, policy_delay=2, num_test_episodes=10, max_ep_len=1000, \n logger_kwargs=dict(), save_freq=1, buffer_path = ''):\n\n logger = EpochLogger(**logger_kwargs)\n logger.save_config(locals())\n\n torch.manual_seed(seed)\n np.random.seed(seed)\n\n env, test_env = env_fn(), env_fn()\n obs_dim = env.observation_space.shape\n act_dim = env.action_space.shape[0]\n\n # Action limit for clamping: critically, assumes all dimensions share the same bound!\n act_limit = env.action_space.high[0]\n\n # Create actor-critic module and target networks\n ac = actor_critic(env.observation_space, env.action_space, **ac_kwargs)\n ac_targ = deepcopy(ac)\n\n # Freeze target networks with respect to optimizers (only update via polyak averaging)\n for p in ac_targ.parameters():\n p.requires_grad = False\n \n # List of parameters for both Q-networks (save this for convenience)\n q_params = itertools.chain(ac.q1.parameters(), ac.q2.parameters())\n\n # Experience buffer, which contains teacher buffer\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=act_dim, size=replay_size)\n \n #student buffer, only the sampled\n \n # Count variables (protip: try to get a feel for how different size networks behave!)\n var_counts = tuple(core.count_vars(module) for module in [ac.pi, ac.q1, ac.q2])\n logger.log('\\nNumber of parameters: \\t pi: %d, \\t q1: %d, \\t q2: %d\\n'%var_counts)\n replay_buffer.load_from_disk(buffer_path)\n \n # Set up function for computing TD3 Q-losses\n def compute_loss_q(data):\n o, a, r, o2, d = data['obs'], data['act'], data['rew'], data['obs2'], data['done']\n\n q1 = ac.q1(o,a)\n q2 = ac.q2(o,a)\n\n # Bellman backup for Q functions\n with torch.no_grad():\n pi_targ = ac_targ.pi(o2)\n\n # Target policy smoothing\n epsilon = torch.randn_like(pi_targ) * target_noise\n epsilon = torch.clamp(epsilon, -noise_clip, noise_clip)\n a2 = pi_targ + epsilon\n a2 = torch.clamp(a2, -act_limit, act_limit)\n\n # Target Q-values\n q1_pi_targ = ac_targ.q1(o2, a2)\n q2_pi_targ = ac_targ.q2(o2, a2)\n q_pi_targ = torch.min(q1_pi_targ, q2_pi_targ)\n backup = r + gamma * (1 - d) * q_pi_targ\n\n # MSE loss against Bellman backup\n loss_q1 = ((q1 - backup)**2).mean()\n loss_q2 = ((q2 - backup)**2).mean()\n loss_q = loss_q1 + loss_q2\n\n # Useful info for logging\n loss_info = dict(Q1Vals=q1.detach().numpy(),\n Q2Vals=q2.detach().numpy())\n\n return loss_q, loss_info\n\n # Set up function for computing TD3 pi loss\n def compute_loss_pi(data):\n o = data['obs']\n q1_pi = ac.q1(o, ac.pi(o))\n return -q1_pi.mean()\n\n # Set up optimizers for policy and q-function\n pi_optimizer = Adam(ac.pi.parameters(), lr=pi_lr)\n q_optimizer = Adam(q_params, lr=q_lr)\n\n # Set up model saving\n logger.setup_pytorch_saver(ac)\n\n def update(data, timer):\n # First run one gradient descent step for Q1 and Q2\n q_optimizer.zero_grad()\n loss_q, loss_info = compute_loss_q(data)\n loss_q.backward()\n q_optimizer.step()\n\n # Record things\n logger.store(LossQ=loss_q.item(), **loss_info)\n\n # Possibly update pi and target networks\n if timer % policy_delay == 0:\n # Freeze Q-networks so you don't waste computational effort \n # computing gradients for them during the policy learning step.\n for p in q_params:\n p.requires_grad = False\n\n # Next run one gradient descent step for pi.\n pi_optimizer.zero_grad()\n loss_pi = compute_loss_pi(data)\n loss_pi.backward()\n pi_optimizer.step()\n\n # Unfreeze Q-networks so you can optimize it at next DDPG step.\n for p in q_params:\n p.requires_grad = True\n\n # Record things\n logger.store(LossPi=loss_pi.item())\n\n # Finally, update target networks by polyak averaging.\n with torch.no_grad():\n for p, p_targ in zip(ac.parameters(), ac_targ.parameters()):\n # NB: We use an in-place operations \"mul_\", \"add_\" to update target\n # params, as opposed to \"mul\" and \"add\", which would make new tensors.\n p_targ.data.mul_(polyak)\n p_targ.data.add_((1 - polyak) * p.data)\n\n def get_action(o, noise_scale):\n a = ac.act(torch.as_tensor(o, dtype=torch.float32))\n a += noise_scale * np.random.randn(act_dim)\n return np.clip(a, -act_limit, act_limit)\n\n def test_agent():\n for j in range(num_test_episodes):\n o, d, ep_ret, ep_len = test_env.reset(), False, 0, 0\n while not(d or (ep_len == max_ep_len)):\n # Take deterministic actions at test time (noise_scale=0)\n o, r, d, _ = test_env.step(get_action(o, 0))\n ep_ret += r\n ep_len += 1\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\n\n # Prepare for interaction with environment\n total_steps = steps_per_epoch * epochs\n start_time = time.time()\n timer = 0\n\n # Main loop: Update using actions taken from replay buffer data\n for t in range(total_steps):\n\n # Update handling\n batch = replay_buffer.sample_batch(batch_size)\n update(data=batch, timer = timer)\n\n # End of epoch handling\n if (t+1) % steps_per_epoch == 0:\n epoch = (t+1) // steps_per_epoch\n\n # Save model\n if (epoch % save_freq == 0) or (epoch == epochs):\n logger.save_state({'env': env}, None)\n\n # Test the performance of the deterministic version of the agent.\n test_agent()\n\n # Log info about epoch\n logger.log_tabular('Epoch', epoch)\n# logger.log_tabular('EpRet', with_min_and_max=True)\n logger.log_tabular('TestEpRet', with_min_and_max=True)\n# logger.log_tabular('EpLen', average_only=True)\n logger.log_tabular('TestEpLen', average_only=True)\n logger.log_tabular('TotalEnvInteracts', t)\n logger.log_tabular('Q1Vals', with_min_and_max=True)\n logger.log_tabular('Q2Vals', with_min_and_max=True)\n logger.log_tabular('LossPi', average_only=True)\n logger.log_tabular('LossQ', average_only=True)\n logger.log_tabular('Time', time.time()-start_time)\n logger.dump_tabular()\n timer += 1","def train():\n pass","def train_models(self, states, actions, rewards, done):\n # Compute discounted rewards and Advantage (TD. Error)\n discounted_rewards = self.discount(rewards, done, states[-1])\n state_values = self.critic.predict(np.array(states))\n advantages = discounted_rewards - np.reshape(state_values, len(state_values))\n # Networks optimization\n self.a_opt([states, actions, advantages])\n self.c_opt([states, discounted_rewards])","def __init__(self, env, actor=None, critic=None, weights=None, warmup_actor=1, warmup_critic=1, gamma=0.99):\n self.env = env\n nactions = np.product(self.env.action_shape)\n actor = self._actor() if actor is None else actor\n critic, action_input = self._critic() if critic is None else critic\n membuf = SequentialMemory(int(1E5), window_length=1)\n random = OrnsteinUhlenbeckProcess(size=nactions, theta=0.15, mu=0.0, sigma=0.3)\n self.agent = DDPGAgent(nb_actions=nactions,\n actor=actor,\n critic=critic,\n critic_action_input=action_input,\n memory=membuf,\n nb_steps_warmup_critic=warmup_critic,\n nb_steps_warmup_actor=warmup_actor,\n random_process=random,\n gamma=gamma,\n target_model_update=1E-3)\n self.agent.compile(keras.optimizers.Adam(lr=0.001, clipnorm=1.0), metrics=['mae', 'accuracy'])\n\n # Potentially load the Agent's weights from disk\n if weights is not None:\n basename, ext = os.path.splitext(weights)\n cweights = basename + \"_critic\" + ext\n aweights = basename + \"_actor\" + ext\n if not os.path.isfile(cweights):\n raise ValueError(\"Could not find file\", cweights)\n elif not os.path.isfile(aweights):\n raise ValueError(\"Could not find file\", aweights)\n else:\n self.agent.load_weights(weights)","def learn(self, agent_id, experiences, gamma, all_next_actions, all_actions):\n\n states, actions, rewards, next_states, dones = experiences\n\n # ---------------------------- update critic ---------------------------- #\n self.critic_optimizer.zero_grad()\n agent_id = torch.tensor([agent_id]).to(device)\n actions_next = torch.cat(all_next_actions, dim=1).to(device)\n with torch.no_grad():\n q_targets_next = self.critic_target(next_states, actions_next)\n q_expected = self.critic_local(states, actions)\n # q_targets = reward of this timestep + discount * Q(st+1,at+1) from target network\n q_targets = rewards.index_select(1, agent_id) + (gamma * q_targets_next * (1 - dones.index_select(1, agent_id)))\n critic_loss = F.mse_loss(q_expected, q_targets.detach())\n critic_loss.backward()\n self.critic_optimizer.step()\n\n # ---------------------------- update actor ---------------------------- #\n self.actor_optimizer.zero_grad()\n actions_pred = [actions if i == self.id else actions.detach() for i, actions in enumerate(all_actions)]\n actions_pred = torch.cat(actions_pred, dim=1).to(device)\n actor_loss = -self.critic_local(states, actions_pred).mean()\n actor_loss.backward()\n self.actor_optimizer.step()\n # ----------------------- update target networks ----------------------- #\n self.soft_update(self.critic_local, self.critic_target, self.tau)\n self.soft_update(self.actor_local, self.actor_target, self.tau)","def train(self, features, actions, rewards):\n self.model.fit(x=features, y=actions, sample_weight=rewards,\n verbose=False)","def _Train(self, limit):\n if len(self.Memory)>BATCH_SIZE: \n # Limit of Agents to Train\n for i in range(limit): \n # 'n' number of rounds to train \n for _ in range(50):\n # Get Batch Data\n experiances = self.Memory.sample()\n # Train Models\n self._Learn(self.Actor[i], self.ActorTarget, self.actorOpt[i], experiances)","def train(self):\n\n agent_step = self._num_actions_taken\n\n if agent_step >= self._train_after:\n if (agent_step % self._train_interval) == 0:\n pre_states, actions, post_states, rewards, terminals = self._memory.minibatch(self._minibatch_size)\n\n self._trainer.train_minibatch(\n self._trainer.loss_function.argument_map(\n pre_states=pre_states,\n actions=Value.one_hot(actions.reshape(-1, 1).tolist(), self.nb_actions),\n post_states=post_states,\n rewards=rewards,\n terminals=terminals\n )\n )\n\n # Update the Target Network if needed\n if (agent_step % self._target_update_interval) == 0:\n self._target_net = self._action_value_net.clone(CloneMethod.freeze)\n filename = \"models\\model%d\" % agent_step\n self._trainer.save_checkpoint(filename)","def learn(self):\n event_batch = self.memory.sample(self.batch_size)\n \n if event_batch is None:\n return\n\n event_batch = self.memory.deserialize(event_batch)\n self.update_critic(event_batch)\n self.update_actor(event_batch)\n self.update_target(self.local_actor, self.target_actor)\n self.update_target(self.local_critic, self.target_critic)","def step(self):\n\n \"\"\" First updates the variables values of the current time form the environment \"\"\"\n self.update_crispval(self.env.context)\n\n \"\"\"\n here the decision making of the agent\n to determine which activity to suggest to the patient\n i apply the creative controller to the current context\n \"\"\"\n curr_input = sample_inputs(False, 0, self.curr_interaction, self.variables_default_val, self.action_var,\n self.fuzzysets_values, self.variables_universe)\n c_out, rules_activations, is_cc_exception = self.creative_controller.computeOutput(curr_input, False)\n\n \"\"\" i obtain a number of ouput crisp values.\n i determine which one achieves the max expected output w.r.t. the a-rules \"\"\"\n best_a = None\n best_a_val = -1000\n best_a_exphapp = 5\n if self.verbose > Constants.VERBOSE_BASIC:\n print(\"rules activations\")\n for a in rules_activations:\n if rules_activations[a] > 0:\n print(str(a) + \"\\n\\t\\t\\t-> \" + str(rules_activations[a]))\n for item in c_out.items(): # for each pair <activity, crisp output>\n if self.verbose > Constants.VERBOSE_BASIC:\n print(item)\n if not item[\n 0] in self.curr_iter_suggestions: # if i didn't suggest the same activity already in the same interaction\n inputs = dict(curr_input) # I create a copy fo the dict\n inputs[item[0]] = item[1]\n assessor_id = self.actions_to_ti[item[0]]\n self.assessors[assessor_id].feed_inputs(inputs)\n is_ac_exception = False\n assout = []\n try:\n a_out, a_rules_activations, is_ac_exception = self.assessors[assessor_id].compute(verbose=False)\n assout = [a_out[ao] for ao in a_out]\n except:\n is_ac_exception = True\n traceback.print_exc()\n # todo the following assumes that every assessor controller has same eval var\n for v in self.eval_var:\n assout.append(self.variables_default_val[v])\n if len(assout) == 0:\n for v in self.eval_var:\n assout.append(self.variables_default_val[v])\n w_ta = self.weights_therapeutic_interventions[self.actions_to_ti[item[0]]]\n\n avg_credit_rules_that_suggested_action = 1.0\n nr_rules_that_suggested_action = 0\n for r in rules_activations:\n if (rules_activations[r] > 0) and (str(item[0]) in str(r)):\n avg_credit_rules_that_suggested_action = avg_credit_rules_that_suggested_action + \\\n self.rules_credits[str(r)]\n nr_rules_that_suggested_action = nr_rules_that_suggested_action + 1\n if nr_rules_that_suggested_action > 0:\n avg_credit_rules_that_suggested_action = (\n avg_credit_rules_that_suggested_action - 1.0) / nr_rules_that_suggested_action\n repetition_cost = 1.0\n a_val = (mean(assout) * w_ta * avg_credit_rules_that_suggested_action) / repetition_cost\n if (a_val > best_a_val) and (\n item[1] >= (self.variables_default_val[item[0]] + self.range_step[item[0]])):\n best_a = item\n best_a_val = a_val\n best_a_exphapp = mean(assout)\n\n \"\"\"I suggest the activity with best expected outcome and store the information to populate the interactions \n memory \"\"\"\n self.proposeActivity(best_a)\n if not best_a is None:\n if (self.verbose > Constants.VERBOSE_FALSE) and (self.verbose <= Constants.VERBOSE_BASIC):\n print(\"proposing activity\" + str(best_a) + \" which has expected feedback: \" + str(\n best_a_exphapp) + \", which weighted is \" + str(best_a_val))\n self.curr_iter_suggestions.append(best_a[0])\n self.last_suggestion = best_a\n else:\n if (self.verbose > Constants.VERBOSE_FALSE) and (self.verbose <= Constants.VERBOSE_BASIC):\n print(\"the activity proposed is \" + str(\n best_a) + \" so I don't suggest anything. I will ask a question instead\")\n self.last_suggestion = []\n self.expected_feedback = best_a_exphapp\n self.last_context = self.env.context.copy()\n self.last_rules_activations = rules_activations","def _setup_actor_critic_agent(self, ppo_cfg: Config, observation_space=None) -> None:\n logger.add_filehandler(self.config.LOG_FILE)\n\n if observation_space is None:\n observation_space = self.envs.observation_spaces[0]\n\n self.actor_critic = AudioNavBaselinePolicy(\n observation_space=observation_space,\n action_space=self.envs.action_spaces[0],\n hidden_size=ppo_cfg.hidden_size,\n goal_sensor_uuid=self.config.TASK_CONFIG.TASK.GOAL_SENSOR_UUID,\n extra_rgb=self.config.EXTRA_RGB\n )\n\n self.agent = PPO(\n actor_critic=self.actor_critic,\n clip_param=ppo_cfg.clip_param,\n ppo_epoch=ppo_cfg.ppo_epoch,\n num_mini_batch=ppo_cfg.num_mini_batch,\n value_loss_coef=ppo_cfg.value_loss_coef,\n entropy_coef=ppo_cfg.entropy_coef,\n lr=ppo_cfg.lr,\n eps=ppo_cfg.eps,\n max_grad_norm=ppo_cfg.max_grad_norm,\n )\n\n if self.config.RESUME:\n ckpt_dict = self.load_checkpoint('data/models/smt_with_pose/ckpt.400.pth', map_location=\"cpu\")\n self.agent.actor_critic.net.visual_encoder.load_state_dict(self.search_dict(ckpt_dict, 'visual_encoder'))\n self.agent.actor_critic.net.goal_encoder.load_state_dict(self.search_dict(ckpt_dict, 'goal_encoder'))\n self.agent.actor_critic.net.action_encoder.load_state_dict(self.search_dict(ckpt_dict, 'action_encoder'))\n\n self.actor_critic.to(self.device)","def trainModel( self, featureTrain, classTrain):","def train():\n # YOUR TRAINING CODE GOES HERE","def train(self):\n feature = Feature(trained=False)\n classifier = LogisticRegression(\n penalty='l2',\n max_iter=100,\n solver='liblinear',\n random_state=self.RAND_SEED)\n\n true_labels = []\n predicted_labels = []\n\n for subj in self.subjects:\n print(subj)\n # preprocess training and testing set\n self.dataset_gen(subject=subj, valid=False)\n\n # train and predict\n pipeline_steps = [('vectorized', feature.vector)]\n if self.istfidf:\n pipeline_steps.append(('tf-idf', feature.tfidftransform))\n if self.islda == 'small':\n pipeline_steps.append(('lda', feature.ldatransform_small))\n elif self.islda == 'large':\n pipeline_steps.append(('lda', feature.ldatransform_large))\n else:\n pass\n if self.isnorm:\n pipeline_steps.append(('scalar', StandardScaler(with_mean=False)))\n pipeline_steps.append(('clf', classifier))\n model = Pipeline(steps=pipeline_steps)\n\n model.fit(self.X_train, self.y_train)\n\n predicted = model.predict(self.X_test)\n # hamming\n predicted_labels.append(predicted)\n true_labels.append(self.y_test)\n\n true_matrix, pred_matrix = np.array(true_labels, int).T, np.array(predicted_labels, int).T\n true_matrix[true_matrix == -1] = 0\n pred_matrix[pred_matrix == -1] = 0\n\n evaluation = Evaluation(self.subjects)\n evaluation.model_evaluate(true_matrix=true_matrix, pred_matrix=pred_matrix, model_name=self.modelname)","def optimize(self):\n\t\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\n\n\t\ts1 = Variable(torch.from_numpy(s1))\n\t\ta1 = Variable(torch.from_numpy(a1))\n\t\tr1 = Variable(torch.from_numpy(r1))\n\t\ts2 = Variable(torch.from_numpy(s2))\n\n\t\tfor i in range(self.critic_step):\n\t\t\t# ---------------------- optimize critic ----------------------\n\t\t\t# Use target actor exploitation policy here for loss evaluation\n\t\t\t\n\t\t\t# a2 = self.target_actor.forward(s2).detach()\n\t\t\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\n\t\t\t\n\t\t\t# y_exp = r + gamma*Q'( s2, pi'(s2))\n\t\t\ty_expected = r1 #+ GAMMA*next_val\n\t\t\t# y_pred = Q( s1, a1)\n\t\t\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\n\t\t\t# compute critic loss, and update the critic\n\t\t\t#print(y_predicted,y_expected,\"hi\")\n\t\t\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\n\t\t\tself.critic_optimizer.zero_grad()\n\t\t\tloss_critic.backward()\n\t\t\tself.critic_optimizer.step()\n\n\t\t# ---------------------- optimize actor ----------------------\n\t\tpred_a1 = self.actor.forward(s1)\n\t\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\n\t\tself.actor_optimizer.zero_grad()\n\t\tloss_actor.backward()\n\t\tself.actor_optimizer.step()\n\n\t\tutils.soft_update(self.target_actor, self.actor, TAU)\n\t\tutils.soft_update(self.target_critic, self.critic, TAU)\n\n\t\t# if self.iter % 100 == 0:\n\t\tif self.batch_size > 1:\n\t\t\ty_1 = y_predicted.data.numpy()[0]\n\t\t\tr_1 = r1.data.numpy()[0]\n\t\telse:\n\t\t\ty_1 = y_predicted.data.numpy()\n\t\t\tr_1 = r1.data.numpy()\n\t\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\n\t\t\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\n\t\tself.iter += 1","def __init__(self,\n sess,\n ob_space,\n ac_space,\n co_space,\n buffer_size,\n batch_size,\n actor_lr,\n critic_lr,\n verbose,\n tau,\n gamma,\n use_huber,\n l2_penalty,\n model_params,\n num_envs=1):\n super(ActorCriticPolicy, self).__init__(\n sess=sess,\n ob_space=ob_space,\n ac_space=ac_space,\n co_space=co_space,\n verbose=verbose,\n l2_penalty=l2_penalty,\n model_params=model_params,\n num_envs=num_envs,\n )\n\n self.buffer_size = buffer_size\n self.batch_size = batch_size\n self.actor_lr = actor_lr\n self.critic_lr = critic_lr\n self.tau = tau\n self.gamma = gamma\n self.use_huber = use_huber","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def train(self):\n pass","def learn(self,experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # --------- Update Critic network -------#\n actions_next = self.actor_target(next_states)\n Q_targets_next = self.critic_target(next_states,actions_next)\n Q_targets = rewards + (gamma * Q_targets_next * (1- dones))\n\n #--------- Compute critic loss using MSE--#\n Q_expected = self.critic_local(states,actions)\n critic_loss = F.mse_loss(Q_expected,Q_targets)\n\n #----------Minimize the loss -----------#\n self.critic_optimizer.zero_grad()\n critic_loss.backward()\n nn.utils.clip_grad_norm(self.critic_local.parameters(),1)\n self.critic_optimizer.step()\n\n #-------- Update Actor network---------#\n # get mu(s)\n actions_pred = self.actor_local(states)\n #get V(s,a)\n actor_loss = -self.critic_local(states,actions_pred).mean()\n #-------- Minize the loss -----------#\n self.actor_optimizer.zero_grad()\n actor_loss.backward()\n self.actor_optimizer.step()\n\n #------- Update Target Networks ----#\n self.soft_update(self.critic_local,self.critic_target,TAU)\n self.soft_update(self.actor_local,self.actor_target,TAU)","def train_step(_states, _actions, _rewards):\n _cumulative_rewards = get_cumulative_rewards(_rewards)\n update.run({states:_states, actions: _actions, cumulative_rewards:_cumulative_rewards})","def update(self, *args: Any, **kwargs: Any):\n obss = []\n losses = []\n for t in range(self.num_teachers):\n concat_ros = StepSequence.concat(kwargs[\"rollouts\"][t])\n concat_ros.torch(data_type=to.get_default_dtype())\n obss.append(concat_ros.get_data_values(\"observations\")[: self.min_steps])\n\n # Train student\n for epoch in range(self.num_epochs):\n self.optimizer.zero_grad()\n\n loss = 0\n for t_idx, teacher in enumerate(self.teacher_policies):\n s_dist = self.expl_strat.action_dist_at(self.policy(obss[t_idx]))\n s_act = s_dist.sample()\n t_dist = self.teacher_expl_strats[t_idx].action_dist_at(teacher(obss[t_idx]))\n\n l = self.teacher_weights[t_idx] * self.criterion(t_dist.log_prob(s_act), s_dist.log_prob(s_act))\n loss += l\n losses.append([t_idx, l.item()])\n print(f\"Epoch {epoch} Loss: {loss.item()}\")\n loss.backward()\n self.optimizer.step()","def _training_before_hook(self):\n pass","def train(self, observation, action, reward, done):\r\n\r\n # Adding organic session to organic view counts.\r\n if observation:\r\n for session in observation.sessions():\r\n self.organic_views[session['v']] += 1","def train_models(self, states, actions, rewards):\n # Compute discounted rewards and Advantage (TD. Error)\n discounted_rewards = self.discount(rewards)\n state_values = self.critic.predict(np.array(states))\n advantages = discounted_rewards - np.reshape(state_values, len(state_values))\n # Networks optimization\n self.act_op([states, actions, advantages])\n self.cri_op([states, discounted_rewards])","def learn(self):\n for a in self.agents:\n a.learn()","def init_trainers(self, args):\n self.actors_cur = [None for _ in range(self.num_agents)]\n self.critics_cur = [None for _ in range(self.num_agents)]\n self.actors_tar = [None for _ in range(self.num_agents)]\n self.critics_tar = [None for _ in range(self.num_agents)]\n self.optimizers_c = [None for _ in range(self.num_agents)]\n self.optimizers_a = [None for _ in range(self.num_agents)]\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\n\n if args.restore == True: # restore the model\n game_step = int(args.old_model_name.split('_')[-1][:-1])\n for idx in range(self.num_agents):\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\n self.var = self.min_var if self.var < self.min_var else self.var\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\n\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\n for i in range(self.num_agents):\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\n args).to(args.device)\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\n args).to(args.device)\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\n\n # return the old data, no need to update the trainers\n if args.restore == True: return old_data\n\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur","def _setup_actor_critic_agent(self, ppo_cfg: Config) -> None:\n logger.add_filehandler(self.config.LOG_FILE)\n\n self.actor_critic = RearrangementBaselinePolicy(\n observation_space=self.envs.observation_spaces[0],\n action_space=self.envs.action_spaces[0],\n hidden_size=ppo_cfg.hidden_size,\n )\n self.actor_critic.to(self.device)\n\n self.agent = PPO(\n actor_critic=self.actor_critic,\n clip_param=ppo_cfg.clip_param,\n ppo_epoch=ppo_cfg.ppo_epoch,\n num_mini_batch=ppo_cfg.num_mini_batch,\n value_loss_coef=ppo_cfg.value_loss_coef,\n entropy_coef=ppo_cfg.entropy_coef,\n lr=ppo_cfg.lr,\n eps=ppo_cfg.eps,\n max_grad_norm=ppo_cfg.max_grad_norm,\n use_normalized_advantage=ppo_cfg.use_normalized_advantage,\n )","def train(self) -> None:\n logger.info(f\"config: {self.config}\")\n random.seed(self.config.SEED)\n np.random.seed(self.config.SEED)\n torch.manual_seed(self.config.SEED)\n\n # add_signal_handlers()\n\n self.envs = construct_envs(\n self.config, get_env_class(self.config.ENV_NAME), workers_ignore_signals=True\n )\n\n ppo_cfg = self.config.RL.PPO\n self.device = (\n torch.device(\"cuda\", self.config.TORCH_GPU_ID)\n if torch.cuda.is_available()\n else torch.device(\"cpu\")\n )\n if not os.path.isdir(self.config.CHECKPOINT_FOLDER):\n os.makedirs(self.config.CHECKPOINT_FOLDER)\n self._setup_actor_critic_agent(ppo_cfg)\n logger.info(\n \"agent number of parameters: {}\".format(\n sum(param.numel() for param in self.agent.parameters())\n )\n )\n\n rollouts = RolloutStorage(\n ppo_cfg.num_steps,\n self.envs.num_envs,\n self.envs.observation_spaces[0],\n self.envs.action_spaces[0],\n ppo_cfg.hidden_size\n )\n rollouts.to(self.device)\n\n observations = self.envs.reset()\n batch = batch_obs(observations)\n\n for sensor in rollouts.observations:\n rollouts.observations[sensor][0].copy_(batch[sensor])\n\n # batch and observations may contain shared PyTorch CUDA\n # tensors. We must explicitly clear them here otherwise\n # they will be kept in memory for the entire duration of training!\n batch = None\n observations = None\n\n current_episode_reward = torch.zeros(self.envs.num_envs, 1)\n running_episode_stats = dict(\n count=torch.zeros(self.envs.num_envs, 1),\n reward=torch.zeros(self.envs.num_envs, 1),\n )\n window_episode_stats = defaultdict(\n lambda: deque(maxlen=ppo_cfg.reward_window_size)\n )\n\n t_start = time.time()\n env_time = 0\n pth_time = 0\n count_steps = 0\n count_checkpoints = 0\n start_update = 0\n prev_time = 0\n\n lr_scheduler = LambdaLR(\n optimizer=self.agent.optimizer,\n lr_lambda=lambda x: linear_decay(x, self.config.NUM_UPDATES),\n )\n\n interrupted_state = load_interrupted_state(model_dir=self.config.MODEL_DIR)\n if interrupted_state is not None:\n self.agent.load_state_dict(interrupted_state[\"state_dict\"])\n self.agent.optimizer.load_state_dict(\n interrupted_state[\"optimizer_state\"]\n )\n lr_scheduler.load_state_dict(interrupted_state[\"lr_scheduler_state\"])\n\n requeue_stats = interrupted_state[\"requeue_stats\"]\n env_time = requeue_stats[\"env_time\"]\n pth_time = requeue_stats[\"pth_time\"]\n count_steps = requeue_stats[\"count_steps\"]\n count_checkpoints = requeue_stats[\"count_checkpoints\"]\n start_update = requeue_stats[\"start_update\"]\n prev_time = requeue_stats[\"prev_time\"]\n\n with TensorboardWriter(\n self.config.TENSORBOARD_DIR, flush_secs=self.flush_secs\n ) as writer:\n for update in range(start_update, self.config.NUM_UPDATES):\n if ppo_cfg.use_linear_lr_decay:\n lr_scheduler.step()\n\n if ppo_cfg.use_linear_clip_decay:\n self.agent.clip_param = ppo_cfg.clip_param * linear_decay(\n update, self.config.NUM_UPDATES\n )\n\n if EXIT.is_set():\n self.envs.close()\n\n if REQUEUE.is_set():\n requeue_stats = dict(\n env_time=env_time,\n pth_time=pth_time,\n count_steps=count_steps,\n count_checkpoints=count_checkpoints,\n start_update=update,\n prev_time=(time.time() - t_start) + prev_time,\n )\n save_interrupted_state(\n dict(\n state_dict=self.agent.state_dict(),\n optimizer_state=self.agent.optimizer.state_dict(),\n lr_scheduler_state=lr_scheduler.state_dict(),\n config=self.config,\n requeue_stats=requeue_stats,\n ),\n model_dir=self.config.MODEL_DIR\n )\n requeue_job()\n return\n\n for step in range(ppo_cfg.num_steps):\n delta_pth_time, delta_env_time, delta_steps = self._collect_rollout_step(\n rollouts,\n current_episode_reward,\n running_episode_stats\n )\n pth_time += delta_pth_time\n env_time += delta_env_time\n count_steps += delta_steps\n\n delta_pth_time, value_loss, action_loss, dist_entropy = self._update_agent(\n ppo_cfg, rollouts\n )\n pth_time += delta_pth_time\n\n deltas = {\n k: (\n (v[-1] - v[0]).sum().item()\n if len(v) > 1\n else v[0].sum().item()\n )\n for k, v in window_episode_stats.items()\n }\n deltas[\"count\"] = max(deltas[\"count\"], 1.0)\n\n writer.add_scalar(\n \"Metrics/reward\", deltas[\"reward\"] / deltas[\"count\"], count_steps\n )\n\n # Check to see if there are any metrics\n # that haven't been logged yet\n metrics = {\n k: v / deltas[\"count\"]\n for k, v in deltas.items()\n if k not in {\"reward\", \"count\"}\n }\n if len(metrics) > 0:\n # writer.add_scalars(\"metrics\", metrics, count_steps)\n for metric, value in metrics.items():\n writer.add_scalar(f\"Metrics/{metric}\", value, count_steps)\n\n writer.add_scalar(\"Policy/value_loss\", value_loss, count_steps)\n writer.add_scalar(\"Policy/policy_loss\", action_loss, count_steps)\n writer.add_scalar(\"Policy/entropy_loss\", dist_entropy, count_steps)\n writer.add_scalar('Policy/learning_rate', lr_scheduler.get_lr()[0], count_steps)\n\n # log stats\n if update > 0 and update % self.config.LOG_INTERVAL == 0:\n logger.info(\n \"update: {}\\tfps: {:.3f}\\t\".format(\n update, count_steps / (time.time() - t_start)\n )\n )\n\n logger.info(\n \"update: {}\\tenv-time: {:.3f}s\\tpth-time: {:.3f}s\\t\"\n \"frames: {}\".format(\n update, env_time, pth_time, count_steps\n )\n )\n\n logger.info(\n \"Average window size: {} {}\".format(\n len(window_episode_stats[\"count\"]),\n \" \".join(\n \"{}: {:.3f}\".format(k, v / deltas[\"count\"])\n for k, v in deltas.items()\n if k != \"count\"\n ),\n )\n )\n\n # checkpoint model\n if update % self.config.CHECKPOINT_INTERVAL == 0:\n self.save_checkpoint(f\"ckpt.{count_checkpoints}.pth\")\n count_checkpoints += 1\n\n self.envs.close()","def _train_model(self):\n self.experiment = EpisodicExperiment(self.task, self.agent)\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\n logger.debug(\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\"\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\n for i in range(n_epochs):\n logger.debug(\"RL epoch {}\".format(i))\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\n self.agent.learn()\n self.agent.reset() # reset buffers","def train(args, worker_id: int, global_model: Union[ActorNetwork, ActorCriticNetwork], T: Value, global_reward: Value,\n optimizer: torch.optim.Optimizer = None, global_model_critic: CriticNetwork = None,\n optimizer_critic: torch.optim.Optimizer = None, lr_scheduler: torch.optim.lr_scheduler = None,\n lr_scheduler_critic: torch.optim.lr_scheduler = None):\n torch.manual_seed(args.seed + worker_id)\n\n if args.worker == 1:\n logging.info(f\"Running A2C with {args.n_envs} environments.\")\n if \"RR\" not in args.env_name:\n env = SubprocVecEnv([make_env(args.env_name, args.seed, i, args.log_dir) for i in range(args.n_envs)])\n else:\n env = DummyVecEnv([make_env(args.env_name, args.seed, worker_id, args.log_dir)])\n else:\n logging.info(f\"Running A3C: training worker {worker_id} started.\")\n env = DummyVecEnv([make_env(args.env_name, args.seed, worker_id, args.log_dir)])\n # avoid any issues if this is not 1\n args.n_envs = 1\n\n normalizer = get_normalizer(args.normalizer, env)\n\n # init local NN instance for worker thread\n model = copy.deepcopy(global_model)\n model.train()\n\n model_critic = None\n\n if global_model_critic:\n model_critic = copy.deepcopy(global_model_critic)\n model_critic.train()\n\n # if no shared optimizer is provided use individual one\n if not optimizer:\n optimizer, optimizer_critic = get_optimizer(args.optimizer, global_model, args.lr,\n model_critic=global_model_critic, lr_critic=args.lr_critic)\n if args.lr_scheduler == \"exponential\":\n lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.99)\n if optimizer_critic:\n lr_scheduler_critic = torch.optim.lr_scheduler.ExponentialLR(optimizer_critic, gamma=0.99)\n\n state = torch.Tensor(env.reset())\n\n t = np.zeros(args.n_envs)\n global_iter = 0\n episode_reward = np.zeros(args.n_envs)\n\n if worker_id == 0:\n writer = SummaryWriter(log_dir='experiments/runs/')\n\n while True:\n # Get state of the global model\n model.load_state_dict(global_model.state_dict())\n if not args.shared_model:\n model_critic.load_state_dict(global_model_critic.state_dict())\n\n # containers for computing loss\n values = []\n log_probs = []\n rewards = []\n entropies = []\n # container to check whether a terminal state was reached from one of the envs\n terminals = []\n\n # reward_sum = 0\n for step in range(args.rollout_steps):\n t += 1\n\n if args.shared_model:\n value, mu, std = model(normalizer(state))\n else:\n mu, std = model(normalizer(state))\n value = model_critic(normalizer(state))\n\n dist = torch.distributions.Normal(mu, std)\n\n # ------------------------------------------\n # # select action\n action = dist.sample()\n\n # ------------------------------------------\n # Compute statistics for loss\n entropy = dist.entropy().sum(-1).unsqueeze(-1)\n log_prob = dist.log_prob(action).sum(-1).unsqueeze(-1)\n\n # make selected move\n action = np.clip(action.detach().numpy(), -args.max_action, args.max_action)\n state, reward, dones, _ = env.step(action[0] if not args.worker == 1 or \"RR\" in args.env_name else action)\n\n reward = shape_reward(args, reward)\n\n episode_reward += reward\n\n # probably don't set terminal state if max_episode length\n dones = np.logical_or(dones, t >= args.max_episode_length)\n\n values.append(value)\n log_probs.append(log_prob)\n rewards.append(torch.Tensor(reward).unsqueeze(-1))\n entropies.append(entropy)\n terminals.append(torch.Tensor(1 - dones).unsqueeze(-1))\n\n for i, done in enumerate(dones):\n if done:\n # keep track of the avg overall global reward\n with global_reward.get_lock():\n if global_reward.value == -np.inf:\n global_reward.value = episode_reward[i]\n else:\n global_reward.value = .99 * global_reward.value + .01 * episode_reward[i]\n if worker_id == 0 and T.value % args.log_frequency == 0:\n writer.add_scalar(\"reward/global\", global_reward.value, T.value)\n\n episode_reward[i] = 0\n t[i] = 0\n if args.worker != 1 or \"RR\" in args.env_name:\n env.reset()\n\n with T.get_lock():\n # this is one for a3c and n for A2C (actually the lock is not needed for A2C)\n T.value += args.n_envs\n\n if lr_scheduler and worker_id == 0 and T.value % args.lr_scheduler_step and global_iter != 0:\n lr_scheduler.step(T.value / args.lr_scheduler_step)\n\n if lr_scheduler_critic:\n lr_scheduler_critic.step(T.value / args.lr_scheduler_step)\n\n state = torch.Tensor(state)\n\n if args.shared_model:\n v, _, _ = model(normalizer(state))\n G = v.detach()\n else:\n G = model_critic(normalizer(state)).detach()\n\n values.append(G)\n\n # compute loss and backprop\n advantages = torch.zeros((args.n_envs, 1))\n\n ret = torch.zeros((args.rollout_steps, args.n_envs, 1))\n adv = torch.zeros((args.rollout_steps, args.n_envs, 1))\n\n # iterate over all time steps from most recent to the starting one\n for i in reversed(range(args.rollout_steps)):\n # G can be seen essentially as the return over the course of the rollout\n G = rewards[i] + args.discount * terminals[i] * G\n if not args.no_gae:\n # Generalized Advantage Estimation\n td_error = rewards[i] + args.discount * terminals[i] * values[i + 1] - values[i]\n # terminals here to \"reset\" advantages to 0, because reset ist called internally in the env\n # and new trajectory started\n advantages = advantages * args.discount * args.tau * terminals[i] + td_error\n else:\n advantages = G - values[i].detach()\n\n adv[i] = advantages.detach()\n ret[i] = G.detach()\n\n policy_loss = -(torch.stack(log_probs) * adv).mean()\n # minus 1 in order to remove the last element, which is only necessary for next timestep value\n value_loss = .5 * (ret - torch.stack(values[:-1])).pow(2).mean()\n entropy_loss = torch.stack(entropies).mean()\n\n # zero grads to reset the gradients\n optimizer.zero_grad()\n\n if args.shared_model:\n # combined loss for shared architecture\n total_loss = policy_loss + args.value_loss_weight * value_loss - args.entropy_loss_weight * entropy_loss\n total_loss.backward()\n else:\n optimizer_critic.zero_grad()\n\n value_loss.backward()\n (policy_loss - args.entropy_loss_weight * entropy_loss).backward()\n\n # this is just used for plotting in tensorboard\n total_loss = policy_loss + args.value_loss_weight * value_loss - args.entropy_loss_weight * entropy_loss\n\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\n sync_grads(model, global_model)\n optimizer.step()\n\n if not args.shared_model:\n torch.nn.utils.clip_grad_norm_(model_critic.parameters(), args.max_grad_norm)\n sync_grads(model_critic, global_model_critic)\n optimizer_critic.step()\n\n global_iter += 1\n\n if worker_id == 0 and T.value % args.log_frequency == 0:\n log_to_tensorboard(writer, model, optimizer, rewards, values, total_loss, policy_loss, value_loss,\n entropy_loss, T.value, model_critic=model_critic, optimizer_critic=optimizer_critic)","def __init__(self):\n self.train(positivity_files, 0)\n self.train(subjectivity_files, 1)","def train(self):\n if len(self.memory) > self.batch_size:\n selecting_time_start = time.time()\n experiences = self.memory.sample()\n self.selecting_time += time.time() - selecting_time_start\n self.learn(experiences)","def train(self, ):\n raise NotImplementedError","def __init__(self, state_size, action_size, num_agents, seed, fc1=400, fc2=300, update_times=10,\n weight_decay=1.e-5):\n self.state_size = state_size\n self.action_size = action_size\n self.seed = random.seed(seed)\n self.n_seed = np.random.seed(seed)\n self.num_agents = num_agents\n self.update_times = update_times\n self.n_step = 0\n self.TAU = 1e-3\n\n self.noise = []\n for i in range(num_agents):\n self.noise.append(rm.OrnsteinUhlenbeckProcess(size=(action_size,), std=LinearSchedule(0.4, 0, 2000)))\n\n # critic local and target network (Q-Learning)\n self.critic_local = Critic(state_size, action_size, fc1, fc2, seed).to(device)\n\n self.critic_target = Critic(state_size, action_size, fc1, fc2, seed).to(device)\n self.critic_target.load_state_dict(self.critic_local.state_dict())\n\n # actor local and target network (Policy gradient)\n self.actor_local = Actor(state_size, action_size, fc1, fc2, seed).to(device)\n self.actor_target = Actor(state_size, action_size, fc1, fc2, seed).to(device)\n self.actor_target.load_state_dict(self.actor_local.state_dict())\n\n # optimizer for critic and actor network\n self.optimizer_critic = optim.Adam(self.critic_local.parameters(), lr=CRITIC_LR, weight_decay=1.e-5)\n self.optimizer_actor = optim.Adam(self.actor_local.parameters(), lr=ACTOR_LR)\n\n # Replay memory\n self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\n\n # Initialize time step (for updating every UPDATE_EVERY steps)\n self.t_step = 0\n self.a_step = 0","def train(self):\n\t\traise NotImplementedError","def __init__(self, agents_count, state_size, action_size, random_seed, buffer_size, batch_size, gamma, fc1_units, fc2_units, noise, lr_actor, lr_critic):\n\n self.agents_count = agents_count\n self.state_size = state_size\n self.action_size = action_size\n self.seed = random.seed(random_seed)\n self.gamma = gamma\n self.batch_size = batch_size\n\n # Actor Network (w/ Target Network)\n self.actor_local = Actor(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\n self.actor_target = Actor(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\n self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=lr_actor)\n\n # Critic Network (w/ Target Network)\n self.critic_local = Critic(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\n self.critic_target = Critic(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\n self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=lr_critic, weight_decay=WEIGHT_DECAY)\n\n # after reading implementating of ShangtongZhang as suggested in the course,\n # It seems relevant to initialize the weights of the target networks\n # with the same values as the local network :\n self.actor_target.load_state_dict(self.actor_local.state_dict())\n self.critic_target.load_state_dict(self.critic_local.state_dict())\n\n # Noise process\n self.noise = noise\n\n # Replay memory\n self.memory = ReplayBuffer(action_size, buffer_size, batch_size, random_seed)","def _evaluate(self):\n coherence = gensim.models.coherencemodel.CoherenceModel(model=self.ldamodel,\n corpus=self.gensim_corpus,\n dictionary=self.ldamodel.id2word,\n coherence='u_mass')\n self.score = coherence.get_coherence()\n if self.verbose:\n print('LDA achieved a coherence (u_mass) of: ', self.score)","def _setup_actor_critic_agent(self, ppo_cfg: Config) -> None:\n logger.add_filehandler(self.config.LOG_FILE)\n\n self.actor_critic = PointNavBaselinePolicy(\n observation_space=self.envs.observation_spaces[0],\n action_space=self.envs.action_spaces[0],\n hidden_size=ppo_cfg.hidden_size,\n goal_sensor_uuid=self.config.TASK_CONFIG.TASK.GOAL_SENSOR_UUID,\n )\n self.actor_critic.to(self.device)\n\n self.agent = PPO(\n actor_critic=self.actor_critic,\n clip_param=ppo_cfg.clip_param,\n ppo_epoch=ppo_cfg.ppo_epoch,\n num_mini_batch=ppo_cfg.num_mini_batch,\n value_loss_coef=ppo_cfg.value_loss_coef,\n entropy_coef=ppo_cfg.entropy_coef,\n lr=ppo_cfg.lr,\n eps=ppo_cfg.eps,\n max_grad_norm=ppo_cfg.max_grad_norm,\n use_normalized_advantage=ppo_cfg.use_normalized_advantage,\n )","def train_step(self, experiences, gamma):\n raise NotImplementedError","def training(self, dataset, repeat=1, gamma=1.0, learning_rate=0.1, model='3yo'):\n for _ in range(repeat):\n for episode in dataset:\n # 1- Get the data stored inside the dataset\n image_index = episode[0] # image of the object\n label_index = episode[1] # label given by the informant\n informant_index = episode[2] # a integer representing the informant\n informant_action = episode[3] # 0=reject, 1=accept\n\n # 2- The agent take an action (with softmax) considering is current state-action table\n # [0=cup, 1=book, 2=ball]\n col = (image_index * self.tot_images) + label_index\n action_array = self.actor_matrix[:, col]\n action_distribution = self._softmax(action_array)\n child_action = np.random.choice(self.tot_actions,\n 1,\n p=action_distribution) # select the action through softmax\n\n # 3- (External) New state and reward obtained from the environment\n # u_t = self.critic_vector[0, col] # previous state\n # New state is estimated, in this simple case nothing happen\n # because the next state is terminal\n # u_t1 = u_t # Only in this example they are the same\n\n # 4- (Intrinsic) The informant_reputation is updated:\n # agent_action, agent_confidence, informant_action, reward\n # informant_vector: 0=unreliable, 1=reliable\n # do_actions_agree: False, True\n # Estimating child_confidence\n distance = np.absolute(action_distribution[0] - action_distribution[1])\n child_confidence_distribution = [1 - distance, distance] # non-knowledgeable, knowledgeable\n child_confidence = np.random.choice(2, 1, p=child_confidence_distribution)\n # Check if child and informant agree\n if (child_action == informant_action):\n do_actions_agree = True\n else:\n do_actions_agree = False\n # Increment the counter in the informant_vector.\n # Here we update the counter distribtuion only if\n # the child is confident, because it is only in that\n # case that the child can say if the informant is\n # reliable or not.\n if (do_actions_agree == False and child_confidence == 1):\n self.informant_vector[informant_index][0] += 1 # unreliable\n elif (do_actions_agree == True and child_confidence == 1):\n self.informant_vector[informant_index][1] += 1 # reliable\n elif (do_actions_agree == False and child_confidence == 0):\n self.informant_vector[informant_index][1] += 0 # reliable\n self.informant_vector[informant_index][0] += 0 # unreliable\n elif (do_actions_agree == True and child_confidence == 0):\n self.informant_vector[informant_index][1] += 0 # reliable\n self.informant_vector[informant_index][0] += 0 # unreliable\n else:\n raise ValueError(\"ERROR: anomaly in the IF condition for informant_vector update\")\n # Using the informant_vector given as input it estimates the reputation of the informant\n informant_reputation_distribution = np.true_divide(self.informant_vector[informant_index],\n np.sum(self.informant_vector[informant_index]))\n informant_reputation = np.random.choice(2, 1, p=informant_reputation_distribution)\n\n # 5- (Intrinsic) The Cost is estimated:\n # current_state, agent_action, agent_confidence, informant_action, informant_reputation\n # child_confidence: 0=non-knowledgeable, 1=knowledgeable\n # informant_reputation: 0=non-knowledgeable, 1=knowledgeable\n # action: 0=reject, 1=accept\n # informant_action: 0=reject, 1=accept\n cost = self._return_cost(child_confidence,\n informant_reputation,\n child_action,\n informant_action,\n value=model)\n\n # 6- The utility table is updated using: previous_state, current_state, cost, reward\n # Updating the critic using Temporal Differencing Learning\n # In this simple case there is not a u_t1 state.\n # The current state is considered terminal.\n # We can delete the term (gamma*u_t1)-u_t and considering\n # only (reward-cost) as utility of the state (see Russel Norvig).\n reward = 0 # only for intrinsic learning reward=0\n delta = (reward - cost) # + (gamma*u_t1) - u_t\n self.critic_vector[0, col] += learning_rate * delta\n\n # 7- The actor table is updated using the delta from the critic\n # Update the ACTOR using the delta\n self.actor_matrix[child_action, col] += learning_rate * delta # the current action\n self.actor_matrix[1 - child_action, col] -= learning_rate * delta # the opposite action","def update_critic(self, epochs, discount_factor, reward, state, state_new, action, endstate):\r\n state = np.concatenate(state)\r\n state_new = np.concatenate(state_new)\r\n target = np.zeros([self.minibatch_size, 1])\r\n\r\n for kk in range(len(self.minibatch)):\r\n if endstate[kk]:\r\n target[kk] = reward[kk]\r\n else:\r\n target[kk] = reward[kk] + discount_factor * self.target_critic.predict((np.reshape(state_new[kk, :], (-1, self.feature_number)),\r\n self.target_actor.predict(np.reshape(state_new[kk, :], (-1, self.feature_number))))) # scalar Q-target value, input to model (state_new) is reshaped to a (x,number_inputs) array\r\n\r\n #target[kk] = reward[kk] + discount_factor * self.target_critic.predict([np.reshape(state_new[kk, :], (-1, self.feature_number))], [self.target_actor.predict(np.reshape(state_new[kk, :], (-1, self.feature_number)))]) # scalar Q-target value, input to model (state_new) is reshaped to a (x,number_inputs) array\r\n state = state.astype(np.float32)\r\n target = target.astype(np.float32)\r\n self.critic_loss[self.step_counter] = self.critic.train_on_batch((state, action), target) # with callback: self.critic.fit((state, action), target, epochs=epochs, verbose=0, batch_size=self.minibatch_size, callbacks=[self.tensorboard])\r","def test_training(self):\n\t\tpass","def start_training(self):\n if self.task_env is None:\n rospy.logfatal(\"No task environment found for training.\")\n if self.agent is None:\n rospy.logfatal(\"No agent found for training.\")\n self.agent.start_training()","def on_train_forward(self, runner):\n self.on_iter_forward(runner)","def __init__(self, limit, noise, random_seed, n_state=33, n_action=4):\n # Actor Model: Local, Target, & Optimizer\n self.Actor, self.ActorTarget, self.actorOpt = [], [], []\n for i in range(limit):\n self.Actor.append(Actor(n_state, n_action, random_seed).to(device)) \n self.actorOpt.append(optim.Adam(self.Actor[i].parameters(), lr=LR_ACTOR))\n self.ActorTarget = Actor(n_state, n_action, random_seed).to(device) \n # Critic Model: Local, Target, & Optimizer\n self.Critic = Critic(n_state, n_action, random_seed).to(device)\n self.CriticTarget = Critic(n_state, n_action, random_seed).to(device)\n self.criticOpt = optim.Adam(self.Critic.parameters(), lr=LR_CRITIC)\n # Replay Buffer\n self.Memory = ReplayBuffer2(n_action, BUFFER_SIZE, BATCH_SIZE, device, random_seed)\n self.step = 0\n # OUNoise Process\n self.noise = noise\n # Display\n print('\\nBUFFER_SIZE', BUFFER_SIZE,\n '\\nBATCH_SIZE', BATCH_SIZE,\n '\\nGAMMA', GAMMA,\n '\\nTAU', TAU,\n '\\nLR_ACTOR', LR_ACTOR,\n '\\nLR_CRITIC', LR_CRITIC)\n # Display Actor & Critic\n print('\\nACTOR[i]:\\n', self.Actor[0])\n print('CRITIC:\\n', self.Critic)","def actor_director_experiment():\n dataset = datasets.ActorDirectorDataset()\n\n # Run the diffusion algorithm\n for left, right in hypalgorithms.find_max_cut(dataset.hypergraph):\n dataset.log_confusion_matrix([left, right])\n dataset.show_clustering_stats([left, right])\n\n hyplogging.logger.info(\"\")\n\n # Run the clique algorithm\n for left, right in hypalgorithms.find_max_cut(dataset.hypergraph, algorithm='clique'):\n dataset.log_confusion_matrix([left, right])\n dataset.show_clustering_stats([left, right])","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # compute and minimize the loss\n next_actions = self.actor_target(next_states)\n next_Qs = self.critic_target(next_states, next_actions).detach()\n \n target_Qs = rewards + gamma * next_Qs * (1 - dones)\n expected_Qs = self.critic_local(states, actions)\n \n loss_critic = F.mse_loss(expected_Qs, target_Qs)\n \n self.critic_optimizer.zero_grad()\n loss_critic.backward()\n self.critic_optimizer.step()\n \n # compute and maximize the policy\n pred_actions = self.actor_local(states)\n loss_actor = -self.critic_local(states, pred_actions).mean()\n \n self.actor_optimizer.zero_grad() \n loss_actor.backward()\n self.actor_optimizer.step()\n\n # update target network\n self.soft_update(self.critic_local, self.critic_target, self.params.tau) \n self.soft_update(self.actor_local, self.actor_target, self.params.tau)","def train_cavia(args, config, path_model, device):\n global DATA, PATH_BASE, PATH_DATA, N_CLS, NAME_DATA, NAME_BACKBONE\n\n if path_model is None:\n masks_dict = None\n learner = None\n else:\n print('Load net from', path_model)\n save_dict = torch.load(path_model)\n state_dict = save_dict['state_dict']\n masks_dict = save_dict.get('masks_dict', None)\n\n learner = Learner(config, args.num_context_params, args.context_in)\n learner.load_state_dict(state_dict)\n\n if masks_dict is None:\n print('masks_dict is None!')\n cr = 1.\n else:\n cr = get_cr(learner, masks_dict)\n\n cavia = Meta(args, config, learner).to(device)\n\n # save path\n if path_model is None:\n path_save = '%s/model/cavia_lobs/%s_%s/%d-way_%d-shot' % (\n PATH_BASE, NAME_DATA, NAME_BACKBONE, args.n_way, args.k_spt)\n else:\n path_save = '/'.join(path_model.split('/')[:-1])\n if not os.path.exists(path_save):\n os.makedirs(path_save)\n\n # meta train\n meta_train(cavia, args, masks_dict, device,\n output=args.log_print,\n save=args.save_each_epoch,\n save_threshold=args.save_threshold,\n test_each_epoch=args.test_each_epoch,\n path_save=path_save,\n cr=cr,\n break_threshold=args.break_threshold)\n\n if not args.save_each_epoch:\n # meta test\n acc_avg, accs = meta_test(cavia, args, masks_dict, device)\n\n path_model = '%s/net_cr-1_acc-%.4f.pkl' % (path_save, acc_avg)\n print('Save as %s' % path_model)\n torch.save(\n {\n 'state_dict': cavia.net.state_dict(),\n 'accs': accs,\n 'config': config,\n 'args': args\n },\n path_model\n )","def __init__(self, state_size, action_size, seed, fc_units=[128, 128, 128]):\n super(Critic, self).__init__()\n self.seed = torch.manual_seed(seed)\n self.fc1 = nn.Sequential(nn.Linear(state_size, fc_units[0]),\n nn.ReLU())\n self.fc2 = []\n for i in range(1,len(fc_units)):\n if i==1:\n self.fc2.append(nn.Linear(fc_units[i-1]+action_size, fc_units[i]))\n else:\n self.fc2.append(nn.Linear(fc_units[i-1], fc_units[i]))\n self.fc2.append(nn.ReLU())\n self.fc2.append(nn.Linear(fc_units[-1], 1))\n self.fc2 = nn.Sequential(*self.fc2)\n #self.reset_parameters()","def actor_critic_continuous(num_inputs, num_hidden, bound):\n # Input\n inputs = Input(shape=(num_inputs,), name='input_layer')\n # Shared layer\n common = Dense(units=num_hidden, activation='relu',\n kernel_initializer='he_uniform', name='common_layer_1')(inputs)\n # common = Dense(units=num_hidden, activation='relu', name='common_layer_2')(common)\n # Actor\n init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)\n action = Dense(units=1, activation='tanh',\n kernel_initializer=init, name='actor_output_layer')(common)\n action = action * bound\n # Critic\n critic = Dense(units=1, activation='linear',\n kernel_initializer='glorot_uniform', name='critic_output_layer')(common)\n # Combine\n model = Model(inputs=inputs, outputs=[action, critic])\n return model","def train(self):\n self.emission_model(self.train_data)\n self.transition_model(self.train_data)","def act(self, observation):\r\n \r\n \r\n self.iteration_episode=self.iteration_episode+1\r\n \r\n if self.iteration_episode>1:\r\n self.learn(observation)\r\n\r\n self.current_state = torch.FloatTensor(self.featurize_state(observation)).to(self.device)\r\n self.distribution = self.Actor.forward(self.current_state )\r\n self.value = self.Critic.forward(self.current_state )\r\n\r\n \r\n \r\n \r\n self.action = self.torch.clamp(self.distribution.sample(),-10,10)\r\n \r\n \r\n if np.random.randint(0,10000)/10000<self.epsilon:\r\n self.action= np.array(np.random.randint(-10000,10000)/1000)\r\n self.action=self.torch.tensor(self.action)\r\n\r\n self.log_prob = self.distribution.log_prob(self.action).unsqueeze(0)\r\n self.entropy += self.distribution.entropy().mean()\r\n\r\n \r\n \r\n return float(self.action.item())","def check_criterion(self) -> None:\n # get criterion class lists\n criterion_names = get_class_names_in_files(\n \"src\" + os.path.sep + \"criterions.py\"\n )\n criterion_names.remove(\"Criterion\")\n\n # Check config criterion exists\n assert self.config[\"CRITERION\"] in criterion_names\n\n # Run criterion config check\n params: Dict[str, Any] = self.config[\"CRITERION_PARAMS\"]\n\n ce_params = None\n if self.config[\"CRITERION\"] == \"HintonKLD\":\n assert \"T\" in params\n assert params[\"T\"] > 0.0\n assert isinstance(params[\"T\"], float)\n\n assert \"alpha\" in params\n assert 0.0 <= params[\"alpha\"] <= 1.0\n assert isinstance(params[\"alpha\"], float)\n\n # check additional params(teacher) exist\n assert \"teacher_model_name\" in params\n assert isinstance(\"teacher_model_name\", str)\n assert \"teacher_model_params\" in params\n\n # if HintonLoss contains crossentropy\n assert \"crossentropy_params\" in params\n ce_params = params[\"crossentropy_params\"]\n\n elif self.config[\"CRITERION\"] == \"CrossEntropy\":\n ce_params = self.config[\"CRITERION_PARAMS\"]\n\n if ce_params:\n # assert \"num_classes\" in ce_params\n # assert ce_params[\"num_classes\"] > 0\n # assert isinstance(ce_params[\"num_classes\"], int)\n\n assert \"num_classes\" in ce_params\n assert ce_params[\"num_classes\"] > 0\n assert isinstance(ce_params[\"num_classes\"], int)\n\n if \"label_smoothing\" not in ce_params:\n ce_params[\"label_smoothing\"] = 0.0\n else:\n assert 0.0 <= ce_params[\"label_smoothing\"] < 1.0\n assert type(ce_params[\"label_smoothing\"]) is float","def trainModels():\n\n # load actives from ChEMBL\n actives = {}\n if not os.path.exists(DATA_FOLDER_PATH):\n os.mkdir(DATA_FOLDER_PATH)\n actives_file = [x for x in os.listdir(DATA_FOLDER_PATH) if x.startswith('actives_chembl') and x.endswith('.p')]\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\n actives = chembl.loadChEMBLData(ACCESSION, IC_50_THRESHOLD, DATA_FOLDER_PATH)\n else:\n actives = pickle.load(open(DATA_FOLDER_PATH + actives_file[0], 'rb'))\n\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\n chembl.computeConsensualIC50(actives, DATA_FOLDER_PATH)\n chembl.appendRDKitMols(actives, DATA_FOLDER_PATH)\n\n # load decoys downloaded from DUD\n decoys = {}\n if os.path.exists(DECOYS_SDF_FILE_PATH[:-4] + \".p\"):\n decoys = pickle.load(open(DECOYS_SDF_FILE_PATH[:-4] + \".p\", 'rb'))\n else:\n if os.path.exists(DECOYS_SDF_FILE_PATH):\n decoys = dud.getDecoys(DECOYS_SDF_FILE_PATH)\n else:\n print \"Decoys not found in: \" + DECOYS_SDF_FILE_PATH\n print \"Make sure you set the right path.\"\n exit()\n\n # merge both data sets\n compounds_all = {}\n compounds_all.update(actives)\n compounds_all.update(decoys)\n\n # compute Morgan fingerprints\n if os.path.exists(MERGED_DATASET_PATH) and not RELOAD_DATA:\n print \"Loading previously created dataset...\"\n compounds_all = pickle.load(open(MERGED_DATASET_PATH, 'rb'))\n else:\n fingerprinter.appendMorganFingerprints(compounds_all)\n\n actives = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if compounds_all[cmpndid]['active']}\n pickle.dump(actives, open(ACTIVES_DUMP, 'wb'))\n decoys = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if not compounds_all[cmpndid]['active']}\n\n # train and cross-validate multiple Naive Bayes Classifiers\n classification_results = dict()\n if not os.path.exists(CLASS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\n classification_results = classification.naiveBayesClassifierTraining(compounds_all)\n print \"Saving results...\"\n pickle.dump(classification_results, open(CLASS_RESULTS_SAVE_FILE_PATH, 'wb'))\n print \"Finished analysis.\"\n else:\n print \"Loading previous results...\"\n classification_results = pickle.load(open(CLASS_RESULTS_SAVE_FILE_PATH, 'rb'))\n\n # have fun with the classification results\n print \"# CLASSIFICATION STATISTICS #\"\n classification.playWithResults(classification_results)\n\n # cluster actives according to their similarity and keep only the diverse molecules\n actives_testset = dict()\n if CLUSTER:\n clusters = utilities.clusterMols(actives)\n actives_kept = dict()\n for cluster in clusters:\n actives_kept[cluster[0]] = actives[cluster[0]]\n remains = cluster[1:]\n actives_filtered_out = {chmblid : actives[chmblid] for chmblid in remains}\n actives_testset.update(actives_filtered_out)\n actives = actives_kept\n\n # estimate maximum distances between active molecules to set threshold for the application domain\n # distance_actives = regression.estimateDistanceThreshold(actives) # median of distances between two actives\n # min_distance_decoys, max_distance_decoys = regression.compareDistances(actives, decoys) # average min/max distance of closest/farthest decoy from any of the actives\n # print \"median of distances between two actives: \" + str(distance_actives)\n # print \"average min/max distance of closest/farthest decoy from any of the actives: \" + str(min_distance_decoys) + \"/\" + str(max_distance_decoys)\n\n # Support vector regression\n regression_results = dict()\n if not os.path.exists(REGRESS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\n regression_results = regression.supportVectorRegression(actives)\n pickle.dump(regression_results, open(REGRESS_RESULTS_SAVE_FILE_PATH, 'wb'))\n else:\n regression_results = pickle.load(open(REGRESS_RESULTS_SAVE_FILE_PATH, 'rb'))\n\n\n # do something with the regression results\n print \"# REGRESSION STATISTICS #\"\n regression.playWithResults(regression_results, decoys, actives_testset)\n\n return classification_results['final_model'], regression_results['final_model']","def test_crowdsource():\n alice = CrowdsourceClient(\n \"Alice\", alice_data, alice_targets, XORModel, F.mse_loss, 0, deploy=True)\n bob = CrowdsourceClient(\n \"Bob\", bob_data, bob_targets, XORModel, F.mse_loss, 1,\n contract_address=alice.contract_address)\n charlie = CrowdsourceClient(\n \"Charlie\", charlie_data, charlie_targets, XORModel, F.mse_loss, 2,\n contract_address=alice.contract_address)\n david = CrowdsourceClient(\n \"David\", david_data, david_targets, XORModel, F.mse_loss, 3,\n contract_address=alice.contract_address)\n eve = CrowdsourceClient(\"Eve\", eve_data, eve_targets,\n XORModel, F.mse_loss, 4,\n contract_address=alice.contract_address)\n\n # alice is evaluator\n # others are trainers\n trainers = [bob, charlie, david, eve]\n\n alice.set_genesis_model(\n round_duration=ROUND_DURATION,\n max_num_updates=len(trainers)\n )\n\n # Training\n threads = [\n threading.Thread(\n target=trainer.train_until,\n kwargs=TRAINING_HYPERPARAMS,\n daemon=True\n ) for trainer in trainers\n ]\n\n # Evaluation\n threads.append(\n threading.Thread(\n target=alice.evaluate_until,\n args=(TRAINING_ITERATIONS, EVAL_METHOD),\n daemon=True\n )\n )\n\n # Run all threads in parallel\n for t in threads:\n t.start()\n for t in threads:\n t.join()\n\n print_token_count(bob)\n print_token_count(charlie)\n print_token_count(david)\n print_token_count(eve)\n\n assert bob.get_token_count() > david.get_token_count(\n ), \"Bob ended up with fewer tokens than David\"\n assert bob.get_token_count() > eve.get_token_count(\n ), \"Bob ended up with fewer tokens than Eve\"\n assert charlie.get_token_count() > david.get_token_count(\n ), \"Charlie ended up with fewer tokens than David\"\n assert charlie.get_token_count() > eve.get_token_count(\n ), \"Charlie ended up with fewer tokens than Eve\"\n\n alice_global_model = alice.get_current_global_model()\n bob_global_model = bob.get_current_global_model()\n\n assert same_weights(\n alice_global_model,\n bob_global_model\n ), \"Alice and Bob ran the same aggregation but got different model weights\"\n\n assert str(alice_global_model.state_dict()) == \\\n str(bob_global_model.state_dict()), \\\n \"Alice and Bob ran the same aggregation but got different model dicts\"","def before_train(self, logs=None):\n self.config = self.trainer.config\n self.unrolled = self.trainer.config.unrolled\n self.device = self.trainer.config.device\n self.model = self.trainer.model\n self.optimizer = self.trainer.optimizer\n self.lr_scheduler = self.trainer.lr_scheduler\n self.loss = self.trainer.loss\n self.search_alg = SearchAlgorithm(SearchSpace())\n self._set_algorithm_model(self.model)\n self.trainer.train_loader = self.trainer._init_dataloader(mode='train')\n self.trainer.valid_loader = self.trainer._init_dataloader(mode='val')\n normal_selected_idxs = torch.tensor(len(self.model.alphas_normal) * [-1],\n requires_grad=False, dtype=torch.int).cuda()\n reduce_selected_idxs = torch.tensor(len(self.model.alphas_reduce) * [-1],\n requires_grad=False, dtype=torch.int).cuda()\n normal_candidate_flags = torch.tensor(len(self.model.alphas_normal) * [True],\n requires_grad=False, dtype=torch.bool).cuda()\n reduce_candidate_flags = torch.tensor(len(self.model.alphas_reduce) * [True],\n requires_grad=False, dtype=torch.bool).cuda()\n logging.info('normal_selected_idxs: {}'.format(normal_selected_idxs))\n logging.info('reduce_selected_idxs: {}'.format(reduce_selected_idxs))\n logging.info('normal_candidate_flags: {}'.format(normal_candidate_flags))\n logging.info('reduce_candidate_flags: {}'.format(reduce_candidate_flags))\n self.model.normal_selected_idxs = normal_selected_idxs\n self.model.reduce_selected_idxs = reduce_selected_idxs\n self.model.normal_candidate_flags = normal_candidate_flags\n self.model.reduce_candidate_flags = reduce_candidate_flags\n logging.info(F.softmax(torch.stack(self.model.alphas_normal, dim=0), dim=-1).detach())\n logging.info(F.softmax(torch.stack(self.model.alphas_reduce, dim=0), dim=-1).detach())\n self.normal_probs_history = []\n self.reduce_probs_history = []","def train(self, item, gamma=1.0):\n [step, state, next_state, reward, done] = item\n\n # must save state for entropy computation\n self.state = state\n\n discount_factor = gamma**step\n\n # reinforce-baseline: delta = return - value\n delta = reward - self.value(state)[0] \n\n # apply the discount factor as shown in Algorithms\n # 10.2.1, 10.3.1 and 10.4.1\n discounted_delta = delta * discount_factor\n discounted_delta = np.reshape(discounted_delta, [-1, 1])\n verbose = 1 if done else 0\n\n # train the logp model (implies training of actor model\n # as well) since they share exactly the same set of\n # parameters\n self.logp_model.fit(np.array(state),\n discounted_delta,\n batch_size=1,\n epochs=1,\n verbose=verbose)\n\n # train the value network (critic)\n self.value_model.fit(np.array(state),\n discounted_delta,\n batch_size=1,\n epochs=1,\n verbose=verbose)","def onTrainStepTaken(self, agent):\n pass","def train(log_dir):\n\n # Create train and test environments\n print(\n colorize(\n f\"INFO: You are training in the {ENV_NAME} environment.\",\n \"cyan\",\n bold=True,\n )\n )\n env = get_env_from_name(ENV_NAME, ENV_SEED)\n test_env = get_env_from_name(ENV_NAME, ENV_SEED)\n\n # Set initial learning rates\n lr_a, lr_l, lr_c = (\n ALG_PARAMS[\"lr_a\"],\n ALG_PARAMS[\"lr_l\"],\n ALG_PARAMS[\"lr_c\"],\n )\n lr_a_now = ALG_PARAMS[\"lr_a\"] # learning rate for actor, lambda and alpha\n lr_l_now = ALG_PARAMS[\"lr_l\"] # learning rate for Lyapunov critic\n lr_c_now = ALG_PARAMS[\"lr_c\"] # learning rate for q critic\n\n # Get observation and action space dimension and limits from the environment\n s_dim = env.observation_space.shape[0]\n a_dim = env.action_space.shape[0]\n a_lowerbound = env.action_space.low\n a_upperbound = env.action_space.high\n\n # Create the Agent\n policy = LAC(a_dim, s_dim, act_limits={\"low\": a_lowerbound, \"high\": a_upperbound})\n\n # Load model if retraining is selected\n if TRAIN_PARAMS[\"continue_training\"]:\n\n # Create retrain model path\n retrain_model_folder = TRAIN_PARAMS[\"continue_model_folder\"]\n retrain_model_path = osp.abspath(\n osp.join(log_dir, \"../..\", TRAIN_PARAMS[\"continue_model_folder\"])\n )\n\n # Check if retrain model exists if not throw error\n if not osp.exists(retrain_model_path):\n print(\n colorize(\n (\n \"ERROR: Shutting down training since the model you specified \"\n f\"in the `continue_model_folder` `{retrain_model_folder}` \"\n f\"argument was not found for the `{ENV_NAME}` environment.\"\n ),\n \"red\",\n bold=True,\n )\n )\n sys.exit(0)\n\n # Load old model\n print(\n colorize(\n f\"INFO: Restoring model `{retrain_model_path}`.\", \"cyan\", bold=True\n )\n )\n result = policy.restore(\n osp.abspath(osp.join(retrain_model_path, \"policy\")),\n restore_lagrance_multipliers=(not ALG_PARAMS[\"reset_lagrance_multipliers\"]),\n )\n if not result:\n print(\n colorize(\n \"ERROR: Shuting down training as something went wrong while \"\n \"loading \"\n f\"model `{retrain_model_folder}`.\",\n \"red\",\n bold=True,\n )\n )\n sys.exit(0)\n\n # Create new storage folder\n log_dir_split = log_dir.split(\"/\")\n log_dir_split[-2] = (\n \"_\".join(TRAIN_PARAMS[\"continue_model_folder\"].split(\"/\")) + \"_finetune\"\n )\n log_dir = \"/\".join(log_dir_split)\n else:\n print(colorize(f\"INFO: Train new model `{log_dir}`\", \"cyan\", bold=True))\n\n # Print logging folder path\n print(colorize(f\"INFO: Logging results to `{log_dir}`.\", \"cyan\", bold=True))\n\n # Create replay memory buffer\n pool = Pool(\n s_dim=s_dim,\n a_dim=a_dim,\n store_last_n_paths=TRAIN_PARAMS[\"num_of_training_paths\"],\n memory_capacity=ALG_PARAMS[\"memory_capacity\"],\n min_memory_size=ALG_PARAMS[\"min_memory_size\"],\n )\n\n # Setup logger and log hyperparameters\n logger.configure(dir=log_dir, format_strs=[\"csv\"])\n logger.logkv(\"tau\", ALG_PARAMS[\"tau\"])\n logger.logkv(\"alpha3\", ALG_PARAMS[\"alpha3\"])\n logger.logkv(\"batch_size\", ALG_PARAMS[\"batch_size\"])\n logger.logkv(\"target_entropy\", policy.target_entropy)\n\n ####################################################\n # Training loop ####################################\n ####################################################\n\n # Setup training loop parameters\n t1 = time.time()\n global_step = 0\n global_episodes = 0\n last_training_paths = deque(maxlen=TRAIN_PARAMS[\"num_of_training_paths\"])\n training_started = False\n\n # Train the agent in the environment until max_episodes has been reached\n print(colorize(\"INFO: Training...\\n\", \"cyan\", bold=True))\n while 1: # Keep running episodes until global step has been reached\n\n # Create variable to store information about the current path\n if policy.use_lyapunov:\n current_path = {\n \"rewards\": [],\n \"lyapunov_error\": [],\n \"alpha\": [],\n \"lambda\": [],\n \"entropy\": [],\n \"a_loss\": [],\n \"alpha_loss\": [],\n \"lambda_loss\": [],\n }\n else:\n current_path = {\n \"rewards\": [],\n \"critic_error\": [],\n \"alpha\": [],\n \"entropy\": [],\n \"a_loss\": [],\n \"alpha_loss\": [],\n }\n\n # Reset environment\n s = env.reset()\n\n # Training Episode loop\n for jj in range(ENVS_PARAMS[ENV_NAME][\"max_ep_steps\"]):\n\n # Break out of loop if global steps have been reached\n if global_step >= TRAIN_PARAMS[\"max_global_steps\"]:\n\n # Print step count, save model and stop the program\n print(\n colorize(\n f\"\\nINFO: Training stopped after {global_step} steps.\",\n \"cyan\",\n bold=True,\n )\n )\n print(\n colorize(\n \"INFO: Running time: {}\".format(time.time() - t1),\n \"cyan\",\n bold=True,\n )\n )\n print(colorize(\"INFO: Saving Model\", \"cyan\", bold=True))\n policy.save_result(log_dir)\n return\n\n # Save intermediate checkpoints if requested\n if TRAIN_PARAMS[\"save_checkpoints\"]:\n if (\n global_step % TRAIN_PARAMS[\"checkpoint_save_freq\"] == 0\n and global_step != 0\n ):\n\n # Create intermediate result checkpoint folder\n checkpoint_save_path = osp.abspath(\n osp.join(log_dir, \"checkpoints\", \"step_\" + str(jj))\n )\n os.makedirs(checkpoint_save_path, exist_ok=True)\n\n # Save intermediate checkpoint\n policy.save_result(checkpoint_save_path)\n\n # Render environment if requested\n if ENVS_PARAMS[ENV_NAME][\"eval_render\"]:\n env.render()\n\n # Retrieve (scaled) action based on the current policy\n # NOTE (rickstaa): The scaling operation is already performed inside the\n # policy based on the `act_limits` you supplied.\n a = policy.choose_action(s)\n\n # Perform action in env\n s_, r, done, _ = env.step(a)\n\n # Increment global step count\n if training_started:\n global_step += 1\n\n # Stop episode if max_steps has been reached\n if jj == ENVS_PARAMS[ENV_NAME][\"max_ep_steps\"] - 1:\n done = True\n terminal = 1.0 if done else 0.0\n\n # Store experience in replay buffer\n pool.store(s, a, r, terminal, s_)\n\n # Optimize network weights and lagrance multipliers\n if (\n pool.memory_pointer > ALG_PARAMS[\"min_memory_size\"]\n and global_step % ALG_PARAMS[\"steps_per_cycle\"] == 0\n ):\n training_started = True\n\n # Perform STG a set number of times (train per cycle)\n for _ in range(ALG_PARAMS[\"train_per_cycle\"]):\n batch = pool.sample(ALG_PARAMS[\"batch_size\"])\n if policy.use_lyapunov:\n (\n labda,\n alpha,\n l_loss,\n entropy,\n a_loss,\n alpha_loss,\n labda_loss,\n ) = policy.learn(lr_a_now, lr_l_now, lr_a, lr_c_now, batch)\n else:\n alpha, loss_q, entropy, a_loss, alpha_loss = policy.learn(\n lr_a_now, lr_l_now, lr_a, lr_c_now, batch\n )\n\n # Store current path results\n if training_started:\n if policy.use_lyapunov:\n current_path[\"rewards\"].append(r)\n current_path[\"lyapunov_error\"].append(l_loss)\n current_path[\"alpha\"].append(alpha)\n current_path[\"lambda\"].append(labda)\n current_path[\"entropy\"].append(entropy)\n current_path[\"a_loss\"].append(a_loss)\n current_path[\"alpha_loss\"].append(alpha_loss)\n current_path[\"lambda_loss\"].append(labda_loss)\n else:\n current_path[\"rewards\"].append(r)\n current_path[\"critic_error\"].append(loss_q.numpy())\n current_path[\"alpha\"].append(alpha.numpy())\n current_path[\"entropy\"].append(entropy.numpy())\n current_path[\"a_loss\"].append(\n a_loss.numpy()\n ) # Improve: Check if this is the fastest way\n current_path[\"alpha_loss\"].append(alpha_loss)\n\n # Evalute the current policy performance and log the results\n if (\n training_started\n and global_step % TRAIN_PARAMS[\"evaluation_frequency\"] == 0\n and global_step > 0\n ):\n logger.logkv(\"total_timesteps\", global_step)\n training_diagnostics = evaluate_training_rollouts(last_training_paths)\n if training_diagnostics is not None:\n if TRAIN_PARAMS[\"num_of_evaluation_paths\"] > 0:\n eval_diagnostics = training_evaluation(test_env, policy)\n [\n logger.logkv(key, eval_diagnostics[key])\n for key in eval_diagnostics.keys()\n ]\n training_diagnostics.pop(\"return\")\n [\n logger.logkv(key, training_diagnostics[key])\n for key in training_diagnostics.keys()\n ]\n logger.logkv(\"lr_a\", lr_a_now)\n if policy.use_lyapunov:\n logger.logkv(\"lr_l\", lr_l_now)\n else:\n logger.logkv(\"lr_c\", lr_c_now)\n string_to_print = [\"time_step:\", str(global_step), \"|\"]\n if TRAIN_PARAMS[\"num_of_evaluation_paths\"] > 0:\n [\n string_to_print.extend(\n [key, \":\", str(eval_diagnostics[key]), \"|\"]\n )\n for key in eval_diagnostics.keys()\n ]\n [\n string_to_print.extend(\n [key, \":\", str(round(training_diagnostics[key], 2)), \"|\"]\n )\n for key in training_diagnostics.keys()\n ]\n prefix = (\n colorize(\"LAC|\", \"green\")\n if ALG_PARAMS[\"use_lyapunov\"]\n else colorize(\"SAC|\", \"yellow\")\n )\n print(\n colorize(prefix, \"yellow\", bold=True) + \"\".join(string_to_print)\n )\n logger.dumpkvs()\n\n # Update state\n s = s_\n\n # Check if episode is done (continue to next episode)\n if done:\n\n # Store paths\n if training_started:\n last_training_paths.appendleft(current_path)\n\n # Decay learning rates\n frac = 1.0 - (global_step - 1.0) / TRAIN_PARAMS[\"max_global_steps\"]\n lr_a_now = lr_a * frac # learning rate for actor, lambda, alpha\n lr_l_now = lr_l * frac # learning rate for Lyapunov critic\n lr_c_now = lr_c * frac # learning rate for q critic\n break # Continue to next episode\n\n # Increase episode counter\n global_episodes += 1","def train(self):\n self.training = True","def pre_train_person(self, dataset, **kwargs):\n \n pass","def train(self):\n raise NotImplementedError","def act(self, state, training):\n\n action = self.actor_local(state)\n if training:\n action += self.noise.sample()\n else:\n action = self.actor_target(state)\n\n return action","def before_update(self, actor_critic, algo, *args):\n raise NotImplementedError","def setup_training(self):\n print('setup training called')\n self.steps_done = 0\n self.current_episode_num = 1\n self.total_reward = 0\n\n # self.optimizer = optim.RMSprop(policy_net.parameters())\n self.memory = ReplayMemory(300000)\n self.total_reward_history = []\n # self.loss_history = []\n self.positions = []\n self.n_destroyed_crates = 0\n self.is_in_bomb_range = False","def _train_step(self):\n if self._replay.add_count > self.min_replay_history:\n if self.training_steps % self.update_period == 0:\n self._sample_from_replay_buffer()\n (self._rng, self.optimizer_state, self.online_params,\n loss, quantile_loss, coherence_loss, orthogonality_loss) = train(\n self.network_def,\n self.online_params,\n self.target_network_params,\n self.optimizer,\n self.optimizer_state,\n self.replay_elements['state'],\n self.replay_elements['action'],\n self.replay_elements['next_state'],\n self.replay_elements['reward'],\n self.replay_elements['terminal'],\n self.num_tau_samples,\n self.num_tau_prime_samples,\n self.num_quantile_samples,\n self.cumulative_gamma,\n self.double_dqn,\n self.kappa,\n self._rng,\n self._coherence_weight,\n self._option,\n self._use_ortho_loss,\n self._use_cohe_loss,\n self._tau,\n self._alpha,\n self._clip_value_min)\n if (self.summary_writer is not None and\n self.training_steps > 0 and\n self.training_steps % self.summary_writing_frequency == 0):\n if self._use_ortho_loss and self._use_cohe_loss:\n summary = tf.compat.v1.Summary(value=[\n tf.compat.v1.Summary.Value(\n tag='Losses/Combined', simple_value=loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Quantile', simple_value=quantile_loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Incoherence', simple_value=coherence_loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Orthogonality',\n simple_value=orthogonality_loss),\n ])\n elif self._use_ortho_loss and not self._use_cohe_loss:\n summary = tf.compat.v1.Summary(value=[\n tf.compat.v1.Summary.Value(\n tag='Losses/Combined', simple_value=loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Quantile', simple_value=quantile_loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Orthogonality', simple_value=orthogonality_loss),\n ])\n elif self._use_cohe_loss and not self._use_ortho_loss:\n summary = tf.compat.v1.Summary(value=[\n tf.compat.v1.Summary.Value(\n tag='Losses/Combined', simple_value=loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Quantile', simple_value=quantile_loss),\n tf.compat.v1.Summary.Value(\n tag='Losses/Incoherence', simple_value=coherence_loss),\n ])\n self.summary_writer.add_summary(summary, self.training_steps)\n if self.training_steps % self.target_update_period == 0:\n self._sync_weights()\n\n self.training_steps += 1","def train_crf(threads=3, hyperparameter_crf='1.5', cut_off='5', alg='CRF-L2'):\n\n print '\\n\\ttrain crf'\n os.system('crf_learn -p ' + threads +\n ' -c ' + hyperparameter_crf +\n ' -f ' + cut_off +\n ' -a ' + alg +\n ' ' + template_file + ' ' + train_file_crf + ' ' + model_file)\n print '\\t--done\\n'","def test(self, test_iter, step, corpus_type, id):\n\n self.model.eval()\n stats = Statistics()\n if not os.path.exists(self.args.result_path):\n os.makedirs(self.args.result_path)\n if not os.path.exists(self.args.story_path):\n os.makedirs(self.args.story_path)\n can_path = self.args.result_path + corpus_type + '.' + id + '_step%d.candidate' % step\n gold_path = self.args.result_path + corpus_type + '.' + id + '_step%d.gold' % step\n story_path = self.args.story_path + corpus_type + '.' + id + '.story'\n with open(story_path, 'w') as save_story:\n with open(can_path, 'w') as save_pred:\n with open(gold_path, 'w') as save_gold:\n with torch.no_grad():\n for batch in test_iter:\n src = batch.src\n labels = batch.labels\n segs = batch.segs\n clss = batch.clss\n mask = batch.mask\n mask_cls = batch.mask_cls\n weight = batch.weight\n index = batch.index\n\n pred = []\n\n sents_vec, sent_scores, mask, cluster_weight = self.model(src, segs, clss, mask, mask_cls)\n loss = self.loss(sent_scores, labels.float())\n weight_loss = self.weight_loss(cluster_weight, weight)\n loss = (loss * mask.float()).sum()\n total_loss = loss + weight_loss * 10\n batch_stats = Statistics(float(total_loss.cpu().data.numpy()), len(labels))\n stats.update(batch_stats)\n\n sent_scores = sent_scores + mask.float()\n sent_scores = sent_scores.cpu().data.numpy()\n cluster_weight = cluster_weight.cpu().data.numpy()\n selected_ids = np.argsort(-sent_scores, 1)\n cluster_weight = np.argsort(cluster_weight)\n # print(selected_ids)\n # selected_ids = np.sort(selected_ids,1)\n cluster_num = len(cluster_weight)\n for i, idx in enumerate(selected_ids):\n rank = np.where(cluster_weight == i)[0][0]\n\n if rank <= max(cluster_num // 6, 6):\n for j in range(5):\n sen_ind = selected_ids[i][j]\n _pred = batch.src_str[i][sen_ind].strip()\n pred.append((index[i][sen_ind], _pred))\n elif rank <= max(cluster_num // 3, 10):\n for j in range(3):\n sen_ind = selected_ids[i][j]\n _pred = batch.src_str[i][sen_ind].strip()\n pred.append((index[i][sen_ind], _pred))\n elif rank <= max(cluster_num * 2 // 3, 15):\n for j in range(2):\n sen_ind = selected_ids[i][j]\n _pred = batch.src_str[i][sen_ind].strip()\n pred.append((index[i][sen_ind], _pred))\n else:\n sen_ind = selected_ids[i][0]\n _pred = batch.src_str[i][sen_ind].strip()\n pred.append((index[i][sen_ind], _pred))\n\n gold_summary = (batch.tgt_str[0].strip())\n pred.sort(key=lambda x: x[0])\n for i in range(len(pred)):\n save_story.write(pred[i][1].strip() + '\\n')\n if i == 0:\n save_pred.write(pred[i][1].strip())\n else:\n save_pred.write('<q> ' + pred[i][1].strip())\n save_gold.write(gold_summary)\n for sent in gold_summary.split('<q>'):\n save_story.write('@highlight {}\\n'.format(sent))\n if self.args.test_txt:\n return stats\n else:\n rouges = calculate_rouge(can_path, gold_path)\n logger.info('Rouges at step %d \\n%s' % (step, rouge_results_to_str(rouges)))\n self._report_step(0, step, valid_stats=stats)\n return stats, rouges","def train(self, data, session=None, **kwargs):\n summary_writer = kwargs['summary_writer']\n logging.info('Training classifier...')\n\n if not self.is_initialized:\n self.is_initialized = True\n else:\n if self.weight_decay_update is not None:\n session.run(self.weight_decay_update)\n logging.info('New weight decay value: %f',\n session.run(self.weight_decay_var))\n # Reset the optimizer state (e.g., momentum).\n session.run(self.reset_optimizer)\n\n if not self.warm_start:\n # Re-initialize variables.\n initializers = [v.initializer for v in self.variables.values()]\n initializers.append(self.global_step.initializer)\n session.run(initializers)\n\n # Construct data iterator.\n logging.info('Training classifier with %d samples...', data.num_train())\n train_indices = data.get_indices_train()\n unlabeled_indices = data.get_indices_unlabeled()\n val_indices = data.get_indices_val()\n test_indices = data.get_indices_test()\n # Create an iterator for labeled samples for the supervised term.\n data_iterator_train = batch_iterator(\n train_indices,\n batch_size=self.batch_size,\n shuffle=True,\n allow_smaller_batch=False,\n repeat=True)\n # Create an iterator for unlabeled samples for the VAT loss term.\n data_iterator_unlabeled = batch_iterator(\n unlabeled_indices,\n batch_size=self.batch_size,\n shuffle=True,\n allow_smaller_batch=False,\n repeat=True)\n # Create iterators for ll, lu, uu pairs of samples for the agreement term.\n if self.use_graph:\n pair_ll_iterator = self.edge_iterator(\n data, batch_size=self.num_pairs_reg, labeling='ll')\n pair_lu_iterator = self.edge_iterator(\n data, batch_size=self.num_pairs_reg, labeling='lu')\n pair_uu_iterator = self.edge_iterator(\n data, batch_size=self.num_pairs_reg, labeling='uu')\n else:\n pair_ll_iterator = self.pair_iterator(train_indices, train_indices,\n self.num_pairs_reg, data)\n pair_lu_iterator = self.pair_iterator(train_indices, unlabeled_indices,\n self.num_pairs_reg, data)\n pair_uu_iterator = self.pair_iterator(unlabeled_indices,\n unlabeled_indices,\n self.num_pairs_reg, data)\n\n step = 0\n iter_below_tol = 0\n min_num_iter = self.min_num_iter\n has_converged = step >= self.max_num_iter\n prev_loss_val = np.inf\n best_test_acc = -1\n best_val_acc = -1\n checkpoint_saved = False\n while not has_converged:\n feed_dict = self._construct_feed_dict(\n data_iterator=data_iterator_train,\n split='train',\n pair_ll_iterator=pair_ll_iterator,\n pair_lu_iterator=pair_lu_iterator,\n pair_uu_iterator=pair_uu_iterator,\n data_iterator_unlabeled=data_iterator_unlabeled)\n if self.enable_summaries and step % self.summary_step == 0:\n loss_val, summary, iter_cls_total, _ = session.run(\n [self.loss_op, self.summary_op, self.iter_cls_total, self.train_op],\n feed_dict=feed_dict)\n summary_writer.add_summary(summary, iter_cls_total)\n summary_writer.flush()\n else:\n loss_val, _ = session.run((self.loss_op, self.train_op),\n feed_dict=feed_dict)\n\n # Log the loss, if necessary.\n if step % self.logging_step == 0:\n logging.info('Classification step %6d | Loss: %10.4f', step, loss_val)\n\n # Evaluate, if necessary.\n if step % self.eval_step == 0:\n val_acc = self._evaluate(val_indices, 'val', session, summary_writer)\n test_acc = self._evaluate(test_indices, 'test', session, summary_writer)\n\n if step % self.logging_step == 0 or val_acc > best_val_acc:\n logging.info(\n 'Classification step %6d | Loss: %10.4f | val_acc: %10.4f | '\n 'test_acc: %10.4f', step, loss_val, val_acc, test_acc)\n if val_acc > best_val_acc:\n best_val_acc = val_acc\n best_test_acc = test_acc\n if self.checkpoint_path:\n self.saver.save(\n session, self.checkpoint_path, write_meta_graph=False)\n checkpoint_saved = True\n # Go for at least num_iter_after_best_val more iterations.\n min_num_iter = max(self.min_num_iter,\n step + self.num_iter_after_best_val)\n logging.info(\n 'Achieved best validation. '\n 'Extending to at least %d iterations...', min_num_iter)\n\n step += 1\n has_converged, iter_below_tol = self.check_convergence(\n prev_loss_val,\n loss_val,\n step,\n self.max_num_iter,\n iter_below_tol,\n min_num_iter=min_num_iter)\n session.run(self.iter_cls_total_update)\n prev_loss_val = loss_val\n\n # Return to the best model.\n if checkpoint_saved:\n logging.info('Restoring best model...')\n self.saver.restore(session, self.checkpoint_path)\n\n return best_test_acc, best_val_acc","def __init__(\n self,\n actor_state_size: int,\n actor_action_size: int,\n critic_state_size: int,\n critic_action_size: int,\n actor_hidden_layer_dimensions: Tuple[int] = (256, 128),\n critic_hidden_layer_dimensions: Tuple[int] = (256, 128),\n lr_actor: float = 1e-3,\n lr_critic: float = 1e-3,\n seed: Optional[int] = None,\n ):\n self.actor_state_size = actor_state_size\n self.actor_action_size = actor_action_size\n self.critic_state_size = critic_state_size\n self.critic_action_size = critic_action_size\n self.lr_actor = lr_actor\n self.lr_critic = lr_critic\n\n self.seed = seed\n if self.seed is not None:\n np.random.seed(self.seed)\n\n self.device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n\n self.critic_local = FullyConnectedQNetwork(\n input_dim=self.critic_state_size,\n output_dim=self.critic_action_size,\n hidden_dims=critic_hidden_layer_dimensions,\n seed=self.seed,\n ).to(self.device)\n self.critic_target = FullyConnectedQNetwork(\n input_dim=self.critic_state_size,\n output_dim=self.critic_action_size,\n hidden_dims=critic_hidden_layer_dimensions,\n seed=self.seed,\n ).to(self.device)\n\n self.actor_local = DeterministicPolicyNetwork(\n input_dim=self.actor_state_size,\n output_dim=self.actor_action_size,\n hidden_dims=actor_hidden_layer_dimensions,\n seed=self.seed,\n ).to(self.device)\n self.actor_target = DeterministicPolicyNetwork(\n input_dim=self.actor_state_size,\n output_dim=self.actor_action_size,\n hidden_dims=actor_hidden_layer_dimensions,\n seed=self.seed,\n ).to(self.device)\n\n self.value_optimizer = optim.Adam(\n self.critic_local.parameters(), lr=self.lr_critic\n )\n self.policy_optimizer = optim.Adam(\n self.actor_local.parameters(), lr=self.lr_actor\n )\n\n self.loss_fn = SmoothL1Loss()","def run_custom_training_tests():\n test_custom_training()\n test_custom_distributed_training()\n test_custom_multimodel_training()\n test_custom_distributed_multimodel_training()","def train(self, training_steps=10):","def train(self, item, cat):\n features = self.get_features(item)\n # Increment the count for every feature with this category\n for f in features:\n self.inc_feature_count(f, cat)\n # Increment the count for this category\n self.inc_category_count(cat)"],"string":"[\n \"def train_actor_and_critic(self):\\n\\n # if not enough transitions in memory, don't train!\\n if len(self.memory) < self.batch_size:\\n return\\n\\n transitions = self.memory.sample() # sample a batch from memory\\n\\n # Convert experience tuples to separate arrays for each element\\n # (states, actions, rewards, etc.)\\n states = np.vstack([e.state for e in transitions if e is not None])\\n actions = np.array([\\n e.action for e in transitions if e is not None]).astype(\\n np.float32).reshape(-1, self.action_size)\\n rewards = np.array([\\n e.reward for e in transitions if e is not None]).astype(\\n np.float32).reshape(-1, 1)\\n dones = np.array([\\n e.done for e in transitions if e is not None]).astype(\\n np.uint8).reshape(-1, 1)\\n next_states = np.vstack(\\n [e.next_state for e in transitions if e is not None])\\n\\n # Get predicted next-state actions and Q values from target models\\n actions_next = self.actor_target.model.predict_on_batch(next_states) #mu_marked in algo\\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next]) #Q' in algo\\n\\n # Compute Q targets for current states and train critic model (local)\\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones) #y_i in algo\\n critic_loss = self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\\n\\n # Train actor model (local)\\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\\n # print(\\\"action_gradients\\\",action_gradients)\\n # custom training function\\n self.actor_local.train_fn([states, action_gradients, 1])\\n\\n # Soft-update target models\\n # self.soft_update(self.critic_local.model, self.critic_target.model, self.tau)\\n # self.soft_update(self.actor_local.model, self.actor_target.model, self.tau)\\n self.soft_update_critic()\\n self.soft_update_actor()\\n\\n return critic_loss\",\n \"def train(actor, critic, task, num_nodes, train_data, valid_data, reward_fn,\\n render_fn, batch_size, actor_lr, critic_lr, max_grad_norm,\\n **kwargs):\\n\\n now = '%s' % datetime.datetime.now().time()\\n now = now.replace(':', '_')\\n save_dir = os.path.join(task, '%d' % num_nodes, now)\\n\\n checkpoint_dir = os.path.join(save_dir, 'checkpoints')\\n if not os.path.exists(checkpoint_dir):\\n os.makedirs(checkpoint_dir)\\n\\n actor_optim = optim.Adam(actor.parameters(), lr=actor_lr)\\n critic_optim = optim.Adam(critic.parameters(), lr=critic_lr)\\n\\n train_loader = DataLoader(train_data, batch_size, True, num_workers=0)\\n valid_loader = DataLoader(valid_data, batch_size, False, num_workers=0)\\n\\n best_params = None\\n best_reward = np.inf\\n\\n for epoch in range(20):\\n\\n actor.train()\\n critic.train()\\n\\n times, losses, rewards, critic_rewards = [], [], [], []\\n\\n epoch_start = time.time()\\n start = epoch_start\\n\\n for batch_idx, batch in enumerate(train_loader):\\n\\n static, dynamic, x0 = batch\\n\\n static = static.to(device)\\n dynamic = dynamic.to(device)\\n x0 = x0.to(device) if len(x0) > 0 else None\\n\\n # Full forward pass through the dataset\\n tour_indices, tour_logp = actor(static, dynamic, x0)\\n\\n # Sum the log probabilities for each city in the tour\\n reward = reward_fn(static, tour_indices)\\n\\n # Query the critic for an estimate of the reward\\n critic_est = critic(static, dynamic).view(-1)\\n\\n advantage = (reward - critic_est)\\n actor_loss = torch.mean(advantage.detach() * tour_logp.sum(dim=1))\\n critic_loss = torch.mean(advantage ** 2)\\n\\n actor_optim.zero_grad()\\n actor_loss.backward()\\n torch.nn.utils.clip_grad_norm_(actor.parameters(), max_grad_norm)\\n actor_optim.step()\\n\\n critic_optim.zero_grad()\\n critic_loss.backward()\\n torch.nn.utils.clip_grad_norm_(critic.parameters(), max_grad_norm)\\n critic_optim.step()\\n\\n critic_rewards.append(torch.mean(critic_est.detach()).item())\\n rewards.append(torch.mean(reward.detach()).item())\\n losses.append(torch.mean(actor_loss.detach()).item())\\n\\n if (batch_idx + 1) % 100 == 0:\\n end = time.time()\\n times.append(end - start)\\n start = end\\n\\n mean_loss = np.mean(losses[-100:])\\n mean_reward = np.mean(rewards[-100:])\\n\\n print(' Batch %d/%d, reward: %2.3f, loss: %2.4f, took: %2.4fs' %\\n (batch_idx, len(train_loader), mean_reward, mean_loss,\\n times[-1]))\\n\\n mean_loss = np.mean(losses)\\n mean_reward = np.mean(rewards)\\n\\n # Save the weights\\n epoch_dir = os.path.join(checkpoint_dir, '%s' % epoch)\\n if not os.path.exists(epoch_dir):\\n os.makedirs(epoch_dir)\\n\\n save_path = os.path.join(epoch_dir, 'actor.pt')\\n torch.save(actor.state_dict(), save_path)\\n\\n save_path = os.path.join(epoch_dir, 'critic.pt')\\n torch.save(critic.state_dict(), save_path)\\n\\n # Save rendering of validation set tours\\n valid_dir = os.path.join(save_dir, '%s' % epoch)\\n\\n mean_valid = validate(valid_loader, actor, reward_fn, render_fn,\\n valid_dir, num_plot=5)\\n\\n # Save best model parameters\\n if mean_valid < best_reward:\\n\\n best_reward = mean_valid\\n\\n save_path = os.path.join(save_dir, 'actor.pt')\\n torch.save(actor.state_dict(), save_path)\\n\\n save_path = os.path.join(save_dir, 'critic.pt')\\n torch.save(critic.state_dict(), save_path)\\n\\n print('Mean epoch loss/reward: %2.4f, %2.4f, %2.4f, took: %2.4fs '\\\\\\n '(%2.4fs / 100 batches)\\\\n' % \\\\\\n (mean_loss, mean_reward, mean_valid, time.time() - epoch_start,\\n np.mean(times)))\",\n \"def _Learn(self, Actor, ActorTarget, actorOpt, experiances):\\n Actor.train() # Set in Train Mode\\n # Get split experiances into: states, actions ...\\n states, actions, rewards, nextStates, dones = experiances\\n # ....................... Update Critic .......................\\n QTargetsNext = self.CriticTarget(nextStates, ActorTarget(nextStates))\\n QTargets = rewards + (GAMMA * QTargetsNext * (1 - dones))\\n QExpected = self.Critic(states, actions)\\n # Minimize Loss & Update Weights\\n critic_loss = F.smooth_l1_loss(QExpected, QTargets.detach())\\n self.criticOpt.zero_grad()\\n critic_loss.backward()\\n T.nn.utils.clip_grad_norm(self.Critic.parameters(), 1)\\n self.criticOpt.step()\\n # ....................... Update Actor .......................\\n actor_loss = -self.Critic(states, Actor(states)).mean()\\n # Update Weights\\n actorOpt.zero_grad()\\n actor_loss.backward()\\n T.nn.utils.clip_grad_norm(Actor.parameters(), 1)\\n actorOpt.step()\\n # ............. Update Actor & Critic Target Nets .............\\n self.SoftUpdate(self.Critic, self.CriticTarget, TAU)\\n self.SoftUpdate(Actor, ActorTarget, TAU)\",\n \"def training_step(self):\\n self.iteration += 1\\n # if not enough replay memories\\n if self.iteration < self.params.min_replays:\\n # skip training\\n return\\n # for each batch\\n for _ in range(self.params.num_batches):\\n # sample memories\\n mem_states, mem_controls, mem_rewards, mem_next_states, mem_continues = \\\\\\n (rl.tools.sample_memories(self.memory, self.params.batch_size))\\n # train the critic\\n max_q = self.sess.run(self.graph.target_critic_outputs, feed_dict={self.graph.states: mem_next_states})\\n td_target = mem_rewards + mem_continues * self.params.discount_factor * max_q\\n self.reg_loss_val, self.critic_loss_val, _ = self.sess.run(\\n [self.graph.critic_reg_loss, self.graph.critic_loss, self.graph.critic_training_op],\\n feed_dict={self.graph.states: mem_states, self.graph.actor_outputs: mem_controls,\\n self.graph.td_target: td_target})\\n # train the actor\\n neg_mean_q_val, _ = self.sess.run([self.graph.neg_mean_q, self.graph.actor_training_op],\\n feed_dict={self.graph.states: mem_states})\\n self.mean_q_val = -1.0 * neg_mean_q_val\\n # copy to target\\n self.sess.run(self.graph.copy_online_to_target)\",\n \"def learn(self, experience):\\n\\n # Convert experiences to separate list\\n states = np.vstack([e.state for e in experience if e is not None])\\n actions = np.array([e.action for e in experience if e is not None]).astype(np.float32).reshape(-1, self.action_size)\\n rewards = np.array([e.reward for e in experience if e is not None]).astype(np.float32).reshape(-1, 1)\\n dones = np.array([e.done for e in experience if e is not None]).astype(np.uint8).reshape(-1, 1)\\n next_states = np.vstack([e.next_state for e in experience if e is not None])\\n\\n # Get predicted next-state actions and Q values from target models\\n # Q_targets_next = critic_target(next_state, actor_target(next_state))\\n actions_next = self.actor_target.model.predict_on_batch(next_states)\\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next])\\n\\n # Compute Q targets for current states and train critic model (local)\\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones)\\n self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\\n\\n # Train actor model (local)\\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\\n self.actor_local.train_fn([states, action_gradients, 1])\\n\\n # soft-update target models\\n self.soft_update(self.critic_local.model, self.critic_target.model)\\n self.soft_update(self.actor_local.model, self.actor_target.model)\",\n \"def build_actor_critic(self):\\n inputs = Input(shape=(self.state_dim, ), name='state')\\n self.encoder.trainable = False\\n x = self.encoder(inputs)\\n mean = Dense(1,\\n activation='linear',\\n kernel_initializer='zero',\\n name='mean')(x)\\n stddev = Dense(1,\\n kernel_initializer='zero',\\n name='stddev')(x)\\n # use of softplusk avoids stddev = 0\\n stddev = Activation('softplusk', name='softplus')(stddev)\\n action = Lambda(self.action,\\n output_shape=(1,),\\n name='action')([mean, stddev])\\n self.actor_model = Model(inputs, action, name='action')\\n self.actor_model.summary()\\n plot_model(self.actor_model, \\n to_file='actor_model.png', \\n show_shapes=True)\\n\\n logp = Lambda(self.logp,\\n output_shape=(1,),\\n name='logp')([mean, stddev, action])\\n self.logp_model = Model(inputs, logp, name='logp')\\n self.logp_model.summary()\\n plot_model(self.logp_model, \\n to_file='logp_model.png', \\n show_shapes=True)\\n\\n entropy = Lambda(self.entropy,\\n output_shape=(1,),\\n name='entropy')([mean, stddev])\\n self.entropy_model = Model(inputs, entropy, name='entropy')\\n self.entropy_model.summary()\\n plot_model(self.entropy_model, \\n to_file='entropy_model.png', \\n show_shapes=True)\\n\\n value = Dense(1,\\n activation='linear',\\n kernel_initializer='zero',\\n name='value')(x)\\n self.value_model = Model(inputs, value, name='value')\\n self.value_model.summary()\\n plot_model(self.value_model, \\n to_file='value_model.png', \\n show_shapes=True)\\n\\n\\n # logp loss of policy network\\n loss = self.logp_loss(self.get_entropy(self.state), \\n beta=self.beta)\\n optimizer = RMSprop(lr=1e-3)\\n self.logp_model.compile(loss=loss, optimizer=optimizer)\\n\\n optimizer = Adam(lr=1e-3)\\n self.value_model.compile(loss=self.loss, optimizer=optimizer)\",\n \"def agents_train(self, game_step, episode_now, args):\\n # update all trainers, if not in display or benchmark mode\\n if episode_now < args.learning_start_episode: return \\n if self.update_cnt > 0 and self.var >= self.min_var: self.var *= args.var_discount\\n #if episode_now > self.last_update_episode and (episode_now - args.learning_start_episode) % args.learning_fre == 0:\\n if game_step % args.learning_fre_step == 0:\\n if self.update_cnt == 0: print('\\\\r=start training ...'+' '*100)\\n self.last_update_episode = episode_now\\n self.update_cnt += 1\\n\\n # update every agent in different memory batch\\n for agent_idx, (actor_c, actor_t, critic_c, critic_t, opt_a, opt_c) in \\\\\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, \\\\\\n self.critics_tar, self.optimizers_a, self.optimizers_c)):\\n # del if opt_c == None: continue # jump to the next model update\\n\\n # sample the experience\\n _obs_n_o, _action_n, _rew_n, _obs_n_n, _done_n = self.memory.sample( \\\\\\n args.batch_size, agent_idx) # Note_The func is not the same as others\\n \\n # --use the date to update the CRITIC\\n rew = torch.tensor(_rew_n, device=args.device, dtype=torch.float) # set the rew to gpu\\n done_n = torch.tensor(~_done_n, dtype=torch.float, device=args.device) # set the rew to gpu\\n action_cur_o = torch.from_numpy(_action_n).to(args.device, torch.float)\\n obs_n_o = torch.from_numpy(_obs_n_o).to(args.device, torch.float)\\n obs_n_n = torch.from_numpy(_obs_n_n).to(args.device, torch.float)\\n\\n action_tar = torch.cat([a_t(obs_n_n[:, self.obs_size[idx][0]:self.obs_size[idx][1]]).detach() \\\\\\n for idx, a_t in enumerate(self.actors_tar)], dim=1)\\n q = critic_c(obs_n_o, action_cur_o).reshape(-1) # q \\n q_ = critic_t(obs_n_n, action_tar).reshape(-1) # q_ \\n q_ = q_*args.gamma*done_n + rew*torch.tensor(args.reward_scale_par, device=args.device) # q_*gamma*done + reward\\n loss_c = torch.nn.MSELoss()(q, q_.detach()) # bellman equation\\n opt_c.zero_grad()\\n loss_c.backward()\\n nn.utils.clip_grad_norm_(critic_c.parameters(), args.max_grad_norm)\\n opt_c.step()\\n\\n # --use the data to update the ACTOR\\n # There is no need to cal other agent's action\\n opt_c.zero_grad()\\n model_out, policy_c_new = actor_c( \\\\\\n obs_n_o[:, self.obs_size[agent_idx][0]:self.obs_size[agent_idx][1]], model_original_out=True)\\n # update the aciton of this agent\\n action_cur_o[:, self.action_size[agent_idx][0]:self.action_size[agent_idx][1]] = policy_c_new \\n loss_pse = torch.mean(torch.pow(model_out, 2))\\n loss_a = torch.mul(torch.tensor(-1.0, device=args.device), torch.mean(critic_c(obs_n_o, action_cur_o)))\\n\\n opt_a.zero_grad()\\n (2e-3*loss_pse+loss_a).backward()\\n #loss_a.backward()\\n nn.utils.clip_grad_norm_(actor_c.parameters(), args.max_grad_norm)\\n opt_a.step()\\n\\n # save the model to the path_dir ---cnt by update number\\n #if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model == 0:\\n if self.update_cnt > args.start_save_model and self.update_cnt % args.fre4save_model_step == 0:\\n time_now = time.strftime('%y%m_%d%H%M')\\n print('=time:{} step:{} save'.format(time_now, game_step))\\n model_file_dir = os.path.join(args.save_dir, '{}_{}_{}'.format( \\\\\\n args.scenario_name, time_now, game_step))\\n if not os.path.exists(model_file_dir): # make the path\\n os.mkdir(model_file_dir)\\n for agent_idx, (a_c, a_t, c_c, c_t) in \\\\\\n enumerate(zip(self.actors_cur, self.actors_tar, self.critics_cur, self.critics_tar)):\\n torch.save(a_c, os.path.join(model_file_dir, 'a_c_{}.pt'.format(agent_idx)))\\n torch.save(a_t, os.path.join(model_file_dir, 'a_t_{}.pt'.format(agent_idx)))\\n torch.save(c_c, os.path.join(model_file_dir, 'c_c_{}.pt'.format(agent_idx)))\\n torch.save(c_t, os.path.join(model_file_dir, 'c_t_{}.pt'.format(agent_idx)))\\n\\n # update the tar par\\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, args.tao) \\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, args.tao)\",\n \"def train(self,\\n replay_buffer_iter,\\n discount=0.99,\\n tau=0.005,\\n target_entropy=0,\\n actor_update_freq=2):\\n states, actions, next_states, rewards, masks = next(replay_buffer_iter)[0]\\n\\n rewards = self.rewards_fn(states, actions, rewards)\\n\\n critic_loss = self.fit_critic(states, actions, next_states, rewards, masks,\\n discount)\\n\\n self.avg_critic_loss(critic_loss)\\n if tf.equal(self.critic_optimizer.iterations % self.log_interval, 0):\\n tf.summary.scalar(\\n 'train sac/critic_loss',\\n self.avg_critic_loss.result(),\\n step=self.critic_optimizer.iterations)\\n keras_utils.my_reset_states(self.avg_critic_loss)\\n\\n if tf.equal(self.critic_optimizer.iterations % actor_update_freq, 0):\\n actor_loss, alpha_loss, entropy = self.fit_actor(states, target_entropy)\\n soft_update(self.critic, self.critic_target, tau=tau)\\n\\n self.avg_actor_loss(actor_loss)\\n self.avg_alpha_loss(alpha_loss)\\n self.avg_actor_entropy(entropy)\\n self.avg_alpha(self.alpha)\\n if tf.equal(self.actor_optimizer.iterations % self.log_interval, 0):\\n tf.summary.scalar(\\n 'train sac/actor_loss',\\n self.avg_actor_loss.result(),\\n step=self.actor_optimizer.iterations)\\n keras_utils.my_reset_states(self.avg_actor_loss)\\n\\n tf.summary.scalar(\\n 'train sac/alpha_loss',\\n self.avg_alpha_loss.result(),\\n step=self.actor_optimizer.iterations)\\n keras_utils.my_reset_states(self.avg_alpha_loss)\\n\\n tf.summary.scalar(\\n 'train sac/actor entropy',\\n self.avg_actor_entropy.result(),\\n step=self.actor_optimizer.iterations)\\n keras_utils.my_reset_states(self.avg_actor_entropy)\\n\\n tf.summary.scalar(\\n 'train sac/alpha',\\n self.avg_alpha.result(),\\n step=self.actor_optimizer.iterations)\\n keras_utils.my_reset_states(self.avg_alpha)\",\n \"def TrainOneStep(self):\\n pass\",\n \"def train(opts):\\n # Set number of actions\\n opts.A = opts.delta_M * opts.delta_N\\n # Set random seeds\\n set_random_seeds(opts.seed)\\n # Create actions mapping\\n count_act = 0\\n opts.act_to_delta = {}\\n opts.delta_to_act = {}\\n for i in range(-(opts.delta_N//2), opts.delta_N//2+1):\\n for j in range(-(opts.delta_M//2), opts.delta_M//2+1):\\n opts.act_to_delta[count_act] = (i, j)\\n opts.delta_to_act[(i, j)] = count_act\\n count_act += 1\\n\\n if opts.expert_rewards:\\n from data_loader import DataLoaderExpert as DataLoader\\n elif opts.expert_trajectories or opts.actorType == 'demo_sidekick' or opts.actorType == 'peek_saliency':\\n from data_loader import DataLoaderExpertPolicy as DataLoader\\n else:\\n from data_loader import DataLoaderSimple as DataLoader\\n\\n if opts.dataset == 0:\\n opts.num_channels = 3\\n if opts.mean_subtract:\\n # R, G, B means and stds\\n opts.mean = [119.16, 107.68, 95.12]\\n opts.std = [61.88, 61.72, 67.24]\\n else:\\n opts.mean = [0, 0, 0]\\n opts.std = [1, 1, 1]\\n elif opts.dataset == 1:\\n opts.num_channels = 1\\n if opts.mean_subtract:\\n # R, G, B means and stds\\n opts.mean = [193.0162338615919]\\n opts.std = [37.716024486312811]\\n else:\\n opts.mean = [0]\\n opts.std = [1]\\n else:\\n raise ValueError('Dataset %d does not exist!'%(opts.dataset))\\n\\n if opts.expert_trajectories:\\n opts.T_sup = opts.T-1\\n loader = DataLoader(opts)\\n if opts.expert_trajectories:\\n agent = AgentSupervised(opts)\\n else:\\n agent = Agent(opts)\\n\\n # Create tensorboard writer\\n writer = SummaryWriter(log_dir=opts.save_path)\\n # Set networks to train\\n agent.policy.train()\\n # Initiate statistics storage variables\\n if opts.load_model == '': \\n best_val_error = 100000\\n train_history = []\\n val_history = []\\n epoch_start = 0\\n else:\\n best_val_error, train_history, val_history, epoch_start = load_module(agent, opts)\\n\\n # To handle job eviction and restarts\\n if os.path.isfile(os.path.join(opts.save_path, 'model_latest.net')):\\n print('====> Resuming training from previous checkpoint')\\n # undo most of the loading done before\\n loaded_model = torch.load(os.path.join(opts.save_path, 'model_latest.net'))\\n opts = loaded_model['opts']\\n epoch_start = loaded_model['epoch'] + 1\\n\\n loader = DataLoader(opts)\\n if opts.expert_trajectories:\\n agent = AgentSupervised(opts)\\n agent.T_sup = loaded_model['T_sup']\\n else:\\n agent = Agent(opts) \\n\\n agent.policy.load_state_dict(loaded_model['state_dict'])\\n train_history = loaded_model['train_history']\\n val_history = loaded_model['val_history']\\n #agent.optimizer.load_state_dict(loaded_model['optimizer'])\\n best_val_error = loaded_model['best_val_error']\\n\\n # Some random selection of images to display\\n rng_choices = random.sample(range(300//opts.batch_size), 2) \\n # Start training\\n for epoch in range(epoch_start, opts.epochs):\\n # Initialize epoch specific variables\\n depleted = False\\n train_err = 0\\n train_count = 0\\n iter_count = 0\\n avg_colln_loss = 0\\n\\n while not depleted:\\n # pano - BxNxMxCx32x32\\n if opts.expert_rewards:\\n pano, pano_rewards, depleted = loader.next_batch('train')\\n pano_maps = None\\n elif opts.expert_trajectories or opts.actorType == 'demo_sidekick' or opts.actorType == 'peek_saliency':\\n pano, pano_maps, depleted = loader.next_batch('train')\\n pano_rewards = None\\n else:\\n pano, depleted = loader.next_batch('train')\\n pano_rewards = None\\n pano_maps = None\\n # Note: This batch size is the current batch size, not the global batch size. This varies\\n\\n # when you reach the boundary of the dataset.\\n batch_size = pano.shape[0]\\n start_idx = get_starts(opts.N, opts.M, batch_size, opts.start_view)\\n state = State(pano, pano_rewards, start_idx, opts)\\n if opts.expert_trajectories:\\n if opts.hybrid_train:\\n rec_errs = agent.train_agent_hybrid(state, pano_maps, opts)\\n else:\\n rec_errs = agent.train_agent(state, pano_maps, opts)\\n else:\\n # Forward pass\\n log_probs, rec_errs, rewards, entropies, decoded, values,\\\\\\n visited_idxes, decoded_all, _ = agent.gather_trajectory(state, eval_opts=None, pano_maps=pano_maps, opts=opts)\\n # Backward pass\\n agent.update_policy(rewards, log_probs, rec_errs, entropies, values) \\n\\n # Accumulate statistics\\n train_err += rec_errs[-1].data.sum()\\n train_count += batch_size\\n iter_count += 1\\n\\n train_err /= train_count\\n\\n # Evaluate the agent after every epoch\\n val_err, _, _, decoded_images = evaluate(loader, agent, 'val', opts)\\n\\n # Write out statistics to tensorboard\\n writer.add_scalar('data/train_error', train_err, epoch+1)\\n writer.add_scalar('data/val_error', val_err, epoch+1)\\n\\n # Write out models and other statistics to torch format file\\n train_history.append([epoch, train_err])\\n val_history.append([epoch, val_err])\\n if best_val_error > val_err:\\n best_val_error = val_err\\n save_state = {\\n 'epoch': epoch,\\n 'state_dict': agent.policy.state_dict(),\\n 'optimizer': agent.optimizer.state_dict(),\\n 'opts': opts, \\n 'best_val_error': best_val_error,\\n 'train_history': train_history,\\n 'val_history': val_history\\n }\\n if opts.expert_trajectories:\\n save_state['T_sup'] = agent.T_sup\\n\\n torch.save(save_state, os.path.join(opts.save_path, 'model_best.net'))\\n\\n save_state = {\\n 'epoch': epoch,\\n 'state_dict': agent.policy.state_dict(),\\n 'optimizer': agent.optimizer.state_dict(),\\n 'opts': opts, \\n 'best_val_error': best_val_error,\\n 'train_history': train_history,\\n 'val_history': val_history\\n }\\n if opts.expert_trajectories:\\n save_state['T_sup'] = agent.T_sup\\n torch.save(save_state, os.path.join(opts.save_path, 'model_latest.net'))\\n\\n print('Epoch %d : Train loss: %9.6f Val loss: %9.6f'%(epoch+1, train_err, val_err))\\n\\n # Reduce supervision gradually\\n if opts.expert_trajectories and opts.hybrid_train:\\n if (epoch+1) % opts.hybrid_schedule == 0 and agent.T_sup > 0:\\n agent.T_sup -= 1\\n # Save the model after the first schedule is over\\n if epoch+1 == opts.hybrid_schedule:\\n torch.save(save_state, os.path.join(opts.save_path, 'model_after_one_schedule.net'))\\n\\n # Decay expert reward gradually\\n if opts.expert_rewards and (epoch+1) % opts.expert_rewards_decay == 0:\\n agent.reward_scale_expert /= opts.expert_rewards_decay_factor\\n\\n # Display three randomly selected batches of panoramas every 10 epochs\\n if (epoch+1) % 10 == 0 or epoch == 0:\\n for choice in rng_choices:\\n for pano_count in range(decoded_images[choice].size(0)):\\n x = vutils.make_grid(decoded_images[choice][pano_count], padding=5, normalize=True, scale_each=True, nrow=opts.T//2+1) \\n writer.add_image('Validation batch # : %d image # : %d'%(choice, pano_count), x, 0) # Converting this to 0 to save disk space, should be epoch ideally\",\n \"def run(opt):\\n U.configure_logger(opt)\\n\\n # set seed\\n opt.seed = (opt.run_id + 1) * opt.base_seed\\n torch.manual_seed(opt.seed)\\n\\n # configure env\\n env = ActionWrapper(TorchWrapper(gym.make(opt.env_name)))\\n env.seed(opt.seed)\\n\\n # build estimator\\n estimator = ActorCriticEstimator(\\n env.observation_space.shape[0],\\n env.action_space,\\n hidden_size=opt.hidden_size,\\n )\\n # load checkpoint and reset\\n rlog.info(\\\"Loading model from %s\\\", opt.model_state)\\n estimator.load_state_dict(torch.load(opt.model_state)[\\\"policy\\\"])\\n estimator.reset_policy()\\n rlog.info(\\\"Policy reset.\\\")\\n if opt.freeze_critic:\\n estimator.freeze_critic()\\n rlog.info(\\\"Freezed feature extractor and critic.\\\")\\n\\n # build the agent\\n policy_improvement, policy_evaluation = build_agent(\\n opt, env, estimator=estimator\\n )\\n\\n # log\\n rlog.info(f\\\"\\\\n{U.config_to_string(opt)}\\\")\\n rlog.info(policy_improvement)\\n\\n # train\\n try:\\n train(env, policy_improvement, policy_evaluation, opt)\\n except Exception as err:\\n rlog.error(clr(str(err), \\\"red\\\", attrs=[\\\"bold\\\"]))\\n raise err\",\n \"def learn(self, experiences, gamma):\\n\\n states, all_state, action, all_actions, rewards, next_state, all_next_state, dones = experiences\\n batch_size = all_next_state.shape[0]\\n\\n all_next_actions = self.actor_target(all_next_state.view(batch_size * 2, -1)).view(batch_size, -1)\\n\\n critic_target_input = torch.cat((all_next_state, all_next_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(\\n device)\\n with torch.no_grad():\\n Q_target_next = self.critic_target(critic_target_input, all_next_actions.view(batch_size * 2, -1)[::2])\\n Q_targets = rewards + (gamma * Q_target_next * (1 - dones))\\n\\n critic_local_input = torch.cat((all_state, all_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(device)\\n Q_expected = self.critic_local(critic_local_input, action)\\n\\n # critic loss\\n huber_loss = torch.nn.SmoothL1Loss()\\n\\n loss = huber_loss(Q_expected, Q_targets.detach())\\n\\n self.optimizer_critic.zero_grad()\\n loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1)\\n self.optimizer_critic.step()\\n\\n # actor loss\\n\\n action_pr_self = self.actor_local(states)\\n action_pr_other = self.actor_local(all_next_state.view(batch_size * 2, -1)[1::2]).detach()\\n\\n # critic_local_input2=torch.cat((all_state,torch.cat((action_pr_self,action_pr_other),dim=1)),dim=1)\\n critic_local_input2 = torch.cat((all_state, action_pr_other), dim=1)\\n p_loss = -self.critic_local(critic_local_input2, action_pr_self).mean()\\n\\n self.optimizer_actor.zero_grad()\\n p_loss.backward()\\n\\n self.optimizer_actor.step()\\n\\n # ------------------- update target network ------------------- #\\n self.TAU = min(5e-1, self.TAU * 1.001)\\n self.soft_update(self.critic_local, self.critic_target, self.TAU)\\n self.soft_update(self.actor_local, self.actor_target, self.TAU)\",\n \"def learn(self):\\n if self.step_count < self.learn_start_step or self.step_count % self.learn_interval != 0:\\n return\\n\\n s, a, r, s_, t = self.sample()\\n self.update_critics(s, a, r, t, s_)\\n self.update_actor_alpha(s)\\n self.update_target()\\n self.learn_cur += 1\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # ------------------- update critic ------------------- #\\n next_actions = self.actor_target(next_states)\\n # Get Q targets (for next states) from target model (on CPU)\\n Q_targets_next = self.critic_target(next_states, next_actions).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.critic_local(states, actions)\\n\\n # Compute critic loss\\n critic_loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the critic loss\\n self.critic_optimizer.zero_grad()\\n critic_loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1) # As mentioned on project page\\n self.critic_optimizer.step()\\n\\n # ------------------- update actor ------------------- #\\n actions_expected = self.actor_local(states)\\n # Compute actor loss based on expectation from actions_expected\\n actor_loss = -self.critic_local(states, actions_expected).mean()\\n # Minimize the actor loss\\n self.actor_optimizer.zero_grad()\\n actor_loss.backward()\\n self.actor_optimizer.step()\\n\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.critic_local, self.critic_target, TAU) \\n self.soft_update(self.actor_local, self.actor_target, TAU)\",\n \"def train(self, item, gamma=1.0):\\n [step, state, next_state, reward, done] = item\\n\\n # must save state for entropy computation\\n self.state = state\\n\\n discount_factor = gamma**step\\n\\n # actor-critic: delta = reward - value \\n # + discounted_next_value\\n delta = reward - self.value(state)[0] \\n\\n # since this function is called by Actor-Critic\\n # directly, evaluate the value function here\\n if not done:\\n next_value = self.value(next_state)[0]\\n # add the discounted next value\\n delta += gamma*next_value\\n\\n # apply the discount factor as shown in Algorithms\\n # 10.2.1, 10.3.1 and 10.4.1\\n discounted_delta = delta * discount_factor\\n discounted_delta = np.reshape(discounted_delta, [-1, 1])\\n verbose = 1 if done else 0\\n\\n # train the logp model (implies training of actor model\\n # as well) since they share exactly the same set of\\n # parameters\\n self.logp_model.fit(np.array(state),\\n discounted_delta,\\n batch_size=1,\\n epochs=1,\\n verbose=verbose)\\n\\n self.value_model.fit(np.array(state),\\n discounted_delta,\\n batch_size=1,\\n epochs=1,\\n verbose=verbose)\",\n \"def train(self, global_step):\\n if self.replay_buffer.size > self.warmup_size:\\n s0, a, r, t, s1 = self.replay_buffer.sample_batch(self.batch_size)\\n target_actions = self.actor.get_target_action(s1)\\n target_qval = self.get_target_qval(s1, target_actions)\\n t = t.astype(dtype=int)\\n y = r + self.gamma * target_qval * (1 - t)\\n self.critic.train(s0, a, y)\\n actions = self.actor.get_action(s0)\\n grads = self.critic.get_action_gradients(s0, actions)\\n self.actor.train(s0, grads[0])\\n self.update_targets()\",\n \"def train(args):\\n # prepare environment\\n brain_name = env.brain_names[0]\\n brain = env.brains[brain_name]\\n env_info = env.reset(train_mode=True)[brain_name]\\n\\n num_agents = len(env_info.agents)\\n print('Number of agents:', num_agents)\\n\\n # size of each action\\n action_size = brain.vector_action_space_size\\n print('Size of each action:', action_size)\\n\\n # examine the state space\\n states = env_info.vector_observations\\n state_size = states.shape[1]\\n print('There are {} agents. Each observes a state with length: {}'.format(\\n states.shape[0], state_size))\\n print('The state for the first agent looks like:', states[0])\\n\\n # Crate instance of MADDPG Class, mainly possible to control the model dimensions, learnrates and batch sizes\\n agent = MADDPG(state_size,\\n action_size,\\n lr_actor=args.lr_actor,\\n lr_critic=args.lr_critic,\\n lr_decay=args.lr_decay,\\n replay_buff_size=args.replay_buff_size,\\n gamma=args.gamma,\\n batch_size=args.batch_size,\\n random_seed=args.random_seed,\\n soft_update_tau=args.soft_update_tau,\\n actor_layer_dim_1=args.actor_layer_dim_1,\\n actor_layer_dim_2=args.actor_layer_dim_2,\\n actor_layer_dim_3=args.actor_layer_dim_3,\\n critic_layer_dim_1=args.critic_layer_dim_1,\\n critic_layer_dim_2=args.critic_layer_dim_2,\\n critic_layer_dim_3=args.critic_layer_dim_3\\n\\n )\\n\\n total_rewards = []\\n avg_scores = []\\n max_avg_score = -1\\n max_score = -1\\n threshold_init = 20\\n noise_t = args.epsilon\\n noise_decay = args.epsilon_decay\\n latest_avg_score = -1\\n # for early-stopping training if consistently worsen for # episodes\\n worsen_tolerance = threshold_init\\n for i_episode in range(1, 1+args.num_episodes):\\n\\n env_inst = env.reset(train_mode=True)[\\n brain_name] # reset the environment\\n states = env_inst.vector_observations # get the current state\\n # initialize score array\\n scores = np.zeros(num_agents)\\n dones = [False]*num_agents\\n while not np.any(dones):\\n # select an action\\n actions = agent.act(states, noise_t)\\n # send the action to the environment\\n env_inst = env.step(actions)[brain_name]\\n next_states = env_inst.vector_observations # get the next state\\n rewards = env_inst.rewards # get the reward\\n dones = env_inst.local_done # see if episode has finished\\n agent.update(states, actions, rewards, next_states, dones)\\n\\n noise_t *= noise_decay\\n scores += rewards # update scores\\n states = next_states\\n\\n episode_score = np.max(scores)\\n total_rewards.append(episode_score)\\n print(\\\"\\\\rEpisodic {} Score: {:.4f}\\\\t Avg Score: {:.4f}\\\".format(\\n i_episode, episode_score, latest_avg_score), end=' ')\\n\\n if max_score <= episode_score:\\n max_score = episode_score\\n # save best model so far\\n agent.save(\\n \\\"chkpts/{}/{:02d}_best_model.checkpoint\\\".format(args.model_path, args.loop_counter))\\n\\n # record avg score for the latest 100 steps\\n if len(total_rewards) >= args.test_n_run:\\n latest_avg_score = sum(\\n total_rewards[(len(total_rewards)-args.test_n_run):]) / args.test_n_run\\n avg_scores.append(latest_avg_score)\\n\\n if max_avg_score <= latest_avg_score: # record better results\\n worsen_tolerance = threshold_init # re-count tolerance\\n max_avg_score = latest_avg_score\\n else:\\n if max_avg_score > 0.5:\\n worsen_tolerance -= 1 # count worsening counts\\n print(\\\"Loaded from last best model.\\\")\\n # continue from last best-model\\n agent.load(\\n \\\"chkpts/{}/{:02d}_best_model.checkpoint\\\".format(args.model_path, args.loop_counter))\\n if worsen_tolerance <= 0: # earliy stop training\\n print(\\\"Early Stop Training.\\\")\\n break\\n del agent\\n return total_rewards\",\n \"def learn(self, experiences, gamma):\\r\\n states, actions, rewards, next_states, dones = experiences\\r\\n\\r\\n # UPDATE CRITIC #\\r\\n actions_next = self.actor_target(next_states.to(device))\\r\\n Q_targets_next = self.critic_target(next_states.to(device), actions_next.to(device))\\r\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\r\\n Q_expected = self.critic_local(states, actions)\\r\\n critic_loss = F.mse_loss(Q_expected, Q_targets)\\r\\n\\r\\n self.critic_optimizer.zero_grad()\\r\\n critic_loss.backward()\\r\\n clip_grad_norm_(self.critic_local.parameters(), 1) # Clip the gradient when update critic network\\r\\n self.critic_optimizer.step()\\r\\n\\r\\n # UPDATE ACTOR #\\r\\n actions_pred = self.actor_local(states)\\r\\n actor_loss = -self.critic_local(states, actions_pred).mean()\\r\\n\\r\\n self.actor_optimizer.zero_grad()\\r\\n actor_loss.backward()\\r\\n self.actor_optimizer.step()\\r\\n\\r\\n # UPDATE TARGET NETWORKS #\\r\\n self.soft_update(self.critic_local, self.critic_target, RHO)\\r\\n self.soft_update(self.actor_local, self.actor_target, RHO) \\r\\n\\r\\n # UPDATE EPSILON AND NOISE # \\r\\n self.epsilon *= EPSILON_DECAY\\r\\n self.noise.reset()\",\n \"def train_agent(self):\\n # Retrieve collected experiences from memory\\n experiences = np.array(self.replay.get_all())\\n # rewards = np.array([h['reward'] for h in experiences])\\n #rewards = experiences[:,2]\\n rewards = np.array([r[2] for r in experiences])\\n\\n # Discount and normalize rewards\\n norm_rewards = self.discount_rewards_and_normalize(rewards)\\n\\n # Shuffle for better learning\\n shuffled_experiences = np.random.shuffle(experiences)\\n\\n # Feed the experiences through the network with rewards to compute and\\n # minimize the loss.\\n\\n feed={\\n self.X: [r[0] for r in experiences],\\n self.rewards:norm_rewards,\\n self.ep_actions:experiences[:,1]\\n }\\n self.tf_sess.run(self.train,feed_dict=feed)\\n\\n pass\",\n \"def learn(self, *args):\\n\\n # unpack args\\n steps, episode_step, _, state_, reward, _, done, _ = args \\n\\n # we check if we should do a learning step,\\n # otherwise, just store the reward and go on\\n\\n if done or episode_step == self.episode_length - 1:\\n \\n # get the last value\\n if done: # terminal state\\n last_value = 0 \\n else: # predict the last value from the critic\\n last_value, _ = self.actor_critic.predict(state_)\\n\\n # calculate the discounted reward\\n self.rewards.append(reward)\\n discounted_rewards = np.zeros(len(self.values))\\n for i in reversed(range(len(self.rewards))):\\n last_value = self.rewards[i] + self.discount_factor * last_value\\n discounted_rewards[i] = last_value\\n \\n # update weights by calculating the loss and performing backward\\n self.actor_critic.calc_loss(discounted_r=discounted_rewards,\\n values=self.values,\\n log_probs=self.log_probs,\\n entropy=self.entropy,\\n entropy_factor=self.entropy_factor)\\n # clean up\\n self.values.clear()\\n self.rewards.clear()\\n self.log_probs.clear()\\n self.entropy.clear()\\n else:\\n self.rewards.append(reward)\",\n \"def get(env, args):\\n state_dim = env.observation_space.shape[0]\\n action_dim = env.action_space.shape[0]\\n\\n hidden_sizes_actor = hyper_params[\\\"NETWORK\\\"][\\\"ACTOR_HIDDEN_SIZES\\\"]\\n hidden_sizes_critic = hyper_params[\\\"NETWORK\\\"][\\\"CRITIC_HIDDEN_SIZES\\\"]\\n\\n # create actor\\n actor = MLP(\\n input_size=state_dim,\\n output_size=action_dim,\\n hidden_sizes=hidden_sizes_actor,\\n output_activation=torch.tanh,\\n ).to(device)\\n\\n actor_target = MLP(\\n input_size=state_dim,\\n output_size=action_dim,\\n hidden_sizes=hidden_sizes_actor,\\n output_activation=torch.tanh,\\n ).to(device)\\n actor_target.load_state_dict(actor.state_dict())\\n\\n # create critic1\\n critic1 = MLP(\\n input_size=state_dim + action_dim,\\n output_size=1,\\n hidden_sizes=hidden_sizes_critic,\\n ).to(device)\\n\\n critic1_target = MLP(\\n input_size=state_dim + action_dim,\\n output_size=1,\\n hidden_sizes=hidden_sizes_critic,\\n ).to(device)\\n critic1_target.load_state_dict(critic1.state_dict())\\n\\n # create critic2\\n critic2 = MLP(\\n input_size=state_dim + action_dim,\\n output_size=1,\\n hidden_sizes=hidden_sizes_critic,\\n ).to(device)\\n\\n critic2_target = MLP(\\n input_size=state_dim + action_dim,\\n output_size=1,\\n hidden_sizes=hidden_sizes_critic,\\n ).to(device)\\n critic2_target.load_state_dict(critic2.state_dict())\\n\\n # concat critic parameters to use one optim\\n critic_parameters = list(critic1.parameters()) + list(critic2.parameters())\\n\\n # create optimizer\\n actor_optim = optim.Adam(\\n actor.parameters(),\\n lr=hyper_params[\\\"LR_ACTOR\\\"],\\n weight_decay=hyper_params[\\\"WEIGHT_DECAY\\\"],\\n )\\n\\n critic_optim = optim.Adam(\\n critic_parameters,\\n lr=hyper_params[\\\"LR_CRITIC\\\"],\\n weight_decay=hyper_params[\\\"WEIGHT_DECAY\\\"],\\n )\\n\\n # noise\\n exploration_noise = GaussianNoise(\\n action_dim,\\n min_sigma=hyper_params[\\\"EXPLORATION_NOISE\\\"],\\n max_sigma=hyper_params[\\\"EXPLORATION_NOISE\\\"],\\n )\\n\\n target_policy_noise = GaussianNoise(\\n action_dim,\\n min_sigma=hyper_params[\\\"TARGET_POLICY_NOISE\\\"],\\n max_sigma=hyper_params[\\\"TARGET_POLICY_NOISE\\\"],\\n )\\n\\n # make tuples to create an agent\\n models = (actor, actor_target, critic1, critic1_target, critic2, critic2_target)\\n optims = (actor_optim, critic_optim)\\n noises = (exploration_noise, target_policy_noise)\\n\\n # create an agent\\n return Agent(env, args, hyper_params, models, optims, noises)\",\n \"def __init__(self, action_space, memory_par, game, reward_clip: bool):\\n super(SoftActorCriticsDiscrete, self).__init__(action_space, memory_par, game, reward_clip)\\n self.device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\\n self.soft = True\\n self.learn_replace = 1000\\n self.learn_start_step = 1000\\n self.tau = 0.005\\n self.step_num = 4\\n self.learn_interval = 4\\n self.actor = PolicyNetwork(img_size=self.multi_frames_size, output_num=self.action_space_len)\\n self.critic1 = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\\n self.critic2 = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\\n with torch.no_grad():\\n self.critic1_target = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\\n self.critic2_target = QNet(img_size=self.multi_frames_size, output_num=self.action_space_len)\\n self.critic1_target.load_state_dict(self.critic1.state_dict())\\n self.critic2_target.load_state_dict(self.critic2.state_dict())\\n\\n self.target_entropy = 0.98 * (-np.log(1 / self.action_space_len))\\n self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\\n self.alpha = self.log_alpha.exp()\\n\\n self.critic1_optimiser = optim.Adam(self.critic1.parameters(), lr=0.0001, eps=1e-6)\\n self.critic2_optimiser = optim.Adam(self.critic2.parameters(), lr=0.0001, eps=1e-6)\\n self.actor_optimiser = optim.Adam(self.actor.parameters(), lr=0.0001, eps=1e-6)\\n self.alpha_optimiser = optim.Adam([self.log_alpha], lr=0.0001, eps=1e-6)\",\n \"def learn(self):\\n\\n self.t_step += 1\\n\\n # Sample from replay buffer, which already has nstep rollout calculated.\\n batch = self.memory.sample(self.batch_size)\\n obs, next_obs, actions, rewards, dones = batch\\n\\n # Gather and concatenate actions because critic networks need ALL\\n # actions as input, the stored actions were concatenated before storing\\n # in the buffer\\n target_actions = [agent.actor_target(next_obs[i]) for i, agent in\\n enumerate(self.agents)]\\n predicted_actions = [agent.actor(obs[i]) for i, agent in\\n enumerate(self.agents)]\\n target_actions = torch.cat(target_actions, dim=-1)\\n predicted_actions = torch.cat(predicted_actions, dim=-1)\\n\\n # Change state data from [agent_count, batch_size]\\n # to [batchsize, state_size * agent_count]\\n # because critic networks need to ALL observations as input\\n obs = obs.transpose(1,0).contiguous().view(self.batch_size, -1)\\n next_obs = next_obs.transpose(1,0).contiguous().view(self.batch_size,-1)\\n\\n # Perform a learning step for each agent using concatenated data as well\\n # as unique-perspective data where algorithmically called for\\n for i, agent in enumerate(self.agents):\\n agent.learn(obs, next_obs, actions, target_actions,\\n predicted_actions, rewards[i], dones[i])\\n self.update_networks(agent)\",\n \"def train_step(self):\\n pass\",\n \"def train(self) -> None:\\n\\n self.envs = construct_envs(self.config, get_env_class(self.config.ENV_NAME))\\n\\n ppo_cfg = self.config.RL.PPO\\n self.device = (\\n torch.device(\\\"cuda\\\", self.config.TORCH_GPU_ID)\\n if torch.cuda.is_available()\\n else torch.device(\\\"cpu\\\")\\n )\\n if not os.path.isdir(self.config.CHECKPOINT_FOLDER):\\n os.makedirs(self.config.CHECKPOINT_FOLDER)\\n self._setup_actor_critic_agent(ppo_cfg)\\n logger.info(\\n \\\"agent number of parameters: {}\\\".format(\\n sum(param.numel() for param in self.agent.parameters())\\n )\\n )\\n\\n rollouts = RolloutStorage(\\n ppo_cfg.num_steps,\\n self.envs.num_envs,\\n self.envs.observation_spaces[0],\\n self.envs.action_spaces[0],\\n ppo_cfg.hidden_size,\\n )\\n rollouts.to(self.device)\\n\\n observations = self.envs.reset()\\n batch = batch_obs(observations)\\n\\n for sensor in rollouts.observations:\\n rollouts.observations[sensor][0].copy_(batch[sensor])\\n\\n # batch and observations may contain shared PyTorch CUDA\\n # tensors. We must explicitly clear them here otherwise\\n # they will be kept in memory for the entire duration of training!\\n batch = None\\n observations = None\\n\\n running_episode_stats = dict(\\n count=torch.zeros(self.envs.num_envs, 1),\\n reward=torch.zeros(self.envs.num_envs, 1),\\n )\\n window_episode_stats = defaultdict(\\n lambda: deque(maxlen=ppo_cfg.reward_window_size)\\n )\\n\\n t_start = time.time()\\n env_time = 0\\n pth_time = 0\\n forward_time = 0\\n agent_update_time = 0\\n count_steps = 0\\n count_checkpoints = 0\\n\\n lr_scheduler = LambdaLR(\\n optimizer=self.agent.optimizer,\\n lr_lambda=lambda x: linear_decay(x, self.config.NUM_UPDATES),\\n )\\n\\n with TensorboardWriter(\\n self.config.TENSORBOARD_DIR, flush_secs=self.flush_secs\\n ) as writer:\\n for update in range(self.config.NUM_UPDATES):\\n if ppo_cfg.use_linear_lr_decay:\\n lr_scheduler.step()\\n\\n if ppo_cfg.use_linear_clip_decay:\\n self.agent.clip_param = ppo_cfg.clip_param * linear_decay(\\n update, self.config.NUM_UPDATES\\n )\\n\\n for step in range(ppo_cfg.num_steps):\\n (\\n delta_pth_time,\\n delta_forward_time,\\n delta_env_time,\\n delta_steps,\\n ) = self._collect_rollout_step(\\n rollouts, current_episode_reward, running_episode_stats,\\n )\\n pth_time += delta_pth_time\\n forward_time += delta_forward_time\\n env_time += delta_env_time\\n count_steps += delta_steps\\n\\n (\\n delta_pth_time,\\n value_loss,\\n action_loss,\\n dist_entropy,\\n ) = self._update_agent(ppo_cfg, rollouts)\\n pth_time += delta_pth_time\\n agent_update_time += delta_pth_time\\n\\n for k, v in running_episode_stats.items():\\n window_episode_stats[k].append(v.clone())\\n\\n deltas = {\\n k: (\\n (v[-1] - v[0]).sum().item() if len(v) > 1 else v[0].sum().item()\\n )\\n for k, v in window_episode_stats.items()\\n }\\n deltas[\\\"count\\\"] = max(deltas[\\\"count\\\"], 1.0)\\n\\n writer.add_scalar(\\n \\\"reward\\\", deltas[\\\"reward\\\"] / deltas[\\\"count\\\"], count_steps\\n )\\n\\n # Check to see if there are any metrics\\n # that haven't been logged yet\\n metrics = {\\n k: v / deltas[\\\"count\\\"]\\n for k, v in deltas.items()\\n if k not in {\\\"reward\\\", \\\"count\\\"}\\n }\\n if len(metrics) > 0:\\n writer.add_scalars(\\\"metrics\\\", metrics, count_steps)\\n\\n losses = [value_loss, action_loss]\\n\\n writer.add_scalars(\\n \\\"losses\\\",\\n {k: l for l, k in zip(losses, [\\\"value\\\", \\\"policy\\\"])},\\n count_steps,\\n )\\n\\n # log stats\\n if update > 0 and update % self.config.LOG_INTERVAL == 0:\\n logger.info(\\n \\\"update: {}\\\\tfps: {:.3f}\\\\t\\\".format(\\n update, count_steps / (time.time() - t_start)\\n )\\n )\\n logger.info(\\n \\\"update: {}\\\\tenv-time: {:.3f}s\\\\tpth-time: {:.3f}s\\\\t\\\"\\n \\\"forward-time: {:.3f}\\\\tagnet-update-time: {:.3f}\\\\t\\\"\\n \\\"frames: {}\\\".format(\\n update,\\n env_time,\\n pth_time,\\n forward_time,\\n agent_update_time,\\n count_steps,\\n )\\n )\\n\\n logger.info(\\n \\\"Average window size: {} {}\\\".format(\\n len(window_episode_stats[\\\"count\\\"]),\\n \\\" \\\".join(\\n \\\"{}: {:.3f}\\\".format(k, v / deltas[\\\"count\\\"])\\n for k, v in deltas.items()\\n if k != \\\"count\\\"\\n ),\\n )\\n )\\n\\n # checkpoint model\\n if update % self.config.CHECKPOINT_INTERVAL == 0:\\n self.save_checkpoint(\\n f\\\"ckpt.{count_checkpoints}.pth\\\", dict(step=count_steps)\\n )\\n count_checkpoints += 1\\n\\n self.envs.close()\",\n \"def td3Student(env_fn, actor_critic=core.MLPActorCritic, ac_kwargs=dict(), seed=0, \\n steps_per_epoch=4000, epochs=100, replay_size=int(1e6), gamma=0.99, \\n polyak=0.995, pi_lr=1e-3, q_lr=1e-3, batch_size=100, start_steps=10000, \\n update_after=1000, update_every=50, act_noise=0.1, target_noise=0.2, \\n noise_clip=0.5, policy_delay=2, num_test_episodes=10, max_ep_len=1000, \\n logger_kwargs=dict(), save_freq=1, buffer_path = ''):\\n\\n logger = EpochLogger(**logger_kwargs)\\n logger.save_config(locals())\\n\\n torch.manual_seed(seed)\\n np.random.seed(seed)\\n\\n env, test_env = env_fn(), env_fn()\\n obs_dim = env.observation_space.shape\\n act_dim = env.action_space.shape[0]\\n\\n # Action limit for clamping: critically, assumes all dimensions share the same bound!\\n act_limit = env.action_space.high[0]\\n\\n # Create actor-critic module and target networks\\n ac = actor_critic(env.observation_space, env.action_space, **ac_kwargs)\\n ac_targ = deepcopy(ac)\\n\\n # Freeze target networks with respect to optimizers (only update via polyak averaging)\\n for p in ac_targ.parameters():\\n p.requires_grad = False\\n \\n # List of parameters for both Q-networks (save this for convenience)\\n q_params = itertools.chain(ac.q1.parameters(), ac.q2.parameters())\\n\\n # Experience buffer, which contains teacher buffer\\n replay_buffer = ReplayBuffer(obs_dim=obs_dim, act_dim=act_dim, size=replay_size)\\n \\n #student buffer, only the sampled\\n \\n # Count variables (protip: try to get a feel for how different size networks behave!)\\n var_counts = tuple(core.count_vars(module) for module in [ac.pi, ac.q1, ac.q2])\\n logger.log('\\\\nNumber of parameters: \\\\t pi: %d, \\\\t q1: %d, \\\\t q2: %d\\\\n'%var_counts)\\n replay_buffer.load_from_disk(buffer_path)\\n \\n # Set up function for computing TD3 Q-losses\\n def compute_loss_q(data):\\n o, a, r, o2, d = data['obs'], data['act'], data['rew'], data['obs2'], data['done']\\n\\n q1 = ac.q1(o,a)\\n q2 = ac.q2(o,a)\\n\\n # Bellman backup for Q functions\\n with torch.no_grad():\\n pi_targ = ac_targ.pi(o2)\\n\\n # Target policy smoothing\\n epsilon = torch.randn_like(pi_targ) * target_noise\\n epsilon = torch.clamp(epsilon, -noise_clip, noise_clip)\\n a2 = pi_targ + epsilon\\n a2 = torch.clamp(a2, -act_limit, act_limit)\\n\\n # Target Q-values\\n q1_pi_targ = ac_targ.q1(o2, a2)\\n q2_pi_targ = ac_targ.q2(o2, a2)\\n q_pi_targ = torch.min(q1_pi_targ, q2_pi_targ)\\n backup = r + gamma * (1 - d) * q_pi_targ\\n\\n # MSE loss against Bellman backup\\n loss_q1 = ((q1 - backup)**2).mean()\\n loss_q2 = ((q2 - backup)**2).mean()\\n loss_q = loss_q1 + loss_q2\\n\\n # Useful info for logging\\n loss_info = dict(Q1Vals=q1.detach().numpy(),\\n Q2Vals=q2.detach().numpy())\\n\\n return loss_q, loss_info\\n\\n # Set up function for computing TD3 pi loss\\n def compute_loss_pi(data):\\n o = data['obs']\\n q1_pi = ac.q1(o, ac.pi(o))\\n return -q1_pi.mean()\\n\\n # Set up optimizers for policy and q-function\\n pi_optimizer = Adam(ac.pi.parameters(), lr=pi_lr)\\n q_optimizer = Adam(q_params, lr=q_lr)\\n\\n # Set up model saving\\n logger.setup_pytorch_saver(ac)\\n\\n def update(data, timer):\\n # First run one gradient descent step for Q1 and Q2\\n q_optimizer.zero_grad()\\n loss_q, loss_info = compute_loss_q(data)\\n loss_q.backward()\\n q_optimizer.step()\\n\\n # Record things\\n logger.store(LossQ=loss_q.item(), **loss_info)\\n\\n # Possibly update pi and target networks\\n if timer % policy_delay == 0:\\n # Freeze Q-networks so you don't waste computational effort \\n # computing gradients for them during the policy learning step.\\n for p in q_params:\\n p.requires_grad = False\\n\\n # Next run one gradient descent step for pi.\\n pi_optimizer.zero_grad()\\n loss_pi = compute_loss_pi(data)\\n loss_pi.backward()\\n pi_optimizer.step()\\n\\n # Unfreeze Q-networks so you can optimize it at next DDPG step.\\n for p in q_params:\\n p.requires_grad = True\\n\\n # Record things\\n logger.store(LossPi=loss_pi.item())\\n\\n # Finally, update target networks by polyak averaging.\\n with torch.no_grad():\\n for p, p_targ in zip(ac.parameters(), ac_targ.parameters()):\\n # NB: We use an in-place operations \\\"mul_\\\", \\\"add_\\\" to update target\\n # params, as opposed to \\\"mul\\\" and \\\"add\\\", which would make new tensors.\\n p_targ.data.mul_(polyak)\\n p_targ.data.add_((1 - polyak) * p.data)\\n\\n def get_action(o, noise_scale):\\n a = ac.act(torch.as_tensor(o, dtype=torch.float32))\\n a += noise_scale * np.random.randn(act_dim)\\n return np.clip(a, -act_limit, act_limit)\\n\\n def test_agent():\\n for j in range(num_test_episodes):\\n o, d, ep_ret, ep_len = test_env.reset(), False, 0, 0\\n while not(d or (ep_len == max_ep_len)):\\n # Take deterministic actions at test time (noise_scale=0)\\n o, r, d, _ = test_env.step(get_action(o, 0))\\n ep_ret += r\\n ep_len += 1\\n logger.store(TestEpRet=ep_ret, TestEpLen=ep_len)\\n\\n # Prepare for interaction with environment\\n total_steps = steps_per_epoch * epochs\\n start_time = time.time()\\n timer = 0\\n\\n # Main loop: Update using actions taken from replay buffer data\\n for t in range(total_steps):\\n\\n # Update handling\\n batch = replay_buffer.sample_batch(batch_size)\\n update(data=batch, timer = timer)\\n\\n # End of epoch handling\\n if (t+1) % steps_per_epoch == 0:\\n epoch = (t+1) // steps_per_epoch\\n\\n # Save model\\n if (epoch % save_freq == 0) or (epoch == epochs):\\n logger.save_state({'env': env}, None)\\n\\n # Test the performance of the deterministic version of the agent.\\n test_agent()\\n\\n # Log info about epoch\\n logger.log_tabular('Epoch', epoch)\\n# logger.log_tabular('EpRet', with_min_and_max=True)\\n logger.log_tabular('TestEpRet', with_min_and_max=True)\\n# logger.log_tabular('EpLen', average_only=True)\\n logger.log_tabular('TestEpLen', average_only=True)\\n logger.log_tabular('TotalEnvInteracts', t)\\n logger.log_tabular('Q1Vals', with_min_and_max=True)\\n logger.log_tabular('Q2Vals', with_min_and_max=True)\\n logger.log_tabular('LossPi', average_only=True)\\n logger.log_tabular('LossQ', average_only=True)\\n logger.log_tabular('Time', time.time()-start_time)\\n logger.dump_tabular()\\n timer += 1\",\n \"def train():\\n pass\",\n \"def train_models(self, states, actions, rewards, done):\\n # Compute discounted rewards and Advantage (TD. Error)\\n discounted_rewards = self.discount(rewards, done, states[-1])\\n state_values = self.critic.predict(np.array(states))\\n advantages = discounted_rewards - np.reshape(state_values, len(state_values))\\n # Networks optimization\\n self.a_opt([states, actions, advantages])\\n self.c_opt([states, discounted_rewards])\",\n \"def __init__(self, env, actor=None, critic=None, weights=None, warmup_actor=1, warmup_critic=1, gamma=0.99):\\n self.env = env\\n nactions = np.product(self.env.action_shape)\\n actor = self._actor() if actor is None else actor\\n critic, action_input = self._critic() if critic is None else critic\\n membuf = SequentialMemory(int(1E5), window_length=1)\\n random = OrnsteinUhlenbeckProcess(size=nactions, theta=0.15, mu=0.0, sigma=0.3)\\n self.agent = DDPGAgent(nb_actions=nactions,\\n actor=actor,\\n critic=critic,\\n critic_action_input=action_input,\\n memory=membuf,\\n nb_steps_warmup_critic=warmup_critic,\\n nb_steps_warmup_actor=warmup_actor,\\n random_process=random,\\n gamma=gamma,\\n target_model_update=1E-3)\\n self.agent.compile(keras.optimizers.Adam(lr=0.001, clipnorm=1.0), metrics=['mae', 'accuracy'])\\n\\n # Potentially load the Agent's weights from disk\\n if weights is not None:\\n basename, ext = os.path.splitext(weights)\\n cweights = basename + \\\"_critic\\\" + ext\\n aweights = basename + \\\"_actor\\\" + ext\\n if not os.path.isfile(cweights):\\n raise ValueError(\\\"Could not find file\\\", cweights)\\n elif not os.path.isfile(aweights):\\n raise ValueError(\\\"Could not find file\\\", aweights)\\n else:\\n self.agent.load_weights(weights)\",\n \"def learn(self, agent_id, experiences, gamma, all_next_actions, all_actions):\\n\\n states, actions, rewards, next_states, dones = experiences\\n\\n # ---------------------------- update critic ---------------------------- #\\n self.critic_optimizer.zero_grad()\\n agent_id = torch.tensor([agent_id]).to(device)\\n actions_next = torch.cat(all_next_actions, dim=1).to(device)\\n with torch.no_grad():\\n q_targets_next = self.critic_target(next_states, actions_next)\\n q_expected = self.critic_local(states, actions)\\n # q_targets = reward of this timestep + discount * Q(st+1,at+1) from target network\\n q_targets = rewards.index_select(1, agent_id) + (gamma * q_targets_next * (1 - dones.index_select(1, agent_id)))\\n critic_loss = F.mse_loss(q_expected, q_targets.detach())\\n critic_loss.backward()\\n self.critic_optimizer.step()\\n\\n # ---------------------------- update actor ---------------------------- #\\n self.actor_optimizer.zero_grad()\\n actions_pred = [actions if i == self.id else actions.detach() for i, actions in enumerate(all_actions)]\\n actions_pred = torch.cat(actions_pred, dim=1).to(device)\\n actor_loss = -self.critic_local(states, actions_pred).mean()\\n actor_loss.backward()\\n self.actor_optimizer.step()\\n # ----------------------- update target networks ----------------------- #\\n self.soft_update(self.critic_local, self.critic_target, self.tau)\\n self.soft_update(self.actor_local, self.actor_target, self.tau)\",\n \"def train(self, features, actions, rewards):\\n self.model.fit(x=features, y=actions, sample_weight=rewards,\\n verbose=False)\",\n \"def _Train(self, limit):\\n if len(self.Memory)>BATCH_SIZE: \\n # Limit of Agents to Train\\n for i in range(limit): \\n # 'n' number of rounds to train \\n for _ in range(50):\\n # Get Batch Data\\n experiances = self.Memory.sample()\\n # Train Models\\n self._Learn(self.Actor[i], self.ActorTarget, self.actorOpt[i], experiances)\",\n \"def train(self):\\n\\n agent_step = self._num_actions_taken\\n\\n if agent_step >= self._train_after:\\n if (agent_step % self._train_interval) == 0:\\n pre_states, actions, post_states, rewards, terminals = self._memory.minibatch(self._minibatch_size)\\n\\n self._trainer.train_minibatch(\\n self._trainer.loss_function.argument_map(\\n pre_states=pre_states,\\n actions=Value.one_hot(actions.reshape(-1, 1).tolist(), self.nb_actions),\\n post_states=post_states,\\n rewards=rewards,\\n terminals=terminals\\n )\\n )\\n\\n # Update the Target Network if needed\\n if (agent_step % self._target_update_interval) == 0:\\n self._target_net = self._action_value_net.clone(CloneMethod.freeze)\\n filename = \\\"models\\\\model%d\\\" % agent_step\\n self._trainer.save_checkpoint(filename)\",\n \"def learn(self):\\n event_batch = self.memory.sample(self.batch_size)\\n \\n if event_batch is None:\\n return\\n\\n event_batch = self.memory.deserialize(event_batch)\\n self.update_critic(event_batch)\\n self.update_actor(event_batch)\\n self.update_target(self.local_actor, self.target_actor)\\n self.update_target(self.local_critic, self.target_critic)\",\n \"def step(self):\\n\\n \\\"\\\"\\\" First updates the variables values of the current time form the environment \\\"\\\"\\\"\\n self.update_crispval(self.env.context)\\n\\n \\\"\\\"\\\"\\n here the decision making of the agent\\n to determine which activity to suggest to the patient\\n i apply the creative controller to the current context\\n \\\"\\\"\\\"\\n curr_input = sample_inputs(False, 0, self.curr_interaction, self.variables_default_val, self.action_var,\\n self.fuzzysets_values, self.variables_universe)\\n c_out, rules_activations, is_cc_exception = self.creative_controller.computeOutput(curr_input, False)\\n\\n \\\"\\\"\\\" i obtain a number of ouput crisp values.\\n i determine which one achieves the max expected output w.r.t. the a-rules \\\"\\\"\\\"\\n best_a = None\\n best_a_val = -1000\\n best_a_exphapp = 5\\n if self.verbose > Constants.VERBOSE_BASIC:\\n print(\\\"rules activations\\\")\\n for a in rules_activations:\\n if rules_activations[a] > 0:\\n print(str(a) + \\\"\\\\n\\\\t\\\\t\\\\t-> \\\" + str(rules_activations[a]))\\n for item in c_out.items(): # for each pair <activity, crisp output>\\n if self.verbose > Constants.VERBOSE_BASIC:\\n print(item)\\n if not item[\\n 0] in self.curr_iter_suggestions: # if i didn't suggest the same activity already in the same interaction\\n inputs = dict(curr_input) # I create a copy fo the dict\\n inputs[item[0]] = item[1]\\n assessor_id = self.actions_to_ti[item[0]]\\n self.assessors[assessor_id].feed_inputs(inputs)\\n is_ac_exception = False\\n assout = []\\n try:\\n a_out, a_rules_activations, is_ac_exception = self.assessors[assessor_id].compute(verbose=False)\\n assout = [a_out[ao] for ao in a_out]\\n except:\\n is_ac_exception = True\\n traceback.print_exc()\\n # todo the following assumes that every assessor controller has same eval var\\n for v in self.eval_var:\\n assout.append(self.variables_default_val[v])\\n if len(assout) == 0:\\n for v in self.eval_var:\\n assout.append(self.variables_default_val[v])\\n w_ta = self.weights_therapeutic_interventions[self.actions_to_ti[item[0]]]\\n\\n avg_credit_rules_that_suggested_action = 1.0\\n nr_rules_that_suggested_action = 0\\n for r in rules_activations:\\n if (rules_activations[r] > 0) and (str(item[0]) in str(r)):\\n avg_credit_rules_that_suggested_action = avg_credit_rules_that_suggested_action + \\\\\\n self.rules_credits[str(r)]\\n nr_rules_that_suggested_action = nr_rules_that_suggested_action + 1\\n if nr_rules_that_suggested_action > 0:\\n avg_credit_rules_that_suggested_action = (\\n avg_credit_rules_that_suggested_action - 1.0) / nr_rules_that_suggested_action\\n repetition_cost = 1.0\\n a_val = (mean(assout) * w_ta * avg_credit_rules_that_suggested_action) / repetition_cost\\n if (a_val > best_a_val) and (\\n item[1] >= (self.variables_default_val[item[0]] + self.range_step[item[0]])):\\n best_a = item\\n best_a_val = a_val\\n best_a_exphapp = mean(assout)\\n\\n \\\"\\\"\\\"I suggest the activity with best expected outcome and store the information to populate the interactions \\n memory \\\"\\\"\\\"\\n self.proposeActivity(best_a)\\n if not best_a is None:\\n if (self.verbose > Constants.VERBOSE_FALSE) and (self.verbose <= Constants.VERBOSE_BASIC):\\n print(\\\"proposing activity\\\" + str(best_a) + \\\" which has expected feedback: \\\" + str(\\n best_a_exphapp) + \\\", which weighted is \\\" + str(best_a_val))\\n self.curr_iter_suggestions.append(best_a[0])\\n self.last_suggestion = best_a\\n else:\\n if (self.verbose > Constants.VERBOSE_FALSE) and (self.verbose <= Constants.VERBOSE_BASIC):\\n print(\\\"the activity proposed is \\\" + str(\\n best_a) + \\\" so I don't suggest anything. I will ask a question instead\\\")\\n self.last_suggestion = []\\n self.expected_feedback = best_a_exphapp\\n self.last_context = self.env.context.copy()\\n self.last_rules_activations = rules_activations\",\n \"def _setup_actor_critic_agent(self, ppo_cfg: Config, observation_space=None) -> None:\\n logger.add_filehandler(self.config.LOG_FILE)\\n\\n if observation_space is None:\\n observation_space = self.envs.observation_spaces[0]\\n\\n self.actor_critic = AudioNavBaselinePolicy(\\n observation_space=observation_space,\\n action_space=self.envs.action_spaces[0],\\n hidden_size=ppo_cfg.hidden_size,\\n goal_sensor_uuid=self.config.TASK_CONFIG.TASK.GOAL_SENSOR_UUID,\\n extra_rgb=self.config.EXTRA_RGB\\n )\\n\\n self.agent = PPO(\\n actor_critic=self.actor_critic,\\n clip_param=ppo_cfg.clip_param,\\n ppo_epoch=ppo_cfg.ppo_epoch,\\n num_mini_batch=ppo_cfg.num_mini_batch,\\n value_loss_coef=ppo_cfg.value_loss_coef,\\n entropy_coef=ppo_cfg.entropy_coef,\\n lr=ppo_cfg.lr,\\n eps=ppo_cfg.eps,\\n max_grad_norm=ppo_cfg.max_grad_norm,\\n )\\n\\n if self.config.RESUME:\\n ckpt_dict = self.load_checkpoint('data/models/smt_with_pose/ckpt.400.pth', map_location=\\\"cpu\\\")\\n self.agent.actor_critic.net.visual_encoder.load_state_dict(self.search_dict(ckpt_dict, 'visual_encoder'))\\n self.agent.actor_critic.net.goal_encoder.load_state_dict(self.search_dict(ckpt_dict, 'goal_encoder'))\\n self.agent.actor_critic.net.action_encoder.load_state_dict(self.search_dict(ckpt_dict, 'action_encoder'))\\n\\n self.actor_critic.to(self.device)\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def train():\\n # YOUR TRAINING CODE GOES HERE\",\n \"def train(self):\\n feature = Feature(trained=False)\\n classifier = LogisticRegression(\\n penalty='l2',\\n max_iter=100,\\n solver='liblinear',\\n random_state=self.RAND_SEED)\\n\\n true_labels = []\\n predicted_labels = []\\n\\n for subj in self.subjects:\\n print(subj)\\n # preprocess training and testing set\\n self.dataset_gen(subject=subj, valid=False)\\n\\n # train and predict\\n pipeline_steps = [('vectorized', feature.vector)]\\n if self.istfidf:\\n pipeline_steps.append(('tf-idf', feature.tfidftransform))\\n if self.islda == 'small':\\n pipeline_steps.append(('lda', feature.ldatransform_small))\\n elif self.islda == 'large':\\n pipeline_steps.append(('lda', feature.ldatransform_large))\\n else:\\n pass\\n if self.isnorm:\\n pipeline_steps.append(('scalar', StandardScaler(with_mean=False)))\\n pipeline_steps.append(('clf', classifier))\\n model = Pipeline(steps=pipeline_steps)\\n\\n model.fit(self.X_train, self.y_train)\\n\\n predicted = model.predict(self.X_test)\\n # hamming\\n predicted_labels.append(predicted)\\n true_labels.append(self.y_test)\\n\\n true_matrix, pred_matrix = np.array(true_labels, int).T, np.array(predicted_labels, int).T\\n true_matrix[true_matrix == -1] = 0\\n pred_matrix[pred_matrix == -1] = 0\\n\\n evaluation = Evaluation(self.subjects)\\n evaluation.model_evaluate(true_matrix=true_matrix, pred_matrix=pred_matrix, model_name=self.modelname)\",\n \"def optimize(self):\\n\\t\\ts1,a1,r1,s2 = self.ram.agg_sample(self.batch_size)\\n\\n\\t\\ts1 = Variable(torch.from_numpy(s1))\\n\\t\\ta1 = Variable(torch.from_numpy(a1))\\n\\t\\tr1 = Variable(torch.from_numpy(r1))\\n\\t\\ts2 = Variable(torch.from_numpy(s2))\\n\\n\\t\\tfor i in range(self.critic_step):\\n\\t\\t\\t# ---------------------- optimize critic ----------------------\\n\\t\\t\\t# Use target actor exploitation policy here for loss evaluation\\n\\t\\t\\t\\n\\t\\t\\t# a2 = self.target_actor.forward(s2).detach()\\n\\t\\t\\t# next_val = torch.squeeze(self.target_critic.forward(s2, a2).detach())\\n\\t\\t\\t\\n\\t\\t\\t# y_exp = r + gamma*Q'( s2, pi'(s2))\\n\\t\\t\\ty_expected = r1 #+ GAMMA*next_val\\n\\t\\t\\t# y_pred = Q( s1, a1)\\n\\t\\t\\ty_predicted = torch.squeeze(self.critic.forward(s1, a1))\\n\\t\\t\\t# compute critic loss, and update the critic\\n\\t\\t\\t#print(y_predicted,y_expected,\\\"hi\\\")\\n\\t\\t\\tloss_critic = F.smooth_l1_loss(y_predicted, y_expected.squeeze())\\n\\t\\t\\tself.critic_optimizer.zero_grad()\\n\\t\\t\\tloss_critic.backward()\\n\\t\\t\\tself.critic_optimizer.step()\\n\\n\\t\\t# ---------------------- optimize actor ----------------------\\n\\t\\tpred_a1 = self.actor.forward(s1)\\n\\t\\tloss_actor = -1*torch.sum(self.critic.forward(s1, pred_a1))\\n\\t\\tself.actor_optimizer.zero_grad()\\n\\t\\tloss_actor.backward()\\n\\t\\tself.actor_optimizer.step()\\n\\n\\t\\tutils.soft_update(self.target_actor, self.actor, TAU)\\n\\t\\tutils.soft_update(self.target_critic, self.critic, TAU)\\n\\n\\t\\t# if self.iter % 100 == 0:\\n\\t\\tif self.batch_size > 1:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()[0]\\n\\t\\t\\tr_1 = r1.data.numpy()[0]\\n\\t\\telse:\\n\\t\\t\\ty_1 = y_predicted.data.numpy()\\n\\t\\t\\tr_1 = r1.data.numpy()\\n\\t\\tprint ('Iteration :- ', self.iter, ' Loss_actor :- ', loss_actor.data.numpy(),\\\\\\n\\t\\t\\t' Loss_critic :- ', loss_critic.data.numpy(), ' Critic Pred Reward :- ', y_1, ' Actual Reward :- ', r_1)\\n\\t\\tself.iter += 1\",\n \"def __init__(self,\\n sess,\\n ob_space,\\n ac_space,\\n co_space,\\n buffer_size,\\n batch_size,\\n actor_lr,\\n critic_lr,\\n verbose,\\n tau,\\n gamma,\\n use_huber,\\n l2_penalty,\\n model_params,\\n num_envs=1):\\n super(ActorCriticPolicy, self).__init__(\\n sess=sess,\\n ob_space=ob_space,\\n ac_space=ac_space,\\n co_space=co_space,\\n verbose=verbose,\\n l2_penalty=l2_penalty,\\n model_params=model_params,\\n num_envs=num_envs,\\n )\\n\\n self.buffer_size = buffer_size\\n self.batch_size = batch_size\\n self.actor_lr = actor_lr\\n self.critic_lr = critic_lr\\n self.tau = tau\\n self.gamma = gamma\\n self.use_huber = use_huber\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def train(self):\\n pass\",\n \"def learn(self,experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # --------- Update Critic network -------#\\n actions_next = self.actor_target(next_states)\\n Q_targets_next = self.critic_target(next_states,actions_next)\\n Q_targets = rewards + (gamma * Q_targets_next * (1- dones))\\n\\n #--------- Compute critic loss using MSE--#\\n Q_expected = self.critic_local(states,actions)\\n critic_loss = F.mse_loss(Q_expected,Q_targets)\\n\\n #----------Minimize the loss -----------#\\n self.critic_optimizer.zero_grad()\\n critic_loss.backward()\\n nn.utils.clip_grad_norm(self.critic_local.parameters(),1)\\n self.critic_optimizer.step()\\n\\n #-------- Update Actor network---------#\\n # get mu(s)\\n actions_pred = self.actor_local(states)\\n #get V(s,a)\\n actor_loss = -self.critic_local(states,actions_pred).mean()\\n #-------- Minize the loss -----------#\\n self.actor_optimizer.zero_grad()\\n actor_loss.backward()\\n self.actor_optimizer.step()\\n\\n #------- Update Target Networks ----#\\n self.soft_update(self.critic_local,self.critic_target,TAU)\\n self.soft_update(self.actor_local,self.actor_target,TAU)\",\n \"def train_step(_states, _actions, _rewards):\\n _cumulative_rewards = get_cumulative_rewards(_rewards)\\n update.run({states:_states, actions: _actions, cumulative_rewards:_cumulative_rewards})\",\n \"def update(self, *args: Any, **kwargs: Any):\\n obss = []\\n losses = []\\n for t in range(self.num_teachers):\\n concat_ros = StepSequence.concat(kwargs[\\\"rollouts\\\"][t])\\n concat_ros.torch(data_type=to.get_default_dtype())\\n obss.append(concat_ros.get_data_values(\\\"observations\\\")[: self.min_steps])\\n\\n # Train student\\n for epoch in range(self.num_epochs):\\n self.optimizer.zero_grad()\\n\\n loss = 0\\n for t_idx, teacher in enumerate(self.teacher_policies):\\n s_dist = self.expl_strat.action_dist_at(self.policy(obss[t_idx]))\\n s_act = s_dist.sample()\\n t_dist = self.teacher_expl_strats[t_idx].action_dist_at(teacher(obss[t_idx]))\\n\\n l = self.teacher_weights[t_idx] * self.criterion(t_dist.log_prob(s_act), s_dist.log_prob(s_act))\\n loss += l\\n losses.append([t_idx, l.item()])\\n print(f\\\"Epoch {epoch} Loss: {loss.item()}\\\")\\n loss.backward()\\n self.optimizer.step()\",\n \"def _training_before_hook(self):\\n pass\",\n \"def train(self, observation, action, reward, done):\\r\\n\\r\\n # Adding organic session to organic view counts.\\r\\n if observation:\\r\\n for session in observation.sessions():\\r\\n self.organic_views[session['v']] += 1\",\n \"def train_models(self, states, actions, rewards):\\n # Compute discounted rewards and Advantage (TD. Error)\\n discounted_rewards = self.discount(rewards)\\n state_values = self.critic.predict(np.array(states))\\n advantages = discounted_rewards - np.reshape(state_values, len(state_values))\\n # Networks optimization\\n self.act_op([states, actions, advantages])\\n self.cri_op([states, discounted_rewards])\",\n \"def learn(self):\\n for a in self.agents:\\n a.learn()\",\n \"def init_trainers(self, args):\\n self.actors_cur = [None for _ in range(self.num_agents)]\\n self.critics_cur = [None for _ in range(self.num_agents)]\\n self.actors_tar = [None for _ in range(self.num_agents)]\\n self.critics_tar = [None for _ in range(self.num_agents)]\\n self.optimizers_c = [None for _ in range(self.num_agents)]\\n self.optimizers_a = [None for _ in range(self.num_agents)]\\n input_size_global = sum(self.obs_shape_n) + sum(self.action_shape_n)\\n\\n if args.restore == True: # restore the model\\n game_step = int(args.old_model_name.split('_')[-1][:-1])\\n for idx in range(self.num_agents):\\n self.actors_cur[idx] = torch.load(args.old_model_name+'a_c_{}.pt'.format(idx))\\n self.actors_tar[idx] = torch.load(args.old_model_name+'a_t_{}.pt'.format(idx))\\n self.critics_cur[idx] = torch.load(args.old_model_name+'c_c_{}.pt'.format(idx))\\n self.critics_tar[idx] = torch.load(args.old_model_name+'c_t_{}.pt'.format(idx))\\n self.optimizers_a[idx] = optim.Adam(self.actors_cur[idx].parameters(), args.lr_a)\\n self.optimizers_c[idx] = optim.Adam(self.critics_cur[idx].parameters(), args.lr_c)\\n self.var = self.var - (game_step-args.learning_start_episode*args.per_episode_max_len)*args.var_discount\\n self.var = self.min_var if self.var < self.min_var else self.var\\n old_data = {'game_step':game_step, 'episode_gone_old':int(game_step/args.per_episode_max_len)}\\n\\n # Note: if you need load old model, there should be a procedure for juding if the trainers[idx] is None\\n for i in range(self.num_agents):\\n self.actors_cur[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_cur[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.actors_tar[i] = actor_agent(self.obs_shape_n[i], self.action_shape_n[i], \\\\\\n args).to(args.device)\\n self.critics_tar[i] = critic_agent(sum(self.obs_shape_n), sum(self.action_shape_n), \\\\\\n args).to(args.device)\\n self.optimizers_a[i] = optim.Adam(self.actors_cur[i].parameters(), args.lr_a)\\n self.optimizers_c[i] = optim.Adam(self.critics_cur[i].parameters(), args.lr_c)\\n\\n # return the old data, no need to update the trainers\\n if args.restore == True: return old_data\\n\\n self.actors_tar = self.update_trainers(self.actors_cur, self.actors_tar, 1.0) # update the target par using the cur\\n self.critics_tar = self.update_trainers(self.critics_cur, self.critics_tar, 1.0) # update the target par using the cur\",\n \"def _setup_actor_critic_agent(self, ppo_cfg: Config) -> None:\\n logger.add_filehandler(self.config.LOG_FILE)\\n\\n self.actor_critic = RearrangementBaselinePolicy(\\n observation_space=self.envs.observation_spaces[0],\\n action_space=self.envs.action_spaces[0],\\n hidden_size=ppo_cfg.hidden_size,\\n )\\n self.actor_critic.to(self.device)\\n\\n self.agent = PPO(\\n actor_critic=self.actor_critic,\\n clip_param=ppo_cfg.clip_param,\\n ppo_epoch=ppo_cfg.ppo_epoch,\\n num_mini_batch=ppo_cfg.num_mini_batch,\\n value_loss_coef=ppo_cfg.value_loss_coef,\\n entropy_coef=ppo_cfg.entropy_coef,\\n lr=ppo_cfg.lr,\\n eps=ppo_cfg.eps,\\n max_grad_norm=ppo_cfg.max_grad_norm,\\n use_normalized_advantage=ppo_cfg.use_normalized_advantage,\\n )\",\n \"def train(self) -> None:\\n logger.info(f\\\"config: {self.config}\\\")\\n random.seed(self.config.SEED)\\n np.random.seed(self.config.SEED)\\n torch.manual_seed(self.config.SEED)\\n\\n # add_signal_handlers()\\n\\n self.envs = construct_envs(\\n self.config, get_env_class(self.config.ENV_NAME), workers_ignore_signals=True\\n )\\n\\n ppo_cfg = self.config.RL.PPO\\n self.device = (\\n torch.device(\\\"cuda\\\", self.config.TORCH_GPU_ID)\\n if torch.cuda.is_available()\\n else torch.device(\\\"cpu\\\")\\n )\\n if not os.path.isdir(self.config.CHECKPOINT_FOLDER):\\n os.makedirs(self.config.CHECKPOINT_FOLDER)\\n self._setup_actor_critic_agent(ppo_cfg)\\n logger.info(\\n \\\"agent number of parameters: {}\\\".format(\\n sum(param.numel() for param in self.agent.parameters())\\n )\\n )\\n\\n rollouts = RolloutStorage(\\n ppo_cfg.num_steps,\\n self.envs.num_envs,\\n self.envs.observation_spaces[0],\\n self.envs.action_spaces[0],\\n ppo_cfg.hidden_size\\n )\\n rollouts.to(self.device)\\n\\n observations = self.envs.reset()\\n batch = batch_obs(observations)\\n\\n for sensor in rollouts.observations:\\n rollouts.observations[sensor][0].copy_(batch[sensor])\\n\\n # batch and observations may contain shared PyTorch CUDA\\n # tensors. We must explicitly clear them here otherwise\\n # they will be kept in memory for the entire duration of training!\\n batch = None\\n observations = None\\n\\n current_episode_reward = torch.zeros(self.envs.num_envs, 1)\\n running_episode_stats = dict(\\n count=torch.zeros(self.envs.num_envs, 1),\\n reward=torch.zeros(self.envs.num_envs, 1),\\n )\\n window_episode_stats = defaultdict(\\n lambda: deque(maxlen=ppo_cfg.reward_window_size)\\n )\\n\\n t_start = time.time()\\n env_time = 0\\n pth_time = 0\\n count_steps = 0\\n count_checkpoints = 0\\n start_update = 0\\n prev_time = 0\\n\\n lr_scheduler = LambdaLR(\\n optimizer=self.agent.optimizer,\\n lr_lambda=lambda x: linear_decay(x, self.config.NUM_UPDATES),\\n )\\n\\n interrupted_state = load_interrupted_state(model_dir=self.config.MODEL_DIR)\\n if interrupted_state is not None:\\n self.agent.load_state_dict(interrupted_state[\\\"state_dict\\\"])\\n self.agent.optimizer.load_state_dict(\\n interrupted_state[\\\"optimizer_state\\\"]\\n )\\n lr_scheduler.load_state_dict(interrupted_state[\\\"lr_scheduler_state\\\"])\\n\\n requeue_stats = interrupted_state[\\\"requeue_stats\\\"]\\n env_time = requeue_stats[\\\"env_time\\\"]\\n pth_time = requeue_stats[\\\"pth_time\\\"]\\n count_steps = requeue_stats[\\\"count_steps\\\"]\\n count_checkpoints = requeue_stats[\\\"count_checkpoints\\\"]\\n start_update = requeue_stats[\\\"start_update\\\"]\\n prev_time = requeue_stats[\\\"prev_time\\\"]\\n\\n with TensorboardWriter(\\n self.config.TENSORBOARD_DIR, flush_secs=self.flush_secs\\n ) as writer:\\n for update in range(start_update, self.config.NUM_UPDATES):\\n if ppo_cfg.use_linear_lr_decay:\\n lr_scheduler.step()\\n\\n if ppo_cfg.use_linear_clip_decay:\\n self.agent.clip_param = ppo_cfg.clip_param * linear_decay(\\n update, self.config.NUM_UPDATES\\n )\\n\\n if EXIT.is_set():\\n self.envs.close()\\n\\n if REQUEUE.is_set():\\n requeue_stats = dict(\\n env_time=env_time,\\n pth_time=pth_time,\\n count_steps=count_steps,\\n count_checkpoints=count_checkpoints,\\n start_update=update,\\n prev_time=(time.time() - t_start) + prev_time,\\n )\\n save_interrupted_state(\\n dict(\\n state_dict=self.agent.state_dict(),\\n optimizer_state=self.agent.optimizer.state_dict(),\\n lr_scheduler_state=lr_scheduler.state_dict(),\\n config=self.config,\\n requeue_stats=requeue_stats,\\n ),\\n model_dir=self.config.MODEL_DIR\\n )\\n requeue_job()\\n return\\n\\n for step in range(ppo_cfg.num_steps):\\n delta_pth_time, delta_env_time, delta_steps = self._collect_rollout_step(\\n rollouts,\\n current_episode_reward,\\n running_episode_stats\\n )\\n pth_time += delta_pth_time\\n env_time += delta_env_time\\n count_steps += delta_steps\\n\\n delta_pth_time, value_loss, action_loss, dist_entropy = self._update_agent(\\n ppo_cfg, rollouts\\n )\\n pth_time += delta_pth_time\\n\\n deltas = {\\n k: (\\n (v[-1] - v[0]).sum().item()\\n if len(v) > 1\\n else v[0].sum().item()\\n )\\n for k, v in window_episode_stats.items()\\n }\\n deltas[\\\"count\\\"] = max(deltas[\\\"count\\\"], 1.0)\\n\\n writer.add_scalar(\\n \\\"Metrics/reward\\\", deltas[\\\"reward\\\"] / deltas[\\\"count\\\"], count_steps\\n )\\n\\n # Check to see if there are any metrics\\n # that haven't been logged yet\\n metrics = {\\n k: v / deltas[\\\"count\\\"]\\n for k, v in deltas.items()\\n if k not in {\\\"reward\\\", \\\"count\\\"}\\n }\\n if len(metrics) > 0:\\n # writer.add_scalars(\\\"metrics\\\", metrics, count_steps)\\n for metric, value in metrics.items():\\n writer.add_scalar(f\\\"Metrics/{metric}\\\", value, count_steps)\\n\\n writer.add_scalar(\\\"Policy/value_loss\\\", value_loss, count_steps)\\n writer.add_scalar(\\\"Policy/policy_loss\\\", action_loss, count_steps)\\n writer.add_scalar(\\\"Policy/entropy_loss\\\", dist_entropy, count_steps)\\n writer.add_scalar('Policy/learning_rate', lr_scheduler.get_lr()[0], count_steps)\\n\\n # log stats\\n if update > 0 and update % self.config.LOG_INTERVAL == 0:\\n logger.info(\\n \\\"update: {}\\\\tfps: {:.3f}\\\\t\\\".format(\\n update, count_steps / (time.time() - t_start)\\n )\\n )\\n\\n logger.info(\\n \\\"update: {}\\\\tenv-time: {:.3f}s\\\\tpth-time: {:.3f}s\\\\t\\\"\\n \\\"frames: {}\\\".format(\\n update, env_time, pth_time, count_steps\\n )\\n )\\n\\n logger.info(\\n \\\"Average window size: {} {}\\\".format(\\n len(window_episode_stats[\\\"count\\\"]),\\n \\\" \\\".join(\\n \\\"{}: {:.3f}\\\".format(k, v / deltas[\\\"count\\\"])\\n for k, v in deltas.items()\\n if k != \\\"count\\\"\\n ),\\n )\\n )\\n\\n # checkpoint model\\n if update % self.config.CHECKPOINT_INTERVAL == 0:\\n self.save_checkpoint(f\\\"ckpt.{count_checkpoints}.pth\\\")\\n count_checkpoints += 1\\n\\n self.envs.close()\",\n \"def _train_model(self):\\n self.experiment = EpisodicExperiment(self.task, self.agent)\\n n_epochs = int(self.rl_params.n_training_episodes / self.rl_params.n_episodes_per_epoch)\\n logger.debug(\\\"Fitting user model over {} epochs, each {} episodes, total {} episodes.\\\"\\n .format(n_epochs, self.rl_params.n_episodes_per_epoch, n_epochs*self.rl_params.n_episodes_per_epoch))\\n for i in range(n_epochs):\\n logger.debug(\\\"RL epoch {}\\\".format(i))\\n self.experiment.doEpisodes(self.rl_params.n_episodes_per_epoch)\\n self.agent.learn()\\n self.agent.reset() # reset buffers\",\n \"def train(args, worker_id: int, global_model: Union[ActorNetwork, ActorCriticNetwork], T: Value, global_reward: Value,\\n optimizer: torch.optim.Optimizer = None, global_model_critic: CriticNetwork = None,\\n optimizer_critic: torch.optim.Optimizer = None, lr_scheduler: torch.optim.lr_scheduler = None,\\n lr_scheduler_critic: torch.optim.lr_scheduler = None):\\n torch.manual_seed(args.seed + worker_id)\\n\\n if args.worker == 1:\\n logging.info(f\\\"Running A2C with {args.n_envs} environments.\\\")\\n if \\\"RR\\\" not in args.env_name:\\n env = SubprocVecEnv([make_env(args.env_name, args.seed, i, args.log_dir) for i in range(args.n_envs)])\\n else:\\n env = DummyVecEnv([make_env(args.env_name, args.seed, worker_id, args.log_dir)])\\n else:\\n logging.info(f\\\"Running A3C: training worker {worker_id} started.\\\")\\n env = DummyVecEnv([make_env(args.env_name, args.seed, worker_id, args.log_dir)])\\n # avoid any issues if this is not 1\\n args.n_envs = 1\\n\\n normalizer = get_normalizer(args.normalizer, env)\\n\\n # init local NN instance for worker thread\\n model = copy.deepcopy(global_model)\\n model.train()\\n\\n model_critic = None\\n\\n if global_model_critic:\\n model_critic = copy.deepcopy(global_model_critic)\\n model_critic.train()\\n\\n # if no shared optimizer is provided use individual one\\n if not optimizer:\\n optimizer, optimizer_critic = get_optimizer(args.optimizer, global_model, args.lr,\\n model_critic=global_model_critic, lr_critic=args.lr_critic)\\n if args.lr_scheduler == \\\"exponential\\\":\\n lr_scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.99)\\n if optimizer_critic:\\n lr_scheduler_critic = torch.optim.lr_scheduler.ExponentialLR(optimizer_critic, gamma=0.99)\\n\\n state = torch.Tensor(env.reset())\\n\\n t = np.zeros(args.n_envs)\\n global_iter = 0\\n episode_reward = np.zeros(args.n_envs)\\n\\n if worker_id == 0:\\n writer = SummaryWriter(log_dir='experiments/runs/')\\n\\n while True:\\n # Get state of the global model\\n model.load_state_dict(global_model.state_dict())\\n if not args.shared_model:\\n model_critic.load_state_dict(global_model_critic.state_dict())\\n\\n # containers for computing loss\\n values = []\\n log_probs = []\\n rewards = []\\n entropies = []\\n # container to check whether a terminal state was reached from one of the envs\\n terminals = []\\n\\n # reward_sum = 0\\n for step in range(args.rollout_steps):\\n t += 1\\n\\n if args.shared_model:\\n value, mu, std = model(normalizer(state))\\n else:\\n mu, std = model(normalizer(state))\\n value = model_critic(normalizer(state))\\n\\n dist = torch.distributions.Normal(mu, std)\\n\\n # ------------------------------------------\\n # # select action\\n action = dist.sample()\\n\\n # ------------------------------------------\\n # Compute statistics for loss\\n entropy = dist.entropy().sum(-1).unsqueeze(-1)\\n log_prob = dist.log_prob(action).sum(-1).unsqueeze(-1)\\n\\n # make selected move\\n action = np.clip(action.detach().numpy(), -args.max_action, args.max_action)\\n state, reward, dones, _ = env.step(action[0] if not args.worker == 1 or \\\"RR\\\" in args.env_name else action)\\n\\n reward = shape_reward(args, reward)\\n\\n episode_reward += reward\\n\\n # probably don't set terminal state if max_episode length\\n dones = np.logical_or(dones, t >= args.max_episode_length)\\n\\n values.append(value)\\n log_probs.append(log_prob)\\n rewards.append(torch.Tensor(reward).unsqueeze(-1))\\n entropies.append(entropy)\\n terminals.append(torch.Tensor(1 - dones).unsqueeze(-1))\\n\\n for i, done in enumerate(dones):\\n if done:\\n # keep track of the avg overall global reward\\n with global_reward.get_lock():\\n if global_reward.value == -np.inf:\\n global_reward.value = episode_reward[i]\\n else:\\n global_reward.value = .99 * global_reward.value + .01 * episode_reward[i]\\n if worker_id == 0 and T.value % args.log_frequency == 0:\\n writer.add_scalar(\\\"reward/global\\\", global_reward.value, T.value)\\n\\n episode_reward[i] = 0\\n t[i] = 0\\n if args.worker != 1 or \\\"RR\\\" in args.env_name:\\n env.reset()\\n\\n with T.get_lock():\\n # this is one for a3c and n for A2C (actually the lock is not needed for A2C)\\n T.value += args.n_envs\\n\\n if lr_scheduler and worker_id == 0 and T.value % args.lr_scheduler_step and global_iter != 0:\\n lr_scheduler.step(T.value / args.lr_scheduler_step)\\n\\n if lr_scheduler_critic:\\n lr_scheduler_critic.step(T.value / args.lr_scheduler_step)\\n\\n state = torch.Tensor(state)\\n\\n if args.shared_model:\\n v, _, _ = model(normalizer(state))\\n G = v.detach()\\n else:\\n G = model_critic(normalizer(state)).detach()\\n\\n values.append(G)\\n\\n # compute loss and backprop\\n advantages = torch.zeros((args.n_envs, 1))\\n\\n ret = torch.zeros((args.rollout_steps, args.n_envs, 1))\\n adv = torch.zeros((args.rollout_steps, args.n_envs, 1))\\n\\n # iterate over all time steps from most recent to the starting one\\n for i in reversed(range(args.rollout_steps)):\\n # G can be seen essentially as the return over the course of the rollout\\n G = rewards[i] + args.discount * terminals[i] * G\\n if not args.no_gae:\\n # Generalized Advantage Estimation\\n td_error = rewards[i] + args.discount * terminals[i] * values[i + 1] - values[i]\\n # terminals here to \\\"reset\\\" advantages to 0, because reset ist called internally in the env\\n # and new trajectory started\\n advantages = advantages * args.discount * args.tau * terminals[i] + td_error\\n else:\\n advantages = G - values[i].detach()\\n\\n adv[i] = advantages.detach()\\n ret[i] = G.detach()\\n\\n policy_loss = -(torch.stack(log_probs) * adv).mean()\\n # minus 1 in order to remove the last element, which is only necessary for next timestep value\\n value_loss = .5 * (ret - torch.stack(values[:-1])).pow(2).mean()\\n entropy_loss = torch.stack(entropies).mean()\\n\\n # zero grads to reset the gradients\\n optimizer.zero_grad()\\n\\n if args.shared_model:\\n # combined loss for shared architecture\\n total_loss = policy_loss + args.value_loss_weight * value_loss - args.entropy_loss_weight * entropy_loss\\n total_loss.backward()\\n else:\\n optimizer_critic.zero_grad()\\n\\n value_loss.backward()\\n (policy_loss - args.entropy_loss_weight * entropy_loss).backward()\\n\\n # this is just used for plotting in tensorboard\\n total_loss = policy_loss + args.value_loss_weight * value_loss - args.entropy_loss_weight * entropy_loss\\n\\n torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)\\n sync_grads(model, global_model)\\n optimizer.step()\\n\\n if not args.shared_model:\\n torch.nn.utils.clip_grad_norm_(model_critic.parameters(), args.max_grad_norm)\\n sync_grads(model_critic, global_model_critic)\\n optimizer_critic.step()\\n\\n global_iter += 1\\n\\n if worker_id == 0 and T.value % args.log_frequency == 0:\\n log_to_tensorboard(writer, model, optimizer, rewards, values, total_loss, policy_loss, value_loss,\\n entropy_loss, T.value, model_critic=model_critic, optimizer_critic=optimizer_critic)\",\n \"def __init__(self):\\n self.train(positivity_files, 0)\\n self.train(subjectivity_files, 1)\",\n \"def train(self):\\n if len(self.memory) > self.batch_size:\\n selecting_time_start = time.time()\\n experiences = self.memory.sample()\\n self.selecting_time += time.time() - selecting_time_start\\n self.learn(experiences)\",\n \"def train(self, ):\\n raise NotImplementedError\",\n \"def __init__(self, state_size, action_size, num_agents, seed, fc1=400, fc2=300, update_times=10,\\n weight_decay=1.e-5):\\n self.state_size = state_size\\n self.action_size = action_size\\n self.seed = random.seed(seed)\\n self.n_seed = np.random.seed(seed)\\n self.num_agents = num_agents\\n self.update_times = update_times\\n self.n_step = 0\\n self.TAU = 1e-3\\n\\n self.noise = []\\n for i in range(num_agents):\\n self.noise.append(rm.OrnsteinUhlenbeckProcess(size=(action_size,), std=LinearSchedule(0.4, 0, 2000)))\\n\\n # critic local and target network (Q-Learning)\\n self.critic_local = Critic(state_size, action_size, fc1, fc2, seed).to(device)\\n\\n self.critic_target = Critic(state_size, action_size, fc1, fc2, seed).to(device)\\n self.critic_target.load_state_dict(self.critic_local.state_dict())\\n\\n # actor local and target network (Policy gradient)\\n self.actor_local = Actor(state_size, action_size, fc1, fc2, seed).to(device)\\n self.actor_target = Actor(state_size, action_size, fc1, fc2, seed).to(device)\\n self.actor_target.load_state_dict(self.actor_local.state_dict())\\n\\n # optimizer for critic and actor network\\n self.optimizer_critic = optim.Adam(self.critic_local.parameters(), lr=CRITIC_LR, weight_decay=1.e-5)\\n self.optimizer_actor = optim.Adam(self.actor_local.parameters(), lr=ACTOR_LR)\\n\\n # Replay memory\\n self.memory = ReplayBuffer(action_size, BUFFER_SIZE, BATCH_SIZE, seed)\\n\\n # Initialize time step (for updating every UPDATE_EVERY steps)\\n self.t_step = 0\\n self.a_step = 0\",\n \"def train(self):\\n\\t\\traise NotImplementedError\",\n \"def __init__(self, agents_count, state_size, action_size, random_seed, buffer_size, batch_size, gamma, fc1_units, fc2_units, noise, lr_actor, lr_critic):\\n\\n self.agents_count = agents_count\\n self.state_size = state_size\\n self.action_size = action_size\\n self.seed = random.seed(random_seed)\\n self.gamma = gamma\\n self.batch_size = batch_size\\n\\n # Actor Network (w/ Target Network)\\n self.actor_local = Actor(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\\n self.actor_target = Actor(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\\n self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=lr_actor)\\n\\n # Critic Network (w/ Target Network)\\n self.critic_local = Critic(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\\n self.critic_target = Critic(state_size, action_size, random_seed, fc1_units, fc2_units).to(device)\\n self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=lr_critic, weight_decay=WEIGHT_DECAY)\\n\\n # after reading implementating of ShangtongZhang as suggested in the course,\\n # It seems relevant to initialize the weights of the target networks\\n # with the same values as the local network :\\n self.actor_target.load_state_dict(self.actor_local.state_dict())\\n self.critic_target.load_state_dict(self.critic_local.state_dict())\\n\\n # Noise process\\n self.noise = noise\\n\\n # Replay memory\\n self.memory = ReplayBuffer(action_size, buffer_size, batch_size, random_seed)\",\n \"def _evaluate(self):\\n coherence = gensim.models.coherencemodel.CoherenceModel(model=self.ldamodel,\\n corpus=self.gensim_corpus,\\n dictionary=self.ldamodel.id2word,\\n coherence='u_mass')\\n self.score = coherence.get_coherence()\\n if self.verbose:\\n print('LDA achieved a coherence (u_mass) of: ', self.score)\",\n \"def _setup_actor_critic_agent(self, ppo_cfg: Config) -> None:\\n logger.add_filehandler(self.config.LOG_FILE)\\n\\n self.actor_critic = PointNavBaselinePolicy(\\n observation_space=self.envs.observation_spaces[0],\\n action_space=self.envs.action_spaces[0],\\n hidden_size=ppo_cfg.hidden_size,\\n goal_sensor_uuid=self.config.TASK_CONFIG.TASK.GOAL_SENSOR_UUID,\\n )\\n self.actor_critic.to(self.device)\\n\\n self.agent = PPO(\\n actor_critic=self.actor_critic,\\n clip_param=ppo_cfg.clip_param,\\n ppo_epoch=ppo_cfg.ppo_epoch,\\n num_mini_batch=ppo_cfg.num_mini_batch,\\n value_loss_coef=ppo_cfg.value_loss_coef,\\n entropy_coef=ppo_cfg.entropy_coef,\\n lr=ppo_cfg.lr,\\n eps=ppo_cfg.eps,\\n max_grad_norm=ppo_cfg.max_grad_norm,\\n use_normalized_advantage=ppo_cfg.use_normalized_advantage,\\n )\",\n \"def train_step(self, experiences, gamma):\\n raise NotImplementedError\",\n \"def training(self, dataset, repeat=1, gamma=1.0, learning_rate=0.1, model='3yo'):\\n for _ in range(repeat):\\n for episode in dataset:\\n # 1- Get the data stored inside the dataset\\n image_index = episode[0] # image of the object\\n label_index = episode[1] # label given by the informant\\n informant_index = episode[2] # a integer representing the informant\\n informant_action = episode[3] # 0=reject, 1=accept\\n\\n # 2- The agent take an action (with softmax) considering is current state-action table\\n # [0=cup, 1=book, 2=ball]\\n col = (image_index * self.tot_images) + label_index\\n action_array = self.actor_matrix[:, col]\\n action_distribution = self._softmax(action_array)\\n child_action = np.random.choice(self.tot_actions,\\n 1,\\n p=action_distribution) # select the action through softmax\\n\\n # 3- (External) New state and reward obtained from the environment\\n # u_t = self.critic_vector[0, col] # previous state\\n # New state is estimated, in this simple case nothing happen\\n # because the next state is terminal\\n # u_t1 = u_t # Only in this example they are the same\\n\\n # 4- (Intrinsic) The informant_reputation is updated:\\n # agent_action, agent_confidence, informant_action, reward\\n # informant_vector: 0=unreliable, 1=reliable\\n # do_actions_agree: False, True\\n # Estimating child_confidence\\n distance = np.absolute(action_distribution[0] - action_distribution[1])\\n child_confidence_distribution = [1 - distance, distance] # non-knowledgeable, knowledgeable\\n child_confidence = np.random.choice(2, 1, p=child_confidence_distribution)\\n # Check if child and informant agree\\n if (child_action == informant_action):\\n do_actions_agree = True\\n else:\\n do_actions_agree = False\\n # Increment the counter in the informant_vector.\\n # Here we update the counter distribtuion only if\\n # the child is confident, because it is only in that\\n # case that the child can say if the informant is\\n # reliable or not.\\n if (do_actions_agree == False and child_confidence == 1):\\n self.informant_vector[informant_index][0] += 1 # unreliable\\n elif (do_actions_agree == True and child_confidence == 1):\\n self.informant_vector[informant_index][1] += 1 # reliable\\n elif (do_actions_agree == False and child_confidence == 0):\\n self.informant_vector[informant_index][1] += 0 # reliable\\n self.informant_vector[informant_index][0] += 0 # unreliable\\n elif (do_actions_agree == True and child_confidence == 0):\\n self.informant_vector[informant_index][1] += 0 # reliable\\n self.informant_vector[informant_index][0] += 0 # unreliable\\n else:\\n raise ValueError(\\\"ERROR: anomaly in the IF condition for informant_vector update\\\")\\n # Using the informant_vector given as input it estimates the reputation of the informant\\n informant_reputation_distribution = np.true_divide(self.informant_vector[informant_index],\\n np.sum(self.informant_vector[informant_index]))\\n informant_reputation = np.random.choice(2, 1, p=informant_reputation_distribution)\\n\\n # 5- (Intrinsic) The Cost is estimated:\\n # current_state, agent_action, agent_confidence, informant_action, informant_reputation\\n # child_confidence: 0=non-knowledgeable, 1=knowledgeable\\n # informant_reputation: 0=non-knowledgeable, 1=knowledgeable\\n # action: 0=reject, 1=accept\\n # informant_action: 0=reject, 1=accept\\n cost = self._return_cost(child_confidence,\\n informant_reputation,\\n child_action,\\n informant_action,\\n value=model)\\n\\n # 6- The utility table is updated using: previous_state, current_state, cost, reward\\n # Updating the critic using Temporal Differencing Learning\\n # In this simple case there is not a u_t1 state.\\n # The current state is considered terminal.\\n # We can delete the term (gamma*u_t1)-u_t and considering\\n # only (reward-cost) as utility of the state (see Russel Norvig).\\n reward = 0 # only for intrinsic learning reward=0\\n delta = (reward - cost) # + (gamma*u_t1) - u_t\\n self.critic_vector[0, col] += learning_rate * delta\\n\\n # 7- The actor table is updated using the delta from the critic\\n # Update the ACTOR using the delta\\n self.actor_matrix[child_action, col] += learning_rate * delta # the current action\\n self.actor_matrix[1 - child_action, col] -= learning_rate * delta # the opposite action\",\n \"def update_critic(self, epochs, discount_factor, reward, state, state_new, action, endstate):\\r\\n state = np.concatenate(state)\\r\\n state_new = np.concatenate(state_new)\\r\\n target = np.zeros([self.minibatch_size, 1])\\r\\n\\r\\n for kk in range(len(self.minibatch)):\\r\\n if endstate[kk]:\\r\\n target[kk] = reward[kk]\\r\\n else:\\r\\n target[kk] = reward[kk] + discount_factor * self.target_critic.predict((np.reshape(state_new[kk, :], (-1, self.feature_number)),\\r\\n self.target_actor.predict(np.reshape(state_new[kk, :], (-1, self.feature_number))))) # scalar Q-target value, input to model (state_new) is reshaped to a (x,number_inputs) array\\r\\n\\r\\n #target[kk] = reward[kk] + discount_factor * self.target_critic.predict([np.reshape(state_new[kk, :], (-1, self.feature_number))], [self.target_actor.predict(np.reshape(state_new[kk, :], (-1, self.feature_number)))]) # scalar Q-target value, input to model (state_new) is reshaped to a (x,number_inputs) array\\r\\n state = state.astype(np.float32)\\r\\n target = target.astype(np.float32)\\r\\n self.critic_loss[self.step_counter] = self.critic.train_on_batch((state, action), target) # with callback: self.critic.fit((state, action), target, epochs=epochs, verbose=0, batch_size=self.minibatch_size, callbacks=[self.tensorboard])\\r\",\n \"def test_training(self):\\n\\t\\tpass\",\n \"def start_training(self):\\n if self.task_env is None:\\n rospy.logfatal(\\\"No task environment found for training.\\\")\\n if self.agent is None:\\n rospy.logfatal(\\\"No agent found for training.\\\")\\n self.agent.start_training()\",\n \"def on_train_forward(self, runner):\\n self.on_iter_forward(runner)\",\n \"def __init__(self, limit, noise, random_seed, n_state=33, n_action=4):\\n # Actor Model: Local, Target, & Optimizer\\n self.Actor, self.ActorTarget, self.actorOpt = [], [], []\\n for i in range(limit):\\n self.Actor.append(Actor(n_state, n_action, random_seed).to(device)) \\n self.actorOpt.append(optim.Adam(self.Actor[i].parameters(), lr=LR_ACTOR))\\n self.ActorTarget = Actor(n_state, n_action, random_seed).to(device) \\n # Critic Model: Local, Target, & Optimizer\\n self.Critic = Critic(n_state, n_action, random_seed).to(device)\\n self.CriticTarget = Critic(n_state, n_action, random_seed).to(device)\\n self.criticOpt = optim.Adam(self.Critic.parameters(), lr=LR_CRITIC)\\n # Replay Buffer\\n self.Memory = ReplayBuffer2(n_action, BUFFER_SIZE, BATCH_SIZE, device, random_seed)\\n self.step = 0\\n # OUNoise Process\\n self.noise = noise\\n # Display\\n print('\\\\nBUFFER_SIZE', BUFFER_SIZE,\\n '\\\\nBATCH_SIZE', BATCH_SIZE,\\n '\\\\nGAMMA', GAMMA,\\n '\\\\nTAU', TAU,\\n '\\\\nLR_ACTOR', LR_ACTOR,\\n '\\\\nLR_CRITIC', LR_CRITIC)\\n # Display Actor & Critic\\n print('\\\\nACTOR[i]:\\\\n', self.Actor[0])\\n print('CRITIC:\\\\n', self.Critic)\",\n \"def actor_director_experiment():\\n dataset = datasets.ActorDirectorDataset()\\n\\n # Run the diffusion algorithm\\n for left, right in hypalgorithms.find_max_cut(dataset.hypergraph):\\n dataset.log_confusion_matrix([left, right])\\n dataset.show_clustering_stats([left, right])\\n\\n hyplogging.logger.info(\\\"\\\")\\n\\n # Run the clique algorithm\\n for left, right in hypalgorithms.find_max_cut(dataset.hypergraph, algorithm='clique'):\\n dataset.log_confusion_matrix([left, right])\\n dataset.show_clustering_stats([left, right])\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # compute and minimize the loss\\n next_actions = self.actor_target(next_states)\\n next_Qs = self.critic_target(next_states, next_actions).detach()\\n \\n target_Qs = rewards + gamma * next_Qs * (1 - dones)\\n expected_Qs = self.critic_local(states, actions)\\n \\n loss_critic = F.mse_loss(expected_Qs, target_Qs)\\n \\n self.critic_optimizer.zero_grad()\\n loss_critic.backward()\\n self.critic_optimizer.step()\\n \\n # compute and maximize the policy\\n pred_actions = self.actor_local(states)\\n loss_actor = -self.critic_local(states, pred_actions).mean()\\n \\n self.actor_optimizer.zero_grad() \\n loss_actor.backward()\\n self.actor_optimizer.step()\\n\\n # update target network\\n self.soft_update(self.critic_local, self.critic_target, self.params.tau) \\n self.soft_update(self.actor_local, self.actor_target, self.params.tau)\",\n \"def train_cavia(args, config, path_model, device):\\n global DATA, PATH_BASE, PATH_DATA, N_CLS, NAME_DATA, NAME_BACKBONE\\n\\n if path_model is None:\\n masks_dict = None\\n learner = None\\n else:\\n print('Load net from', path_model)\\n save_dict = torch.load(path_model)\\n state_dict = save_dict['state_dict']\\n masks_dict = save_dict.get('masks_dict', None)\\n\\n learner = Learner(config, args.num_context_params, args.context_in)\\n learner.load_state_dict(state_dict)\\n\\n if masks_dict is None:\\n print('masks_dict is None!')\\n cr = 1.\\n else:\\n cr = get_cr(learner, masks_dict)\\n\\n cavia = Meta(args, config, learner).to(device)\\n\\n # save path\\n if path_model is None:\\n path_save = '%s/model/cavia_lobs/%s_%s/%d-way_%d-shot' % (\\n PATH_BASE, NAME_DATA, NAME_BACKBONE, args.n_way, args.k_spt)\\n else:\\n path_save = '/'.join(path_model.split('/')[:-1])\\n if not os.path.exists(path_save):\\n os.makedirs(path_save)\\n\\n # meta train\\n meta_train(cavia, args, masks_dict, device,\\n output=args.log_print,\\n save=args.save_each_epoch,\\n save_threshold=args.save_threshold,\\n test_each_epoch=args.test_each_epoch,\\n path_save=path_save,\\n cr=cr,\\n break_threshold=args.break_threshold)\\n\\n if not args.save_each_epoch:\\n # meta test\\n acc_avg, accs = meta_test(cavia, args, masks_dict, device)\\n\\n path_model = '%s/net_cr-1_acc-%.4f.pkl' % (path_save, acc_avg)\\n print('Save as %s' % path_model)\\n torch.save(\\n {\\n 'state_dict': cavia.net.state_dict(),\\n 'accs': accs,\\n 'config': config,\\n 'args': args\\n },\\n path_model\\n )\",\n \"def __init__(self, state_size, action_size, seed, fc_units=[128, 128, 128]):\\n super(Critic, self).__init__()\\n self.seed = torch.manual_seed(seed)\\n self.fc1 = nn.Sequential(nn.Linear(state_size, fc_units[0]),\\n nn.ReLU())\\n self.fc2 = []\\n for i in range(1,len(fc_units)):\\n if i==1:\\n self.fc2.append(nn.Linear(fc_units[i-1]+action_size, fc_units[i]))\\n else:\\n self.fc2.append(nn.Linear(fc_units[i-1], fc_units[i]))\\n self.fc2.append(nn.ReLU())\\n self.fc2.append(nn.Linear(fc_units[-1], 1))\\n self.fc2 = nn.Sequential(*self.fc2)\\n #self.reset_parameters()\",\n \"def actor_critic_continuous(num_inputs, num_hidden, bound):\\n # Input\\n inputs = Input(shape=(num_inputs,), name='input_layer')\\n # Shared layer\\n common = Dense(units=num_hidden, activation='relu',\\n kernel_initializer='he_uniform', name='common_layer_1')(inputs)\\n # common = Dense(units=num_hidden, activation='relu', name='common_layer_2')(common)\\n # Actor\\n init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003)\\n action = Dense(units=1, activation='tanh',\\n kernel_initializer=init, name='actor_output_layer')(common)\\n action = action * bound\\n # Critic\\n critic = Dense(units=1, activation='linear',\\n kernel_initializer='glorot_uniform', name='critic_output_layer')(common)\\n # Combine\\n model = Model(inputs=inputs, outputs=[action, critic])\\n return model\",\n \"def train(self):\\n self.emission_model(self.train_data)\\n self.transition_model(self.train_data)\",\n \"def act(self, observation):\\r\\n \\r\\n \\r\\n self.iteration_episode=self.iteration_episode+1\\r\\n \\r\\n if self.iteration_episode>1:\\r\\n self.learn(observation)\\r\\n\\r\\n self.current_state = torch.FloatTensor(self.featurize_state(observation)).to(self.device)\\r\\n self.distribution = self.Actor.forward(self.current_state )\\r\\n self.value = self.Critic.forward(self.current_state )\\r\\n\\r\\n \\r\\n \\r\\n \\r\\n self.action = self.torch.clamp(self.distribution.sample(),-10,10)\\r\\n \\r\\n \\r\\n if np.random.randint(0,10000)/10000<self.epsilon:\\r\\n self.action= np.array(np.random.randint(-10000,10000)/1000)\\r\\n self.action=self.torch.tensor(self.action)\\r\\n\\r\\n self.log_prob = self.distribution.log_prob(self.action).unsqueeze(0)\\r\\n self.entropy += self.distribution.entropy().mean()\\r\\n\\r\\n \\r\\n \\r\\n return float(self.action.item())\",\n \"def check_criterion(self) -> None:\\n # get criterion class lists\\n criterion_names = get_class_names_in_files(\\n \\\"src\\\" + os.path.sep + \\\"criterions.py\\\"\\n )\\n criterion_names.remove(\\\"Criterion\\\")\\n\\n # Check config criterion exists\\n assert self.config[\\\"CRITERION\\\"] in criterion_names\\n\\n # Run criterion config check\\n params: Dict[str, Any] = self.config[\\\"CRITERION_PARAMS\\\"]\\n\\n ce_params = None\\n if self.config[\\\"CRITERION\\\"] == \\\"HintonKLD\\\":\\n assert \\\"T\\\" in params\\n assert params[\\\"T\\\"] > 0.0\\n assert isinstance(params[\\\"T\\\"], float)\\n\\n assert \\\"alpha\\\" in params\\n assert 0.0 <= params[\\\"alpha\\\"] <= 1.0\\n assert isinstance(params[\\\"alpha\\\"], float)\\n\\n # check additional params(teacher) exist\\n assert \\\"teacher_model_name\\\" in params\\n assert isinstance(\\\"teacher_model_name\\\", str)\\n assert \\\"teacher_model_params\\\" in params\\n\\n # if HintonLoss contains crossentropy\\n assert \\\"crossentropy_params\\\" in params\\n ce_params = params[\\\"crossentropy_params\\\"]\\n\\n elif self.config[\\\"CRITERION\\\"] == \\\"CrossEntropy\\\":\\n ce_params = self.config[\\\"CRITERION_PARAMS\\\"]\\n\\n if ce_params:\\n # assert \\\"num_classes\\\" in ce_params\\n # assert ce_params[\\\"num_classes\\\"] > 0\\n # assert isinstance(ce_params[\\\"num_classes\\\"], int)\\n\\n assert \\\"num_classes\\\" in ce_params\\n assert ce_params[\\\"num_classes\\\"] > 0\\n assert isinstance(ce_params[\\\"num_classes\\\"], int)\\n\\n if \\\"label_smoothing\\\" not in ce_params:\\n ce_params[\\\"label_smoothing\\\"] = 0.0\\n else:\\n assert 0.0 <= ce_params[\\\"label_smoothing\\\"] < 1.0\\n assert type(ce_params[\\\"label_smoothing\\\"]) is float\",\n \"def trainModels():\\n\\n # load actives from ChEMBL\\n actives = {}\\n if not os.path.exists(DATA_FOLDER_PATH):\\n os.mkdir(DATA_FOLDER_PATH)\\n actives_file = [x for x in os.listdir(DATA_FOLDER_PATH) if x.startswith('actives_chembl') and x.endswith('.p')]\\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\\n actives = chembl.loadChEMBLData(ACCESSION, IC_50_THRESHOLD, DATA_FOLDER_PATH)\\n else:\\n actives = pickle.load(open(DATA_FOLDER_PATH + actives_file[0], 'rb'))\\n\\n if not actives_file or RELOAD_DATA and not USE_DOWNLOADED_STRUCTS:\\n chembl.computeConsensualIC50(actives, DATA_FOLDER_PATH)\\n chembl.appendRDKitMols(actives, DATA_FOLDER_PATH)\\n\\n # load decoys downloaded from DUD\\n decoys = {}\\n if os.path.exists(DECOYS_SDF_FILE_PATH[:-4] + \\\".p\\\"):\\n decoys = pickle.load(open(DECOYS_SDF_FILE_PATH[:-4] + \\\".p\\\", 'rb'))\\n else:\\n if os.path.exists(DECOYS_SDF_FILE_PATH):\\n decoys = dud.getDecoys(DECOYS_SDF_FILE_PATH)\\n else:\\n print \\\"Decoys not found in: \\\" + DECOYS_SDF_FILE_PATH\\n print \\\"Make sure you set the right path.\\\"\\n exit()\\n\\n # merge both data sets\\n compounds_all = {}\\n compounds_all.update(actives)\\n compounds_all.update(decoys)\\n\\n # compute Morgan fingerprints\\n if os.path.exists(MERGED_DATASET_PATH) and not RELOAD_DATA:\\n print \\\"Loading previously created dataset...\\\"\\n compounds_all = pickle.load(open(MERGED_DATASET_PATH, 'rb'))\\n else:\\n fingerprinter.appendMorganFingerprints(compounds_all)\\n\\n actives = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if compounds_all[cmpndid]['active']}\\n pickle.dump(actives, open(ACTIVES_DUMP, 'wb'))\\n decoys = { cmpndid : compounds_all[cmpndid] for cmpndid in compounds_all.keys() if not compounds_all[cmpndid]['active']}\\n\\n # train and cross-validate multiple Naive Bayes Classifiers\\n classification_results = dict()\\n if not os.path.exists(CLASS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\\n classification_results = classification.naiveBayesClassifierTraining(compounds_all)\\n print \\\"Saving results...\\\"\\n pickle.dump(classification_results, open(CLASS_RESULTS_SAVE_FILE_PATH, 'wb'))\\n print \\\"Finished analysis.\\\"\\n else:\\n print \\\"Loading previous results...\\\"\\n classification_results = pickle.load(open(CLASS_RESULTS_SAVE_FILE_PATH, 'rb'))\\n\\n # have fun with the classification results\\n print \\\"# CLASSIFICATION STATISTICS #\\\"\\n classification.playWithResults(classification_results)\\n\\n # cluster actives according to their similarity and keep only the diverse molecules\\n actives_testset = dict()\\n if CLUSTER:\\n clusters = utilities.clusterMols(actives)\\n actives_kept = dict()\\n for cluster in clusters:\\n actives_kept[cluster[0]] = actives[cluster[0]]\\n remains = cluster[1:]\\n actives_filtered_out = {chmblid : actives[chmblid] for chmblid in remains}\\n actives_testset.update(actives_filtered_out)\\n actives = actives_kept\\n\\n # estimate maximum distances between active molecules to set threshold for the application domain\\n # distance_actives = regression.estimateDistanceThreshold(actives) # median of distances between two actives\\n # min_distance_decoys, max_distance_decoys = regression.compareDistances(actives, decoys) # average min/max distance of closest/farthest decoy from any of the actives\\n # print \\\"median of distances between two actives: \\\" + str(distance_actives)\\n # print \\\"average min/max distance of closest/farthest decoy from any of the actives: \\\" + str(min_distance_decoys) + \\\"/\\\" + str(max_distance_decoys)\\n\\n # Support vector regression\\n regression_results = dict()\\n if not os.path.exists(REGRESS_RESULTS_SAVE_FILE_PATH) or RELOAD_DATA:\\n regression_results = regression.supportVectorRegression(actives)\\n pickle.dump(regression_results, open(REGRESS_RESULTS_SAVE_FILE_PATH, 'wb'))\\n else:\\n regression_results = pickle.load(open(REGRESS_RESULTS_SAVE_FILE_PATH, 'rb'))\\n\\n\\n # do something with the regression results\\n print \\\"# REGRESSION STATISTICS #\\\"\\n regression.playWithResults(regression_results, decoys, actives_testset)\\n\\n return classification_results['final_model'], regression_results['final_model']\",\n \"def test_crowdsource():\\n alice = CrowdsourceClient(\\n \\\"Alice\\\", alice_data, alice_targets, XORModel, F.mse_loss, 0, deploy=True)\\n bob = CrowdsourceClient(\\n \\\"Bob\\\", bob_data, bob_targets, XORModel, F.mse_loss, 1,\\n contract_address=alice.contract_address)\\n charlie = CrowdsourceClient(\\n \\\"Charlie\\\", charlie_data, charlie_targets, XORModel, F.mse_loss, 2,\\n contract_address=alice.contract_address)\\n david = CrowdsourceClient(\\n \\\"David\\\", david_data, david_targets, XORModel, F.mse_loss, 3,\\n contract_address=alice.contract_address)\\n eve = CrowdsourceClient(\\\"Eve\\\", eve_data, eve_targets,\\n XORModel, F.mse_loss, 4,\\n contract_address=alice.contract_address)\\n\\n # alice is evaluator\\n # others are trainers\\n trainers = [bob, charlie, david, eve]\\n\\n alice.set_genesis_model(\\n round_duration=ROUND_DURATION,\\n max_num_updates=len(trainers)\\n )\\n\\n # Training\\n threads = [\\n threading.Thread(\\n target=trainer.train_until,\\n kwargs=TRAINING_HYPERPARAMS,\\n daemon=True\\n ) for trainer in trainers\\n ]\\n\\n # Evaluation\\n threads.append(\\n threading.Thread(\\n target=alice.evaluate_until,\\n args=(TRAINING_ITERATIONS, EVAL_METHOD),\\n daemon=True\\n )\\n )\\n\\n # Run all threads in parallel\\n for t in threads:\\n t.start()\\n for t in threads:\\n t.join()\\n\\n print_token_count(bob)\\n print_token_count(charlie)\\n print_token_count(david)\\n print_token_count(eve)\\n\\n assert bob.get_token_count() > david.get_token_count(\\n ), \\\"Bob ended up with fewer tokens than David\\\"\\n assert bob.get_token_count() > eve.get_token_count(\\n ), \\\"Bob ended up with fewer tokens than Eve\\\"\\n assert charlie.get_token_count() > david.get_token_count(\\n ), \\\"Charlie ended up with fewer tokens than David\\\"\\n assert charlie.get_token_count() > eve.get_token_count(\\n ), \\\"Charlie ended up with fewer tokens than Eve\\\"\\n\\n alice_global_model = alice.get_current_global_model()\\n bob_global_model = bob.get_current_global_model()\\n\\n assert same_weights(\\n alice_global_model,\\n bob_global_model\\n ), \\\"Alice and Bob ran the same aggregation but got different model weights\\\"\\n\\n assert str(alice_global_model.state_dict()) == \\\\\\n str(bob_global_model.state_dict()), \\\\\\n \\\"Alice and Bob ran the same aggregation but got different model dicts\\\"\",\n \"def before_train(self, logs=None):\\n self.config = self.trainer.config\\n self.unrolled = self.trainer.config.unrolled\\n self.device = self.trainer.config.device\\n self.model = self.trainer.model\\n self.optimizer = self.trainer.optimizer\\n self.lr_scheduler = self.trainer.lr_scheduler\\n self.loss = self.trainer.loss\\n self.search_alg = SearchAlgorithm(SearchSpace())\\n self._set_algorithm_model(self.model)\\n self.trainer.train_loader = self.trainer._init_dataloader(mode='train')\\n self.trainer.valid_loader = self.trainer._init_dataloader(mode='val')\\n normal_selected_idxs = torch.tensor(len(self.model.alphas_normal) * [-1],\\n requires_grad=False, dtype=torch.int).cuda()\\n reduce_selected_idxs = torch.tensor(len(self.model.alphas_reduce) * [-1],\\n requires_grad=False, dtype=torch.int).cuda()\\n normal_candidate_flags = torch.tensor(len(self.model.alphas_normal) * [True],\\n requires_grad=False, dtype=torch.bool).cuda()\\n reduce_candidate_flags = torch.tensor(len(self.model.alphas_reduce) * [True],\\n requires_grad=False, dtype=torch.bool).cuda()\\n logging.info('normal_selected_idxs: {}'.format(normal_selected_idxs))\\n logging.info('reduce_selected_idxs: {}'.format(reduce_selected_idxs))\\n logging.info('normal_candidate_flags: {}'.format(normal_candidate_flags))\\n logging.info('reduce_candidate_flags: {}'.format(reduce_candidate_flags))\\n self.model.normal_selected_idxs = normal_selected_idxs\\n self.model.reduce_selected_idxs = reduce_selected_idxs\\n self.model.normal_candidate_flags = normal_candidate_flags\\n self.model.reduce_candidate_flags = reduce_candidate_flags\\n logging.info(F.softmax(torch.stack(self.model.alphas_normal, dim=0), dim=-1).detach())\\n logging.info(F.softmax(torch.stack(self.model.alphas_reduce, dim=0), dim=-1).detach())\\n self.normal_probs_history = []\\n self.reduce_probs_history = []\",\n \"def train(self, item, gamma=1.0):\\n [step, state, next_state, reward, done] = item\\n\\n # must save state for entropy computation\\n self.state = state\\n\\n discount_factor = gamma**step\\n\\n # reinforce-baseline: delta = return - value\\n delta = reward - self.value(state)[0] \\n\\n # apply the discount factor as shown in Algorithms\\n # 10.2.1, 10.3.1 and 10.4.1\\n discounted_delta = delta * discount_factor\\n discounted_delta = np.reshape(discounted_delta, [-1, 1])\\n verbose = 1 if done else 0\\n\\n # train the logp model (implies training of actor model\\n # as well) since they share exactly the same set of\\n # parameters\\n self.logp_model.fit(np.array(state),\\n discounted_delta,\\n batch_size=1,\\n epochs=1,\\n verbose=verbose)\\n\\n # train the value network (critic)\\n self.value_model.fit(np.array(state),\\n discounted_delta,\\n batch_size=1,\\n epochs=1,\\n verbose=verbose)\",\n \"def onTrainStepTaken(self, agent):\\n pass\",\n \"def train(log_dir):\\n\\n # Create train and test environments\\n print(\\n colorize(\\n f\\\"INFO: You are training in the {ENV_NAME} environment.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n env = get_env_from_name(ENV_NAME, ENV_SEED)\\n test_env = get_env_from_name(ENV_NAME, ENV_SEED)\\n\\n # Set initial learning rates\\n lr_a, lr_l, lr_c = (\\n ALG_PARAMS[\\\"lr_a\\\"],\\n ALG_PARAMS[\\\"lr_l\\\"],\\n ALG_PARAMS[\\\"lr_c\\\"],\\n )\\n lr_a_now = ALG_PARAMS[\\\"lr_a\\\"] # learning rate for actor, lambda and alpha\\n lr_l_now = ALG_PARAMS[\\\"lr_l\\\"] # learning rate for Lyapunov critic\\n lr_c_now = ALG_PARAMS[\\\"lr_c\\\"] # learning rate for q critic\\n\\n # Get observation and action space dimension and limits from the environment\\n s_dim = env.observation_space.shape[0]\\n a_dim = env.action_space.shape[0]\\n a_lowerbound = env.action_space.low\\n a_upperbound = env.action_space.high\\n\\n # Create the Agent\\n policy = LAC(a_dim, s_dim, act_limits={\\\"low\\\": a_lowerbound, \\\"high\\\": a_upperbound})\\n\\n # Load model if retraining is selected\\n if TRAIN_PARAMS[\\\"continue_training\\\"]:\\n\\n # Create retrain model path\\n retrain_model_folder = TRAIN_PARAMS[\\\"continue_model_folder\\\"]\\n retrain_model_path = osp.abspath(\\n osp.join(log_dir, \\\"../..\\\", TRAIN_PARAMS[\\\"continue_model_folder\\\"])\\n )\\n\\n # Check if retrain model exists if not throw error\\n if not osp.exists(retrain_model_path):\\n print(\\n colorize(\\n (\\n \\\"ERROR: Shutting down training since the model you specified \\\"\\n f\\\"in the `continue_model_folder` `{retrain_model_folder}` \\\"\\n f\\\"argument was not found for the `{ENV_NAME}` environment.\\\"\\n ),\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Load old model\\n print(\\n colorize(\\n f\\\"INFO: Restoring model `{retrain_model_path}`.\\\", \\\"cyan\\\", bold=True\\n )\\n )\\n result = policy.restore(\\n osp.abspath(osp.join(retrain_model_path, \\\"policy\\\")),\\n restore_lagrance_multipliers=(not ALG_PARAMS[\\\"reset_lagrance_multipliers\\\"]),\\n )\\n if not result:\\n print(\\n colorize(\\n \\\"ERROR: Shuting down training as something went wrong while \\\"\\n \\\"loading \\\"\\n f\\\"model `{retrain_model_folder}`.\\\",\\n \\\"red\\\",\\n bold=True,\\n )\\n )\\n sys.exit(0)\\n\\n # Create new storage folder\\n log_dir_split = log_dir.split(\\\"/\\\")\\n log_dir_split[-2] = (\\n \\\"_\\\".join(TRAIN_PARAMS[\\\"continue_model_folder\\\"].split(\\\"/\\\")) + \\\"_finetune\\\"\\n )\\n log_dir = \\\"/\\\".join(log_dir_split)\\n else:\\n print(colorize(f\\\"INFO: Train new model `{log_dir}`\\\", \\\"cyan\\\", bold=True))\\n\\n # Print logging folder path\\n print(colorize(f\\\"INFO: Logging results to `{log_dir}`.\\\", \\\"cyan\\\", bold=True))\\n\\n # Create replay memory buffer\\n pool = Pool(\\n s_dim=s_dim,\\n a_dim=a_dim,\\n store_last_n_paths=TRAIN_PARAMS[\\\"num_of_training_paths\\\"],\\n memory_capacity=ALG_PARAMS[\\\"memory_capacity\\\"],\\n min_memory_size=ALG_PARAMS[\\\"min_memory_size\\\"],\\n )\\n\\n # Setup logger and log hyperparameters\\n logger.configure(dir=log_dir, format_strs=[\\\"csv\\\"])\\n logger.logkv(\\\"tau\\\", ALG_PARAMS[\\\"tau\\\"])\\n logger.logkv(\\\"alpha3\\\", ALG_PARAMS[\\\"alpha3\\\"])\\n logger.logkv(\\\"batch_size\\\", ALG_PARAMS[\\\"batch_size\\\"])\\n logger.logkv(\\\"target_entropy\\\", policy.target_entropy)\\n\\n ####################################################\\n # Training loop ####################################\\n ####################################################\\n\\n # Setup training loop parameters\\n t1 = time.time()\\n global_step = 0\\n global_episodes = 0\\n last_training_paths = deque(maxlen=TRAIN_PARAMS[\\\"num_of_training_paths\\\"])\\n training_started = False\\n\\n # Train the agent in the environment until max_episodes has been reached\\n print(colorize(\\\"INFO: Training...\\\\n\\\", \\\"cyan\\\", bold=True))\\n while 1: # Keep running episodes until global step has been reached\\n\\n # Create variable to store information about the current path\\n if policy.use_lyapunov:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"lyapunov_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"lambda\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n \\\"lambda_loss\\\": [],\\n }\\n else:\\n current_path = {\\n \\\"rewards\\\": [],\\n \\\"critic_error\\\": [],\\n \\\"alpha\\\": [],\\n \\\"entropy\\\": [],\\n \\\"a_loss\\\": [],\\n \\\"alpha_loss\\\": [],\\n }\\n\\n # Reset environment\\n s = env.reset()\\n\\n # Training Episode loop\\n for jj in range(ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"]):\\n\\n # Break out of loop if global steps have been reached\\n if global_step >= TRAIN_PARAMS[\\\"max_global_steps\\\"]:\\n\\n # Print step count, save model and stop the program\\n print(\\n colorize(\\n f\\\"\\\\nINFO: Training stopped after {global_step} steps.\\\",\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(\\n colorize(\\n \\\"INFO: Running time: {}\\\".format(time.time() - t1),\\n \\\"cyan\\\",\\n bold=True,\\n )\\n )\\n print(colorize(\\\"INFO: Saving Model\\\", \\\"cyan\\\", bold=True))\\n policy.save_result(log_dir)\\n return\\n\\n # Save intermediate checkpoints if requested\\n if TRAIN_PARAMS[\\\"save_checkpoints\\\"]:\\n if (\\n global_step % TRAIN_PARAMS[\\\"checkpoint_save_freq\\\"] == 0\\n and global_step != 0\\n ):\\n\\n # Create intermediate result checkpoint folder\\n checkpoint_save_path = osp.abspath(\\n osp.join(log_dir, \\\"checkpoints\\\", \\\"step_\\\" + str(jj))\\n )\\n os.makedirs(checkpoint_save_path, exist_ok=True)\\n\\n # Save intermediate checkpoint\\n policy.save_result(checkpoint_save_path)\\n\\n # Render environment if requested\\n if ENVS_PARAMS[ENV_NAME][\\\"eval_render\\\"]:\\n env.render()\\n\\n # Retrieve (scaled) action based on the current policy\\n # NOTE (rickstaa): The scaling operation is already performed inside the\\n # policy based on the `act_limits` you supplied.\\n a = policy.choose_action(s)\\n\\n # Perform action in env\\n s_, r, done, _ = env.step(a)\\n\\n # Increment global step count\\n if training_started:\\n global_step += 1\\n\\n # Stop episode if max_steps has been reached\\n if jj == ENVS_PARAMS[ENV_NAME][\\\"max_ep_steps\\\"] - 1:\\n done = True\\n terminal = 1.0 if done else 0.0\\n\\n # Store experience in replay buffer\\n pool.store(s, a, r, terminal, s_)\\n\\n # Optimize network weights and lagrance multipliers\\n if (\\n pool.memory_pointer > ALG_PARAMS[\\\"min_memory_size\\\"]\\n and global_step % ALG_PARAMS[\\\"steps_per_cycle\\\"] == 0\\n ):\\n training_started = True\\n\\n # Perform STG a set number of times (train per cycle)\\n for _ in range(ALG_PARAMS[\\\"train_per_cycle\\\"]):\\n batch = pool.sample(ALG_PARAMS[\\\"batch_size\\\"])\\n if policy.use_lyapunov:\\n (\\n labda,\\n alpha,\\n l_loss,\\n entropy,\\n a_loss,\\n alpha_loss,\\n labda_loss,\\n ) = policy.learn(lr_a_now, lr_l_now, lr_a, lr_c_now, batch)\\n else:\\n alpha, loss_q, entropy, a_loss, alpha_loss = policy.learn(\\n lr_a_now, lr_l_now, lr_a, lr_c_now, batch\\n )\\n\\n # Store current path results\\n if training_started:\\n if policy.use_lyapunov:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"lyapunov_error\\\"].append(l_loss)\\n current_path[\\\"alpha\\\"].append(alpha)\\n current_path[\\\"lambda\\\"].append(labda)\\n current_path[\\\"entropy\\\"].append(entropy)\\n current_path[\\\"a_loss\\\"].append(a_loss)\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n current_path[\\\"lambda_loss\\\"].append(labda_loss)\\n else:\\n current_path[\\\"rewards\\\"].append(r)\\n current_path[\\\"critic_error\\\"].append(loss_q.numpy())\\n current_path[\\\"alpha\\\"].append(alpha.numpy())\\n current_path[\\\"entropy\\\"].append(entropy.numpy())\\n current_path[\\\"a_loss\\\"].append(\\n a_loss.numpy()\\n ) # Improve: Check if this is the fastest way\\n current_path[\\\"alpha_loss\\\"].append(alpha_loss)\\n\\n # Evalute the current policy performance and log the results\\n if (\\n training_started\\n and global_step % TRAIN_PARAMS[\\\"evaluation_frequency\\\"] == 0\\n and global_step > 0\\n ):\\n logger.logkv(\\\"total_timesteps\\\", global_step)\\n training_diagnostics = evaluate_training_rollouts(last_training_paths)\\n if training_diagnostics is not None:\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n eval_diagnostics = training_evaluation(test_env, policy)\\n [\\n logger.logkv(key, eval_diagnostics[key])\\n for key in eval_diagnostics.keys()\\n ]\\n training_diagnostics.pop(\\\"return\\\")\\n [\\n logger.logkv(key, training_diagnostics[key])\\n for key in training_diagnostics.keys()\\n ]\\n logger.logkv(\\\"lr_a\\\", lr_a_now)\\n if policy.use_lyapunov:\\n logger.logkv(\\\"lr_l\\\", lr_l_now)\\n else:\\n logger.logkv(\\\"lr_c\\\", lr_c_now)\\n string_to_print = [\\\"time_step:\\\", str(global_step), \\\"|\\\"]\\n if TRAIN_PARAMS[\\\"num_of_evaluation_paths\\\"] > 0:\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(eval_diagnostics[key]), \\\"|\\\"]\\n )\\n for key in eval_diagnostics.keys()\\n ]\\n [\\n string_to_print.extend(\\n [key, \\\":\\\", str(round(training_diagnostics[key], 2)), \\\"|\\\"]\\n )\\n for key in training_diagnostics.keys()\\n ]\\n prefix = (\\n colorize(\\\"LAC|\\\", \\\"green\\\")\\n if ALG_PARAMS[\\\"use_lyapunov\\\"]\\n else colorize(\\\"SAC|\\\", \\\"yellow\\\")\\n )\\n print(\\n colorize(prefix, \\\"yellow\\\", bold=True) + \\\"\\\".join(string_to_print)\\n )\\n logger.dumpkvs()\\n\\n # Update state\\n s = s_\\n\\n # Check if episode is done (continue to next episode)\\n if done:\\n\\n # Store paths\\n if training_started:\\n last_training_paths.appendleft(current_path)\\n\\n # Decay learning rates\\n frac = 1.0 - (global_step - 1.0) / TRAIN_PARAMS[\\\"max_global_steps\\\"]\\n lr_a_now = lr_a * frac # learning rate for actor, lambda, alpha\\n lr_l_now = lr_l * frac # learning rate for Lyapunov critic\\n lr_c_now = lr_c * frac # learning rate for q critic\\n break # Continue to next episode\\n\\n # Increase episode counter\\n global_episodes += 1\",\n \"def train(self):\\n self.training = True\",\n \"def pre_train_person(self, dataset, **kwargs):\\n \\n pass\",\n \"def train(self):\\n raise NotImplementedError\",\n \"def act(self, state, training):\\n\\n action = self.actor_local(state)\\n if training:\\n action += self.noise.sample()\\n else:\\n action = self.actor_target(state)\\n\\n return action\",\n \"def before_update(self, actor_critic, algo, *args):\\n raise NotImplementedError\",\n \"def setup_training(self):\\n print('setup training called')\\n self.steps_done = 0\\n self.current_episode_num = 1\\n self.total_reward = 0\\n\\n # self.optimizer = optim.RMSprop(policy_net.parameters())\\n self.memory = ReplayMemory(300000)\\n self.total_reward_history = []\\n # self.loss_history = []\\n self.positions = []\\n self.n_destroyed_crates = 0\\n self.is_in_bomb_range = False\",\n \"def _train_step(self):\\n if self._replay.add_count > self.min_replay_history:\\n if self.training_steps % self.update_period == 0:\\n self._sample_from_replay_buffer()\\n (self._rng, self.optimizer_state, self.online_params,\\n loss, quantile_loss, coherence_loss, orthogonality_loss) = train(\\n self.network_def,\\n self.online_params,\\n self.target_network_params,\\n self.optimizer,\\n self.optimizer_state,\\n self.replay_elements['state'],\\n self.replay_elements['action'],\\n self.replay_elements['next_state'],\\n self.replay_elements['reward'],\\n self.replay_elements['terminal'],\\n self.num_tau_samples,\\n self.num_tau_prime_samples,\\n self.num_quantile_samples,\\n self.cumulative_gamma,\\n self.double_dqn,\\n self.kappa,\\n self._rng,\\n self._coherence_weight,\\n self._option,\\n self._use_ortho_loss,\\n self._use_cohe_loss,\\n self._tau,\\n self._alpha,\\n self._clip_value_min)\\n if (self.summary_writer is not None and\\n self.training_steps > 0 and\\n self.training_steps % self.summary_writing_frequency == 0):\\n if self._use_ortho_loss and self._use_cohe_loss:\\n summary = tf.compat.v1.Summary(value=[\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Combined', simple_value=loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Quantile', simple_value=quantile_loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Incoherence', simple_value=coherence_loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Orthogonality',\\n simple_value=orthogonality_loss),\\n ])\\n elif self._use_ortho_loss and not self._use_cohe_loss:\\n summary = tf.compat.v1.Summary(value=[\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Combined', simple_value=loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Quantile', simple_value=quantile_loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Orthogonality', simple_value=orthogonality_loss),\\n ])\\n elif self._use_cohe_loss and not self._use_ortho_loss:\\n summary = tf.compat.v1.Summary(value=[\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Combined', simple_value=loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Quantile', simple_value=quantile_loss),\\n tf.compat.v1.Summary.Value(\\n tag='Losses/Incoherence', simple_value=coherence_loss),\\n ])\\n self.summary_writer.add_summary(summary, self.training_steps)\\n if self.training_steps % self.target_update_period == 0:\\n self._sync_weights()\\n\\n self.training_steps += 1\",\n \"def train_crf(threads=3, hyperparameter_crf='1.5', cut_off='5', alg='CRF-L2'):\\n\\n print '\\\\n\\\\ttrain crf'\\n os.system('crf_learn -p ' + threads +\\n ' -c ' + hyperparameter_crf +\\n ' -f ' + cut_off +\\n ' -a ' + alg +\\n ' ' + template_file + ' ' + train_file_crf + ' ' + model_file)\\n print '\\\\t--done\\\\n'\",\n \"def test(self, test_iter, step, corpus_type, id):\\n\\n self.model.eval()\\n stats = Statistics()\\n if not os.path.exists(self.args.result_path):\\n os.makedirs(self.args.result_path)\\n if not os.path.exists(self.args.story_path):\\n os.makedirs(self.args.story_path)\\n can_path = self.args.result_path + corpus_type + '.' + id + '_step%d.candidate' % step\\n gold_path = self.args.result_path + corpus_type + '.' + id + '_step%d.gold' % step\\n story_path = self.args.story_path + corpus_type + '.' + id + '.story'\\n with open(story_path, 'w') as save_story:\\n with open(can_path, 'w') as save_pred:\\n with open(gold_path, 'w') as save_gold:\\n with torch.no_grad():\\n for batch in test_iter:\\n src = batch.src\\n labels = batch.labels\\n segs = batch.segs\\n clss = batch.clss\\n mask = batch.mask\\n mask_cls = batch.mask_cls\\n weight = batch.weight\\n index = batch.index\\n\\n pred = []\\n\\n sents_vec, sent_scores, mask, cluster_weight = self.model(src, segs, clss, mask, mask_cls)\\n loss = self.loss(sent_scores, labels.float())\\n weight_loss = self.weight_loss(cluster_weight, weight)\\n loss = (loss * mask.float()).sum()\\n total_loss = loss + weight_loss * 10\\n batch_stats = Statistics(float(total_loss.cpu().data.numpy()), len(labels))\\n stats.update(batch_stats)\\n\\n sent_scores = sent_scores + mask.float()\\n sent_scores = sent_scores.cpu().data.numpy()\\n cluster_weight = cluster_weight.cpu().data.numpy()\\n selected_ids = np.argsort(-sent_scores, 1)\\n cluster_weight = np.argsort(cluster_weight)\\n # print(selected_ids)\\n # selected_ids = np.sort(selected_ids,1)\\n cluster_num = len(cluster_weight)\\n for i, idx in enumerate(selected_ids):\\n rank = np.where(cluster_weight == i)[0][0]\\n\\n if rank <= max(cluster_num // 6, 6):\\n for j in range(5):\\n sen_ind = selected_ids[i][j]\\n _pred = batch.src_str[i][sen_ind].strip()\\n pred.append((index[i][sen_ind], _pred))\\n elif rank <= max(cluster_num // 3, 10):\\n for j in range(3):\\n sen_ind = selected_ids[i][j]\\n _pred = batch.src_str[i][sen_ind].strip()\\n pred.append((index[i][sen_ind], _pred))\\n elif rank <= max(cluster_num * 2 // 3, 15):\\n for j in range(2):\\n sen_ind = selected_ids[i][j]\\n _pred = batch.src_str[i][sen_ind].strip()\\n pred.append((index[i][sen_ind], _pred))\\n else:\\n sen_ind = selected_ids[i][0]\\n _pred = batch.src_str[i][sen_ind].strip()\\n pred.append((index[i][sen_ind], _pred))\\n\\n gold_summary = (batch.tgt_str[0].strip())\\n pred.sort(key=lambda x: x[0])\\n for i in range(len(pred)):\\n save_story.write(pred[i][1].strip() + '\\\\n')\\n if i == 0:\\n save_pred.write(pred[i][1].strip())\\n else:\\n save_pred.write('<q> ' + pred[i][1].strip())\\n save_gold.write(gold_summary)\\n for sent in gold_summary.split('<q>'):\\n save_story.write('@highlight {}\\\\n'.format(sent))\\n if self.args.test_txt:\\n return stats\\n else:\\n rouges = calculate_rouge(can_path, gold_path)\\n logger.info('Rouges at step %d \\\\n%s' % (step, rouge_results_to_str(rouges)))\\n self._report_step(0, step, valid_stats=stats)\\n return stats, rouges\",\n \"def train(self, data, session=None, **kwargs):\\n summary_writer = kwargs['summary_writer']\\n logging.info('Training classifier...')\\n\\n if not self.is_initialized:\\n self.is_initialized = True\\n else:\\n if self.weight_decay_update is not None:\\n session.run(self.weight_decay_update)\\n logging.info('New weight decay value: %f',\\n session.run(self.weight_decay_var))\\n # Reset the optimizer state (e.g., momentum).\\n session.run(self.reset_optimizer)\\n\\n if not self.warm_start:\\n # Re-initialize variables.\\n initializers = [v.initializer for v in self.variables.values()]\\n initializers.append(self.global_step.initializer)\\n session.run(initializers)\\n\\n # Construct data iterator.\\n logging.info('Training classifier with %d samples...', data.num_train())\\n train_indices = data.get_indices_train()\\n unlabeled_indices = data.get_indices_unlabeled()\\n val_indices = data.get_indices_val()\\n test_indices = data.get_indices_test()\\n # Create an iterator for labeled samples for the supervised term.\\n data_iterator_train = batch_iterator(\\n train_indices,\\n batch_size=self.batch_size,\\n shuffle=True,\\n allow_smaller_batch=False,\\n repeat=True)\\n # Create an iterator for unlabeled samples for the VAT loss term.\\n data_iterator_unlabeled = batch_iterator(\\n unlabeled_indices,\\n batch_size=self.batch_size,\\n shuffle=True,\\n allow_smaller_batch=False,\\n repeat=True)\\n # Create iterators for ll, lu, uu pairs of samples for the agreement term.\\n if self.use_graph:\\n pair_ll_iterator = self.edge_iterator(\\n data, batch_size=self.num_pairs_reg, labeling='ll')\\n pair_lu_iterator = self.edge_iterator(\\n data, batch_size=self.num_pairs_reg, labeling='lu')\\n pair_uu_iterator = self.edge_iterator(\\n data, batch_size=self.num_pairs_reg, labeling='uu')\\n else:\\n pair_ll_iterator = self.pair_iterator(train_indices, train_indices,\\n self.num_pairs_reg, data)\\n pair_lu_iterator = self.pair_iterator(train_indices, unlabeled_indices,\\n self.num_pairs_reg, data)\\n pair_uu_iterator = self.pair_iterator(unlabeled_indices,\\n unlabeled_indices,\\n self.num_pairs_reg, data)\\n\\n step = 0\\n iter_below_tol = 0\\n min_num_iter = self.min_num_iter\\n has_converged = step >= self.max_num_iter\\n prev_loss_val = np.inf\\n best_test_acc = -1\\n best_val_acc = -1\\n checkpoint_saved = False\\n while not has_converged:\\n feed_dict = self._construct_feed_dict(\\n data_iterator=data_iterator_train,\\n split='train',\\n pair_ll_iterator=pair_ll_iterator,\\n pair_lu_iterator=pair_lu_iterator,\\n pair_uu_iterator=pair_uu_iterator,\\n data_iterator_unlabeled=data_iterator_unlabeled)\\n if self.enable_summaries and step % self.summary_step == 0:\\n loss_val, summary, iter_cls_total, _ = session.run(\\n [self.loss_op, self.summary_op, self.iter_cls_total, self.train_op],\\n feed_dict=feed_dict)\\n summary_writer.add_summary(summary, iter_cls_total)\\n summary_writer.flush()\\n else:\\n loss_val, _ = session.run((self.loss_op, self.train_op),\\n feed_dict=feed_dict)\\n\\n # Log the loss, if necessary.\\n if step % self.logging_step == 0:\\n logging.info('Classification step %6d | Loss: %10.4f', step, loss_val)\\n\\n # Evaluate, if necessary.\\n if step % self.eval_step == 0:\\n val_acc = self._evaluate(val_indices, 'val', session, summary_writer)\\n test_acc = self._evaluate(test_indices, 'test', session, summary_writer)\\n\\n if step % self.logging_step == 0 or val_acc > best_val_acc:\\n logging.info(\\n 'Classification step %6d | Loss: %10.4f | val_acc: %10.4f | '\\n 'test_acc: %10.4f', step, loss_val, val_acc, test_acc)\\n if val_acc > best_val_acc:\\n best_val_acc = val_acc\\n best_test_acc = test_acc\\n if self.checkpoint_path:\\n self.saver.save(\\n session, self.checkpoint_path, write_meta_graph=False)\\n checkpoint_saved = True\\n # Go for at least num_iter_after_best_val more iterations.\\n min_num_iter = max(self.min_num_iter,\\n step + self.num_iter_after_best_val)\\n logging.info(\\n 'Achieved best validation. '\\n 'Extending to at least %d iterations...', min_num_iter)\\n\\n step += 1\\n has_converged, iter_below_tol = self.check_convergence(\\n prev_loss_val,\\n loss_val,\\n step,\\n self.max_num_iter,\\n iter_below_tol,\\n min_num_iter=min_num_iter)\\n session.run(self.iter_cls_total_update)\\n prev_loss_val = loss_val\\n\\n # Return to the best model.\\n if checkpoint_saved:\\n logging.info('Restoring best model...')\\n self.saver.restore(session, self.checkpoint_path)\\n\\n return best_test_acc, best_val_acc\",\n \"def __init__(\\n self,\\n actor_state_size: int,\\n actor_action_size: int,\\n critic_state_size: int,\\n critic_action_size: int,\\n actor_hidden_layer_dimensions: Tuple[int] = (256, 128),\\n critic_hidden_layer_dimensions: Tuple[int] = (256, 128),\\n lr_actor: float = 1e-3,\\n lr_critic: float = 1e-3,\\n seed: Optional[int] = None,\\n ):\\n self.actor_state_size = actor_state_size\\n self.actor_action_size = actor_action_size\\n self.critic_state_size = critic_state_size\\n self.critic_action_size = critic_action_size\\n self.lr_actor = lr_actor\\n self.lr_critic = lr_critic\\n\\n self.seed = seed\\n if self.seed is not None:\\n np.random.seed(self.seed)\\n\\n self.device = torch.device(\\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n self.critic_local = FullyConnectedQNetwork(\\n input_dim=self.critic_state_size,\\n output_dim=self.critic_action_size,\\n hidden_dims=critic_hidden_layer_dimensions,\\n seed=self.seed,\\n ).to(self.device)\\n self.critic_target = FullyConnectedQNetwork(\\n input_dim=self.critic_state_size,\\n output_dim=self.critic_action_size,\\n hidden_dims=critic_hidden_layer_dimensions,\\n seed=self.seed,\\n ).to(self.device)\\n\\n self.actor_local = DeterministicPolicyNetwork(\\n input_dim=self.actor_state_size,\\n output_dim=self.actor_action_size,\\n hidden_dims=actor_hidden_layer_dimensions,\\n seed=self.seed,\\n ).to(self.device)\\n self.actor_target = DeterministicPolicyNetwork(\\n input_dim=self.actor_state_size,\\n output_dim=self.actor_action_size,\\n hidden_dims=actor_hidden_layer_dimensions,\\n seed=self.seed,\\n ).to(self.device)\\n\\n self.value_optimizer = optim.Adam(\\n self.critic_local.parameters(), lr=self.lr_critic\\n )\\n self.policy_optimizer = optim.Adam(\\n self.actor_local.parameters(), lr=self.lr_actor\\n )\\n\\n self.loss_fn = SmoothL1Loss()\",\n \"def run_custom_training_tests():\\n test_custom_training()\\n test_custom_distributed_training()\\n test_custom_multimodel_training()\\n test_custom_distributed_multimodel_training()\",\n \"def train(self, training_steps=10):\",\n \"def train(self, item, cat):\\n features = self.get_features(item)\\n # Increment the count for every feature with this category\\n for f in features:\\n self.inc_feature_count(f, cat)\\n # Increment the count for this category\\n self.inc_category_count(cat)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7754257","0.6942381","0.67552686","0.6744409","0.64315784","0.6248872","0.61960554","0.6153682","0.61321175","0.6125277","0.6124174","0.6114244","0.6085445","0.6071526","0.59699905","0.59624714","0.595758","0.59572315","0.59403145","0.58573264","0.58545685","0.5850144","0.58467406","0.5844807","0.5844639","0.5834204","0.5815795","0.58137596","0.57955164","0.5793069","0.5788377","0.5767631","0.5767377","0.57604873","0.57529515","0.57429355","0.57425314","0.57266307","0.5722174","0.5701872","0.5686215","0.5679076","0.5679076","0.5679076","0.5679076","0.5679076","0.5669133","0.5668392","0.56635875","0.5659751","0.56576246","0.5655989","0.56530696","0.56391895","0.56152","0.56103104","0.55891377","0.55737585","0.55679476","0.55581033","0.5557766","0.55510294","0.5550721","0.5540625","0.553806","0.5535943","0.5534835","0.55341727","0.55278987","0.55258834","0.55206215","0.5516491","0.55132604","0.55131763","0.5499864","0.54936737","0.54919076","0.5490284","0.5487554","0.548498","0.5483838","0.5473226","0.54724467","0.5471758","0.5467439","0.5467403","0.5466936","0.54646885","0.54638135","0.5452467","0.54467505","0.54432476","0.5442832","0.5442577","0.54339284","0.5427706","0.54272234","0.5426568","0.5425901","0.5413891","0.5405901"],"string":"[\n \"0.7754257\",\n \"0.6942381\",\n \"0.67552686\",\n \"0.6744409\",\n \"0.64315784\",\n \"0.6248872\",\n \"0.61960554\",\n \"0.6153682\",\n \"0.61321175\",\n \"0.6125277\",\n \"0.6124174\",\n \"0.6114244\",\n \"0.6085445\",\n \"0.6071526\",\n \"0.59699905\",\n \"0.59624714\",\n \"0.595758\",\n \"0.59572315\",\n \"0.59403145\",\n \"0.58573264\",\n \"0.58545685\",\n \"0.5850144\",\n \"0.58467406\",\n \"0.5844807\",\n \"0.5844639\",\n \"0.5834204\",\n \"0.5815795\",\n \"0.58137596\",\n \"0.57955164\",\n \"0.5793069\",\n \"0.5788377\",\n \"0.5767631\",\n \"0.5767377\",\n \"0.57604873\",\n \"0.57529515\",\n \"0.57429355\",\n \"0.57425314\",\n \"0.57266307\",\n \"0.5722174\",\n \"0.5701872\",\n \"0.5686215\",\n \"0.5679076\",\n \"0.5679076\",\n \"0.5679076\",\n \"0.5679076\",\n \"0.5679076\",\n \"0.5669133\",\n \"0.5668392\",\n \"0.56635875\",\n \"0.5659751\",\n \"0.56576246\",\n \"0.5655989\",\n \"0.56530696\",\n \"0.56391895\",\n \"0.56152\",\n \"0.56103104\",\n \"0.55891377\",\n \"0.55737585\",\n \"0.55679476\",\n \"0.55581033\",\n \"0.5557766\",\n \"0.55510294\",\n \"0.5550721\",\n \"0.5540625\",\n \"0.553806\",\n \"0.5535943\",\n \"0.5534835\",\n \"0.55341727\",\n \"0.55278987\",\n \"0.55258834\",\n \"0.55206215\",\n \"0.5516491\",\n \"0.55132604\",\n \"0.55131763\",\n \"0.5499864\",\n \"0.54936737\",\n \"0.54919076\",\n \"0.5490284\",\n \"0.5487554\",\n \"0.548498\",\n \"0.5483838\",\n \"0.5473226\",\n \"0.54724467\",\n \"0.5471758\",\n \"0.5467439\",\n \"0.5467403\",\n \"0.5466936\",\n \"0.54646885\",\n \"0.54638135\",\n \"0.5452467\",\n \"0.54467505\",\n \"0.54432476\",\n \"0.5442832\",\n \"0.5442577\",\n \"0.54339284\",\n \"0.5427706\",\n \"0.54272234\",\n \"0.5426568\",\n \"0.5425901\",\n \"0.5413891\",\n \"0.5405901\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85155,"cells":{"query":{"kind":"string","value":"Ensure we can retrieve a list of our own photos and photos accessible via album groups."},"document":{"kind":"string","value":"def test_paginated_photos(self):\n\n own_album = AlbumFactory.create(user=self.user)\n photos = PhotoFactory.create_batch(3, album=own_album)\n PhotoFactory.create_batch(2, album=own_album, trash=True)\n trash_album = AlbumFactory.create(user=self.user, trash=True)\n PhotoFactory.create(album=trash_album)\n album_group = AlbumGroupFactory.create(users=[self.user])\n photos += PhotoFactory.create_batch(4, album=album_group.album)\n random_album = AlbumFactory.create()\n PhotoFactory.create_batch(5, album=random_album)\n\n url = reverse(\"api:my/photos-list\")\n\n # check as anonymous user\n response = self.client.get(url)\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)\n self.assertEqual(\n response.data, {\"detail\": \"Authentication credentials were not provided.\"}\n )\n\n # authenticated\n self.client.login(username=self.user.username, password=\"password\")\n response = self.client.get(url)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n # ensure pagination is active\n self.assertEqual(response.data[\"count\"], len(photos))\n\n photos.reverse()\n results = response.data[\"results\"]\n for photo, result in zip(photos, results):\n self.assertEqual(result[\"id\"], photo.id)\n self.assertEqual(result[\"user\"], photo.user_id)\n image = result[\"image\"]\n self.assertIn(\"large\", image)\n self.assertIn(\"thumb\", image)\n\n # test filter\n response = self.client.get(url, {\"album\": own_album.pk})\n self.assertEqual(response.data[\"count\"], 3)\n results = response.data[\"results\"]\n\n for result, photo in zip(results, photos[-3:]):\n self.assertEqual(result[\"id\"], photo.id)"},"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 test_users_photos_view_set_get_own_photos(self):\n # Create user and data\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\n category = photo_models.PhotoClassification.objects\\\n .create_or_update(name='Test', classification_type='category')\n\n photo1 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo1-min.jpg', 'rb')), user=user)\n photo1.save()\n photo1.category.set([category])\n photo1.save()\n\n photo2 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo2-min.jpg', 'rb')), user=user)\n photo2.save()\n photo2.category.set([category])\n photo2.save()\n\n # Simulate auth\n token = test_helpers.get_token_for_user(user)\n\n # Get data from endpoint\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\n\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\n result = request.data['results']\n\n self.assertEquals(request.status_code, 200)\n self.assertEquals(len(result), 2)\n self.assertEquals(result[0]['id'], photo2.id) # newest first\n self.assertIn('dimensions', result[0])\n self.assertIn('image_blurred', result[0])\n self.assertIn('image', result[0])","def test_album_limited_to_user(self, api_client, test_user):\n\n user2 = get_user_model().objects.create_user(\n 'otheruser@company.com',\n 'password123'\n )\n sample_photo_album(user=user2)\n sample_photo_album(user=test_user)\n\n api_client.force_authenticate(test_user)\n res = api_client.get(PHOTO_ALBUM_URL)\n\n albums = PhotoAlbum.objects.filter(user=test_user)\n serializer = PhotoAlbumSerializer(albums, many=True)\n\n assert res.status_code == status.HTTP_200_OK\n assert len(res.data) == 1\n assert res.data == serializer.data","def get_albums():\n return query_multiple(request.args, album_search, \\\n album_filter, Album, albums_schema)","def get_albums(self):\n artist = self.get_request_arg(\"artist\")\n if artist:\n lib = self.ctrl.library\n lst = sorted(self.ctrl.library.get_albums(artist))\n albums = [{\"artist\": artist,\n \"album\": album,\n \"path\": lib.get_path(artist, album)} for album in lst]\n if lst:\n return self.resp_from_data(albums)\n return self.resp_from_data(\n {\"message\": f\"No album found for artist={artist}\"}, 400)","def test_retrieval_of_user_photos(self):\t\n\t\tget_response = self.client.get(reverse('photos'))\n\n\t\tself.assertEqual(get_response.status_code, status.HTTP_200_OK)\n\t\tdata = [i.values() for i in get_response.data]\n\t\tself.assertIn(u'{}'.format(self.image_name), data[0])","def get_albums(self):\n self.artist = self.artists_list.currentText()\n self.c_albums = [x['album'] for x in dmlc.list_albums(self.artist)\n if [x['album'] in self.albums_map[self.artist]]]\n self.albums_list.clear()\n self.albums_list.addItems(self.c_albums)\n self.update_navigation_buttons()","def test_retrieve_album(self, api_client, test_user):\n\n sample_photo_album(user=test_user)\n sample_photo_album(user=test_user, title=\"2019\")\n\n api_client.force_authenticate(test_user)\n res = api_client.get(PHOTO_ALBUM_URL)\n\n albums = PhotoAlbum.objects.all().order_by('-created')\n serializer = PhotoAlbumSerializer(albums, many=True)\n assert res.status_code == status.HTTP_200_OK\n assert res.data == serializer.data","def test_users_photos_view_set_get_successful(self):\n # Create user and data\n access_user = account_models.User.objects.create_user(email='m@mypapaya.io', password='pass', username='m')\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\n category = photo_models.PhotoClassification.objects\\\n .create_or_update(name='Test', classification_type='category')\n\n photo1 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo1-min.jpg', 'rb')), user=user)\n photo1.save()\n photo1.category.set([category])\n photo1.save()\n\n photo2 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo2-min.jpg', 'rb')), user=user)\n photo2.save()\n photo2.category.set([category])\n photo2.save()\n\n # Simulate auth\n token = test_helpers.get_token_for_user(access_user)\n\n # Get data from endpoint\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\n\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\n result = request.data['results']\n\n self.assertEquals(request.status_code, 200)\n self.assertEquals(len(result), 2)\n self.assertEquals(result[0]['id'], photo2.id) # newest first\n self.assertIn('dimensions', result[0])\n self.assertIn('image_blurred', result[0])\n self.assertIn('image', result[0])","def get_albums(self, only_published=True, only_active=True, list_only=False,\n only_smart=False, exclude_smart=False, tags=None, tags_exclusive=True):\n if not tags:\n tags = []\n\n if not hasattr(tags, '__iter__'):\n tags = [tags]\n\n options = {\n 'only_published': int(bool(only_published)),\n 'only_active': int(bool(only_active)),\n 'list_only': int(bool(list_only)),\n 'only_smart': int(bool(only_smart)),\n 'exclude_smart': int(bool(exclude_smart)),\n }\n\n if tags:\n options.update({'tags': ','.join(str(tag) for tag in tags),\n 'tags_exclusive': int(bool(tags_exclusive))})\n\n data = self._get('get_album_list', options)\n return data['albums']","def test_users_photos_view_set_get_no_photos(self):\n # Create user\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\n\n # Simulate auth\n token = test_helpers.get_token_for_user(user)\n\n # Get data from endpoint\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\n\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\n result = request.data['results']\n\n self.assertEquals(request.status_code, 200)\n self.assertEquals(len(result), 0)","def get_albums(self, limit=None):\n url = (\"https://api.imgur.com/3/account/{0}/albums/{1}\".format(self.name,\n '{}'))\n resp = self._imgur._send_request(url, limit=limit)\n return [Album(alb, self._imgur, False) for alb in resp]","def get_albums(self, ctx, page, templ_vars):\n if 'type' in page.meta and page.meta['type'] == 'index':\n album_pages = sorted(\n templ_vars['site']['categories']['gallery'],\n key=lambda album: album['datetime'],\n )\n albums = {}\n for album_page in album_pages:\n image_list = []\n images = map(\n lambda i: i['thumb_src'],\n self.albums[album_page['slug']]\n )\n image_list += images[:PREVIEW_IMGS_NUM]\n albums[album_page['slug']] = image_list\n templ_vars['site']['albums'] = albums","def test_get_owner_image(self):\n\n # user1 is owner of image_id 1\n # user2 is owner of image ids (2,3)\n for image_id in range(1, 4):\n url = reverse(self.url_name_one, args=(image_id,))\n if image_id == 1:\n self.client.force_authenticate(self.user1)\n else:\n self.client.force_authenticate(self.user2)\n\n response = self.client.get(url, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n if image_id == 1:\n self.assertEqual(response.data[\"owner\"], \"user1\")\n else:\n self.assertEqual(response.data[\"owner\"], \"user2\")\n\n # user2 try to get image_id 1 which is owner user1\n url = reverse(self.url_name_one, args=(1,))\n response = self.client.get(url, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)","def current_user_saved_albums(self, limit=20, offset=0, **kwargs):\n return self._get(API.MY_ALBUMS.value, limit=limit, offset=offset, **kwargs)","def test_get_photos(self):\n recipe = Recipes.objects.create(chef=self.user, draft=False, private=False)\n photo = Photos.objects.create(recipe=recipe, photo_order=1)\n\n url = '/0/chefs/%i/photos' % self.user.pk\n\n resp = self.client.get(url)\n self.assertPermissionDenied(resp)\n\n headers = self.login()\n resp = self.client.get(url, **headers)\n self.assertEqual(resp.status_code, 200)\n self.assertIn('photos', resp.data)\n self.assertEqual(1, len(resp.data['photos']))\n keys = ('edit_date', 'creation_date', 'id', u'temperature', 'url', 'recipe', 'cover',\n 'time', 'instructions', 'order', 'quantity')\n self.assertEqual(set(keys), set(resp.data['photos'][0].keys()))","def get_images(self, ctx, page):\n is_imgur = 'source' in page.meta and page.meta['source'] == 'imgur'\n if 'type' in page.meta and page.meta['type'] == 'album':\n album = page.meta\n images = []\n if is_imgur:\n pp.pprint(page.meta)\n # bind to template via json\n images = self.get_imgur_album_images(page)\n self.albums[album['slug']] = images\n else:\n # get paths of all of the images in the album\n srcs = []\n # get absolute paths of images in album for each file type\n for file_type in FILE_TYPES:\n imgs = glob.glob(\n GALLERY_DIR + album['slug'] + '/*.' + file_type\n )\n\n for img in imgs:\n img_rel_path = (\n REL_GALLERY_DIR +\n album['slug'] + '/' + img.split('/')[-1]\n )\n srcs.append(img_rel_path)\n\n # split full srcs and thumb srcs from srcs into two lists\n images = []\n thumb_srcs = filter(\n lambda src: src.split('/')[-1].startswith(THUMB_PREFIX),\n srcs\n )\n for thumb_src in thumb_srcs:\n src = thumb_src.replace(THUMB_PREFIX, '')\n thumb_width, thumb_height = self.calc_img_hw(thumb_src)\n width, height = self.calc_img_hw(src)\n images.append({\n 'thumb_src': thumb_src,\n 'thumb_width': thumb_width,\n 'thumb_height': thumb_height,\n\n 'src': src,\n 'width': width,\n 'height': height,\n })\n self.albums[album['slug']] = images","def test_shared_albums(self):\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n t = (\n TestAccount.album_image_count\n + TestAccount.album_shared_image_count\n + TestAccount.shared_album_image_count\n + TestAccount.shared_album_shared_image_count\n )\n\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums including shared\".format(t),\n )\n\n with ts.SetupDbAndCredentials() as s:\n args = [\"--skip-files\", \"--skip-shared-albums\"]\n s.test_setup(\n \"test_shared_albums\", args=args, trash_files=True, trash_db=True\n )\n s.gp.start(s.parsed_args)\n\n # note that unless we use --no-album-index the shared files in the\n # visible album will show up here\n t = (\n TestAccount.album_image_count + TestAccount.album_shared_image_count\n ) # see above\n with LocalData(s.root) as db:\n db.cur.execute(\"SELECT COUNT() FROM AlbumFiles\")\n count = db.cur.fetchone()\n self.assertEqual(\n t,\n count[0],\n \"expected {} files in all albums excluding shared\".format(t),\n )","def getAlbums():\n\n r = requests.get(ALBUMS_URL, headers=HEADER, timeout=5)\n\n if r.status_code == 200:\n \n try:\n albums = [] \n soup = BeautifulSoup(r.text, \"html.parser\")\n album = soup.find_all(\"div\", class_=\"duv\")\n for i,al in enumerate(album): \n temp = {}\n temp['link'] = al.find_all(\"a\")[0]['href']\n temp['album'] = al.find_all(\"span\", class_=\"title\")[0].text\n albums.append(temp)\n\n if len(albums) > 0:\n return albums\n else:\n print(\"No albums found on site2!\")\n sys.exit(0)\n \n except Exception as e:\n print(\"Failed to get albums from site2\\n\", e)\n sys.exit(0)\n\n else:\n print(\"Albums Url fetch failed! Status code: {}\".format(r.status_code))\n sys.exit(0)","def test_get(self):\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\n self.u, album.manage_album_permissions, ALBUM_PRIVATE)\n # add u2 as contributor\n self.make_logged_in_contributor()\n\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\n self.u2, album.manage_album_permissions, ALBUM_PRIVATE)\n\n # contributor does not obtain addcontributorsform from get\n resp = self.client.get(reverse('manage_album', kwargs={'albumid': self.testalbum.id}))\n assert 'addcontributorsform' not in resp.context.keys()\n assert 'accesstypeform' not in resp.context.keys()\n # todo: elsewhere we need to add testing for group form if the access type is or is not groups\n\n # use u3 as control, not owner or contributor, pass 0 as permission, no access\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\n self.u3, album.manage_album_permissions, 0)","def test_get_owned_interest_lists_auth(self):\n url = reverse('xds_api:owned-lists')\n _, token = AuthToken.objects.create(self.user_1)\n response = self.client \\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\n responseDict = json.loads(response.content)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(responseDict[0][\"owner\"][\"email\"], self.user_1.email)\n self.assertEqual(len(self.user_1.interest_lists.all()),\n len(responseDict))","def get_albums(self, offset=None):\n return self.__get('albums')","def test_get_photos_paging(self):\n pass","def test_logged_in_friend_in_group(self):\n self.make_logged_in_friend_in_group()\n\n # test show album\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\n self.u2, album.display_album, ALBUM_GROUPS)\n\n # test photo view\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\n \"photoid\", \"show_photo\", ALBUM_GROUPS)\n\n # test individual photo view page\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\n self.u2, album.display_photo, ALBUM_GROUPS)","def tracked_albums():\n print('Your Google Photos Albums ([X] = tracked):')\n albums = get_albums(service)\n for i, a in enumerate(albums):\n check = 'X' if a.id in library.get_album_ids() else ' '\n print('[{}] {}. {}'.format(check, i+1, a.title))\n return albums","def test_logged_in_owner(self):\n self.make_logged_in_owner()\n\n # test show album\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\n self.u, album.display_album, ALBUM_PRIVATE)\n\n # test photo view\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\n \"photoid\", \"show_photo\", ALBUM_PRIVATE)\n\n # test individual photo view page\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\n self.u, album.display_photo, ALBUM_PRIVATE)","def test_photos_limited_to_user(self, api_client, test_user):\n\n user2 = get_user_model().objects.create_user(\n 'otheruser@company.com',\n 'password123'\n )\n sample_photo(user=user2)\n sample_photo(user=test_user)\n\n api_client.force_authenticate(test_user)\n res = api_client.get(PHOTO_URL)\n\n photos = Photo.objects.filter(user=test_user)\n serializer = PhotoSerializer(photos, many=True)\n\n assert res.status_code == status.HTTP_200_OK\n assert len(res.data) == 1\n assert res.data == serializer.data","def albums(self, albums, **kwargs):\n album_list = map(self._get_album_id, albums)\n return self._get(API.ALBUMS.value, ids=\",\".join(album_list), **kwargs)","def test_create_photo_album(self, api_client, test_user):\n photo_1 = sample_photo(user=test_user, title='Home')\n photo_2 = sample_photo(user=test_user, title='Work')\n\n payload = {\n 'title': 'Holidays in LA',\n 'photos': [str(photo_1.id), str(photo_2.id)],\n }\n\n api_client.force_authenticate(test_user)\n res = api_client.post(PHOTO_ALBUM_URL, payload)\n print(res.data)\n assert res.status_code == status.HTTP_201_CREATED\n album = PhotoAlbum.objects.get(id=res.data['id'])\n photos = album.photos.all()\n assert photos.count() == 2","def get(self):\n return PhotoGalleryService().get_all(), 200","def get(request):\n return Response(\n GallerySerializer(\n request.user.gallery.all(),\n many=True\n ).data\n )","def glance_list_owned_public_images(glance, owner_id, image_info):\n\n images = []\n list_kwargs = {'filters': {'visibility': 'public', 'owner': owner_id}}\n public_owned_images = glance.images.list(**list_kwargs)\n for image in public_owned_images:\n # only images with the \"same\" name ('TOTO' matches 'test_TOTO' or 'TOTO - 2016-10-03')\n if image_info['image_name'] in image.name:\n images.append(image)\n return images","def get_album_photos_json():\n args = request.args.to_dict()\n # print(args)\n if request.method == 'GET':\n if len(args) > 0:\n\n if 'limit' not in args.keys():\n args['limit'] = 20\n\n if 'offset' not in args.keys():\n args['offset'] = 0\n\n album_data = a.get_album_photos_in_range(\n args['album_id'],\n args['limit'],\n args['offset']\n )\n json_data = album_data\n return jsonify(json_data)\n\n if request.method == 'POST':\n # print('test', request.get_json())\n data = request.get_json()\n a.remove_photos_from_album(data['albumId'], data['photos'])\n return redirect(\"/albums/{}\".format(data['albumId']), code=302)","def getAlbums(owner_id=None, album_ids=None, offset=None, count=None, need_system=None,\\\n need_covers=None, photo_sizes=None):\n params = {\n 'owner_id': owner_id,\n 'album_ids': album_ids,\n 'offset': offset,\n 'count': count,\n 'need_system': need_system,\n 'need_covers': need_covers,\n 'photo_sizes': photo_sizes\n }\n result = call('photos.getAlbums', **params)\n return parse_response(result)","def get_albums(entity_url: str) -> list:\n entity_url = entity_url.rstrip(\"/\")\n response = requests.get(entity_url)\n soup = BeautifulSoup(response.text, \"html.parser\")\n albums = []\n for link in soup.find_all('a'):\n url = link.get('href')\n if url is not None and \"/album/\" in url:\n if url.startswith(\"http\"):\n albums.append(url)\n else:\n albums.append(f\"{entity_url}{url}\")\n return albums","def test_logged_in_friend_not_in_group(self):\n\n self.make_logged_in_friend_not_in_group()\n\n # test show album\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\n self.u2, album.display_album, ALBUM_ALLFRIENDS)\n\n # test photo view\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\n \"photoid\", \"show_photo\", ALBUM_ALLFRIENDS)\n\n # test individual photo view page\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\n self.u2, album.display_photo, ALBUM_ALLFRIENDS)","def get_album_list():\n\n # TODO: Paginate this, etc\n entities = PhotoAlbum.query().order(-PhotoAlbum.title).fetch(1000)\n\n return entities","def test_aws_service_api_private_images_get(self):\n pass","def test_auth_required(self, api_client):\n res = api_client.get(PHOTO_ALBUM_URL)\n\n assert res.status_code == status.HTTP_401_UNAUTHORIZED","def test_album_image_user(self):\n self.assertEqual(self.album.user, self.photo.user)","def get_goods_photos_same_user(self):\n photos = GoodsPhotos.objects.filter(good__user=self.user).exclude(good=self)\n return photos","def test_users_photos_view_set_get_no_user(self):\n # Create user\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\n\n # Simulate auth\n token = test_helpers.get_token_for_user(user)\n\n # Get data from endpoint\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\n\n request = client.get('/api/users/{}/photos'.format(99999), format='json')\n\n self.assertEquals(request.status_code, 404)","def test_get_albums_no_params(self, id_name_elms, service_config, request):\n service_config.album_store.get_all.return_value = id_name_elms\n params = avalon.web.request.Parameters(request)\n\n service = avalon.web.services.AvalonMetadataService(service_config)\n results = service.get_albums(params)\n\n assert results == id_name_elms, 'Expected all albums returned'","def test_list_auth(self):\n self.api_client.logout()\n resp = self.api_client.get('/api/metadata/tracks/')\n self.assertEqual(resp.status_code, 403)","def test_top_albums(self):\n \n rss = AppleRSS()\n objs = rss.get_top_albums(limit=10)\n \n self.__test_artists('top_albums', objs)","def test_get_all_interest_lists_auth(self):\n url = reverse('xds_api:interest-lists')\n _, token = AuthToken.objects.create(self.user_1)\n response = self.client \\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\n responseDict = json.loads(response.content)\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(responseDict[0][\"owner\"][\"email\"], self.user_1.email)","def test_get_all_need_transform_no_albums(self):\n self.assertEqual(Album.get_all_need_transform(self.app.curs, 1), [])","def test_ms_album_search(helpers):\n item_from_xml, item_from_dict = common_tests(\n MSAlbum,\n MS_ALBUM_SEARCH_XML,\n MS_ALBUM_SEARCH_DICT,\n \"00020064albumsearch:de unge\",\n helpers,\n )\n getter_attributes_test(\n \"artist\", item_from_xml, item_from_dict, MS_ALBUM_SEARCH_DICT.get(\"artist\")\n )\n getter_attributes_test(\n \"uri\", item_from_xml, item_from_dict, MS_ALBUM_SEARCH_DICT[\"uri\"]\n )","def album_list(self):\n\n artist_id = self.addon_args[\"artist_id\"][0]\n\n xbmcplugin.setContent(self.addon_handle, \"albums\")\n\n for album in self.connection.walk_artist(artist_id):\n self.add_album(album)\n\n xbmcplugin.addSortMethod(\n self.addon_handle, xbmcplugin.SORT_METHOD_UNSORTED)\n xbmcplugin.addSortMethod(\n self.addon_handle, xbmcplugin.SORT_METHOD_ALBUM)\n xbmcplugin.addSortMethod(\n self.addon_handle, xbmcplugin.SORT_METHOD_ARTIST)\n xbmcplugin.addSortMethod(\n self.addon_handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR)\n\n xbmcplugin.endOfDirectory(self.addon_handle)","def search_for_album(album_name):\n\n print(f'Searching for album: {album_name}')\n\n search_result = spotifyObject.search(q=f'\"{album_name}\"', limit=20, type='album')\n\n items = search_result['albums']['items']\n\n results = []\n\n for item in items:\n if len(item['artists']) > 1:\n artists = tuple(art['name'] for art in item['artists'])\n else:\n artists = item['artists'][0]['name']\n\n results.append((artists, item['name'], item['id']))\n\n return results","def GetAlbums(self, start=0, end=0, sortmethod='label', sortorder='ascending', filter='', artistid=None):\n self.logger.debug(\"Loading all albums for ARTISTID \" + str(artistid))\n try:\n xbmc = Server(self.url('/jsonrpc', True))\n sort = {'order': sortorder, 'method': sortmethod, 'ignorearticle': True}\n properties=['artist', 'title', 'year', 'description', 'thumbnail']\n limits = {'start': int(start), 'end': int(end)}\n if artistid is not None:\n filter = {'artistid': int(artistid)}\n else:\n filter = {'or': [\n {'field': 'album', 'operator': 'contains', 'value': filter},\n {'field': 'artist', 'operator': 'contains', 'value': filter}\n ]}\n return xbmc.AudioLibrary.GetAlbums(properties=properties, limits=limits, sort=sort, filter=filter)\n except ValueError:\n return","def _get_album_or_image(json, imgur):\n if json['is_album']:\n return Gallery_album(json, imgur, has_fetched=False)\n return Gallery_image(json, imgur)","def get_albums(username):\n cur = mysql.connection.cursor()\n cur.execute(\"SELECT * FROM album WHERE username = '{0}'\".format(username))\n return cur.fetchall()","def test_getImages(self): # GIVEN the group chat has at least one image\n testBot = bot.Bot(os.environ['bot_id'], os.environ['token'], os.environ['group_ID'])\n imageList = testBot.run() #AND THEN post_images calls the private get_images method which returns an array\n self.assertTrue(len(imageList) > 0) #THEN there should be at least one element in the array","def simple_album_list():\r\n album_list = []\r\n data = dbase()\r\n for album in data.keys():\r\n album_list += [album]\r\n return album_list","def get_albums(self):\n return AlbumView.get_by_artist(self.name)","def get_gallery(self, section='hot', sort='viral', window='day',\n show_viral=True, limit=None):\n url = (\"https://api.imgur.com/3/gallery/{}/{}/{}/{}?showViral=\"\n \"{}\".format(section, sort, window, '{}', show_viral))\n resp = self._send_request(url, limit=limit)\n return [_get_album_or_image(thing, self) for thing in resp]","def getAll(owner_id=None, extended=None, offset=None, count=None, photo_sizes=None,\\\n no_service_albums=None, need_hidden=None, skip_hidden=None):\n params = {\n 'owner_id': owner_id,\n 'extended': extended,\n 'offset': offset,\n 'count': count,\n 'photo_sizes': photo_sizes,\n 'no_service_albums': no_service_albums,\n 'need_hidden': need_hidden,\n 'skip_hidden': skip_hidden\n }\n result = call('photos.getAll', **params)\n return parse_response(result)","def test_get_all_need_transform_two_albums(self):\n album = Album(artist='Artist', album='Album',\n totaltracks=1, totalseconds=120)\n pk = album.insert(self.app.db, self.app.curs)\n album = Album(artist='Artist', album='Album 2',\n totaltracks=1, totalseconds=120)\n pk = album.insert(self.app.db, self.app.curs)\n self.assertEqual(self.get_album_count(), 2)\n\n albums = Album.get_all_need_transform(self.app.curs, 1)\n self.assertEqual(len(albums), 2)","def get_context_data(self):\n user = self.request.user\n return {\n 'photos': user.photo.all(),\n 'albums': user.album.all(),\n }","def test_groups_group_users_get(self):\n pass","def test_groups_group_users_get(self):\n pass","def obj_get_list(self, request=None, **kwargs):\n filters = {}\n if hasattr(request, 'GET'):\n # Grab a mutable copy.\n filters = request.GET.copy()\n\n # Update with the provided kwargs.\n filters.update(kwargs)\n if \"user\" in filters and \"media\" in filters:\n try:\n image_uuid_list = []\n wordbox_uuid_list = []\n for item in filters['media'].split(','):\n # use kwarg \"resource\" field to be more general rather\n # than take the 2 element\n try:\n if item.split('/')[2] == 'image':\n image_uuid_list.append(uuid_re.findall(item)[0])\n elif item.split('/')[2] == 'wordbox':\n wordbox_uuid_list.append(uuid_re.findall(item)[0])\n except IndexError:\n raise BadRequest(\"Invalid uuid or resource URI.\")\n userprofile = UserProfile.objects.get(\n uuid=uuid_from_uri(filters['user']))\n im = userprofile.image_collection_set.filter(\n is_active=True, uuid__in=image_uuid_list)\n wb = userprofile.wordbox_collection_set.\\\n filter(is_active=True, uuid__in=wordbox_uuid_list)\n base_object_list = sorted(chain(im, wb),\n key=attrgetter('created_time'))[::-1]\n return self.apply_authorization_limits(request,\n base_object_list)\n except ValueError:\n raise BadRequest(\"Invalid resource lookup data provided \"\n \"(mismatched type).\")\n elif \"user\" in filters and len(filters) == 1:\n try:\n userprofile = UserProfile.objects.get(\n uuid=uuid_from_uri(filters['user']))\n im = userprofile.image_collection_set.filter(is_active=True)\n wb = userprofile.wordbox_collection_set.filter(is_active=True)\n base_object_list = sorted(chain(im, wb),\n key=attrgetter('created_time'))[::-1]\n return self.apply_authorization_limits(request,\n base_object_list)\n except ValueError:\n raise BadRequest(\"Invalid resource lookup data provided \"\n \"(mismatched type).\")\n else:\n raise BadRequest(\"Invalid filtering parameter(s)\")","def test_get_resource_group_member_list(self):\n pass","def get_tracks(self):\n artist = self.get_request_arg(\"artist\")\n album = self.get_request_arg(\"album\")\n if not (album and artist):\n return self.resp_from_data(\n {\"message\": \"Please specify a valid artist and album\"}, 403)\n else:\n tracks = self.ctrl.library.get_tracks(artist, album)\n return self.resp_from_data(tracks)","def test_not_logged_in(self):\n\n # test show album\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\n AnonymousUser(), album.display_album, ALBUM_PUBLIC)\n\n # test photo view\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\n \"photoid\", \"show_photo\", ALBUM_PUBLIC)\n\n # test individual photo view page\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\n AnonymousUser(), album.display_photo, ALBUM_PUBLIC)","def test_groups_get(self):\n pass","def test_groups_get(self):\n pass","def load_photos(self, api):\n self.photos = []\n try:\n # Update authorized ?\n if not main.FLICKR_UPDATE:\n raise Exception(\"No flickr update authorized from settings.\")\n\n photos = api.photosets_getPhotos(photoset_id=self.id, media=\"photos\")\n xml_photos = photos.find(\"photoset\").findall(\"photo\")\n except:\n xml_photos = self.data[\"photos\"]\n\n for i, xml in enumerate(xml_photos):\n photo_id = type(xml) == unicode and xml or xml.attrib[\"id\"]\n try:\n photo = FlickrPhoto(photo_id, api, self)\n except Exception, e:\n logger.error(\n \"%d/%d Failed loading of %s : %s\",\n i + 1,\n len(xml_photos),\n photo_id,\n str(e),\n )\n continue\n logger.debug(\n u\"%d/%d %s from %s\"\n % (i + 1, len(xml_photos), photo, photo.cached and \"cache\" or \"flickr\")\n )\n\n # Save photo\n self.photos.append(photo)\n if not photo.cached:\n photo.save()\n\n # Check primary\n if self.data[\"primary\"] == photo.id:\n self.primary = photo\n\n self.data[\"photos\"] = [p.id for p in self.photos]","def get_photos(album_id):\n opts = RUN_OPTS.opts\n\n payload = {'albumId': album_id}\n try:\n resp = requests.get(PHOTOS_URL, params=payload,\n timeout=opts['timeout'])\n except (requests.ConnectionError, requests.ReadTimeout):\n print(f\"get for {PHOTOS_URL} errored or timed out after \" +\n f\"{opts['timeout']} seconds\")\n return None\n\n print_debug(f\"http status_code = {resp.status_code}; url = {resp.url}\")\n\n if not resp.ok:\n print(f'url for album_id={album_id} or \"{resp.url}\" not found: ' +\n f'status {resp.status_code}')\n return None\n\n photos = resp.json()\n if not resp.ok or len(photos) <= 0:\n print(f'zero rows returned for album_id={album_id}')\n return None\n\n return photos","def test_activity_photos(self):\n activity = self.client.get_activity(152668627)\n self.assertTrue(activity.photo_count > 0)\n photos = list(activity.photos)\n self.assertEqual(len(photos), 1)\n self.assertEqual(len(photos), activity.photo_count)\n self.assertIsInstance(photos[0], model.ActivityPhoto)","def cmd_account_albums(client, args):\n account_albums = client.get_account_albums(args.username, args.page)\n data = [item.__dict__ for item in account_albums]\n generate_output({'account_albums': data}, args.output_file)","def get_memes_gallery(self, sort='viral', window='week', limit=None):\n url = (\"https://api.imgur.com/3/gallery/g/memes/{0}/{1}/{2}\".format(\n sort, window, '{}'))\n resp = self._send_request(url, limit=limit)\n return [_get_album_or_image(thing, self) for thing in resp]","def test_group_get_objects_all_perms(self):\n group0 = self.test_save('TestGroup0', user0)\n group1 = self.test_save('TestGroup1', user1)\n \n object2 = TestModel.objects.create(name='test2')\n object2.save()\n object3 = TestModel.objects.create(name='test3')\n object3.save()\n object4 = TestModel.objects.create(name='test4')\n object4.save()\n \n group0.grant('Perm1', object0)\n group0.grant('Perm2', object0)\n group0.grant('Perm4', object1)\n group1.grant('Perm3', object2)\n group1.grant('Perm4', object2)\n \n # retrieve single perm\n self.assert_(object0 in group0.get_objects_all_perms(TestModel, ['Perm1']))\n self.assert_(object1 in group0.get_objects_all_perms(TestModel, ['Perm4']))\n self.assert_(object2 in group1.get_objects_all_perms(TestModel, ['Perm3']))\n self.assert_(object2 in group1.get_objects_all_perms(TestModel, ['Perm4']))\n \n # retrieve multiple perms\n query = group0.get_objects_all_perms(TestModel, ['Perm1', 'Perm2'])\n self.assert_(object0 in query)\n self.assertFalse(object1 in query)\n self.assertEqual(1, query.count())\n query = group1.get_objects_all_perms(TestModel, ['Perm3', 'Perm4'])\n self.assert_(object2 in query)\n self.assertFalse(object3 in query)\n self.assertEqual(1, query.count())\n \n # retrieve no results\n self.assertFalse(group0.get_objects_all_perms(TestModel, ['Perm3']).exists())\n self.assertFalse(group0.get_objects_all_perms(TestModel, ['Perm1','Perm4']).exists())\n self.assertFalse(group1.get_objects_all_perms(TestModel, ['Perm1']).exists())\n \n # extra kwargs\n query = group0.get_objects_all_perms(TestModel, ['Perm1', 'Perm2']).filter( name='test0')\n self.assert_(object0 in query)\n self.assertEqual(1, query.count())","def index(request):\n\n #Collect all photos owned by the user and not associated with albums for display\n photos = Photo.objects.filter(owner = request.user, album_id=None)\n\n #Collect all albums owned by the user for display\n albums = Album.objects.filter(owner = request.user)\n\n #Form to upload multiple images extends Djangos form.ImageField()\n #Fields taken 'file' (image)\n form = UploadFileForm()\n\n #Form to upload album\n #Fields taken are 'title'(charfield)\n formAlbum = AlbumForm()\n return render_to_response('photos/index.html',\n {\n 'form': form,\n 'formAlbum': formAlbum,\n 'photos': photos,\n 'albums':albums,\n },\n context_instance=RequestContext(request))","def test_users_groups_get(self):\n pass","def test_filter_only_with_photo(self):\n request = self.factory.get('/api/v1/cars', {'only_with_photo': True,\n 'distance': 1000})\n response = CarAdViewSet.as_view({'get': 'list'})(request)\n car_without_photo = None\n for car in response.data['results']:\n if not car['photos']:\n car_without_photo = car\n break\n self.assertEqual(response.status_code, HTTPStatus.OK._value_)\n self.assertIs(car_without_photo, None)","def photos(self):\n return self._photos","def get_top_albums(\n self, period: Period, limit: int = 50, page: int = 1\n ) -> ListModel[Album]:\n assert isinstance(period, Period)\n\n return self.retrieve(\n bind=Album,\n flatten=\"album\",\n params=dict(\n method=\"user.getTopAlbums\",\n user=self.name,\n limit=limit,\n page=page,\n period=period.value,\n ),\n )","def album_assignment(self):\n log.debug(\"Called album_assignment for %s.\" % self.name)\n self.success = False\n for splitter in splitters:\n if splitter in self.name:\n self.artist, self.album = self.name.split(splitter, 1) # May need to look at this again, can be more than 1!\n self.success = True\n break\n if self.success:\n results = self.sp.search(q='artist: ' + self.artist + 'album: ' + self.album, type='album', limit=1)\n if results['albums']['total'] >= 1:\n for items in results['albums']['items']:\n self.album = items['name']\n self.album_uri = items['uri']\n for artist in items['artists'][0]:\n self.artist = artist['name']\n self.artist_uri = artist['uri']\n else:\n self.success = False","def list(self, request, *args, **kwargs):\n if not request.user.is_superuser:\n self.queryset = Group.objects.filter(owner__pk=request.user.id)\n\n return super().list(request, args, kwargs)","def test_get_groups(self):\n pass","def test_get_groups(self):\n pass","def every_existing_owner_should_have_valid_profile_image_link(context):\n items = context.response.json()['items']\n for item in items:\n owner = item['owner']\n if owner['user_type'] == 'does_not_exist':\n continue\n link = owner['profile_image']\n assert validators.url(link), (\n 'Owner %s (%d) in item %d has an invalid profile image link: %s'\n .format(owner['display_name'], owner['user_id'], link))\n logging.debug(\n 'Owner %s (%d) has a valid profile image link: %s',\n owner['display_name'], owner['user_id'], link)","def test_list_image_stream_for_all_namespaces(self):\n pass","def test_filesystem_can_list_contents_of_root_directory(self):\n self.index.photos_unique_domains = MagicMock(return_value=[\n 'example.com',\n 'example.net'\n ])\n\n files = self.filesystem._list('/')\n\n self.assertListOfFilesEqual(\n [\n Directory('.'),\n Directory('..'),\n Directory('example.com'),\n Directory('example.net'),\n ],\n files\n )\n self.index.photos_unique_domains.assert_called_with(self.refresh_rate)","def test_photo_classification_view_set_get_filtered_does_not_exist(self):\n # Test data\n user = account_models.User.objects.get(email='mrtest@mypapaya.io')\n\n # Simulate auth\n token = test_helpers.get_token_for_user(user)\n\n # Get data from endpoint\n client = APIClient()\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\n\n request = client.get('/api/photo_classifications?classification=group')\n\n self.assertEquals(request.status_code, 400)","def test_list_members_with_owner_rights(self):\n url = '/api/v1/communities/4/retrieve_members/'\n\n response = self.client.get(url, HTTP_AUTHORIZATION=self.auth('user1'))\n self.assertEqual(status.HTTP_200_OK, response.status_code)\n\n data = response.data\n self.assertEqual(3, data['count'])","def test_list_media_collection(self):\n self.login_editor()\n\n # Create a media collection object and test that is present on list\n MediaCollection.objects.create(name='Coleção 1',\n description='Coleção de teste 1',\n created_by_id=1, cooperative_center_code='BR1.1')\n\n MediaCollection.objects.create(name='Coleção 2',\n description='Coleção de teste 2',\n created_by_id=2, cooperative_center_code='BR1.1')\n\n MediaCollection.objects.create(name='Coleção 3',\n description='Coleção de teste 3',\n created_by_id=3, cooperative_center_code='PY3.8')\n\n\n response = self.client.get('/multimedia/collections')\n # check if only one collection is returned (restrict by user)\n self.assertContains(response, \"Coleção 1\")\n self.assertEquals(response.context['object_list'].count(), 3)\n\n # check if return only colections from cooperative center BR1.1\n response = self.client.get('/multimedia/collections/?filter_created_by_cc=BR1.1')\n self.assertEquals(response.context['object_list'].count(), 2)","def get(owner_id=None, album_id=None, photo_ids=None, rev=None, extended=None,\\\n feed_type=None, feed=None, photo_sizes=None, offset=None, count=None):\n params = {\n 'owner_id': owner_id,\n 'album_id': album_id,\n 'photo_ids': photo_ids,\n 'rev': rev,\n 'extended': extended,\n 'feed_type': feed_type,\n 'feed': feed,\n 'photo_sizes': photo_sizes,\n 'offset': offset,\n 'count': count\n }\n result = call('photos.get', **params)\n return parse_response(result)","def cmd_account_album_ids(client, args):\n account_album_ids = client.get_account_album_ids(args.username, args.page)\n generate_output({'account_album_ids': account_album_ids})","def album_detection(user):\n seen_tracks = user.seen_tracks\n\n list_of_albums = {}\n album_number_of_tracks = {}\n for track in seen_tracks:\n if \"album\" not in track:\n continue\n\n if track[\"name\"] == \"sanjake\":\n continue\n\n album_name = track[\"album\"][\"name\"]\n if album_name not in list_of_albums:\n list_of_albums[album_name] = 0\n album_number_of_tracks[album_name] = track[\"album\"][\"total_tracks\"]\n list_of_albums[album_name] += 1\n\n if list_of_albums[album_name] > 1 and list_of_albums[album_name] == album_number_of_tracks[album_name]:\n print(f\"Album search detected: {album_name}, number of tracks: {album_number_of_tracks[album_name]}\")\n print(f\"User: {user.email_address}\")","def test_api_v1_groups_get(self):\n pass","def test_group_get_objects_any_perms(self):\n group0 = self.test_save('TestGroup0', user0)\n group1 = self.test_save('TestGroup1', user1)\n \n object2 = TestModel.objects.create(name='test2')\n object2.save()\n object3 = TestModel.objects.create(name='test3')\n object3.save()\n object4 = TestModel.objects.create(name='test4')\n object4.save()\n \n group0.grant('Perm1', object0)\n group0.grant('Perm2', object1)\n group1.grant('Perm3', object2)\n group1.grant('Perm4', object3)\n \n # implicit any\n self.assert_(object0 in group0.get_objects_any_perms(TestModel, ['Perm1']))\n self.assert_(object1 in group0.get_objects_any_perms(TestModel, ['Perm2']))\n self.assertFalse(object2 in group0.get_objects_any_perms(TestModel, ['Perm2']))\n self.assert_(object2 in group1.get_objects_any_perms(TestModel, ['Perm3']))\n self.assert_(object3 in group1.get_objects_any_perms(TestModel, ['Perm4']))\n \n # retrieve single perm\n self.assert_(object0 in group0.get_objects_any_perms(TestModel, ['Perm1']))\n self.assert_(object1 in group0.get_objects_any_perms(TestModel, ['Perm2']))\n self.assert_(object2 in group1.get_objects_any_perms(TestModel, ['Perm3']))\n self.assert_(object3 in group1.get_objects_any_perms(TestModel, ['Perm4']))\n \n # retrieve multiple perms\n query = group0.get_objects_any_perms(TestModel, ['Perm1', 'Perm2', 'Perm3'])\n self.assert_(object0 in query)\n self.assert_(object1 in query)\n self.assertEqual(2, query.count())\n query = group1.get_objects_any_perms(TestModel, ['Perm1', 'Perm3', 'Perm4'])\n self.assert_(object2 in query)\n self.assert_(object3 in query)\n self.assertEqual(2, query.count())\n \n # retrieve no results\n query = group0.get_objects_any_perms(TestModel, ['Perm3'])\n self.assertEqual(0, query.count())\n query = group1.get_objects_any_perms(TestModel, ['Perm1'])\n self.assertEqual(0, query.count())\n \n # extra kwargs\n query = group0.get_objects_any_perms(TestModel, ['Perm1', 'Perm2', 'Perm3']).filter( name='test0')\n self.assert_(object0 in query)\n self.assertEqual(1, query.count())","def get_album_cover(self):\n artist = self.get_request_arg(\"artist\")\n album = self.get_request_arg(\"album\")\n if not (album and artist):\n return self.resp_from_data(\n {\"message\": \"Please specify a valid artist and album\"}, 403)\n else:\n cover = self.ctrl.library.get_cover_path(artist, album)\n return self.resp_from_image(cover)","def get(self, request, *args, **kwargs):\n\n liked_photos = None\n l_squarefollowings_count = None\n l_best_media = None\n\n # Common for all members views ===================================================\n l_categories = Category.objects.all()\n l_attributes = Attribute.objects.all()\n try:\n logged_member = Member.objects.get(django_user__username=request.user)\n show_describe_button = logged_member.is_editor(request)\n is_monthly_member = logged_member.is_monthly_member()\n is_yearly_member = logged_member.is_yearly_member()\n except ObjectDoesNotExist:\n logged_member = None\n except:\n raise HttpResponseNotFound\n\n l_squarefollowings_count = SquareFollowing.objects.filter(member_id2=logged_member).count()\n if l_squarefollowings_count >= MIN_SQUAREFOLLOWINGS:\n\n # END Common for all members views ===============================================\n l_squarefollowing_queryset = SquareFollowing.objects.all()\n\n l_token = logged_member.get_member_token(request)\n instagram_session = InstagramSession(p_is_admin=False, p_token=l_token['access_token'])\n instagram_session.init_instagram_API()\n\n l_smart_feed_helper = SmartFeedHelper(\n p_feed_owner_instagram_id=logged_member.instagram_user_id,\n p_instagram_session=instagram_session,\n p_batch_size=SMART_FEED_BATCH_SIZE,\n p_min_id=logged_member.smartfeed_last_seen_instagram_photo_id\n )\n l_best_media = l_smart_feed_helper.find_best_media(\n p_media_to_return=SMART_FEED_BATCH_SIZE,\n p_starting_media_id=None,\n p_logged_member=logged_member,\n p_max_days=30\n )\n\n liked_photos = []\n for x_media in l_best_media:\n my_likes = MyLikes(request.user.username, x_media.id, instagram_session )\n has_user_liked_media, no_of_likes = my_likes.has_user_liked_media()\n if has_user_liked_media:\n liked_photos.extend([x_media.id])\n\n\n # Limit calculation --------------------------------------------------------------\n logged_member.refresh_api_limits(request)\n x_ratelimit_remaining, x_ratelimit = logged_member.get_api_limits()\n\n x_ratelimit_used = x_ratelimit - x_ratelimit_remaining\n if x_ratelimit != 0:\n x_limit_pct = (x_ratelimit_used / x_ratelimit) * 100\n else:\n x_limit_pct = 100\n # END Limit calculation ----------------------------------------------------------\n\n return render(request,\n self.template_name,\n dict(\n best_media=l_best_media,\n liked_photos=liked_photos,\n squarefollowings_count=l_squarefollowings_count,\n new_friends_interaction=0,\n\n is_monthly_member=is_monthly_member,\n is_yearly_member=is_yearly_member,\n logged_member=logged_member,\n x_ratelimit_remaining=x_ratelimit_remaining,\n x_ratelimit=x_ratelimit,\n x_limit_pct=x_limit_pct,\n categories=l_categories,\n attributes=l_attributes,\n )\n )","def test_get_groups(self):\n group0 = self.test_save('TestGroup0')\n group1 = self.test_save('TestGroup1')\n \n group0.grant('Perm1', object0)\n group0.grant('Perm3', object1)\n group1.grant('Perm2', object1)\n \n self.assert_(group0 in get_groups(object0))\n self.assertFalse(group1 in get_groups(object0))\n self.assert_(group0 in get_groups(object1))\n self.assert_(group1 in get_groups(object1))\n self.assert_(len(get_groups(object1))==2)","def pic (self, list) : \n result = []\n for pmod in list :\n result.append (pmod.photo_uri)\n return result","def get_queryset(self):\n return Photo.objects.filter(user=self.request.user)","def test_get_resource_membership_holder_list(self):\n pass","def test_list_image_metadata(self):\n pass"],"string":"[\n \"def test_users_photos_view_set_get_own_photos(self):\\n # Create user and data\\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\\n category = photo_models.PhotoClassification.objects\\\\\\n .create_or_update(name='Test', classification_type='category')\\n\\n photo1 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo1-min.jpg', 'rb')), user=user)\\n photo1.save()\\n photo1.category.set([category])\\n photo1.save()\\n\\n photo2 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo2-min.jpg', 'rb')), user=user)\\n photo2.save()\\n photo2.category.set([category])\\n photo2.save()\\n\\n # Simulate auth\\n token = test_helpers.get_token_for_user(user)\\n\\n # Get data from endpoint\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\\n\\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\\n result = request.data['results']\\n\\n self.assertEquals(request.status_code, 200)\\n self.assertEquals(len(result), 2)\\n self.assertEquals(result[0]['id'], photo2.id) # newest first\\n self.assertIn('dimensions', result[0])\\n self.assertIn('image_blurred', result[0])\\n self.assertIn('image', result[0])\",\n \"def test_album_limited_to_user(self, api_client, test_user):\\n\\n user2 = get_user_model().objects.create_user(\\n 'otheruser@company.com',\\n 'password123'\\n )\\n sample_photo_album(user=user2)\\n sample_photo_album(user=test_user)\\n\\n api_client.force_authenticate(test_user)\\n res = api_client.get(PHOTO_ALBUM_URL)\\n\\n albums = PhotoAlbum.objects.filter(user=test_user)\\n serializer = PhotoAlbumSerializer(albums, many=True)\\n\\n assert res.status_code == status.HTTP_200_OK\\n assert len(res.data) == 1\\n assert res.data == serializer.data\",\n \"def get_albums():\\n return query_multiple(request.args, album_search, \\\\\\n album_filter, Album, albums_schema)\",\n \"def get_albums(self):\\n artist = self.get_request_arg(\\\"artist\\\")\\n if artist:\\n lib = self.ctrl.library\\n lst = sorted(self.ctrl.library.get_albums(artist))\\n albums = [{\\\"artist\\\": artist,\\n \\\"album\\\": album,\\n \\\"path\\\": lib.get_path(artist, album)} for album in lst]\\n if lst:\\n return self.resp_from_data(albums)\\n return self.resp_from_data(\\n {\\\"message\\\": f\\\"No album found for artist={artist}\\\"}, 400)\",\n \"def test_retrieval_of_user_photos(self):\\t\\n\\t\\tget_response = self.client.get(reverse('photos'))\\n\\n\\t\\tself.assertEqual(get_response.status_code, status.HTTP_200_OK)\\n\\t\\tdata = [i.values() for i in get_response.data]\\n\\t\\tself.assertIn(u'{}'.format(self.image_name), data[0])\",\n \"def get_albums(self):\\n self.artist = self.artists_list.currentText()\\n self.c_albums = [x['album'] for x in dmlc.list_albums(self.artist)\\n if [x['album'] in self.albums_map[self.artist]]]\\n self.albums_list.clear()\\n self.albums_list.addItems(self.c_albums)\\n self.update_navigation_buttons()\",\n \"def test_retrieve_album(self, api_client, test_user):\\n\\n sample_photo_album(user=test_user)\\n sample_photo_album(user=test_user, title=\\\"2019\\\")\\n\\n api_client.force_authenticate(test_user)\\n res = api_client.get(PHOTO_ALBUM_URL)\\n\\n albums = PhotoAlbum.objects.all().order_by('-created')\\n serializer = PhotoAlbumSerializer(albums, many=True)\\n assert res.status_code == status.HTTP_200_OK\\n assert res.data == serializer.data\",\n \"def test_users_photos_view_set_get_successful(self):\\n # Create user and data\\n access_user = account_models.User.objects.create_user(email='m@mypapaya.io', password='pass', username='m')\\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\\n category = photo_models.PhotoClassification.objects\\\\\\n .create_or_update(name='Test', classification_type='category')\\n\\n photo1 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo1-min.jpg', 'rb')), user=user)\\n photo1.save()\\n photo1.category.set([category])\\n photo1.save()\\n\\n photo2 = photo_models.Photo(image=Photo(open('apps/common/test/data/photos/photo2-min.jpg', 'rb')), user=user)\\n photo2.save()\\n photo2.category.set([category])\\n photo2.save()\\n\\n # Simulate auth\\n token = test_helpers.get_token_for_user(access_user)\\n\\n # Get data from endpoint\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\\n\\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\\n result = request.data['results']\\n\\n self.assertEquals(request.status_code, 200)\\n self.assertEquals(len(result), 2)\\n self.assertEquals(result[0]['id'], photo2.id) # newest first\\n self.assertIn('dimensions', result[0])\\n self.assertIn('image_blurred', result[0])\\n self.assertIn('image', result[0])\",\n \"def get_albums(self, only_published=True, only_active=True, list_only=False,\\n only_smart=False, exclude_smart=False, tags=None, tags_exclusive=True):\\n if not tags:\\n tags = []\\n\\n if not hasattr(tags, '__iter__'):\\n tags = [tags]\\n\\n options = {\\n 'only_published': int(bool(only_published)),\\n 'only_active': int(bool(only_active)),\\n 'list_only': int(bool(list_only)),\\n 'only_smart': int(bool(only_smart)),\\n 'exclude_smart': int(bool(exclude_smart)),\\n }\\n\\n if tags:\\n options.update({'tags': ','.join(str(tag) for tag in tags),\\n 'tags_exclusive': int(bool(tags_exclusive))})\\n\\n data = self._get('get_album_list', options)\\n return data['albums']\",\n \"def test_users_photos_view_set_get_no_photos(self):\\n # Create user\\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\\n\\n # Simulate auth\\n token = test_helpers.get_token_for_user(user)\\n\\n # Get data from endpoint\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\\n\\n request = client.get('/api/users/{}/photos'.format(user.id), format='json')\\n result = request.data['results']\\n\\n self.assertEquals(request.status_code, 200)\\n self.assertEquals(len(result), 0)\",\n \"def get_albums(self, limit=None):\\n url = (\\\"https://api.imgur.com/3/account/{0}/albums/{1}\\\".format(self.name,\\n '{}'))\\n resp = self._imgur._send_request(url, limit=limit)\\n return [Album(alb, self._imgur, False) for alb in resp]\",\n \"def get_albums(self, ctx, page, templ_vars):\\n if 'type' in page.meta and page.meta['type'] == 'index':\\n album_pages = sorted(\\n templ_vars['site']['categories']['gallery'],\\n key=lambda album: album['datetime'],\\n )\\n albums = {}\\n for album_page in album_pages:\\n image_list = []\\n images = map(\\n lambda i: i['thumb_src'],\\n self.albums[album_page['slug']]\\n )\\n image_list += images[:PREVIEW_IMGS_NUM]\\n albums[album_page['slug']] = image_list\\n templ_vars['site']['albums'] = albums\",\n \"def test_get_owner_image(self):\\n\\n # user1 is owner of image_id 1\\n # user2 is owner of image ids (2,3)\\n for image_id in range(1, 4):\\n url = reverse(self.url_name_one, args=(image_id,))\\n if image_id == 1:\\n self.client.force_authenticate(self.user1)\\n else:\\n self.client.force_authenticate(self.user2)\\n\\n response = self.client.get(url, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n if image_id == 1:\\n self.assertEqual(response.data[\\\"owner\\\"], \\\"user1\\\")\\n else:\\n self.assertEqual(response.data[\\\"owner\\\"], \\\"user2\\\")\\n\\n # user2 try to get image_id 1 which is owner user1\\n url = reverse(self.url_name_one, args=(1,))\\n response = self.client.get(url, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)\",\n \"def current_user_saved_albums(self, limit=20, offset=0, **kwargs):\\n return self._get(API.MY_ALBUMS.value, limit=limit, offset=offset, **kwargs)\",\n \"def test_get_photos(self):\\n recipe = Recipes.objects.create(chef=self.user, draft=False, private=False)\\n photo = Photos.objects.create(recipe=recipe, photo_order=1)\\n\\n url = '/0/chefs/%i/photos' % self.user.pk\\n\\n resp = self.client.get(url)\\n self.assertPermissionDenied(resp)\\n\\n headers = self.login()\\n resp = self.client.get(url, **headers)\\n self.assertEqual(resp.status_code, 200)\\n self.assertIn('photos', resp.data)\\n self.assertEqual(1, len(resp.data['photos']))\\n keys = ('edit_date', 'creation_date', 'id', u'temperature', 'url', 'recipe', 'cover',\\n 'time', 'instructions', 'order', 'quantity')\\n self.assertEqual(set(keys), set(resp.data['photos'][0].keys()))\",\n \"def get_images(self, ctx, page):\\n is_imgur = 'source' in page.meta and page.meta['source'] == 'imgur'\\n if 'type' in page.meta and page.meta['type'] == 'album':\\n album = page.meta\\n images = []\\n if is_imgur:\\n pp.pprint(page.meta)\\n # bind to template via json\\n images = self.get_imgur_album_images(page)\\n self.albums[album['slug']] = images\\n else:\\n # get paths of all of the images in the album\\n srcs = []\\n # get absolute paths of images in album for each file type\\n for file_type in FILE_TYPES:\\n imgs = glob.glob(\\n GALLERY_DIR + album['slug'] + '/*.' + file_type\\n )\\n\\n for img in imgs:\\n img_rel_path = (\\n REL_GALLERY_DIR +\\n album['slug'] + '/' + img.split('/')[-1]\\n )\\n srcs.append(img_rel_path)\\n\\n # split full srcs and thumb srcs from srcs into two lists\\n images = []\\n thumb_srcs = filter(\\n lambda src: src.split('/')[-1].startswith(THUMB_PREFIX),\\n srcs\\n )\\n for thumb_src in thumb_srcs:\\n src = thumb_src.replace(THUMB_PREFIX, '')\\n thumb_width, thumb_height = self.calc_img_hw(thumb_src)\\n width, height = self.calc_img_hw(src)\\n images.append({\\n 'thumb_src': thumb_src,\\n 'thumb_width': thumb_width,\\n 'thumb_height': thumb_height,\\n\\n 'src': src,\\n 'width': width,\\n 'height': height,\\n })\\n self.albums[album['slug']] = images\",\n \"def test_shared_albums(self):\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n t = (\\n TestAccount.album_image_count\\n + TestAccount.album_shared_image_count\\n + TestAccount.shared_album_image_count\\n + TestAccount.shared_album_shared_image_count\\n )\\n\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums including shared\\\".format(t),\\n )\\n\\n with ts.SetupDbAndCredentials() as s:\\n args = [\\\"--skip-files\\\", \\\"--skip-shared-albums\\\"]\\n s.test_setup(\\n \\\"test_shared_albums\\\", args=args, trash_files=True, trash_db=True\\n )\\n s.gp.start(s.parsed_args)\\n\\n # note that unless we use --no-album-index the shared files in the\\n # visible album will show up here\\n t = (\\n TestAccount.album_image_count + TestAccount.album_shared_image_count\\n ) # see above\\n with LocalData(s.root) as db:\\n db.cur.execute(\\\"SELECT COUNT() FROM AlbumFiles\\\")\\n count = db.cur.fetchone()\\n self.assertEqual(\\n t,\\n count[0],\\n \\\"expected {} files in all albums excluding shared\\\".format(t),\\n )\",\n \"def getAlbums():\\n\\n r = requests.get(ALBUMS_URL, headers=HEADER, timeout=5)\\n\\n if r.status_code == 200:\\n \\n try:\\n albums = [] \\n soup = BeautifulSoup(r.text, \\\"html.parser\\\")\\n album = soup.find_all(\\\"div\\\", class_=\\\"duv\\\")\\n for i,al in enumerate(album): \\n temp = {}\\n temp['link'] = al.find_all(\\\"a\\\")[0]['href']\\n temp['album'] = al.find_all(\\\"span\\\", class_=\\\"title\\\")[0].text\\n albums.append(temp)\\n\\n if len(albums) > 0:\\n return albums\\n else:\\n print(\\\"No albums found on site2!\\\")\\n sys.exit(0)\\n \\n except Exception as e:\\n print(\\\"Failed to get albums from site2\\\\n\\\", e)\\n sys.exit(0)\\n\\n else:\\n print(\\\"Albums Url fetch failed! Status code: {}\\\".format(r.status_code))\\n sys.exit(0)\",\n \"def test_get(self):\\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\\n self.u, album.manage_album_permissions, ALBUM_PRIVATE)\\n # add u2 as contributor\\n self.make_logged_in_contributor()\\n\\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\\n self.u2, album.manage_album_permissions, ALBUM_PRIVATE)\\n\\n # contributor does not obtain addcontributorsform from get\\n resp = self.client.get(reverse('manage_album', kwargs={'albumid': self.testalbum.id}))\\n assert 'addcontributorsform' not in resp.context.keys()\\n assert 'accesstypeform' not in resp.context.keys()\\n # todo: elsewhere we need to add testing for group form if the access type is or is not groups\\n\\n # use u3 as control, not owner or contributor, pass 0 as permission, no access\\n self.perm_escalate_helper(self.albumcontrol, self.managepagerequest, self.testalbum, self.testalbum.id,\\n self.u3, album.manage_album_permissions, 0)\",\n \"def test_get_owned_interest_lists_auth(self):\\n url = reverse('xds_api:owned-lists')\\n _, token = AuthToken.objects.create(self.user_1)\\n response = self.client \\\\\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\\n responseDict = json.loads(response.content)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(responseDict[0][\\\"owner\\\"][\\\"email\\\"], self.user_1.email)\\n self.assertEqual(len(self.user_1.interest_lists.all()),\\n len(responseDict))\",\n \"def get_albums(self, offset=None):\\n return self.__get('albums')\",\n \"def test_get_photos_paging(self):\\n pass\",\n \"def test_logged_in_friend_in_group(self):\\n self.make_logged_in_friend_in_group()\\n\\n # test show album\\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\\n self.u2, album.display_album, ALBUM_GROUPS)\\n\\n # test photo view\\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\\n \\\"photoid\\\", \\\"show_photo\\\", ALBUM_GROUPS)\\n\\n # test individual photo view page\\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\\n self.u2, album.display_photo, ALBUM_GROUPS)\",\n \"def tracked_albums():\\n print('Your Google Photos Albums ([X] = tracked):')\\n albums = get_albums(service)\\n for i, a in enumerate(albums):\\n check = 'X' if a.id in library.get_album_ids() else ' '\\n print('[{}] {}. {}'.format(check, i+1, a.title))\\n return albums\",\n \"def test_logged_in_owner(self):\\n self.make_logged_in_owner()\\n\\n # test show album\\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\\n self.u, album.display_album, ALBUM_PRIVATE)\\n\\n # test photo view\\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\\n \\\"photoid\\\", \\\"show_photo\\\", ALBUM_PRIVATE)\\n\\n # test individual photo view page\\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\\n self.u, album.display_photo, ALBUM_PRIVATE)\",\n \"def test_photos_limited_to_user(self, api_client, test_user):\\n\\n user2 = get_user_model().objects.create_user(\\n 'otheruser@company.com',\\n 'password123'\\n )\\n sample_photo(user=user2)\\n sample_photo(user=test_user)\\n\\n api_client.force_authenticate(test_user)\\n res = api_client.get(PHOTO_URL)\\n\\n photos = Photo.objects.filter(user=test_user)\\n serializer = PhotoSerializer(photos, many=True)\\n\\n assert res.status_code == status.HTTP_200_OK\\n assert len(res.data) == 1\\n assert res.data == serializer.data\",\n \"def albums(self, albums, **kwargs):\\n album_list = map(self._get_album_id, albums)\\n return self._get(API.ALBUMS.value, ids=\\\",\\\".join(album_list), **kwargs)\",\n \"def test_create_photo_album(self, api_client, test_user):\\n photo_1 = sample_photo(user=test_user, title='Home')\\n photo_2 = sample_photo(user=test_user, title='Work')\\n\\n payload = {\\n 'title': 'Holidays in LA',\\n 'photos': [str(photo_1.id), str(photo_2.id)],\\n }\\n\\n api_client.force_authenticate(test_user)\\n res = api_client.post(PHOTO_ALBUM_URL, payload)\\n print(res.data)\\n assert res.status_code == status.HTTP_201_CREATED\\n album = PhotoAlbum.objects.get(id=res.data['id'])\\n photos = album.photos.all()\\n assert photos.count() == 2\",\n \"def get(self):\\n return PhotoGalleryService().get_all(), 200\",\n \"def get(request):\\n return Response(\\n GallerySerializer(\\n request.user.gallery.all(),\\n many=True\\n ).data\\n )\",\n \"def glance_list_owned_public_images(glance, owner_id, image_info):\\n\\n images = []\\n list_kwargs = {'filters': {'visibility': 'public', 'owner': owner_id}}\\n public_owned_images = glance.images.list(**list_kwargs)\\n for image in public_owned_images:\\n # only images with the \\\"same\\\" name ('TOTO' matches 'test_TOTO' or 'TOTO - 2016-10-03')\\n if image_info['image_name'] in image.name:\\n images.append(image)\\n return images\",\n \"def get_album_photos_json():\\n args = request.args.to_dict()\\n # print(args)\\n if request.method == 'GET':\\n if len(args) > 0:\\n\\n if 'limit' not in args.keys():\\n args['limit'] = 20\\n\\n if 'offset' not in args.keys():\\n args['offset'] = 0\\n\\n album_data = a.get_album_photos_in_range(\\n args['album_id'],\\n args['limit'],\\n args['offset']\\n )\\n json_data = album_data\\n return jsonify(json_data)\\n\\n if request.method == 'POST':\\n # print('test', request.get_json())\\n data = request.get_json()\\n a.remove_photos_from_album(data['albumId'], data['photos'])\\n return redirect(\\\"/albums/{}\\\".format(data['albumId']), code=302)\",\n \"def getAlbums(owner_id=None, album_ids=None, offset=None, count=None, need_system=None,\\\\\\n need_covers=None, photo_sizes=None):\\n params = {\\n 'owner_id': owner_id,\\n 'album_ids': album_ids,\\n 'offset': offset,\\n 'count': count,\\n 'need_system': need_system,\\n 'need_covers': need_covers,\\n 'photo_sizes': photo_sizes\\n }\\n result = call('photos.getAlbums', **params)\\n return parse_response(result)\",\n \"def get_albums(entity_url: str) -> list:\\n entity_url = entity_url.rstrip(\\\"/\\\")\\n response = requests.get(entity_url)\\n soup = BeautifulSoup(response.text, \\\"html.parser\\\")\\n albums = []\\n for link in soup.find_all('a'):\\n url = link.get('href')\\n if url is not None and \\\"/album/\\\" in url:\\n if url.startswith(\\\"http\\\"):\\n albums.append(url)\\n else:\\n albums.append(f\\\"{entity_url}{url}\\\")\\n return albums\",\n \"def test_logged_in_friend_not_in_group(self):\\n\\n self.make_logged_in_friend_not_in_group()\\n\\n # test show album\\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\\n self.u2, album.display_album, ALBUM_ALLFRIENDS)\\n\\n # test photo view\\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\\n \\\"photoid\\\", \\\"show_photo\\\", ALBUM_ALLFRIENDS)\\n\\n # test individual photo view page\\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\\n self.u2, album.display_photo, ALBUM_ALLFRIENDS)\",\n \"def get_album_list():\\n\\n # TODO: Paginate this, etc\\n entities = PhotoAlbum.query().order(-PhotoAlbum.title).fetch(1000)\\n\\n return entities\",\n \"def test_aws_service_api_private_images_get(self):\\n pass\",\n \"def test_auth_required(self, api_client):\\n res = api_client.get(PHOTO_ALBUM_URL)\\n\\n assert res.status_code == status.HTTP_401_UNAUTHORIZED\",\n \"def test_album_image_user(self):\\n self.assertEqual(self.album.user, self.photo.user)\",\n \"def get_goods_photos_same_user(self):\\n photos = GoodsPhotos.objects.filter(good__user=self.user).exclude(good=self)\\n return photos\",\n \"def test_users_photos_view_set_get_no_user(self):\\n # Create user\\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\\n\\n # Simulate auth\\n token = test_helpers.get_token_for_user(user)\\n\\n # Get data from endpoint\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\\n\\n request = client.get('/api/users/{}/photos'.format(99999), format='json')\\n\\n self.assertEquals(request.status_code, 404)\",\n \"def test_get_albums_no_params(self, id_name_elms, service_config, request):\\n service_config.album_store.get_all.return_value = id_name_elms\\n params = avalon.web.request.Parameters(request)\\n\\n service = avalon.web.services.AvalonMetadataService(service_config)\\n results = service.get_albums(params)\\n\\n assert results == id_name_elms, 'Expected all albums returned'\",\n \"def test_list_auth(self):\\n self.api_client.logout()\\n resp = self.api_client.get('/api/metadata/tracks/')\\n self.assertEqual(resp.status_code, 403)\",\n \"def test_top_albums(self):\\n \\n rss = AppleRSS()\\n objs = rss.get_top_albums(limit=10)\\n \\n self.__test_artists('top_albums', objs)\",\n \"def test_get_all_interest_lists_auth(self):\\n url = reverse('xds_api:interest-lists')\\n _, token = AuthToken.objects.create(self.user_1)\\n response = self.client \\\\\\n .get(url, HTTP_AUTHORIZATION='Token {}'.format(token))\\n responseDict = json.loads(response.content)\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(responseDict[0][\\\"owner\\\"][\\\"email\\\"], self.user_1.email)\",\n \"def test_get_all_need_transform_no_albums(self):\\n self.assertEqual(Album.get_all_need_transform(self.app.curs, 1), [])\",\n \"def test_ms_album_search(helpers):\\n item_from_xml, item_from_dict = common_tests(\\n MSAlbum,\\n MS_ALBUM_SEARCH_XML,\\n MS_ALBUM_SEARCH_DICT,\\n \\\"00020064albumsearch:de unge\\\",\\n helpers,\\n )\\n getter_attributes_test(\\n \\\"artist\\\", item_from_xml, item_from_dict, MS_ALBUM_SEARCH_DICT.get(\\\"artist\\\")\\n )\\n getter_attributes_test(\\n \\\"uri\\\", item_from_xml, item_from_dict, MS_ALBUM_SEARCH_DICT[\\\"uri\\\"]\\n )\",\n \"def album_list(self):\\n\\n artist_id = self.addon_args[\\\"artist_id\\\"][0]\\n\\n xbmcplugin.setContent(self.addon_handle, \\\"albums\\\")\\n\\n for album in self.connection.walk_artist(artist_id):\\n self.add_album(album)\\n\\n xbmcplugin.addSortMethod(\\n self.addon_handle, xbmcplugin.SORT_METHOD_UNSORTED)\\n xbmcplugin.addSortMethod(\\n self.addon_handle, xbmcplugin.SORT_METHOD_ALBUM)\\n xbmcplugin.addSortMethod(\\n self.addon_handle, xbmcplugin.SORT_METHOD_ARTIST)\\n xbmcplugin.addSortMethod(\\n self.addon_handle, xbmcplugin.SORT_METHOD_VIDEO_YEAR)\\n\\n xbmcplugin.endOfDirectory(self.addon_handle)\",\n \"def search_for_album(album_name):\\n\\n print(f'Searching for album: {album_name}')\\n\\n search_result = spotifyObject.search(q=f'\\\"{album_name}\\\"', limit=20, type='album')\\n\\n items = search_result['albums']['items']\\n\\n results = []\\n\\n for item in items:\\n if len(item['artists']) > 1:\\n artists = tuple(art['name'] for art in item['artists'])\\n else:\\n artists = item['artists'][0]['name']\\n\\n results.append((artists, item['name'], item['id']))\\n\\n return results\",\n \"def GetAlbums(self, start=0, end=0, sortmethod='label', sortorder='ascending', filter='', artistid=None):\\n self.logger.debug(\\\"Loading all albums for ARTISTID \\\" + str(artistid))\\n try:\\n xbmc = Server(self.url('/jsonrpc', True))\\n sort = {'order': sortorder, 'method': sortmethod, 'ignorearticle': True}\\n properties=['artist', 'title', 'year', 'description', 'thumbnail']\\n limits = {'start': int(start), 'end': int(end)}\\n if artistid is not None:\\n filter = {'artistid': int(artistid)}\\n else:\\n filter = {'or': [\\n {'field': 'album', 'operator': 'contains', 'value': filter},\\n {'field': 'artist', 'operator': 'contains', 'value': filter}\\n ]}\\n return xbmc.AudioLibrary.GetAlbums(properties=properties, limits=limits, sort=sort, filter=filter)\\n except ValueError:\\n return\",\n \"def _get_album_or_image(json, imgur):\\n if json['is_album']:\\n return Gallery_album(json, imgur, has_fetched=False)\\n return Gallery_image(json, imgur)\",\n \"def get_albums(username):\\n cur = mysql.connection.cursor()\\n cur.execute(\\\"SELECT * FROM album WHERE username = '{0}'\\\".format(username))\\n return cur.fetchall()\",\n \"def test_getImages(self): # GIVEN the group chat has at least one image\\n testBot = bot.Bot(os.environ['bot_id'], os.environ['token'], os.environ['group_ID'])\\n imageList = testBot.run() #AND THEN post_images calls the private get_images method which returns an array\\n self.assertTrue(len(imageList) > 0) #THEN there should be at least one element in the array\",\n \"def simple_album_list():\\r\\n album_list = []\\r\\n data = dbase()\\r\\n for album in data.keys():\\r\\n album_list += [album]\\r\\n return album_list\",\n \"def get_albums(self):\\n return AlbumView.get_by_artist(self.name)\",\n \"def get_gallery(self, section='hot', sort='viral', window='day',\\n show_viral=True, limit=None):\\n url = (\\\"https://api.imgur.com/3/gallery/{}/{}/{}/{}?showViral=\\\"\\n \\\"{}\\\".format(section, sort, window, '{}', show_viral))\\n resp = self._send_request(url, limit=limit)\\n return [_get_album_or_image(thing, self) for thing in resp]\",\n \"def getAll(owner_id=None, extended=None, offset=None, count=None, photo_sizes=None,\\\\\\n no_service_albums=None, need_hidden=None, skip_hidden=None):\\n params = {\\n 'owner_id': owner_id,\\n 'extended': extended,\\n 'offset': offset,\\n 'count': count,\\n 'photo_sizes': photo_sizes,\\n 'no_service_albums': no_service_albums,\\n 'need_hidden': need_hidden,\\n 'skip_hidden': skip_hidden\\n }\\n result = call('photos.getAll', **params)\\n return parse_response(result)\",\n \"def test_get_all_need_transform_two_albums(self):\\n album = Album(artist='Artist', album='Album',\\n totaltracks=1, totalseconds=120)\\n pk = album.insert(self.app.db, self.app.curs)\\n album = Album(artist='Artist', album='Album 2',\\n totaltracks=1, totalseconds=120)\\n pk = album.insert(self.app.db, self.app.curs)\\n self.assertEqual(self.get_album_count(), 2)\\n\\n albums = Album.get_all_need_transform(self.app.curs, 1)\\n self.assertEqual(len(albums), 2)\",\n \"def get_context_data(self):\\n user = self.request.user\\n return {\\n 'photos': user.photo.all(),\\n 'albums': user.album.all(),\\n }\",\n \"def test_groups_group_users_get(self):\\n pass\",\n \"def test_groups_group_users_get(self):\\n pass\",\n \"def obj_get_list(self, request=None, **kwargs):\\n filters = {}\\n if hasattr(request, 'GET'):\\n # Grab a mutable copy.\\n filters = request.GET.copy()\\n\\n # Update with the provided kwargs.\\n filters.update(kwargs)\\n if \\\"user\\\" in filters and \\\"media\\\" in filters:\\n try:\\n image_uuid_list = []\\n wordbox_uuid_list = []\\n for item in filters['media'].split(','):\\n # use kwarg \\\"resource\\\" field to be more general rather\\n # than take the 2 element\\n try:\\n if item.split('/')[2] == 'image':\\n image_uuid_list.append(uuid_re.findall(item)[0])\\n elif item.split('/')[2] == 'wordbox':\\n wordbox_uuid_list.append(uuid_re.findall(item)[0])\\n except IndexError:\\n raise BadRequest(\\\"Invalid uuid or resource URI.\\\")\\n userprofile = UserProfile.objects.get(\\n uuid=uuid_from_uri(filters['user']))\\n im = userprofile.image_collection_set.filter(\\n is_active=True, uuid__in=image_uuid_list)\\n wb = userprofile.wordbox_collection_set.\\\\\\n filter(is_active=True, uuid__in=wordbox_uuid_list)\\n base_object_list = sorted(chain(im, wb),\\n key=attrgetter('created_time'))[::-1]\\n return self.apply_authorization_limits(request,\\n base_object_list)\\n except ValueError:\\n raise BadRequest(\\\"Invalid resource lookup data provided \\\"\\n \\\"(mismatched type).\\\")\\n elif \\\"user\\\" in filters and len(filters) == 1:\\n try:\\n userprofile = UserProfile.objects.get(\\n uuid=uuid_from_uri(filters['user']))\\n im = userprofile.image_collection_set.filter(is_active=True)\\n wb = userprofile.wordbox_collection_set.filter(is_active=True)\\n base_object_list = sorted(chain(im, wb),\\n key=attrgetter('created_time'))[::-1]\\n return self.apply_authorization_limits(request,\\n base_object_list)\\n except ValueError:\\n raise BadRequest(\\\"Invalid resource lookup data provided \\\"\\n \\\"(mismatched type).\\\")\\n else:\\n raise BadRequest(\\\"Invalid filtering parameter(s)\\\")\",\n \"def test_get_resource_group_member_list(self):\\n pass\",\n \"def get_tracks(self):\\n artist = self.get_request_arg(\\\"artist\\\")\\n album = self.get_request_arg(\\\"album\\\")\\n if not (album and artist):\\n return self.resp_from_data(\\n {\\\"message\\\": \\\"Please specify a valid artist and album\\\"}, 403)\\n else:\\n tracks = self.ctrl.library.get_tracks(artist, album)\\n return self.resp_from_data(tracks)\",\n \"def test_not_logged_in(self):\\n\\n # test show album\\n self.perm_escalate_helper(self.albumcontrol, self.showalbumrequest, self.testalbum, self.testalbum.id,\\n AnonymousUser(), album.display_album, ALBUM_PUBLIC)\\n\\n # test photo view\\n self.perm_escalate_helper_get_with_client(self.albumcontrol, self.testalbum, self.photo.id,\\n \\\"photoid\\\", \\\"show_photo\\\", ALBUM_PUBLIC)\\n\\n # test individual photo view page\\n self.perm_escalate_helper(self.albumcontrol, self.indivphotorequest, self.testalbum, self.photo.id,\\n AnonymousUser(), album.display_photo, ALBUM_PUBLIC)\",\n \"def test_groups_get(self):\\n pass\",\n \"def test_groups_get(self):\\n pass\",\n \"def load_photos(self, api):\\n self.photos = []\\n try:\\n # Update authorized ?\\n if not main.FLICKR_UPDATE:\\n raise Exception(\\\"No flickr update authorized from settings.\\\")\\n\\n photos = api.photosets_getPhotos(photoset_id=self.id, media=\\\"photos\\\")\\n xml_photos = photos.find(\\\"photoset\\\").findall(\\\"photo\\\")\\n except:\\n xml_photos = self.data[\\\"photos\\\"]\\n\\n for i, xml in enumerate(xml_photos):\\n photo_id = type(xml) == unicode and xml or xml.attrib[\\\"id\\\"]\\n try:\\n photo = FlickrPhoto(photo_id, api, self)\\n except Exception, e:\\n logger.error(\\n \\\"%d/%d Failed loading of %s : %s\\\",\\n i + 1,\\n len(xml_photos),\\n photo_id,\\n str(e),\\n )\\n continue\\n logger.debug(\\n u\\\"%d/%d %s from %s\\\"\\n % (i + 1, len(xml_photos), photo, photo.cached and \\\"cache\\\" or \\\"flickr\\\")\\n )\\n\\n # Save photo\\n self.photos.append(photo)\\n if not photo.cached:\\n photo.save()\\n\\n # Check primary\\n if self.data[\\\"primary\\\"] == photo.id:\\n self.primary = photo\\n\\n self.data[\\\"photos\\\"] = [p.id for p in self.photos]\",\n \"def get_photos(album_id):\\n opts = RUN_OPTS.opts\\n\\n payload = {'albumId': album_id}\\n try:\\n resp = requests.get(PHOTOS_URL, params=payload,\\n timeout=opts['timeout'])\\n except (requests.ConnectionError, requests.ReadTimeout):\\n print(f\\\"get for {PHOTOS_URL} errored or timed out after \\\" +\\n f\\\"{opts['timeout']} seconds\\\")\\n return None\\n\\n print_debug(f\\\"http status_code = {resp.status_code}; url = {resp.url}\\\")\\n\\n if not resp.ok:\\n print(f'url for album_id={album_id} or \\\"{resp.url}\\\" not found: ' +\\n f'status {resp.status_code}')\\n return None\\n\\n photos = resp.json()\\n if not resp.ok or len(photos) <= 0:\\n print(f'zero rows returned for album_id={album_id}')\\n return None\\n\\n return photos\",\n \"def test_activity_photos(self):\\n activity = self.client.get_activity(152668627)\\n self.assertTrue(activity.photo_count > 0)\\n photos = list(activity.photos)\\n self.assertEqual(len(photos), 1)\\n self.assertEqual(len(photos), activity.photo_count)\\n self.assertIsInstance(photos[0], model.ActivityPhoto)\",\n \"def cmd_account_albums(client, args):\\n account_albums = client.get_account_albums(args.username, args.page)\\n data = [item.__dict__ for item in account_albums]\\n generate_output({'account_albums': data}, args.output_file)\",\n \"def get_memes_gallery(self, sort='viral', window='week', limit=None):\\n url = (\\\"https://api.imgur.com/3/gallery/g/memes/{0}/{1}/{2}\\\".format(\\n sort, window, '{}'))\\n resp = self._send_request(url, limit=limit)\\n return [_get_album_or_image(thing, self) for thing in resp]\",\n \"def test_group_get_objects_all_perms(self):\\n group0 = self.test_save('TestGroup0', user0)\\n group1 = self.test_save('TestGroup1', user1)\\n \\n object2 = TestModel.objects.create(name='test2')\\n object2.save()\\n object3 = TestModel.objects.create(name='test3')\\n object3.save()\\n object4 = TestModel.objects.create(name='test4')\\n object4.save()\\n \\n group0.grant('Perm1', object0)\\n group0.grant('Perm2', object0)\\n group0.grant('Perm4', object1)\\n group1.grant('Perm3', object2)\\n group1.grant('Perm4', object2)\\n \\n # retrieve single perm\\n self.assert_(object0 in group0.get_objects_all_perms(TestModel, ['Perm1']))\\n self.assert_(object1 in group0.get_objects_all_perms(TestModel, ['Perm4']))\\n self.assert_(object2 in group1.get_objects_all_perms(TestModel, ['Perm3']))\\n self.assert_(object2 in group1.get_objects_all_perms(TestModel, ['Perm4']))\\n \\n # retrieve multiple perms\\n query = group0.get_objects_all_perms(TestModel, ['Perm1', 'Perm2'])\\n self.assert_(object0 in query)\\n self.assertFalse(object1 in query)\\n self.assertEqual(1, query.count())\\n query = group1.get_objects_all_perms(TestModel, ['Perm3', 'Perm4'])\\n self.assert_(object2 in query)\\n self.assertFalse(object3 in query)\\n self.assertEqual(1, query.count())\\n \\n # retrieve no results\\n self.assertFalse(group0.get_objects_all_perms(TestModel, ['Perm3']).exists())\\n self.assertFalse(group0.get_objects_all_perms(TestModel, ['Perm1','Perm4']).exists())\\n self.assertFalse(group1.get_objects_all_perms(TestModel, ['Perm1']).exists())\\n \\n # extra kwargs\\n query = group0.get_objects_all_perms(TestModel, ['Perm1', 'Perm2']).filter( name='test0')\\n self.assert_(object0 in query)\\n self.assertEqual(1, query.count())\",\n \"def index(request):\\n\\n #Collect all photos owned by the user and not associated with albums for display\\n photos = Photo.objects.filter(owner = request.user, album_id=None)\\n\\n #Collect all albums owned by the user for display\\n albums = Album.objects.filter(owner = request.user)\\n\\n #Form to upload multiple images extends Djangos form.ImageField()\\n #Fields taken 'file' (image)\\n form = UploadFileForm()\\n\\n #Form to upload album\\n #Fields taken are 'title'(charfield)\\n formAlbum = AlbumForm()\\n return render_to_response('photos/index.html',\\n {\\n 'form': form,\\n 'formAlbum': formAlbum,\\n 'photos': photos,\\n 'albums':albums,\\n },\\n context_instance=RequestContext(request))\",\n \"def test_users_groups_get(self):\\n pass\",\n \"def test_filter_only_with_photo(self):\\n request = self.factory.get('/api/v1/cars', {'only_with_photo': True,\\n 'distance': 1000})\\n response = CarAdViewSet.as_view({'get': 'list'})(request)\\n car_without_photo = None\\n for car in response.data['results']:\\n if not car['photos']:\\n car_without_photo = car\\n break\\n self.assertEqual(response.status_code, HTTPStatus.OK._value_)\\n self.assertIs(car_without_photo, None)\",\n \"def photos(self):\\n return self._photos\",\n \"def get_top_albums(\\n self, period: Period, limit: int = 50, page: int = 1\\n ) -> ListModel[Album]:\\n assert isinstance(period, Period)\\n\\n return self.retrieve(\\n bind=Album,\\n flatten=\\\"album\\\",\\n params=dict(\\n method=\\\"user.getTopAlbums\\\",\\n user=self.name,\\n limit=limit,\\n page=page,\\n period=period.value,\\n ),\\n )\",\n \"def album_assignment(self):\\n log.debug(\\\"Called album_assignment for %s.\\\" % self.name)\\n self.success = False\\n for splitter in splitters:\\n if splitter in self.name:\\n self.artist, self.album = self.name.split(splitter, 1) # May need to look at this again, can be more than 1!\\n self.success = True\\n break\\n if self.success:\\n results = self.sp.search(q='artist: ' + self.artist + 'album: ' + self.album, type='album', limit=1)\\n if results['albums']['total'] >= 1:\\n for items in results['albums']['items']:\\n self.album = items['name']\\n self.album_uri = items['uri']\\n for artist in items['artists'][0]:\\n self.artist = artist['name']\\n self.artist_uri = artist['uri']\\n else:\\n self.success = False\",\n \"def list(self, request, *args, **kwargs):\\n if not request.user.is_superuser:\\n self.queryset = Group.objects.filter(owner__pk=request.user.id)\\n\\n return super().list(request, args, kwargs)\",\n \"def test_get_groups(self):\\n pass\",\n \"def test_get_groups(self):\\n pass\",\n \"def every_existing_owner_should_have_valid_profile_image_link(context):\\n items = context.response.json()['items']\\n for item in items:\\n owner = item['owner']\\n if owner['user_type'] == 'does_not_exist':\\n continue\\n link = owner['profile_image']\\n assert validators.url(link), (\\n 'Owner %s (%d) in item %d has an invalid profile image link: %s'\\n .format(owner['display_name'], owner['user_id'], link))\\n logging.debug(\\n 'Owner %s (%d) has a valid profile image link: %s',\\n owner['display_name'], owner['user_id'], link)\",\n \"def test_list_image_stream_for_all_namespaces(self):\\n pass\",\n \"def test_filesystem_can_list_contents_of_root_directory(self):\\n self.index.photos_unique_domains = MagicMock(return_value=[\\n 'example.com',\\n 'example.net'\\n ])\\n\\n files = self.filesystem._list('/')\\n\\n self.assertListOfFilesEqual(\\n [\\n Directory('.'),\\n Directory('..'),\\n Directory('example.com'),\\n Directory('example.net'),\\n ],\\n files\\n )\\n self.index.photos_unique_domains.assert_called_with(self.refresh_rate)\",\n \"def test_photo_classification_view_set_get_filtered_does_not_exist(self):\\n # Test data\\n user = account_models.User.objects.get(email='mrtest@mypapaya.io')\\n\\n # Simulate auth\\n token = test_helpers.get_token_for_user(user)\\n\\n # Get data from endpoint\\n client = APIClient()\\n client.credentials(HTTP_AUTHORIZATION='Token ' + token)\\n\\n request = client.get('/api/photo_classifications?classification=group')\\n\\n self.assertEquals(request.status_code, 400)\",\n \"def test_list_members_with_owner_rights(self):\\n url = '/api/v1/communities/4/retrieve_members/'\\n\\n response = self.client.get(url, HTTP_AUTHORIZATION=self.auth('user1'))\\n self.assertEqual(status.HTTP_200_OK, response.status_code)\\n\\n data = response.data\\n self.assertEqual(3, data['count'])\",\n \"def test_list_media_collection(self):\\n self.login_editor()\\n\\n # Create a media collection object and test that is present on list\\n MediaCollection.objects.create(name='Coleção 1',\\n description='Coleção de teste 1',\\n created_by_id=1, cooperative_center_code='BR1.1')\\n\\n MediaCollection.objects.create(name='Coleção 2',\\n description='Coleção de teste 2',\\n created_by_id=2, cooperative_center_code='BR1.1')\\n\\n MediaCollection.objects.create(name='Coleção 3',\\n description='Coleção de teste 3',\\n created_by_id=3, cooperative_center_code='PY3.8')\\n\\n\\n response = self.client.get('/multimedia/collections')\\n # check if only one collection is returned (restrict by user)\\n self.assertContains(response, \\\"Coleção 1\\\")\\n self.assertEquals(response.context['object_list'].count(), 3)\\n\\n # check if return only colections from cooperative center BR1.1\\n response = self.client.get('/multimedia/collections/?filter_created_by_cc=BR1.1')\\n self.assertEquals(response.context['object_list'].count(), 2)\",\n \"def get(owner_id=None, album_id=None, photo_ids=None, rev=None, extended=None,\\\\\\n feed_type=None, feed=None, photo_sizes=None, offset=None, count=None):\\n params = {\\n 'owner_id': owner_id,\\n 'album_id': album_id,\\n 'photo_ids': photo_ids,\\n 'rev': rev,\\n 'extended': extended,\\n 'feed_type': feed_type,\\n 'feed': feed,\\n 'photo_sizes': photo_sizes,\\n 'offset': offset,\\n 'count': count\\n }\\n result = call('photos.get', **params)\\n return parse_response(result)\",\n \"def cmd_account_album_ids(client, args):\\n account_album_ids = client.get_account_album_ids(args.username, args.page)\\n generate_output({'account_album_ids': account_album_ids})\",\n \"def album_detection(user):\\n seen_tracks = user.seen_tracks\\n\\n list_of_albums = {}\\n album_number_of_tracks = {}\\n for track in seen_tracks:\\n if \\\"album\\\" not in track:\\n continue\\n\\n if track[\\\"name\\\"] == \\\"sanjake\\\":\\n continue\\n\\n album_name = track[\\\"album\\\"][\\\"name\\\"]\\n if album_name not in list_of_albums:\\n list_of_albums[album_name] = 0\\n album_number_of_tracks[album_name] = track[\\\"album\\\"][\\\"total_tracks\\\"]\\n list_of_albums[album_name] += 1\\n\\n if list_of_albums[album_name] > 1 and list_of_albums[album_name] == album_number_of_tracks[album_name]:\\n print(f\\\"Album search detected: {album_name}, number of tracks: {album_number_of_tracks[album_name]}\\\")\\n print(f\\\"User: {user.email_address}\\\")\",\n \"def test_api_v1_groups_get(self):\\n pass\",\n \"def test_group_get_objects_any_perms(self):\\n group0 = self.test_save('TestGroup0', user0)\\n group1 = self.test_save('TestGroup1', user1)\\n \\n object2 = TestModel.objects.create(name='test2')\\n object2.save()\\n object3 = TestModel.objects.create(name='test3')\\n object3.save()\\n object4 = TestModel.objects.create(name='test4')\\n object4.save()\\n \\n group0.grant('Perm1', object0)\\n group0.grant('Perm2', object1)\\n group1.grant('Perm3', object2)\\n group1.grant('Perm4', object3)\\n \\n # implicit any\\n self.assert_(object0 in group0.get_objects_any_perms(TestModel, ['Perm1']))\\n self.assert_(object1 in group0.get_objects_any_perms(TestModel, ['Perm2']))\\n self.assertFalse(object2 in group0.get_objects_any_perms(TestModel, ['Perm2']))\\n self.assert_(object2 in group1.get_objects_any_perms(TestModel, ['Perm3']))\\n self.assert_(object3 in group1.get_objects_any_perms(TestModel, ['Perm4']))\\n \\n # retrieve single perm\\n self.assert_(object0 in group0.get_objects_any_perms(TestModel, ['Perm1']))\\n self.assert_(object1 in group0.get_objects_any_perms(TestModel, ['Perm2']))\\n self.assert_(object2 in group1.get_objects_any_perms(TestModel, ['Perm3']))\\n self.assert_(object3 in group1.get_objects_any_perms(TestModel, ['Perm4']))\\n \\n # retrieve multiple perms\\n query = group0.get_objects_any_perms(TestModel, ['Perm1', 'Perm2', 'Perm3'])\\n self.assert_(object0 in query)\\n self.assert_(object1 in query)\\n self.assertEqual(2, query.count())\\n query = group1.get_objects_any_perms(TestModel, ['Perm1', 'Perm3', 'Perm4'])\\n self.assert_(object2 in query)\\n self.assert_(object3 in query)\\n self.assertEqual(2, query.count())\\n \\n # retrieve no results\\n query = group0.get_objects_any_perms(TestModel, ['Perm3'])\\n self.assertEqual(0, query.count())\\n query = group1.get_objects_any_perms(TestModel, ['Perm1'])\\n self.assertEqual(0, query.count())\\n \\n # extra kwargs\\n query = group0.get_objects_any_perms(TestModel, ['Perm1', 'Perm2', 'Perm3']).filter( name='test0')\\n self.assert_(object0 in query)\\n self.assertEqual(1, query.count())\",\n \"def get_album_cover(self):\\n artist = self.get_request_arg(\\\"artist\\\")\\n album = self.get_request_arg(\\\"album\\\")\\n if not (album and artist):\\n return self.resp_from_data(\\n {\\\"message\\\": \\\"Please specify a valid artist and album\\\"}, 403)\\n else:\\n cover = self.ctrl.library.get_cover_path(artist, album)\\n return self.resp_from_image(cover)\",\n \"def get(self, request, *args, **kwargs):\\n\\n liked_photos = None\\n l_squarefollowings_count = None\\n l_best_media = None\\n\\n # Common for all members views ===================================================\\n l_categories = Category.objects.all()\\n l_attributes = Attribute.objects.all()\\n try:\\n logged_member = Member.objects.get(django_user__username=request.user)\\n show_describe_button = logged_member.is_editor(request)\\n is_monthly_member = logged_member.is_monthly_member()\\n is_yearly_member = logged_member.is_yearly_member()\\n except ObjectDoesNotExist:\\n logged_member = None\\n except:\\n raise HttpResponseNotFound\\n\\n l_squarefollowings_count = SquareFollowing.objects.filter(member_id2=logged_member).count()\\n if l_squarefollowings_count >= MIN_SQUAREFOLLOWINGS:\\n\\n # END Common for all members views ===============================================\\n l_squarefollowing_queryset = SquareFollowing.objects.all()\\n\\n l_token = logged_member.get_member_token(request)\\n instagram_session = InstagramSession(p_is_admin=False, p_token=l_token['access_token'])\\n instagram_session.init_instagram_API()\\n\\n l_smart_feed_helper = SmartFeedHelper(\\n p_feed_owner_instagram_id=logged_member.instagram_user_id,\\n p_instagram_session=instagram_session,\\n p_batch_size=SMART_FEED_BATCH_SIZE,\\n p_min_id=logged_member.smartfeed_last_seen_instagram_photo_id\\n )\\n l_best_media = l_smart_feed_helper.find_best_media(\\n p_media_to_return=SMART_FEED_BATCH_SIZE,\\n p_starting_media_id=None,\\n p_logged_member=logged_member,\\n p_max_days=30\\n )\\n\\n liked_photos = []\\n for x_media in l_best_media:\\n my_likes = MyLikes(request.user.username, x_media.id, instagram_session )\\n has_user_liked_media, no_of_likes = my_likes.has_user_liked_media()\\n if has_user_liked_media:\\n liked_photos.extend([x_media.id])\\n\\n\\n # Limit calculation --------------------------------------------------------------\\n logged_member.refresh_api_limits(request)\\n x_ratelimit_remaining, x_ratelimit = logged_member.get_api_limits()\\n\\n x_ratelimit_used = x_ratelimit - x_ratelimit_remaining\\n if x_ratelimit != 0:\\n x_limit_pct = (x_ratelimit_used / x_ratelimit) * 100\\n else:\\n x_limit_pct = 100\\n # END Limit calculation ----------------------------------------------------------\\n\\n return render(request,\\n self.template_name,\\n dict(\\n best_media=l_best_media,\\n liked_photos=liked_photos,\\n squarefollowings_count=l_squarefollowings_count,\\n new_friends_interaction=0,\\n\\n is_monthly_member=is_monthly_member,\\n is_yearly_member=is_yearly_member,\\n logged_member=logged_member,\\n x_ratelimit_remaining=x_ratelimit_remaining,\\n x_ratelimit=x_ratelimit,\\n x_limit_pct=x_limit_pct,\\n categories=l_categories,\\n attributes=l_attributes,\\n )\\n )\",\n \"def test_get_groups(self):\\n group0 = self.test_save('TestGroup0')\\n group1 = self.test_save('TestGroup1')\\n \\n group0.grant('Perm1', object0)\\n group0.grant('Perm3', object1)\\n group1.grant('Perm2', object1)\\n \\n self.assert_(group0 in get_groups(object0))\\n self.assertFalse(group1 in get_groups(object0))\\n self.assert_(group0 in get_groups(object1))\\n self.assert_(group1 in get_groups(object1))\\n self.assert_(len(get_groups(object1))==2)\",\n \"def pic (self, list) : \\n result = []\\n for pmod in list :\\n result.append (pmod.photo_uri)\\n return result\",\n \"def get_queryset(self):\\n return Photo.objects.filter(user=self.request.user)\",\n \"def test_get_resource_membership_holder_list(self):\\n pass\",\n \"def test_list_image_metadata(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6538849","0.63964623","0.6376904","0.6322045","0.6120553","0.60942847","0.60395104","0.5947685","0.594612","0.5942414","0.59387887","0.5931279","0.59208906","0.59201974","0.58497167","0.5842505","0.5822845","0.578619","0.57696813","0.5761645","0.5749474","0.5735181","0.5681504","0.56800216","0.5658629","0.56493336","0.5611164","0.55992365","0.55743533","0.5563592","0.55553734","0.5553067","0.55497676","0.5546815","0.5536884","0.5535433","0.5531988","0.5525942","0.55013406","0.5500275","0.54890853","0.54844475","0.54804194","0.54668635","0.54571855","0.5456601","0.54360455","0.541732","0.5407631","0.54063714","0.53921","0.5386654","0.53804606","0.5377549","0.53704864","0.5356646","0.53463113","0.5342921","0.534184","0.5331058","0.5331058","0.5327507","0.53189033","0.53146845","0.53099924","0.53048104","0.53048104","0.5299745","0.5292049","0.52765495","0.5265378","0.5242898","0.5238538","0.5238327","0.52321386","0.52305394","0.5221219","0.52186453","0.5218289","0.5217744","0.5211181","0.5211181","0.52094966","0.52076775","0.5204791","0.5200895","0.51980567","0.51923424","0.51833","0.5178261","0.51771075","0.5172984","0.5172904","0.5168655","0.5141417","0.5140503","0.513696","0.51351756","0.512936","0.5125385"],"string":"[\n \"0.6538849\",\n \"0.63964623\",\n \"0.6376904\",\n \"0.6322045\",\n \"0.6120553\",\n \"0.60942847\",\n \"0.60395104\",\n \"0.5947685\",\n \"0.594612\",\n \"0.5942414\",\n \"0.59387887\",\n \"0.5931279\",\n \"0.59208906\",\n \"0.59201974\",\n \"0.58497167\",\n \"0.5842505\",\n \"0.5822845\",\n \"0.578619\",\n \"0.57696813\",\n \"0.5761645\",\n \"0.5749474\",\n \"0.5735181\",\n \"0.5681504\",\n \"0.56800216\",\n \"0.5658629\",\n \"0.56493336\",\n \"0.5611164\",\n \"0.55992365\",\n \"0.55743533\",\n \"0.5563592\",\n \"0.55553734\",\n \"0.5553067\",\n \"0.55497676\",\n \"0.5546815\",\n \"0.5536884\",\n \"0.5535433\",\n \"0.5531988\",\n \"0.5525942\",\n \"0.55013406\",\n \"0.5500275\",\n \"0.54890853\",\n \"0.54844475\",\n \"0.54804194\",\n \"0.54668635\",\n \"0.54571855\",\n \"0.5456601\",\n \"0.54360455\",\n \"0.541732\",\n \"0.5407631\",\n \"0.54063714\",\n \"0.53921\",\n \"0.5386654\",\n \"0.53804606\",\n \"0.5377549\",\n \"0.53704864\",\n \"0.5356646\",\n \"0.53463113\",\n \"0.5342921\",\n \"0.534184\",\n \"0.5331058\",\n \"0.5331058\",\n \"0.5327507\",\n \"0.53189033\",\n \"0.53146845\",\n \"0.53099924\",\n \"0.53048104\",\n \"0.53048104\",\n \"0.5299745\",\n \"0.5292049\",\n \"0.52765495\",\n \"0.5265378\",\n \"0.5242898\",\n \"0.5238538\",\n \"0.5238327\",\n \"0.52321386\",\n \"0.52305394\",\n \"0.5221219\",\n \"0.52186453\",\n \"0.5218289\",\n \"0.5217744\",\n \"0.5211181\",\n \"0.5211181\",\n \"0.52094966\",\n \"0.52076775\",\n \"0.5204791\",\n \"0.5200895\",\n \"0.51980567\",\n \"0.51923424\",\n \"0.51833\",\n \"0.5178261\",\n \"0.51771075\",\n \"0.5172984\",\n \"0.5172904\",\n \"0.5168655\",\n \"0.5141417\",\n \"0.5140503\",\n \"0.513696\",\n \"0.51351756\",\n \"0.512936\",\n \"0.5125385\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.58845454"},"document_rank":{"kind":"string","value":"14"}}},{"rowIdx":85156,"cells":{"query":{"kind":"string","value":"This callback is called on every http request to the server"},"document":{"kind":"string","value":"def callback_uri(flow):\n\n print(\"\\033[93m\" + \"WARNING: Potential possible Attack detected on %s\" % str(flow) + \"\\033[0m\")\n\n uri = flow.http_info.uri\n if ((uri)and(len(uri) > 500)):\n \"\"\" A URI bigger than 500 bytes could be suspicious \"\"\"\n items = uri.split(\"?\")\n args = items[1].split(\"&\")\n for arg in args:\n \"\"\" Iterate through the arguments \"\"\"\n idx = arg.find(\"=\")\n if (idx > -1):\n value = arg[idx + 1:]\n if (len(value) > 64):\n \"\"\" Ummmm a value of an argument bigger than 64 \"\"\" \n decode = value.replace(\"%\", \"\").decode(\"hex\")\n if (decode.find(\"Runtime.getRuntime().exec\") > -1):\n \"\"\" Somebody is executing remote commands \"\"\"\n print(\"\\033[31m\" + \"ALERT: Jboss exploit detected %s\" % str(flow) + \"\\033[0m\")\n # print(\"[WARNING]: argument value:%s\" % decode)"},"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 onConnect(self, request_or_response):","def _process_request(self, request, response):\n ...","def event_handler(self, response):\n pass","async def _response_handler(self):","def connectionMade(self):","def on_response(self, response):\n pass","def run(self):\n self.initialize()\n\n # run the start callback\n tools.run_callback(\"start\", {'request': self._request})\n\n data = self._request.getData()\n pyhttp = self._request.getHttp()\n config = self._request.getConfiguration()\n\n # allow anyone else to handle the request at this point\n handled = tools.run_callback(\"handle\", \n {'request': self._request},\n mappingfunc=lambda x,y:x,\n donefunc=lambda x:x)\n\n if not handled == 1:\n blosxom_handler(self._request)\n\n # do end callback\n tools.run_callback(\"end\", {'request': self._request})","def _handle_first_request(self):\n pass","def request_callback(request):\n headers = {'content-type': 'text/html',\n 'cache-control': \"no-cache\"}\n return (200, headers, graph_data)","async def handle_request(self, request: aioweb.request.Request):","def handler(self):\n msg = self.create_http_request()\n self.send(msg)\n\n if self.file_name == \"/\":\n self.file_name = \"/index.html\"\n else:\n self.file_name = HttpClient.create_file_location(self.file_name)\n\n if self.http_command == \"HEAD\":\n recv_raw, _ = self.recv_header()\n recv = recv_raw.decode(self.format_body)\n recv_with_updated_imgs = self.update_images(recv)\n self.write_to_html_file(recv_with_updated_imgs)\n elif self.http_command == \"PUT\":\n recv_raw = self.recv_all_data()\n if recv_raw != b'':\n recv = recv_raw.decode(self.format_body)\n recv_with_updated_imgs = self.update_images(recv)\n self.write_to_html_file(recv_with_updated_imgs)\n elif self.http_command == \"POST\":\n recv_raw = self.recv_all_data()\n if recv_raw != b'':\n recv = recv_raw.decode(self.format_body)\n recv_with_updated_imgs = self.update_images(recv)\n self.write_to_html_file(recv_with_updated_imgs)\n else: # http_command == \"GET\" or it is a bad request\n recv_raw = self.recv_all_data()\n recv = recv_raw.decode(self.format_body)\n recv_with_updated_imgs = self.update_images(recv)\n self.write_to_html_file(recv_with_updated_imgs)\n\n self.disconnect()\n print(\"[CONNECTION] Client terminated\")","def renderHTTP(req):","def process_server_response(self, server_response):","def server():","def server():","def main_response(self, data):","def main_response(self, data):","def renderHTTP(ctx):","def onfinish( request ):","def onfinish( request ):","def request_callback(request):\n headers = {'content-type': \"application/json\",\n 'cache-control': \"no-cache\"}\n return (200, headers, json.dumps(response_data))","def serve(self,cb):\n self.cb = cb\n self.run()","def handle(self):\n data = self.request.recv(1024)\n self.request.send(data)","def _handle_connection(self, conn):\n conn.serve_all()","def process(self, request):\n pass","def do_GET(self):\n # nothing more to do before handle_data()\n self.body = {}\n self.handle_data()","def handle_request(self, request: HttpParser) -> None:\n raise NotImplementedError() # pragma: no cover","def handle_request(self,host,path,data=b''):\n\t\tself.response_code(5,\"Request handler not implemented\")","def connectionMade(self):\n print \"new connection made to\", host, \"port\", port\n self.transport.write(\"GET /movies/32 HTTP/1.0\\r\\n\\r\\n\") # some get request\n self.transport.loseConnection()","def _process_request(self):\n if not self._requests:\n if self._stream:\n self._stream.close()\n self._stream = None\n if self._processing:\n self._processing = False\n Engine.instance().stop()\n return\n\n request = self._requests[0]\n\n request.append(\n Engine.instance().defer(request[5], self._request_timeout, request))\n\n port = request[2].port\n if not port:\n if request[2].scheme.lower() == 'https':\n port = 443\n else:\n port = 80\n\n host = \"%s:%d\" % (request[2].hostname, port)\n\n if self._stream:\n if not self._server == host.lower() or not \\\n self._is_secure == (request[2].scheme.lower() == 'https'):\n self._stream.end()\n return\n\n if not self._stream:\n # Store the current server.\n self._server = host.lower()\n\n # Create a Stream, hook into it, and connect.\n self._stream = Stream()\n\n self._stream.on_close = self._on_close\n self._stream.on_connect = self._on_connect\n\n self._is_secure = request[2].scheme.lower() == 'https'\n if self._is_secure:\n raise Exception(\"SSL has not yet been implemented in this version of Pants.\")\n self._stream.startTLS()\n\n self._stream.connect((request[2].hostname, port))\n return\n\n # If we got here, we're connected, and to the right server. Do stuff.\n self._stream.write('%s %s HTTP/1.1%s' % (request[0], request[8], CRLF))\n for k, v in request[3].iteritems():\n self._stream.write('%s: %s%s' % (k, v, CRLF))\n\n if request[4]:\n self._stream.write('%s%s' % (CRLF, request[4]))\n else:\n self._stream.write(CRLF)\n\n # Now, wait for a response.\n self._stream.on_read = self._read_headers\n self._stream.read_delimiter = DOUBLE_CRLF","def handle(self):\n self.request.recv(1024)\n self.request.sendall(pickle.dumps(self.server.lymphocytes_getter()))","async def _handle_request(self, request: web.Request) -> web.Response:\n event = await request.json()\n # This handler will be called on the server thread. Call the external\n # handler on the app thread.\n self._main_loop.call_soon_threadsafe(self.handle_event, event)\n return web.Response(text=\"OK\")","def on_success(self) -> None:","def process_request(self, req, resp, resource, params):","def handle_request(self):\n\t\ttry:\n\t\t\trequest, client_address = self.get_request()\n\t\texcept socket.error:\n\t\t\treturn\n\t\tif self.verify_request(request, client_address):\n\t\t\ttry:\n\t\t\t\tself.process_request(request, client_address)\n\t\t\texcept:\n\t\t\t\tself.handle_error(request, client_address)\n\t\t\t\tself.close_request(request)","def request_handler(self):\n\n size = 1024\n while True:\n # accept message from client\n clientSock, addr = self.socket.accept()\n self.printLine()\n print('connect to {}'.format(addr))\n\n # print client message content\n msg = clientSock.recv(size).decode('utf-8')\n self.printLine()\n print(\"sent message :\")\n print(msg)\n\n self.printLine()\n self._set_fileName(msg)\n\n # check for existance of file in the server (with name of file.txt)\n data, isFileExist = self._send_file_handler()\n\n self.printLine()\n print('data of file :')\n print(data)\n\n # create header for response message\n if isFileExist:\n header = self._generate_headers(200)\n else:\n header = self._generate_headers(404)\n\n response = header.encode() + data.encode()\n\n # send response in http protocol\n clientSock.send(response)\n\n # close the signal\n clientSock.close()","def __call__(self, request):","def serve(self, rq):\n # Call callback by key directly from socket\n request = rq['request']\n\n if request in self.callbacks :\n self.callbacks[request](rq)\n else :\n print \"unrecognised request\"","def serve(self, rq):\n # Call callback by key directly from socket\n request = rq['request']\n\n if request in self.callbacks :\n self.callbacks[request](rq)\n else :\n print \"unrecognised request\"","def handler(self):\n\t\treturn self.handle_request","def handle_request( method, uri, version, headers, body=None, chunk=None,\n trailers=None ):","def do_GET(self):\n self.log.debug('do_GET called')\n self.HeadGet('GET')","def _handle_head_request(self):\n self._header_only = True\n self._handle_get_request()","def request_handler(self, client_connection):\n request = client_connection.recv(1024)\n\n #Make sure we recieved some data before proceeding\n if not request:\n response = 'Empty request'\n http_code = 400\n else:\n response, http_code = self.parse_request(request)\n\n #print response\n self.send_response(client_connection, response, http_code)","def do_GET(self):\r\n self.logger.debug(\"SseHTTPRequestHandler(Thread-%s): do_GET, path=%s\",\r\n threading.current_thread().ident, self.path)\r\n threading.current_thread().name = (self.path + \"_thread_\" +\r\n str(threading.current_thread().ident))\r\n if self.path == SseHTTPRequestHandler.eventsource_path:\r\n self._start_event_stream()\r\n else:\r\n http.server.SimpleHTTPRequestHandler.do_GET(self)","def on_connection_closed(self):","def on_get(self, req, resp):\n try:\n n_reqs = int(req.params.get('n', self.default_reqs))\n except ValueError:\n error_response(resp, 'ERROR: Incorrect number of requests')\n return\n\n urls = self.scheduler.requests(n_reqs)\n resp.data = json.dumps(urls, ensure_ascii=True)\n resp.content_type = \"application/json\"\n resp.status = falcon.HTTP_200","def serve(host, port, callback=None):\n\n class ViewVC_Handler(BaseHTTPServer.BaseHTTPRequestHandler):\n \n def do_GET(self):\n \"\"\"Serve a GET request.\"\"\"\n if not self.path or self.path == \"/\":\n self.redirect()\n elif self.is_viewvc():\n try:\n self.run_viewvc()\n except IOError:\n # ignore IOError: [Errno 32] Broken pipe\n pass\n else:\n self.send_error(404)\n\n def do_POST(self):\n \"\"\"Serve a POST request.\"\"\"\n if self.is_viewvc():\n self.run_viewvc()\n else:\n self.send_error(501, \"Can only POST to %s\"\n % (options.script_alias))\n\n def is_viewvc(self):\n \"\"\"Check whether self.path is, or is a child of, the ScriptAlias\"\"\"\n if self.path == '/' + options.script_alias:\n return 1\n if self.path[:len(options.script_alias)+2] == \\\n '/' + options.script_alias + '/':\n return 1\n if self.path[:len(options.script_alias)+2] == \\\n '/' + options.script_alias + '?':\n return 1\n return 0\n\n def redirect(self):\n \"\"\"redirect the browser to the viewvc URL\"\"\"\n new_url = self.server.url + options.script_alias + '/'\n self.send_response(301, \"Moved (redirection follows)\")\n self.send_header(\"Content-type\", \"text/html\")\n self.send_header(\"Location\", new_url)\n self.end_headers()\n self.wfile.write(\"\"\"<html>\n<head>\n<meta http-equiv=\"refresh\" content=\"1; URL=%s\">\n</head>\n<body>\n<h1>Redirection to <a href=\"%s\">ViewVC</a></h1>\nWait a second. You will be automatically redirected to <b>ViewVC</b>.\nIf this doesn't work, please click on the link above.\n</body>\n</html>\n\"\"\" % tuple([new_url]*2))\n\n def run_viewvc(self):\n \"\"\"This is a quick and dirty cut'n'rape from Python's \n standard library module CGIHTTPServer.\"\"\"\n scriptname = '/' + options.script_alias\n assert string.find(self.path, scriptname) == 0\n viewvc_url = self.server.url[:-1] + scriptname\n rest = self.path[len(scriptname):]\n i = string.rfind(rest, '?')\n if i >= 0:\n rest, query = rest[:i], rest[i+1:]\n else:\n query = ''\n # sys.stderr.write(\"Debug: '\"+scriptname+\"' '\"+rest+\"' '\"+query+\"'\\n\")\n env = os.environ\n # Since we're going to modify the env in the parent, provide empty\n # values to override previously set values\n for k in env.keys():\n if k[:5] == 'HTTP_':\n del env[k]\n for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',\n 'HTTP_USER_AGENT', 'HTTP_COOKIE'):\n if env.has_key(k): \n env[k] = \"\"\n # XXX Much of the following could be prepared ahead of time!\n env['SERVER_SOFTWARE'] = self.version_string()\n env['SERVER_NAME'] = self.server.server_name\n env['GATEWAY_INTERFACE'] = 'CGI/1.1'\n env['SERVER_PROTOCOL'] = self.protocol_version\n env['SERVER_PORT'] = str(self.server.server_port)\n env['REQUEST_METHOD'] = self.command\n uqrest = urllib.unquote(rest)\n env['PATH_INFO'] = uqrest\n env['SCRIPT_NAME'] = scriptname\n if query:\n env['QUERY_STRING'] = query\n env['HTTP_HOST'] = self.server.address[0]\n host = self.address_string()\n if host != self.client_address[0]:\n env['REMOTE_HOST'] = host\n env['REMOTE_ADDR'] = self.client_address[0]\n # AUTH_TYPE\n # REMOTE_USER\n # REMOTE_IDENT\n if self.headers.typeheader is None:\n env['CONTENT_TYPE'] = self.headers.type\n else:\n env['CONTENT_TYPE'] = self.headers.typeheader\n length = self.headers.getheader('content-length')\n if length:\n env['CONTENT_LENGTH'] = length\n accept = []\n for line in self.headers.getallmatchingheaders('accept'):\n if line[:1] in string.whitespace:\n accept.append(string.strip(line))\n else:\n accept = accept + string.split(line[7:], ',')\n env['HTTP_ACCEPT'] = string.joinfields(accept, ',')\n ua = self.headers.getheader('user-agent')\n if ua:\n env['HTTP_USER_AGENT'] = ua\n modified = self.headers.getheader('if-modified-since')\n if modified:\n env['HTTP_IF_MODIFIED_SINCE'] = modified\n etag = self.headers.getheader('if-none-match')\n if etag:\n env['HTTP_IF_NONE_MATCH'] = etag\n # XXX Other HTTP_* headers\n decoded_query = string.replace(query, '+', ' ')\n\n # Preserve state, because we execute script in current process:\n save_argv = sys.argv\n save_stdin = sys.stdin\n save_stdout = sys.stdout\n save_stderr = sys.stderr\n # For external tools like enscript we also need to redirect\n # the real stdout file descriptor. (On windows, reassigning the\n # sys.stdout variable is sufficient because pipe_cmds makes it\n # the standard output for child processes.)\n if sys.platform != \"win32\": save_realstdout = os.dup(1) \n try:\n try:\n sys.stdout = self.wfile\n if sys.platform != \"win32\":\n os.dup2(self.wfile.fileno(), 1)\n sys.stdin = self.rfile\n viewvc.main(StandaloneServer(self), cfg)\n finally:\n sys.argv = save_argv\n sys.stdin = save_stdin\n sys.stdout.flush()\n if sys.platform != \"win32\":\n os.dup2(save_realstdout, 1)\n os.close(save_realstdout)\n sys.stdout = save_stdout\n sys.stderr = save_stderr\n except SystemExit, status:\n self.log_error(\"ViewVC exit status %s\", str(status))\n else:\n self.log_error(\"ViewVC exited ok\")\n\n class ViewVC_Server(BaseHTTPServer.HTTPServer):\n def __init__(self, host, port, callback):\n self.address = (host, port)\n self.url = 'http://%s:%d/' % (host, port)\n self.callback = callback\n BaseHTTPServer.HTTPServer.__init__(self, self.address,\n self.handler)\n\n def serve_until_quit(self):\n self.quit = 0\n while not self.quit:\n rd, wr, ex = select.select([self.socket.fileno()], [], [], 1)\n if rd:\n self.handle_request()\n\n def server_activate(self):\n BaseHTTPServer.HTTPServer.server_activate(self)\n if self.callback:\n self.callback(self)\n\n def server_bind(self):\n # set SO_REUSEADDR (if available on this platform)\n if hasattr(socket, 'SOL_SOCKET') \\\n and hasattr(socket, 'SO_REUSEADDR'):\n self.socket.setsockopt(socket.SOL_SOCKET,\n socket.SO_REUSEADDR, 1)\n BaseHTTPServer.HTTPServer.server_bind(self)\n\n ViewVC_Server.handler = ViewVC_Handler\n\n try:\n # XXX Move this code out of this function.\n # Early loading of configuration here. Used to\n # allow tinkering with some configuration settings:\n handle_config()\n if options.repositories:\n cfg.general.default_root = \"Development\"\n cfg.general.cvs_roots.update(options.repositories)\n elif cfg.general.cvs_roots.has_key(\"Development\") and \\\n not os.path.isdir(cfg.general.cvs_roots[\"Development\"]):\n sys.stderr.write(\"*** No repository found. Please use the -r option.\\n\")\n sys.stderr.write(\" Use --help for more info.\\n\")\n raise KeyboardInterrupt # Hack!\n os.close(0) # To avoid problems with shell job control\n\n # always use default docroot location\n cfg.options.docroot = None\n\n # if cvsnt isn't found, fall back to rcs\n if (cfg.conf_path is None\n and cfg.general.cvsnt_exe_path):\n import popen\n cvsnt_works = 0\n try:\n fp = popen.popen(cfg.general.cvsnt_exe_path, ['--version'], 'rt')\n try:\n while 1:\n line = fp.readline()\n if not line: break\n if string.find(line, \"Concurrent Versions System (CVSNT)\")>=0:\n cvsnt_works = 1\n while fp.read(4096):\n pass\n break\n finally:\n fp.close()\n except:\n pass\n if not cvsnt_works:\n cfg.cvsnt_exe_path = None\n\n ViewVC_Server(host, port, callback).serve_until_quit()\n except (KeyboardInterrupt, select.error):\n pass\n print 'server stopped'","def callback(self):\n pass # pragma: no cover","def handle_request(self):\n\t\ttry:\n\t\t\tr,w,e=select.select([self.socket],[],[], 1.0)\n\t\t\tif not r:\n\t\t\t\treturn\n\t\t\trequest, client_address=self.socket.accept()\n\t\texcept:\n\t\t\treturn\t\t\n\t\t\n\t\ttry:\n\t\t\tif self.debug:\n\t\t\t\tprint \"got request\"\n\t\t\tself.process_request(request, client_address)\n\t\texcept:\n\t\t\tself.handle_error(request, client_address)","def request(self, flow: mitmproxy.http.HTTPFlow):","def request(self, flow: mitmproxy.http.HTTPFlow):","def handle_request(self, t):\n\n # respect ur elders\n super(StoreServer,self).handle_request(t)\n\n # convert out tuple to a request\n request = StoreRequest(t)\n\n # come up w/ a response for them\n response = StoreResponse(key=request.key,\n url=self.get_url(),\n port=self.get_port())\n\n # now spin up a handler for that port\n handler = StoreHandler(self,(response.url,response.port))\n\n # send back our response\n self.bb_client.put(response)","def onRequestStart(self, api, request):\n logging.info('Request start ({})'.format(request))","def _request(self, *args):\n raise NotImplementedError","def handle(self):\n\t\ttry:\n\t\t\trequest_line = self.rfile.readline().decode(\"ascii\")\n\t\t\tassert request_line.endswith(\"\\r\\n\"), \"Request line must end in CRLF\"\n\t\t\tparts = request_line.strip().split()\n\t\t\tassert len(parts)==3, \"Invalid request line\"\n\t\t\thost, path, content_length = parts\n\t\t\tif (content_length:=int(content_length))>0:\n\t\t\t\tdata = self.rfile.read(content_length)\n\t\t\telse:\n\t\t\t\tdata = b''\n\t\t\tself.handle_request(host,path,data)\n\t\texcept AssertionError as e:\n\t\t\tself.response_code(4,e.args[0])","def do_GET(self):\n #if self.path.startswith('/api/'):\n # f = self.send_response_headers('api call')\n #else:\n f=self.route()\n if f==False:\n f = self.send_head()\n if f:\n try:\n self.copyfile(f, self.wfile)\n finally:\n f.close()","def serve(self):\n\t\timport thread\n\t\tthread.start_new_thread(self._server_thread, tuple())","def on_server_start(self):\n raise NotImplementedError","def on_success(self):\n pass","def handle_one_request(self):\n \n try:\n \n self.raw_requestline = self.rfile.readline(65537)\n \n if len(self.raw_requestline) > 65536:\n \n self.requestline = ''\n \n self.request_version = ''\n \n self.command = ''\n \n self.send_error(414)\n \n return\n \n if not self.raw_requestline:\n \n self.close_connection = 1\n \n return\n \n if not self.parse_request():\n \n # An error code has been sent, just exit\n \n return\n \n mname = 'do_' + self.command\n \n if not hasattr(self, mname):\n \n self.send_error(501, \"Unsupported method (%r)\" % self.command)\n \n return\n \n method = getattr(self, mname)\n \n print \"before call do_Get\"\n \n method()\n \n #增加 debug info 及 wfile 判断是否已经 close\n \n print \"after call do_Get\"\n \n if not self.wfile.closed:\n self.wfile.flush() #actually send the response if not already done.\n \n print \"after wfile.flush()\"\n \n except socket.timeout, e:\n \n #a read or a write timed out. Discard this connection\n self.log_error(\"Request timed out: %r\", e)\n self.close_connection = 1\n return","def _handle_get_request(self):\n docroot = self._get_config_value('main', 'staticdocumentroot')\n local_path = sanitize_path(self.path)\n path = docroot + local_path\n try:\n # actually try deliver the requested file - First we try to send\n # every static content\n requested_file = open(path)\n text = requested_file.read()\n requested_file.close()\n except IOError:\n try:\n parsed_path = urlparse(self.path)\n params = dict([p.split('=') for p in parsed_path[4].split('&')])\n if params['addurl']:\n tmp = self._insert_url_to_db(params['addurl'])\n if tmp and tmp < 0:\n self._send_database_problem()\n return\n blocked = self._db.is_hash_blocked(tmp)\n if blocked:\n self._send_blocked_page(blocked[3])\n return\n elif tmp:\n self._send_return_page(tmp)\n return\n else:\n # There was a general issue with URL\n self._send_homepage('''<p class=\"warning\">Please check your input.</p>''')\n return\n else:\n # There was a general issue with URL\n self._send_homepage('''<p class=\"warning\">Please check your input.</p>''')\n return\n except YuDatabaseError:\n self._send_database_problem()\n return\n except:\n if self.path in ('/', '/URLRequest'):\n self._send_homepage()\n return\n elif self.path.startswith('/stats') or self.path.endswith('+'):\n if self.path == '/stats':\n # Doing general statistics here\n # Let's hope this page is not getting to popular ....\n # Create a new stats objekt which is fetching data in background\n self._show_general_stats()\n return\n else:\n # Check whether we do have the + or the stats kind of URL\n if self.path.endswith('+'):\n # Well I guess this is the proof you can write\n # real ugly code in Python too.\n try:\n if self.path.startswith('/show/'):\n request_path = self.path[6:]\n elif self.path.startswith('/s/'):\n request_path = self.path[3:]\n elif self.path.startswith('/stats/'):\n request_path = self.path[7:]\n else:\n request_path = self.path[1:]\n self._show_link_stats(request_path[:request_path.rfind('+')])\n return\n except Exception, e:\n # Oopps. Something went wrong. Most likely\n # a malformed link\n # TODO raise a (yet to be written) FileNotFoundException\n self._logger.error(\n u'An exception occurred: %s' % unicode(e), exc_info=True)\n self._send_404()\n return\n else:\n # Trying to understand for which link we shall print\n # out stats.\n splitted = self.path[1:].split('/')\n try:\n self._show_link_stats(splitted[1])\n return\n except IndexError:\n # Something went wrong. Most likely there was a\n # malformed URL for accessing the stats.\n self._send_404()\n return\n # Any other page\n else:\n # First check, whether we want to have a real redirect\n # or just an info\n request_path = self.path\n if self.path.startswith('/show/'):\n request_path = self.path[5:]\n show = True\n elif self.path.startswith('/s/'):\n request_path = self.path[2:]\n show = True\n else:\n show = False\n # Assuming, if there is anything else than an\n # alphanumeric character after the starting /, it's\n # not a valid hash at all\n if request_path[1:].isalnum():\n try:\n result = self._db.get_link_from_db(request_path[1:])\n blocked = self._db.is_hash_blocked(request_path[1:])\n except YuDatabaseError:\n self._send_database_problem()\n return\n if result and blocked == None:\n if show == True:\n template_filename = self._get_config_template('showpage')\n url = \"/\" + request_path[1:]\n new_url = '<p><a href=\"%(url)s\">%(result)s</a></p>' % \\\n {'result': result, 'url': url}\n stats = self._db.get_statistics_for_hash(request_path[1:])\n text = read_template(\n template_filename,\n title=SERVER_NAME,\n header=SERVER_NAME,\n msg=new_url,\n stat=stats,\n statspage=\"/stats/\" + request_path[1:])\n else:\n self._db.add_logentry_to_database(request_path[1:])\n self._send_301(result)\n return\n elif blocked:\n self._send_blocked_page(blocked[3])\n return\n else:\n self._send_404()\n return\n else:\n self._send_404()\n return\n self._send_response(text, 200)","def do_GET(self):\n global st_point, cur_request\n if time.time() - st_point < 1 and cur_request > args.MAX_REQ:\n self.send_response(429)\n self.send_header(\"Content-type\",\"text/html\")\n self.end_headers()\n time.sleep(0.2)\n return\n elif time.time() - st_point > 1:\n st_point = time.time()\n cur_request = 1\n self.func_PARSE()\n if self.parsed_url[2] in [\"/ping\", \"/cats\"]:\n self.func_DO()\n else:\n self.send_response(400)\n text=\"<h1 align=center>Bad request</h1>\"\n self.func_PRINT(text)","def run(self):\n while self.running:\n self.handle_request()","def process_request_starts(self, request):\n pass","def _listen_to_requests(self):\n while True:\n try:\n request = self._client.recv(1024)\n except socket.error as err:\n if DEBUG_LEVEL >= 1:\n print \"Got socket error: {}\".format(err.message)\n self._client.close()\n return True\n\n if not request:\n if DEBUG_LEVEL >= 0:\n print \"Closing connection\"\n self._client.close()\n return True\n\n if DEBUG_LEVEL >= 2:\n print request\n\n if not HTTPValidation.validate_request(request):\n if DEBUG_LEVEL >= 0:\n print \"Invalid request, closing...\"\n self._client.send(public_response_functions.get_error_response())\n self._client.close()\n return True\n\n if not self._send_response(request):\n if DEBUG_LEVEL >= 0:\n print \"Closing connection...\"\n self._client.close()\n return","def on_server_start(self, server):\n pass","def __init__(self, server_address,db,RequestHandlerClass):\n self.db = db\n http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)","def handle_request(request, client, stat):\n\n # Parse headers\n print(\"Request:\"+request)\n headers = request.split('\\n')\n re = Request(headers=headers)\n\n # Fazer log do sucedido\n add_log(client.getpeername(), re.path)\n\n # Ir buscar a cache o ficheiro\n response = stat.get_from_cache(re.path)\n\n if response is not None:\n return response\n\n # Se nao houver a resposta em cache entao vai criar uma nova\n time.sleep(0.1)\n\n try:\n if re.isPrivate():\n response = Response(status=\"HTTP/1.0 403 Forbidden\", body=\"Private link\",\n connectionType=\"close\")\n stat.add_cache(response, re.path)\n return response\n\n body = re.getContent()\n\n # Restorna so o cabeçalho\n if re.verbo == \"HEAD\":\n response = Response(status=\"HTTP/1.0 200 OK\", connectionType=\"close\", length=len(body))\n stat.add_cache(response, re.path)\n return response\n\n # If is a Bad Request\n except PermissionError:\n response = Response(status=\"HTTP/1.0 400 Bad Request\", body=\"Bad Request\", connectionType=\"close\")\n stat.add_cache(response, re.path)\n return response\n\n # If the file doesn't exist\n except FileNotFoundError:\n response = Response(status=\"HTTP/1.0 404 Not Found\", body=\"File Not Found\", connectionType=\"close\")\n stat.add_cache(response, re.path)\n return response\n\n # Return response\n response = Response(status=\"HTTP/1.0 200 OK\", body=body, contentType=re.filetype,\n connectionType=re.connectionType, length=len(body))\n stat.add_cache(response, re.path)\n return response","def on_open(self):\n def event_loop():\n logger.debug(pformat(self.query.request))\n self.send(json.dumps(self.query.request))\n while not self.event.is_set():\n #print('Waiting around on the socket: %s' % self.gettimeout())\n self.event.wait(self.gettimeout())\n \n logger.debug('Event loop terminating.')\n \n self.thread = threading.Thread(\n target=event_loop)\n self.thread.setDaemon(True)\n self.thread.start()","def on_iteration(self):\n self.send_pending_requests()\n super().on_iteration()","def done(self):\n ## All done with the request object\n self.closed = True\n self.d.callback('')","def handle(self):\n try:\n # Wait for data\n data = json.loads(self.request.recv(1024).decode('UTF-8').strip())\n\n # Process data\n self.process_data(data)\n\n except Exception as e:\n print(\"Exception wile receiving message: \", e)\n self.request.sendall(\n bytes(json.dumps({'return': 'error'}), 'UTF-8'))","def request(self, url, *args, **kwargs):\n raise NotImplementedError","def work(self, request):\n raise NotImplementedError","def start(self):\n self.get(self.url)","def handle_one_request(self):\n import socket\n try:\n self.raw_requestline = self.rfile.readline(65537)\n if len(self.raw_requestline) > 65536:\n self.requestline = ''\n self.request_version = ''\n self.command = ''\n self.send_error(414)\n return\n if not self.raw_requestline:\n self.close_connection = 1\n return\n if not self.parse_request():\n # An error code has been sent, just exit\n return\n\n ##### Customization\n # origin\n \"\"\"\n mname = 'do_' + self.command\n if not hasattr(self, mname):\n self.send_error(501, \"Unsupported method (%r)\" % self.command)\n return\n method = getattr(self, mname)\n method()\n \"\"\"\n # now\n #import pdb; pdb.set_trace()\n self.delegate(self.get_environ(), self.gen_response, self.send_error)\n\n self.wfile.flush() #actually send the response if not already done.\n except socket.timeout, e:\n #a read or a write timed out. Discard this connection\n self.log_error(\"Request timed out: %r\", e)\n self.close_connection = 1\n return","def request_received(self, event):\n log.debug(\"request received, stream %s\", event.stream_id)","def __manage_client_thread(self, conn_socket: socket.socket, address: tuple):\n print(\"[THREAD] new thread started for client\")\n connected = True\n\n while connected:\n request_header = HttpServer.get_request_header(conn_socket)\n split_request_header = request_header.split()\n file = split_request_header[1]\n print(\"[RECV] header received from IPv4 address\", address[0], \":\", request_header)\n\n if not HttpServer.is_valid_http_request(split_request_header):\n http_message = HttpServer.create_400_response()\n pass\n else:\n if file == \"/\":\n file = \"/index.html\"\n\n put_or_post = HttpServer.is_put_or_post(split_request_header)\n try:\n if put_or_post:\n request_body = HttpServer.get_request_body(conn_socket, request_header)\n status_code = HttpServer.get_status_code_for_put_or_post(request_header, file)\n\n if status_code == 204:\n if split_request_header[0] == \"PUT\":\n f = open(file[1:], \"w\")\n else:\n f = open(file[1:], \"a\")\n\n f.write(request_body)\n f.close()\n http_message = HttpServer.create_204_response()\n elif status_code == 501:\n http_message = HttpServer.create_501_response()\n else: # status code is 201\n f = open(file[1:], \"x\")\n f.write(request_body)\n f.close()\n http_message = self.create_201_response(file)\n\n else:\n if split_request_header[0] == \"GET\":\n # GET needs filename\n status_code = HttpServer.get_status_code_for_get(request_header, file)\n else:\n status_code = HttpServer.get_status_code_for_head(file)\n\n if status_code == 404:\n http_message = HttpServer.create_404_response()\n elif status_code == 304:\n http_message = HttpServer.create_304_response()\n else: # status code is 200\n http_message = HttpServer.create_200_response(file)\n except Exception:\n http_message = HttpServer.create_500_response()\n\n conn_socket.send(http_message)\n\n # determine if connection has to be closed\n conn_str = \"Connection:\"\n conn_begin_ind = request_header.find(conn_str)\n\n if conn_begin_ind != -1:\n conn_end_ind = request_header[conn_begin_ind:].find(\"\\r\\n\") + conn_begin_ind\n conn_status = request_header[conn_begin_ind+len(conn_str):conn_end_ind].strip()\n if conn_status == \"close\":\n conn_socket.close()\n connected = False\n print(\"[THREAD] client thread ended\")","def process_request(self, req):\n return None","def request_handler(client_connection, request_path, request_proto, response_code, response_string, response_body,\r\n is_request_valid):\r\n\r\n response_headers = {}\r\n client_connection.send_header('Access-Control-Allow-Origin', '*')\r\n client_connection.send(\"%s %s %s\\r\\n\" % (request_proto, response_code, response_string))\r\n\r\n if is_request_valid:\r\n response_headers['Date'] = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S %Z')\r\n response_headers['Last-Modified'] = datetime.datetime.fromtimestamp(\r\n int(os.path.getmtime(os.getcwd() + request_path))).strftime('%a, %d %b %Y %H:%M:%S %Z')\r\n response_headers['Server'] = 'bing_2.0 (Unix)'\r\n response_headers['Content-Length'] = os.path.getsize(os.getcwd() + request_path)\r\n response_headers['Content-Type'] = mimetypes.guess_type(os.getcwd() + request_path)[0]\r\n if request_path == '/www/access_list.txt':\r\n response_headers['Content-Type'] = 'text/html'\r\n if response_headers['Content-Type'] is None:\r\n response_headers['Content-Type'] = 'application/octet-stream'\r\n client_connection.send(''.join('%s: %s\\n' % (k, v) for k, v in response_headers.iteritems()))\r\n\r\n client_connection.send(\"\\n\")\r\n client_connection.send(response_body)","def on_response(self, response):\n log.debug(\"Received response: %s\", response)","def serve(self, request, *args, **kwargs):\n raise Http404","def serve(self, request, *args, **kwargs):\n raise Http404","def serve(self, request, *args, **kwargs):\n raise Http404","def serve(self, request, *args, **kwargs):\n raise Http404","def serve(self, request, *args, **kwargs):\n raise Http404","def do_POST(self): # pylint: disable=invalid-name\n self.handle_request()","def get(self, request):\n pass","def main():\n host = ''\n port = 8088\n HTTPServer((host, port), HandleRequests).serve_forever()","def serve(self):\n\t\tself.keep_running=1\n\t\tif self.debug:\n\t\t\tprint \"server started\"\n\t\ttry:\n\t\t\twhile self.keep_running:\n\t\t\t\tself.handle_request()\n\t\tfinally:\n\t\t\tif self.debug:\n\t\t\t\tprint \"server finished\"\n\t\t\tself.keep_running=0\n\t\t\tself.close()","def __init__( request ):","def _request(self, *args, **kwargs):\n raise NotImplementedError()","def handle_request(self, data, peer):\n\n req = Request.parse(data)\n if req:\n handler = self.get_hanlder(\n req, (self.host, self.port), peer, \n self._retries, self._timeout\n )\n handler.run()","def _request_ended(self, reply):\n\n if reply.attribute(QNetworkRequest.HttpStatusCodeAttribute):\n self.http_resources.append(HttpResource(reply, self.cache))","def callback_connect(self):\n pass","def callback_connect(self):\n pass","def callback_connect(self):\n pass","def process_data(request, response, resource):\n response.set_header('Access-Control-Allow-Origin', '*')","def dispatch(self):\n handler_start_time = time.time()\n\n logging.info('\\n\\n\\nRequest handler: %r', self)\n count0, count1, count2 = gc.get_count()\n logging.info('gc counts: %d %d %d', count0, count1, count2)\n GC_COUNT.add(count0, {'generation': 0})\n GC_COUNT.add(count1, {'generation': 1})\n GC_COUNT.add(count2, {'generation': 2})\n\n self.mr = monorailrequest.MonorailRequest(self.services)\n\n self.ratelimiter.CheckStart(self.request)\n self.response.headers.add('Strict-Transport-Security',\n 'max-age=31536000; includeSubDomains')\n\n if 'X-Cloud-Trace-Context' in self.request.headers:\n self.mr.profiler.trace_context = (\n self.request.headers.get('X-Cloud-Trace-Context'))\n if trace_service is not None:\n self.mr.profiler.trace_service = trace_service\n\n if self.services.cache_manager:\n # TODO(jrobbins): don't do this step if invalidation_timestep was\n # passed via the request and matches our last timestep\n try:\n with self.mr.profiler.Phase('distributed invalidation'):\n self.services.cache_manager.DoDistributedInvalidation(self.mr.cnxn)\n\n except MySQLdb.OperationalError as e:\n logging.exception(e)\n page_data = {\n 'http_response_code': httplib.SERVICE_UNAVAILABLE,\n 'requested_url': self.request.url,\n }\n self.template = template_helpers.GetTemplate(\n 'templates/framework/database-maintenance.ezt',\n eliminate_blank_lines=self._ELIMINATE_BLANK_LINES)\n self.template.WriteResponse(\n self.response, page_data, content_type='text/html')\n return\n\n try:\n with self.mr.profiler.Phase('parsing request and doing lookups'):\n self.mr.ParseRequest(self.request, self.services)\n\n self.response.headers['X-Frame-Options'] = 'SAMEORIGIN'\n webapp2.RequestHandler.dispatch(self)\n\n except exceptions.NoSuchUserException as e:\n logging.warning('Trapped NoSuchUserException %s', e)\n self.abort(404, 'user not found')\n\n except exceptions.NoSuchGroupException as e:\n logging.warning('Trapped NoSuchGroupException %s', e)\n self.abort(404, 'user group not found')\n\n except exceptions.InputException as e:\n logging.info('Rejecting invalid input: %r', e)\n self.response.status = httplib.BAD_REQUEST\n\n except exceptions.NoSuchProjectException as e:\n logging.info('Rejecting invalid request: %r', e)\n self.response.status = httplib.NOT_FOUND\n\n except xsrf.TokenIncorrect as e:\n logging.info('Bad XSRF token: %r', e.message)\n self.response.status = httplib.BAD_REQUEST\n\n except permissions.BannedUserException as e:\n logging.warning('The user has been banned')\n url = framework_helpers.FormatAbsoluteURL(\n self.mr, urls.BANNED, include_project=False, copy_params=False)\n self.redirect(url, abort=True)\n\n except ratelimiter.RateLimitExceeded as e:\n logging.info('RateLimitExceeded Exception %s', e)\n self.response.status = httplib.BAD_REQUEST\n self.response.body = 'Slow your roll.'\n\n finally:\n self.mr.CleanUp()\n self.ratelimiter.CheckEnd(self.request, time.time(), handler_start_time)\n\n total_processing_time = time.time() - handler_start_time\n logging.warn('Processed request in %d ms',\n int(total_processing_time * 1000))\n\n end_count0, end_count1, end_count2 = gc.get_count()\n logging.info('gc counts: %d %d %d', end_count0, end_count1, end_count2)\n if (end_count0 < count0) or (end_count1 < count1) or (end_count2 < count2):\n GC_EVENT_REQUEST.increment()\n\n if settings.enable_profiler_logging:\n self.mr.profiler.LogStats()\n\n if (self.mr.profiler.trace_context is not None and\n random.random() < settings.trace_fraction):\n self.mr.profiler.ReportTrace()","def connectionMade(self):\n \t#print \"[K] Connect effettuata\", self.port\n \tself.factory.state=\"0 open\"\n \tif (self.port in self.portfForHTTPGet):\n\t\tself.transport.write(\"GET / HTTP/1.1\\r\\n\\r\\n\")\n \t\t#self.transport.write(\"GET /index.html HTTP/1.1\\r\\n\\r\\n\")"],"string":"[\n \"def onConnect(self, request_or_response):\",\n \"def _process_request(self, request, response):\\n ...\",\n \"def event_handler(self, response):\\n pass\",\n \"async def _response_handler(self):\",\n \"def connectionMade(self):\",\n \"def on_response(self, response):\\n pass\",\n \"def run(self):\\n self.initialize()\\n\\n # run the start callback\\n tools.run_callback(\\\"start\\\", {'request': self._request})\\n\\n data = self._request.getData()\\n pyhttp = self._request.getHttp()\\n config = self._request.getConfiguration()\\n\\n # allow anyone else to handle the request at this point\\n handled = tools.run_callback(\\\"handle\\\", \\n {'request': self._request},\\n mappingfunc=lambda x,y:x,\\n donefunc=lambda x:x)\\n\\n if not handled == 1:\\n blosxom_handler(self._request)\\n\\n # do end callback\\n tools.run_callback(\\\"end\\\", {'request': self._request})\",\n \"def _handle_first_request(self):\\n pass\",\n \"def request_callback(request):\\n headers = {'content-type': 'text/html',\\n 'cache-control': \\\"no-cache\\\"}\\n return (200, headers, graph_data)\",\n \"async def handle_request(self, request: aioweb.request.Request):\",\n \"def handler(self):\\n msg = self.create_http_request()\\n self.send(msg)\\n\\n if self.file_name == \\\"/\\\":\\n self.file_name = \\\"/index.html\\\"\\n else:\\n self.file_name = HttpClient.create_file_location(self.file_name)\\n\\n if self.http_command == \\\"HEAD\\\":\\n recv_raw, _ = self.recv_header()\\n recv = recv_raw.decode(self.format_body)\\n recv_with_updated_imgs = self.update_images(recv)\\n self.write_to_html_file(recv_with_updated_imgs)\\n elif self.http_command == \\\"PUT\\\":\\n recv_raw = self.recv_all_data()\\n if recv_raw != b'':\\n recv = recv_raw.decode(self.format_body)\\n recv_with_updated_imgs = self.update_images(recv)\\n self.write_to_html_file(recv_with_updated_imgs)\\n elif self.http_command == \\\"POST\\\":\\n recv_raw = self.recv_all_data()\\n if recv_raw != b'':\\n recv = recv_raw.decode(self.format_body)\\n recv_with_updated_imgs = self.update_images(recv)\\n self.write_to_html_file(recv_with_updated_imgs)\\n else: # http_command == \\\"GET\\\" or it is a bad request\\n recv_raw = self.recv_all_data()\\n recv = recv_raw.decode(self.format_body)\\n recv_with_updated_imgs = self.update_images(recv)\\n self.write_to_html_file(recv_with_updated_imgs)\\n\\n self.disconnect()\\n print(\\\"[CONNECTION] Client terminated\\\")\",\n \"def renderHTTP(req):\",\n \"def process_server_response(self, server_response):\",\n \"def server():\",\n \"def server():\",\n \"def main_response(self, data):\",\n \"def main_response(self, data):\",\n \"def renderHTTP(ctx):\",\n \"def onfinish( request ):\",\n \"def onfinish( request ):\",\n \"def request_callback(request):\\n headers = {'content-type': \\\"application/json\\\",\\n 'cache-control': \\\"no-cache\\\"}\\n return (200, headers, json.dumps(response_data))\",\n \"def serve(self,cb):\\n self.cb = cb\\n self.run()\",\n \"def handle(self):\\n data = self.request.recv(1024)\\n self.request.send(data)\",\n \"def _handle_connection(self, conn):\\n conn.serve_all()\",\n \"def process(self, request):\\n pass\",\n \"def do_GET(self):\\n # nothing more to do before handle_data()\\n self.body = {}\\n self.handle_data()\",\n \"def handle_request(self, request: HttpParser) -> None:\\n raise NotImplementedError() # pragma: no cover\",\n \"def handle_request(self,host,path,data=b''):\\n\\t\\tself.response_code(5,\\\"Request handler not implemented\\\")\",\n \"def connectionMade(self):\\n print \\\"new connection made to\\\", host, \\\"port\\\", port\\n self.transport.write(\\\"GET /movies/32 HTTP/1.0\\\\r\\\\n\\\\r\\\\n\\\") # some get request\\n self.transport.loseConnection()\",\n \"def _process_request(self):\\n if not self._requests:\\n if self._stream:\\n self._stream.close()\\n self._stream = None\\n if self._processing:\\n self._processing = False\\n Engine.instance().stop()\\n return\\n\\n request = self._requests[0]\\n\\n request.append(\\n Engine.instance().defer(request[5], self._request_timeout, request))\\n\\n port = request[2].port\\n if not port:\\n if request[2].scheme.lower() == 'https':\\n port = 443\\n else:\\n port = 80\\n\\n host = \\\"%s:%d\\\" % (request[2].hostname, port)\\n\\n if self._stream:\\n if not self._server == host.lower() or not \\\\\\n self._is_secure == (request[2].scheme.lower() == 'https'):\\n self._stream.end()\\n return\\n\\n if not self._stream:\\n # Store the current server.\\n self._server = host.lower()\\n\\n # Create a Stream, hook into it, and connect.\\n self._stream = Stream()\\n\\n self._stream.on_close = self._on_close\\n self._stream.on_connect = self._on_connect\\n\\n self._is_secure = request[2].scheme.lower() == 'https'\\n if self._is_secure:\\n raise Exception(\\\"SSL has not yet been implemented in this version of Pants.\\\")\\n self._stream.startTLS()\\n\\n self._stream.connect((request[2].hostname, port))\\n return\\n\\n # If we got here, we're connected, and to the right server. Do stuff.\\n self._stream.write('%s %s HTTP/1.1%s' % (request[0], request[8], CRLF))\\n for k, v in request[3].iteritems():\\n self._stream.write('%s: %s%s' % (k, v, CRLF))\\n\\n if request[4]:\\n self._stream.write('%s%s' % (CRLF, request[4]))\\n else:\\n self._stream.write(CRLF)\\n\\n # Now, wait for a response.\\n self._stream.on_read = self._read_headers\\n self._stream.read_delimiter = DOUBLE_CRLF\",\n \"def handle(self):\\n self.request.recv(1024)\\n self.request.sendall(pickle.dumps(self.server.lymphocytes_getter()))\",\n \"async def _handle_request(self, request: web.Request) -> web.Response:\\n event = await request.json()\\n # This handler will be called on the server thread. Call the external\\n # handler on the app thread.\\n self._main_loop.call_soon_threadsafe(self.handle_event, event)\\n return web.Response(text=\\\"OK\\\")\",\n \"def on_success(self) -> None:\",\n \"def process_request(self, req, resp, resource, params):\",\n \"def handle_request(self):\\n\\t\\ttry:\\n\\t\\t\\trequest, client_address = self.get_request()\\n\\t\\texcept socket.error:\\n\\t\\t\\treturn\\n\\t\\tif self.verify_request(request, client_address):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tself.process_request(request, client_address)\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tself.handle_error(request, client_address)\\n\\t\\t\\t\\tself.close_request(request)\",\n \"def request_handler(self):\\n\\n size = 1024\\n while True:\\n # accept message from client\\n clientSock, addr = self.socket.accept()\\n self.printLine()\\n print('connect to {}'.format(addr))\\n\\n # print client message content\\n msg = clientSock.recv(size).decode('utf-8')\\n self.printLine()\\n print(\\\"sent message :\\\")\\n print(msg)\\n\\n self.printLine()\\n self._set_fileName(msg)\\n\\n # check for existance of file in the server (with name of file.txt)\\n data, isFileExist = self._send_file_handler()\\n\\n self.printLine()\\n print('data of file :')\\n print(data)\\n\\n # create header for response message\\n if isFileExist:\\n header = self._generate_headers(200)\\n else:\\n header = self._generate_headers(404)\\n\\n response = header.encode() + data.encode()\\n\\n # send response in http protocol\\n clientSock.send(response)\\n\\n # close the signal\\n clientSock.close()\",\n \"def __call__(self, request):\",\n \"def serve(self, rq):\\n # Call callback by key directly from socket\\n request = rq['request']\\n\\n if request in self.callbacks :\\n self.callbacks[request](rq)\\n else :\\n print \\\"unrecognised request\\\"\",\n \"def serve(self, rq):\\n # Call callback by key directly from socket\\n request = rq['request']\\n\\n if request in self.callbacks :\\n self.callbacks[request](rq)\\n else :\\n print \\\"unrecognised request\\\"\",\n \"def handler(self):\\n\\t\\treturn self.handle_request\",\n \"def handle_request( method, uri, version, headers, body=None, chunk=None,\\n trailers=None ):\",\n \"def do_GET(self):\\n self.log.debug('do_GET called')\\n self.HeadGet('GET')\",\n \"def _handle_head_request(self):\\n self._header_only = True\\n self._handle_get_request()\",\n \"def request_handler(self, client_connection):\\n request = client_connection.recv(1024)\\n\\n #Make sure we recieved some data before proceeding\\n if not request:\\n response = 'Empty request'\\n http_code = 400\\n else:\\n response, http_code = self.parse_request(request)\\n\\n #print response\\n self.send_response(client_connection, response, http_code)\",\n \"def do_GET(self):\\r\\n self.logger.debug(\\\"SseHTTPRequestHandler(Thread-%s): do_GET, path=%s\\\",\\r\\n threading.current_thread().ident, self.path)\\r\\n threading.current_thread().name = (self.path + \\\"_thread_\\\" +\\r\\n str(threading.current_thread().ident))\\r\\n if self.path == SseHTTPRequestHandler.eventsource_path:\\r\\n self._start_event_stream()\\r\\n else:\\r\\n http.server.SimpleHTTPRequestHandler.do_GET(self)\",\n \"def on_connection_closed(self):\",\n \"def on_get(self, req, resp):\\n try:\\n n_reqs = int(req.params.get('n', self.default_reqs))\\n except ValueError:\\n error_response(resp, 'ERROR: Incorrect number of requests')\\n return\\n\\n urls = self.scheduler.requests(n_reqs)\\n resp.data = json.dumps(urls, ensure_ascii=True)\\n resp.content_type = \\\"application/json\\\"\\n resp.status = falcon.HTTP_200\",\n \"def serve(host, port, callback=None):\\n\\n class ViewVC_Handler(BaseHTTPServer.BaseHTTPRequestHandler):\\n \\n def do_GET(self):\\n \\\"\\\"\\\"Serve a GET request.\\\"\\\"\\\"\\n if not self.path or self.path == \\\"/\\\":\\n self.redirect()\\n elif self.is_viewvc():\\n try:\\n self.run_viewvc()\\n except IOError:\\n # ignore IOError: [Errno 32] Broken pipe\\n pass\\n else:\\n self.send_error(404)\\n\\n def do_POST(self):\\n \\\"\\\"\\\"Serve a POST request.\\\"\\\"\\\"\\n if self.is_viewvc():\\n self.run_viewvc()\\n else:\\n self.send_error(501, \\\"Can only POST to %s\\\"\\n % (options.script_alias))\\n\\n def is_viewvc(self):\\n \\\"\\\"\\\"Check whether self.path is, or is a child of, the ScriptAlias\\\"\\\"\\\"\\n if self.path == '/' + options.script_alias:\\n return 1\\n if self.path[:len(options.script_alias)+2] == \\\\\\n '/' + options.script_alias + '/':\\n return 1\\n if self.path[:len(options.script_alias)+2] == \\\\\\n '/' + options.script_alias + '?':\\n return 1\\n return 0\\n\\n def redirect(self):\\n \\\"\\\"\\\"redirect the browser to the viewvc URL\\\"\\\"\\\"\\n new_url = self.server.url + options.script_alias + '/'\\n self.send_response(301, \\\"Moved (redirection follows)\\\")\\n self.send_header(\\\"Content-type\\\", \\\"text/html\\\")\\n self.send_header(\\\"Location\\\", new_url)\\n self.end_headers()\\n self.wfile.write(\\\"\\\"\\\"<html>\\n<head>\\n<meta http-equiv=\\\"refresh\\\" content=\\\"1; URL=%s\\\">\\n</head>\\n<body>\\n<h1>Redirection to <a href=\\\"%s\\\">ViewVC</a></h1>\\nWait a second. You will be automatically redirected to <b>ViewVC</b>.\\nIf this doesn't work, please click on the link above.\\n</body>\\n</html>\\n\\\"\\\"\\\" % tuple([new_url]*2))\\n\\n def run_viewvc(self):\\n \\\"\\\"\\\"This is a quick and dirty cut'n'rape from Python's \\n standard library module CGIHTTPServer.\\\"\\\"\\\"\\n scriptname = '/' + options.script_alias\\n assert string.find(self.path, scriptname) == 0\\n viewvc_url = self.server.url[:-1] + scriptname\\n rest = self.path[len(scriptname):]\\n i = string.rfind(rest, '?')\\n if i >= 0:\\n rest, query = rest[:i], rest[i+1:]\\n else:\\n query = ''\\n # sys.stderr.write(\\\"Debug: '\\\"+scriptname+\\\"' '\\\"+rest+\\\"' '\\\"+query+\\\"'\\\\n\\\")\\n env = os.environ\\n # Since we're going to modify the env in the parent, provide empty\\n # values to override previously set values\\n for k in env.keys():\\n if k[:5] == 'HTTP_':\\n del env[k]\\n for k in ('QUERY_STRING', 'REMOTE_HOST', 'CONTENT_LENGTH',\\n 'HTTP_USER_AGENT', 'HTTP_COOKIE'):\\n if env.has_key(k): \\n env[k] = \\\"\\\"\\n # XXX Much of the following could be prepared ahead of time!\\n env['SERVER_SOFTWARE'] = self.version_string()\\n env['SERVER_NAME'] = self.server.server_name\\n env['GATEWAY_INTERFACE'] = 'CGI/1.1'\\n env['SERVER_PROTOCOL'] = self.protocol_version\\n env['SERVER_PORT'] = str(self.server.server_port)\\n env['REQUEST_METHOD'] = self.command\\n uqrest = urllib.unquote(rest)\\n env['PATH_INFO'] = uqrest\\n env['SCRIPT_NAME'] = scriptname\\n if query:\\n env['QUERY_STRING'] = query\\n env['HTTP_HOST'] = self.server.address[0]\\n host = self.address_string()\\n if host != self.client_address[0]:\\n env['REMOTE_HOST'] = host\\n env['REMOTE_ADDR'] = self.client_address[0]\\n # AUTH_TYPE\\n # REMOTE_USER\\n # REMOTE_IDENT\\n if self.headers.typeheader is None:\\n env['CONTENT_TYPE'] = self.headers.type\\n else:\\n env['CONTENT_TYPE'] = self.headers.typeheader\\n length = self.headers.getheader('content-length')\\n if length:\\n env['CONTENT_LENGTH'] = length\\n accept = []\\n for line in self.headers.getallmatchingheaders('accept'):\\n if line[:1] in string.whitespace:\\n accept.append(string.strip(line))\\n else:\\n accept = accept + string.split(line[7:], ',')\\n env['HTTP_ACCEPT'] = string.joinfields(accept, ',')\\n ua = self.headers.getheader('user-agent')\\n if ua:\\n env['HTTP_USER_AGENT'] = ua\\n modified = self.headers.getheader('if-modified-since')\\n if modified:\\n env['HTTP_IF_MODIFIED_SINCE'] = modified\\n etag = self.headers.getheader('if-none-match')\\n if etag:\\n env['HTTP_IF_NONE_MATCH'] = etag\\n # XXX Other HTTP_* headers\\n decoded_query = string.replace(query, '+', ' ')\\n\\n # Preserve state, because we execute script in current process:\\n save_argv = sys.argv\\n save_stdin = sys.stdin\\n save_stdout = sys.stdout\\n save_stderr = sys.stderr\\n # For external tools like enscript we also need to redirect\\n # the real stdout file descriptor. (On windows, reassigning the\\n # sys.stdout variable is sufficient because pipe_cmds makes it\\n # the standard output for child processes.)\\n if sys.platform != \\\"win32\\\": save_realstdout = os.dup(1) \\n try:\\n try:\\n sys.stdout = self.wfile\\n if sys.platform != \\\"win32\\\":\\n os.dup2(self.wfile.fileno(), 1)\\n sys.stdin = self.rfile\\n viewvc.main(StandaloneServer(self), cfg)\\n finally:\\n sys.argv = save_argv\\n sys.stdin = save_stdin\\n sys.stdout.flush()\\n if sys.platform != \\\"win32\\\":\\n os.dup2(save_realstdout, 1)\\n os.close(save_realstdout)\\n sys.stdout = save_stdout\\n sys.stderr = save_stderr\\n except SystemExit, status:\\n self.log_error(\\\"ViewVC exit status %s\\\", str(status))\\n else:\\n self.log_error(\\\"ViewVC exited ok\\\")\\n\\n class ViewVC_Server(BaseHTTPServer.HTTPServer):\\n def __init__(self, host, port, callback):\\n self.address = (host, port)\\n self.url = 'http://%s:%d/' % (host, port)\\n self.callback = callback\\n BaseHTTPServer.HTTPServer.__init__(self, self.address,\\n self.handler)\\n\\n def serve_until_quit(self):\\n self.quit = 0\\n while not self.quit:\\n rd, wr, ex = select.select([self.socket.fileno()], [], [], 1)\\n if rd:\\n self.handle_request()\\n\\n def server_activate(self):\\n BaseHTTPServer.HTTPServer.server_activate(self)\\n if self.callback:\\n self.callback(self)\\n\\n def server_bind(self):\\n # set SO_REUSEADDR (if available on this platform)\\n if hasattr(socket, 'SOL_SOCKET') \\\\\\n and hasattr(socket, 'SO_REUSEADDR'):\\n self.socket.setsockopt(socket.SOL_SOCKET,\\n socket.SO_REUSEADDR, 1)\\n BaseHTTPServer.HTTPServer.server_bind(self)\\n\\n ViewVC_Server.handler = ViewVC_Handler\\n\\n try:\\n # XXX Move this code out of this function.\\n # Early loading of configuration here. Used to\\n # allow tinkering with some configuration settings:\\n handle_config()\\n if options.repositories:\\n cfg.general.default_root = \\\"Development\\\"\\n cfg.general.cvs_roots.update(options.repositories)\\n elif cfg.general.cvs_roots.has_key(\\\"Development\\\") and \\\\\\n not os.path.isdir(cfg.general.cvs_roots[\\\"Development\\\"]):\\n sys.stderr.write(\\\"*** No repository found. Please use the -r option.\\\\n\\\")\\n sys.stderr.write(\\\" Use --help for more info.\\\\n\\\")\\n raise KeyboardInterrupt # Hack!\\n os.close(0) # To avoid problems with shell job control\\n\\n # always use default docroot location\\n cfg.options.docroot = None\\n\\n # if cvsnt isn't found, fall back to rcs\\n if (cfg.conf_path is None\\n and cfg.general.cvsnt_exe_path):\\n import popen\\n cvsnt_works = 0\\n try:\\n fp = popen.popen(cfg.general.cvsnt_exe_path, ['--version'], 'rt')\\n try:\\n while 1:\\n line = fp.readline()\\n if not line: break\\n if string.find(line, \\\"Concurrent Versions System (CVSNT)\\\")>=0:\\n cvsnt_works = 1\\n while fp.read(4096):\\n pass\\n break\\n finally:\\n fp.close()\\n except:\\n pass\\n if not cvsnt_works:\\n cfg.cvsnt_exe_path = None\\n\\n ViewVC_Server(host, port, callback).serve_until_quit()\\n except (KeyboardInterrupt, select.error):\\n pass\\n print 'server stopped'\",\n \"def callback(self):\\n pass # pragma: no cover\",\n \"def handle_request(self):\\n\\t\\ttry:\\n\\t\\t\\tr,w,e=select.select([self.socket],[],[], 1.0)\\n\\t\\t\\tif not r:\\n\\t\\t\\t\\treturn\\n\\t\\t\\trequest, client_address=self.socket.accept()\\n\\t\\texcept:\\n\\t\\t\\treturn\\t\\t\\n\\t\\t\\n\\t\\ttry:\\n\\t\\t\\tif self.debug:\\n\\t\\t\\t\\tprint \\\"got request\\\"\\n\\t\\t\\tself.process_request(request, client_address)\\n\\t\\texcept:\\n\\t\\t\\tself.handle_error(request, client_address)\",\n \"def request(self, flow: mitmproxy.http.HTTPFlow):\",\n \"def request(self, flow: mitmproxy.http.HTTPFlow):\",\n \"def handle_request(self, t):\\n\\n # respect ur elders\\n super(StoreServer,self).handle_request(t)\\n\\n # convert out tuple to a request\\n request = StoreRequest(t)\\n\\n # come up w/ a response for them\\n response = StoreResponse(key=request.key,\\n url=self.get_url(),\\n port=self.get_port())\\n\\n # now spin up a handler for that port\\n handler = StoreHandler(self,(response.url,response.port))\\n\\n # send back our response\\n self.bb_client.put(response)\",\n \"def onRequestStart(self, api, request):\\n logging.info('Request start ({})'.format(request))\",\n \"def _request(self, *args):\\n raise NotImplementedError\",\n \"def handle(self):\\n\\t\\ttry:\\n\\t\\t\\trequest_line = self.rfile.readline().decode(\\\"ascii\\\")\\n\\t\\t\\tassert request_line.endswith(\\\"\\\\r\\\\n\\\"), \\\"Request line must end in CRLF\\\"\\n\\t\\t\\tparts = request_line.strip().split()\\n\\t\\t\\tassert len(parts)==3, \\\"Invalid request line\\\"\\n\\t\\t\\thost, path, content_length = parts\\n\\t\\t\\tif (content_length:=int(content_length))>0:\\n\\t\\t\\t\\tdata = self.rfile.read(content_length)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = b''\\n\\t\\t\\tself.handle_request(host,path,data)\\n\\t\\texcept AssertionError as e:\\n\\t\\t\\tself.response_code(4,e.args[0])\",\n \"def do_GET(self):\\n #if self.path.startswith('/api/'):\\n # f = self.send_response_headers('api call')\\n #else:\\n f=self.route()\\n if f==False:\\n f = self.send_head()\\n if f:\\n try:\\n self.copyfile(f, self.wfile)\\n finally:\\n f.close()\",\n \"def serve(self):\\n\\t\\timport thread\\n\\t\\tthread.start_new_thread(self._server_thread, tuple())\",\n \"def on_server_start(self):\\n raise NotImplementedError\",\n \"def on_success(self):\\n pass\",\n \"def handle_one_request(self):\\n \\n try:\\n \\n self.raw_requestline = self.rfile.readline(65537)\\n \\n if len(self.raw_requestline) > 65536:\\n \\n self.requestline = ''\\n \\n self.request_version = ''\\n \\n self.command = ''\\n \\n self.send_error(414)\\n \\n return\\n \\n if not self.raw_requestline:\\n \\n self.close_connection = 1\\n \\n return\\n \\n if not self.parse_request():\\n \\n # An error code has been sent, just exit\\n \\n return\\n \\n mname = 'do_' + self.command\\n \\n if not hasattr(self, mname):\\n \\n self.send_error(501, \\\"Unsupported method (%r)\\\" % self.command)\\n \\n return\\n \\n method = getattr(self, mname)\\n \\n print \\\"before call do_Get\\\"\\n \\n method()\\n \\n #增加 debug info 及 wfile 判断是否已经 close\\n \\n print \\\"after call do_Get\\\"\\n \\n if not self.wfile.closed:\\n self.wfile.flush() #actually send the response if not already done.\\n \\n print \\\"after wfile.flush()\\\"\\n \\n except socket.timeout, e:\\n \\n #a read or a write timed out. Discard this connection\\n self.log_error(\\\"Request timed out: %r\\\", e)\\n self.close_connection = 1\\n return\",\n \"def _handle_get_request(self):\\n docroot = self._get_config_value('main', 'staticdocumentroot')\\n local_path = sanitize_path(self.path)\\n path = docroot + local_path\\n try:\\n # actually try deliver the requested file - First we try to send\\n # every static content\\n requested_file = open(path)\\n text = requested_file.read()\\n requested_file.close()\\n except IOError:\\n try:\\n parsed_path = urlparse(self.path)\\n params = dict([p.split('=') for p in parsed_path[4].split('&')])\\n if params['addurl']:\\n tmp = self._insert_url_to_db(params['addurl'])\\n if tmp and tmp < 0:\\n self._send_database_problem()\\n return\\n blocked = self._db.is_hash_blocked(tmp)\\n if blocked:\\n self._send_blocked_page(blocked[3])\\n return\\n elif tmp:\\n self._send_return_page(tmp)\\n return\\n else:\\n # There was a general issue with URL\\n self._send_homepage('''<p class=\\\"warning\\\">Please check your input.</p>''')\\n return\\n else:\\n # There was a general issue with URL\\n self._send_homepage('''<p class=\\\"warning\\\">Please check your input.</p>''')\\n return\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n except:\\n if self.path in ('/', '/URLRequest'):\\n self._send_homepage()\\n return\\n elif self.path.startswith('/stats') or self.path.endswith('+'):\\n if self.path == '/stats':\\n # Doing general statistics here\\n # Let's hope this page is not getting to popular ....\\n # Create a new stats objekt which is fetching data in background\\n self._show_general_stats()\\n return\\n else:\\n # Check whether we do have the + or the stats kind of URL\\n if self.path.endswith('+'):\\n # Well I guess this is the proof you can write\\n # real ugly code in Python too.\\n try:\\n if self.path.startswith('/show/'):\\n request_path = self.path[6:]\\n elif self.path.startswith('/s/'):\\n request_path = self.path[3:]\\n elif self.path.startswith('/stats/'):\\n request_path = self.path[7:]\\n else:\\n request_path = self.path[1:]\\n self._show_link_stats(request_path[:request_path.rfind('+')])\\n return\\n except Exception, e:\\n # Oopps. Something went wrong. Most likely\\n # a malformed link\\n # TODO raise a (yet to be written) FileNotFoundException\\n self._logger.error(\\n u'An exception occurred: %s' % unicode(e), exc_info=True)\\n self._send_404()\\n return\\n else:\\n # Trying to understand for which link we shall print\\n # out stats.\\n splitted = self.path[1:].split('/')\\n try:\\n self._show_link_stats(splitted[1])\\n return\\n except IndexError:\\n # Something went wrong. Most likely there was a\\n # malformed URL for accessing the stats.\\n self._send_404()\\n return\\n # Any other page\\n else:\\n # First check, whether we want to have a real redirect\\n # or just an info\\n request_path = self.path\\n if self.path.startswith('/show/'):\\n request_path = self.path[5:]\\n show = True\\n elif self.path.startswith('/s/'):\\n request_path = self.path[2:]\\n show = True\\n else:\\n show = False\\n # Assuming, if there is anything else than an\\n # alphanumeric character after the starting /, it's\\n # not a valid hash at all\\n if request_path[1:].isalnum():\\n try:\\n result = self._db.get_link_from_db(request_path[1:])\\n blocked = self._db.is_hash_blocked(request_path[1:])\\n except YuDatabaseError:\\n self._send_database_problem()\\n return\\n if result and blocked == None:\\n if show == True:\\n template_filename = self._get_config_template('showpage')\\n url = \\\"/\\\" + request_path[1:]\\n new_url = '<p><a href=\\\"%(url)s\\\">%(result)s</a></p>' % \\\\\\n {'result': result, 'url': url}\\n stats = self._db.get_statistics_for_hash(request_path[1:])\\n text = read_template(\\n template_filename,\\n title=SERVER_NAME,\\n header=SERVER_NAME,\\n msg=new_url,\\n stat=stats,\\n statspage=\\\"/stats/\\\" + request_path[1:])\\n else:\\n self._db.add_logentry_to_database(request_path[1:])\\n self._send_301(result)\\n return\\n elif blocked:\\n self._send_blocked_page(blocked[3])\\n return\\n else:\\n self._send_404()\\n return\\n else:\\n self._send_404()\\n return\\n self._send_response(text, 200)\",\n \"def do_GET(self):\\n global st_point, cur_request\\n if time.time() - st_point < 1 and cur_request > args.MAX_REQ:\\n self.send_response(429)\\n self.send_header(\\\"Content-type\\\",\\\"text/html\\\")\\n self.end_headers()\\n time.sleep(0.2)\\n return\\n elif time.time() - st_point > 1:\\n st_point = time.time()\\n cur_request = 1\\n self.func_PARSE()\\n if self.parsed_url[2] in [\\\"/ping\\\", \\\"/cats\\\"]:\\n self.func_DO()\\n else:\\n self.send_response(400)\\n text=\\\"<h1 align=center>Bad request</h1>\\\"\\n self.func_PRINT(text)\",\n \"def run(self):\\n while self.running:\\n self.handle_request()\",\n \"def process_request_starts(self, request):\\n pass\",\n \"def _listen_to_requests(self):\\n while True:\\n try:\\n request = self._client.recv(1024)\\n except socket.error as err:\\n if DEBUG_LEVEL >= 1:\\n print \\\"Got socket error: {}\\\".format(err.message)\\n self._client.close()\\n return True\\n\\n if not request:\\n if DEBUG_LEVEL >= 0:\\n print \\\"Closing connection\\\"\\n self._client.close()\\n return True\\n\\n if DEBUG_LEVEL >= 2:\\n print request\\n\\n if not HTTPValidation.validate_request(request):\\n if DEBUG_LEVEL >= 0:\\n print \\\"Invalid request, closing...\\\"\\n self._client.send(public_response_functions.get_error_response())\\n self._client.close()\\n return True\\n\\n if not self._send_response(request):\\n if DEBUG_LEVEL >= 0:\\n print \\\"Closing connection...\\\"\\n self._client.close()\\n return\",\n \"def on_server_start(self, server):\\n pass\",\n \"def __init__(self, server_address,db,RequestHandlerClass):\\n self.db = db\\n http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)\",\n \"def handle_request(request, client, stat):\\n\\n # Parse headers\\n print(\\\"Request:\\\"+request)\\n headers = request.split('\\\\n')\\n re = Request(headers=headers)\\n\\n # Fazer log do sucedido\\n add_log(client.getpeername(), re.path)\\n\\n # Ir buscar a cache o ficheiro\\n response = stat.get_from_cache(re.path)\\n\\n if response is not None:\\n return response\\n\\n # Se nao houver a resposta em cache entao vai criar uma nova\\n time.sleep(0.1)\\n\\n try:\\n if re.isPrivate():\\n response = Response(status=\\\"HTTP/1.0 403 Forbidden\\\", body=\\\"Private link\\\",\\n connectionType=\\\"close\\\")\\n stat.add_cache(response, re.path)\\n return response\\n\\n body = re.getContent()\\n\\n # Restorna so o cabeçalho\\n if re.verbo == \\\"HEAD\\\":\\n response = Response(status=\\\"HTTP/1.0 200 OK\\\", connectionType=\\\"close\\\", length=len(body))\\n stat.add_cache(response, re.path)\\n return response\\n\\n # If is a Bad Request\\n except PermissionError:\\n response = Response(status=\\\"HTTP/1.0 400 Bad Request\\\", body=\\\"Bad Request\\\", connectionType=\\\"close\\\")\\n stat.add_cache(response, re.path)\\n return response\\n\\n # If the file doesn't exist\\n except FileNotFoundError:\\n response = Response(status=\\\"HTTP/1.0 404 Not Found\\\", body=\\\"File Not Found\\\", connectionType=\\\"close\\\")\\n stat.add_cache(response, re.path)\\n return response\\n\\n # Return response\\n response = Response(status=\\\"HTTP/1.0 200 OK\\\", body=body, contentType=re.filetype,\\n connectionType=re.connectionType, length=len(body))\\n stat.add_cache(response, re.path)\\n return response\",\n \"def on_open(self):\\n def event_loop():\\n logger.debug(pformat(self.query.request))\\n self.send(json.dumps(self.query.request))\\n while not self.event.is_set():\\n #print('Waiting around on the socket: %s' % self.gettimeout())\\n self.event.wait(self.gettimeout())\\n \\n logger.debug('Event loop terminating.')\\n \\n self.thread = threading.Thread(\\n target=event_loop)\\n self.thread.setDaemon(True)\\n self.thread.start()\",\n \"def on_iteration(self):\\n self.send_pending_requests()\\n super().on_iteration()\",\n \"def done(self):\\n ## All done with the request object\\n self.closed = True\\n self.d.callback('')\",\n \"def handle(self):\\n try:\\n # Wait for data\\n data = json.loads(self.request.recv(1024).decode('UTF-8').strip())\\n\\n # Process data\\n self.process_data(data)\\n\\n except Exception as e:\\n print(\\\"Exception wile receiving message: \\\", e)\\n self.request.sendall(\\n bytes(json.dumps({'return': 'error'}), 'UTF-8'))\",\n \"def request(self, url, *args, **kwargs):\\n raise NotImplementedError\",\n \"def work(self, request):\\n raise NotImplementedError\",\n \"def start(self):\\n self.get(self.url)\",\n \"def handle_one_request(self):\\n import socket\\n try:\\n self.raw_requestline = self.rfile.readline(65537)\\n if len(self.raw_requestline) > 65536:\\n self.requestline = ''\\n self.request_version = ''\\n self.command = ''\\n self.send_error(414)\\n return\\n if not self.raw_requestline:\\n self.close_connection = 1\\n return\\n if not self.parse_request():\\n # An error code has been sent, just exit\\n return\\n\\n ##### Customization\\n # origin\\n \\\"\\\"\\\"\\n mname = 'do_' + self.command\\n if not hasattr(self, mname):\\n self.send_error(501, \\\"Unsupported method (%r)\\\" % self.command)\\n return\\n method = getattr(self, mname)\\n method()\\n \\\"\\\"\\\"\\n # now\\n #import pdb; pdb.set_trace()\\n self.delegate(self.get_environ(), self.gen_response, self.send_error)\\n\\n self.wfile.flush() #actually send the response if not already done.\\n except socket.timeout, e:\\n #a read or a write timed out. Discard this connection\\n self.log_error(\\\"Request timed out: %r\\\", e)\\n self.close_connection = 1\\n return\",\n \"def request_received(self, event):\\n log.debug(\\\"request received, stream %s\\\", event.stream_id)\",\n \"def __manage_client_thread(self, conn_socket: socket.socket, address: tuple):\\n print(\\\"[THREAD] new thread started for client\\\")\\n connected = True\\n\\n while connected:\\n request_header = HttpServer.get_request_header(conn_socket)\\n split_request_header = request_header.split()\\n file = split_request_header[1]\\n print(\\\"[RECV] header received from IPv4 address\\\", address[0], \\\":\\\", request_header)\\n\\n if not HttpServer.is_valid_http_request(split_request_header):\\n http_message = HttpServer.create_400_response()\\n pass\\n else:\\n if file == \\\"/\\\":\\n file = \\\"/index.html\\\"\\n\\n put_or_post = HttpServer.is_put_or_post(split_request_header)\\n try:\\n if put_or_post:\\n request_body = HttpServer.get_request_body(conn_socket, request_header)\\n status_code = HttpServer.get_status_code_for_put_or_post(request_header, file)\\n\\n if status_code == 204:\\n if split_request_header[0] == \\\"PUT\\\":\\n f = open(file[1:], \\\"w\\\")\\n else:\\n f = open(file[1:], \\\"a\\\")\\n\\n f.write(request_body)\\n f.close()\\n http_message = HttpServer.create_204_response()\\n elif status_code == 501:\\n http_message = HttpServer.create_501_response()\\n else: # status code is 201\\n f = open(file[1:], \\\"x\\\")\\n f.write(request_body)\\n f.close()\\n http_message = self.create_201_response(file)\\n\\n else:\\n if split_request_header[0] == \\\"GET\\\":\\n # GET needs filename\\n status_code = HttpServer.get_status_code_for_get(request_header, file)\\n else:\\n status_code = HttpServer.get_status_code_for_head(file)\\n\\n if status_code == 404:\\n http_message = HttpServer.create_404_response()\\n elif status_code == 304:\\n http_message = HttpServer.create_304_response()\\n else: # status code is 200\\n http_message = HttpServer.create_200_response(file)\\n except Exception:\\n http_message = HttpServer.create_500_response()\\n\\n conn_socket.send(http_message)\\n\\n # determine if connection has to be closed\\n conn_str = \\\"Connection:\\\"\\n conn_begin_ind = request_header.find(conn_str)\\n\\n if conn_begin_ind != -1:\\n conn_end_ind = request_header[conn_begin_ind:].find(\\\"\\\\r\\\\n\\\") + conn_begin_ind\\n conn_status = request_header[conn_begin_ind+len(conn_str):conn_end_ind].strip()\\n if conn_status == \\\"close\\\":\\n conn_socket.close()\\n connected = False\\n print(\\\"[THREAD] client thread ended\\\")\",\n \"def process_request(self, req):\\n return None\",\n \"def request_handler(client_connection, request_path, request_proto, response_code, response_string, response_body,\\r\\n is_request_valid):\\r\\n\\r\\n response_headers = {}\\r\\n client_connection.send_header('Access-Control-Allow-Origin', '*')\\r\\n client_connection.send(\\\"%s %s %s\\\\r\\\\n\\\" % (request_proto, response_code, response_string))\\r\\n\\r\\n if is_request_valid:\\r\\n response_headers['Date'] = datetime.datetime.now().strftime('%a, %d %b %Y %H:%M:%S %Z')\\r\\n response_headers['Last-Modified'] = datetime.datetime.fromtimestamp(\\r\\n int(os.path.getmtime(os.getcwd() + request_path))).strftime('%a, %d %b %Y %H:%M:%S %Z')\\r\\n response_headers['Server'] = 'bing_2.0 (Unix)'\\r\\n response_headers['Content-Length'] = os.path.getsize(os.getcwd() + request_path)\\r\\n response_headers['Content-Type'] = mimetypes.guess_type(os.getcwd() + request_path)[0]\\r\\n if request_path == '/www/access_list.txt':\\r\\n response_headers['Content-Type'] = 'text/html'\\r\\n if response_headers['Content-Type'] is None:\\r\\n response_headers['Content-Type'] = 'application/octet-stream'\\r\\n client_connection.send(''.join('%s: %s\\\\n' % (k, v) for k, v in response_headers.iteritems()))\\r\\n\\r\\n client_connection.send(\\\"\\\\n\\\")\\r\\n client_connection.send(response_body)\",\n \"def on_response(self, response):\\n log.debug(\\\"Received response: %s\\\", response)\",\n \"def serve(self, request, *args, **kwargs):\\n raise Http404\",\n \"def serve(self, request, *args, **kwargs):\\n raise Http404\",\n \"def serve(self, request, *args, **kwargs):\\n raise Http404\",\n \"def serve(self, request, *args, **kwargs):\\n raise Http404\",\n \"def serve(self, request, *args, **kwargs):\\n raise Http404\",\n \"def do_POST(self): # pylint: disable=invalid-name\\n self.handle_request()\",\n \"def get(self, request):\\n pass\",\n \"def main():\\n host = ''\\n port = 8088\\n HTTPServer((host, port), HandleRequests).serve_forever()\",\n \"def serve(self):\\n\\t\\tself.keep_running=1\\n\\t\\tif self.debug:\\n\\t\\t\\tprint \\\"server started\\\"\\n\\t\\ttry:\\n\\t\\t\\twhile self.keep_running:\\n\\t\\t\\t\\tself.handle_request()\\n\\t\\tfinally:\\n\\t\\t\\tif self.debug:\\n\\t\\t\\t\\tprint \\\"server finished\\\"\\n\\t\\t\\tself.keep_running=0\\n\\t\\t\\tself.close()\",\n \"def __init__( request ):\",\n \"def _request(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def handle_request(self, data, peer):\\n\\n req = Request.parse(data)\\n if req:\\n handler = self.get_hanlder(\\n req, (self.host, self.port), peer, \\n self._retries, self._timeout\\n )\\n handler.run()\",\n \"def _request_ended(self, reply):\\n\\n if reply.attribute(QNetworkRequest.HttpStatusCodeAttribute):\\n self.http_resources.append(HttpResource(reply, self.cache))\",\n \"def callback_connect(self):\\n pass\",\n \"def callback_connect(self):\\n pass\",\n \"def callback_connect(self):\\n pass\",\n \"def process_data(request, response, resource):\\n response.set_header('Access-Control-Allow-Origin', '*')\",\n \"def dispatch(self):\\n handler_start_time = time.time()\\n\\n logging.info('\\\\n\\\\n\\\\nRequest handler: %r', self)\\n count0, count1, count2 = gc.get_count()\\n logging.info('gc counts: %d %d %d', count0, count1, count2)\\n GC_COUNT.add(count0, {'generation': 0})\\n GC_COUNT.add(count1, {'generation': 1})\\n GC_COUNT.add(count2, {'generation': 2})\\n\\n self.mr = monorailrequest.MonorailRequest(self.services)\\n\\n self.ratelimiter.CheckStart(self.request)\\n self.response.headers.add('Strict-Transport-Security',\\n 'max-age=31536000; includeSubDomains')\\n\\n if 'X-Cloud-Trace-Context' in self.request.headers:\\n self.mr.profiler.trace_context = (\\n self.request.headers.get('X-Cloud-Trace-Context'))\\n if trace_service is not None:\\n self.mr.profiler.trace_service = trace_service\\n\\n if self.services.cache_manager:\\n # TODO(jrobbins): don't do this step if invalidation_timestep was\\n # passed via the request and matches our last timestep\\n try:\\n with self.mr.profiler.Phase('distributed invalidation'):\\n self.services.cache_manager.DoDistributedInvalidation(self.mr.cnxn)\\n\\n except MySQLdb.OperationalError as e:\\n logging.exception(e)\\n page_data = {\\n 'http_response_code': httplib.SERVICE_UNAVAILABLE,\\n 'requested_url': self.request.url,\\n }\\n self.template = template_helpers.GetTemplate(\\n 'templates/framework/database-maintenance.ezt',\\n eliminate_blank_lines=self._ELIMINATE_BLANK_LINES)\\n self.template.WriteResponse(\\n self.response, page_data, content_type='text/html')\\n return\\n\\n try:\\n with self.mr.profiler.Phase('parsing request and doing lookups'):\\n self.mr.ParseRequest(self.request, self.services)\\n\\n self.response.headers['X-Frame-Options'] = 'SAMEORIGIN'\\n webapp2.RequestHandler.dispatch(self)\\n\\n except exceptions.NoSuchUserException as e:\\n logging.warning('Trapped NoSuchUserException %s', e)\\n self.abort(404, 'user not found')\\n\\n except exceptions.NoSuchGroupException as e:\\n logging.warning('Trapped NoSuchGroupException %s', e)\\n self.abort(404, 'user group not found')\\n\\n except exceptions.InputException as e:\\n logging.info('Rejecting invalid input: %r', e)\\n self.response.status = httplib.BAD_REQUEST\\n\\n except exceptions.NoSuchProjectException as e:\\n logging.info('Rejecting invalid request: %r', e)\\n self.response.status = httplib.NOT_FOUND\\n\\n except xsrf.TokenIncorrect as e:\\n logging.info('Bad XSRF token: %r', e.message)\\n self.response.status = httplib.BAD_REQUEST\\n\\n except permissions.BannedUserException as e:\\n logging.warning('The user has been banned')\\n url = framework_helpers.FormatAbsoluteURL(\\n self.mr, urls.BANNED, include_project=False, copy_params=False)\\n self.redirect(url, abort=True)\\n\\n except ratelimiter.RateLimitExceeded as e:\\n logging.info('RateLimitExceeded Exception %s', e)\\n self.response.status = httplib.BAD_REQUEST\\n self.response.body = 'Slow your roll.'\\n\\n finally:\\n self.mr.CleanUp()\\n self.ratelimiter.CheckEnd(self.request, time.time(), handler_start_time)\\n\\n total_processing_time = time.time() - handler_start_time\\n logging.warn('Processed request in %d ms',\\n int(total_processing_time * 1000))\\n\\n end_count0, end_count1, end_count2 = gc.get_count()\\n logging.info('gc counts: %d %d %d', end_count0, end_count1, end_count2)\\n if (end_count0 < count0) or (end_count1 < count1) or (end_count2 < count2):\\n GC_EVENT_REQUEST.increment()\\n\\n if settings.enable_profiler_logging:\\n self.mr.profiler.LogStats()\\n\\n if (self.mr.profiler.trace_context is not None and\\n random.random() < settings.trace_fraction):\\n self.mr.profiler.ReportTrace()\",\n \"def connectionMade(self):\\n \\t#print \\\"[K] Connect effettuata\\\", self.port\\n \\tself.factory.state=\\\"0 open\\\"\\n \\tif (self.port in self.portfForHTTPGet):\\n\\t\\tself.transport.write(\\\"GET / HTTP/1.1\\\\r\\\\n\\\\r\\\\n\\\")\\n \\t\\t#self.transport.write(\\\"GET /index.html HTTP/1.1\\\\r\\\\n\\\\r\\\\n\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68035215","0.66667825","0.66151416","0.6559298","0.64284265","0.6419971","0.6418524","0.6417652","0.63845855","0.6382211","0.6347527","0.6285853","0.6277875","0.6248943","0.6248943","0.6242948","0.6242948","0.624212","0.6197155","0.6197155","0.6190355","0.61887485","0.6186611","0.61806774","0.61738735","0.61666226","0.6101814","0.6092928","0.6085743","0.60811466","0.6061392","0.6055404","0.60254455","0.60169506","0.60137373","0.601272","0.59955055","0.5969965","0.5969965","0.5950412","0.59310627","0.589702","0.5880718","0.5878184","0.5872583","0.58703613","0.58559346","0.58532447","0.5846385","0.584461","0.58389163","0.58389163","0.58344984","0.58293545","0.5809088","0.5798712","0.578855","0.57710147","0.5770809","0.5768808","0.5756951","0.57564986","0.5754351","0.57445997","0.5737185","0.5729618","0.57262605","0.57234097","0.57233006","0.5715182","0.5692718","0.56866854","0.56858796","0.56837404","0.56806546","0.5679698","0.56652564","0.5655882","0.56537026","0.5650971","0.564215","0.5628468","0.56277585","0.56277585","0.56277585","0.56277585","0.56277585","0.56215906","0.56164175","0.5613448","0.56132615","0.5611002","0.56095546","0.5594332","0.5592498","0.5588481","0.5588481","0.5588481","0.55854315","0.5583978","0.55755085"],"string":"[\n \"0.68035215\",\n \"0.66667825\",\n \"0.66151416\",\n \"0.6559298\",\n \"0.64284265\",\n \"0.6419971\",\n \"0.6418524\",\n \"0.6417652\",\n \"0.63845855\",\n \"0.6382211\",\n \"0.6347527\",\n \"0.6285853\",\n \"0.6277875\",\n \"0.6248943\",\n \"0.6248943\",\n \"0.6242948\",\n \"0.6242948\",\n \"0.624212\",\n \"0.6197155\",\n \"0.6197155\",\n \"0.6190355\",\n \"0.61887485\",\n \"0.6186611\",\n \"0.61806774\",\n \"0.61738735\",\n \"0.61666226\",\n \"0.6101814\",\n \"0.6092928\",\n \"0.6085743\",\n \"0.60811466\",\n \"0.6061392\",\n \"0.6055404\",\n \"0.60254455\",\n \"0.60169506\",\n \"0.60137373\",\n \"0.601272\",\n \"0.59955055\",\n \"0.5969965\",\n \"0.5969965\",\n \"0.5950412\",\n \"0.59310627\",\n \"0.589702\",\n \"0.5880718\",\n \"0.5878184\",\n \"0.5872583\",\n \"0.58703613\",\n \"0.58559346\",\n \"0.58532447\",\n \"0.5846385\",\n \"0.584461\",\n \"0.58389163\",\n \"0.58389163\",\n \"0.58344984\",\n \"0.58293545\",\n \"0.5809088\",\n \"0.5798712\",\n \"0.578855\",\n \"0.57710147\",\n \"0.5770809\",\n \"0.5768808\",\n \"0.5756951\",\n \"0.57564986\",\n \"0.5754351\",\n \"0.57445997\",\n \"0.5737185\",\n \"0.5729618\",\n \"0.57262605\",\n \"0.57234097\",\n \"0.57233006\",\n \"0.5715182\",\n \"0.5692718\",\n \"0.56866854\",\n \"0.56858796\",\n \"0.56837404\",\n \"0.56806546\",\n \"0.5679698\",\n \"0.56652564\",\n \"0.5655882\",\n \"0.56537026\",\n \"0.5650971\",\n \"0.564215\",\n \"0.5628468\",\n \"0.56277585\",\n \"0.56277585\",\n \"0.56277585\",\n \"0.56277585\",\n \"0.56277585\",\n \"0.56215906\",\n \"0.56164175\",\n \"0.5613448\",\n \"0.56132615\",\n \"0.5611002\",\n \"0.56095546\",\n \"0.5594332\",\n \"0.5592498\",\n \"0.5588481\",\n \"0.5588481\",\n \"0.5588481\",\n \"0.55854315\",\n \"0.5583978\",\n \"0.55755085\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85157,"cells":{"query":{"kind":"string","value":"Pad x and y so that the results have the same length (second dimension)."},"document":{"kind":"string","value":"def _pad_tensors_to_same_length(x, y):\n with tf.compat.v1.name_scope(\"pad_to_same_length\"):\n x_length = tf.shape(input=x)[1]\n y_length = tf.shape(input=y)[1]\n\n max_length = tf.maximum(x_length, y_length)\n\n x = tf.pad(tensor=x, paddings=[[0, 0], [0, max_length - x_length], [0, 0]])\n y = tf.pad(tensor=y, paddings=[[0, 0], [0, max_length - y_length]])\n return x, y"},"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 pad_vals(x, y):\n\n xshapes = []\n for x_arr in x:\n\n x_arr = np.array(x_arr)\n xshapes.append(x_arr.shape[0])\n\n x_max_shape = np.max(xshapes)\n for i, x_arr in enumerate(x):\n\n pad_len = x_max_shape - x_arr.shape[0]\n x[i] = np.pad(x_arr, (0, pad_len), mode='constant',\n constant_values=np.NaN)\n y[i] = np.pad(y[i], (0, pad_len), mode='constant',\n constant_values=np.NaN)\n\n x = np.vstack(x).astype(np.float64)\n y = np.vstack(y).astype(np.float64)\n return x, y","def pad_spatial(self, x):\n n, t, c, h, w = x.size()\n\n pad_h = (4 - h % 4) % 4\n pad_w = (4 - w % 4) % 4\n\n # padding\n x = x.view(-1, c, h, w)\n x = F.pad(x, [0, pad_w, 0, pad_h], mode='reflect')\n\n return x.view(n, t, c, h + pad_h, w + pad_w)","def test_pad_coords_matrices(self):\r\n # first is longer\r\n m1 = array([[1, 0, 3, 9, 4],\r\n [4, 5, 6, 94, 5],\r\n [7, 8, 9, 6, 6],\r\n [10, 11, 12, 4, 6]])\r\n m2 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\r\n m2_expected = array([[1, 2, 3, 0., 0.], [4, 5, 6, 0., 0.],\r\n [7, 8, 9, 0., 0.], [10, 11, 12, 0., 0.]])\r\n actual = pad_coords_matrices(m1, m2)\r\n expected = (m1, m2_expected)\r\n assert_almost_equal(actual, expected)\r\n\r\n # second is longer\r\n m1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\r\n m2 = array(\r\n [[1, 2, 3, 9], [4, 5, 6, 94], [7, 8, 9, 6], [10, 11, 12, 4]])\r\n m1_expected = array(\r\n [[1, 2, 3, 0.], [4, 5, 6, 0.], [7, 8, 9, 0.], [10, 11, 12, 0.]])\r\n actual = pad_coords_matrices(m1, m2)\r\n expected = (m1_expected, m2)\r\n assert_almost_equal(actual, expected)\r\n\r\n # equal length, so no change\r\n m1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\r\n m2 = array([[0, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\r\n actual = pad_coords_matrices(m1, m2)\r\n expected = (m1, m2)\r\n assert_almost_equal(actual, expected)","def _pad_with_zeros(self, X, margin):\n newX = np.zeros((X.shape[0] + 2 * margin, X.shape[1] + 2 * margin, X.shape[2]))\n x_offset = margin\n y_offset = margin\n newX[x_offset:X.shape[0] + x_offset, y_offset:X.shape[1] + y_offset, :] = X\n return newX","def test_pad():\n x = randtool(\"float\", -10, 10, [3, 2, 1, 2])\n pad = [1, 1, 2, 3]\n mode = \"constant\"\n value = 2.0\n data_format = \"NCHW\"\n res = np.array(\n [\n [\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, -8.88523461, 1.99072967, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 4.45995261, 9.40579439, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n ],\n [\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 6.43138915, 0.55102135, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, -3.37046541, -2.92035609, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n ],\n [\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, -8.41939397, 1.11828761, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, -6.68411074, -4.09524338, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ],\n ],\n ]\n )\n obj.run(res=res, x=x, pad=pad, mode=mode, value=value, data_format=data_format)","def _pad(x, depth=4):\n divisor = np.power(2, depth)\n remainder = x.shape[0] % divisor\n\n # no padding because already of even shape\n if remainder == 0:\n return x\n # add zero rows after 1D feature\n elif len(x.shape) == 2:\n return np.pad(x, [(0, divisor - remainder), (0, 0)], \"constant\")\n # add zero columns and rows after 2D feature\n elif len(x.shape) == 3:\n return np.pad(x, [(0, divisor - remainder), (0, divisor - remainder),\n (0, 0)], \"constant\")","def reflection_pad2d(self, x, pad=1):\n x = torch.cat([torch.flip(x[:, :, 1:pad + 1, :], [2]), x, torch.flip(x[:, :, -pad - 1:-1, :], [2])], 2)\n x = torch.cat([torch.flip(x[:, :, :, 1:pad + 1], [3]), x, torch.flip(x[:, :, :, -pad - 1:-1], [3])], 3)\n return x","def pad(x, pad_left=0, pad_right=0, to_complex=True):\n output = pad_1d(x, pad_left, pad_right, mode='reflect')\n if to_complex:\n output = torch.stack((output, torch.zeros_like(output)), dim=-1)\n return output","def _padding(self, x, shape, value=0):\n row_padding = shape[0] - x.shape[0]\n col_padding = shape[1] - x.shape[1]\n return np.pad(x, [[0, row_padding], [0, col_padding]], mode=\"constant\", constant_values=value)","def _pad1d(self, x: torch.Tensor, padding_left: int, padding_right: int, mode: str = \"zero\", value: float = 0.0):\n length = x.shape[-1]\n if mode == \"reflect\":\n max_pad = max(padding_left, padding_right)\n if length <= max_pad:\n x = F.pad(x, (0, max_pad - length + 1))\n return F.pad(x, (padding_left, padding_right), mode, value)","def image_pad(image, pixel_loc_x, pixel_loc_y):\r\n input_size = np.shape(image)\r\n padded_image = np.zeros((input_size[0]+200, input_size[1]+200, 1))\r\n if np.size(input_size) == 2:\r\n padded_image[:, :, 0] = skut.pad(image[:, :], 100, mode='constant', constant_values=float(0))\r\n else:\r\n for i in range(input_size[2]):\r\n if i == 0:\r\n padded_image[:, :, 0] = skut.pad(image[:, :, i], 100, mode='constant', constant_values=float(0))\r\n else:\r\n padded_dim = np.zeros((input_size[0]+200, input_size[1]+200, 1))\r\n padded_dim[:, :, 0] = skut.pad(image[:, :, i], 100, mode='constant', constant_values=float(0))\r\n padded_image = np.append(padded_image, padded_dim, axis=2)\r\n pixel_loc_x = pixel_loc_x + 100\r\n pixel_loc_y = pixel_loc_y + 100\r\n return padded_image, pixel_loc_x, pixel_loc_y","def pad(x, padding, fill_value=0):\n input_shape = x.shape\n output_shape = []\n indices = []\n\n for dim, pad in enumerate(padding):\n try:\n left_pad, right_pad = pad\n except TypeError:\n left_pad = right_pad = pad\n output_shape.append(left_pad + input_shape[dim] + right_pad)\n indices.append(slice(left_pad, left_pad + input_shape[dim]))\n\n if fill_value:\n out = T.ones(output_shape) * fill_value\n else:\n out = T.zeros(output_shape)\n return T.set_subtensor(out[tuple(indices)], x)","def pad_with_border(x, n_pad):\n x_pad_list = [x[0:1]] * int(n_pad) + [x] + [x[-1:]] * int(n_pad)\n return np.concatenate(x_pad_list, axis=0)","def pad(self, nxp, nyp):\n assert (nxp > self.nx)\n assert (nyp > self.ny)\n assert (np.mod(nxp - self.nx, 2) == 0)\n assert (np.mod(nyp - self.ny, 2) == 0)\n\n ret = rmap(nx=nxp, dx=self.dx, ny=nyp, dy=self.dy)\n ret.map[(nyp - self.ny) / 2:(nyp + self.ny) / 2, (nxp - self.nx) / 2:(\n nxp + self.nx) / 2] = self.map\n return ret","def test_pad_and_concatenate_with_1d(self):\n array1 = 1.0\n array2 = 2.0\n result = numpy_pad_and_concatenate(array1, array2)\n self.assertTrue(np.array_equal(np.array([1.0, 2.0]), result))\n\n tensor1 = torch.tensor(1.0)\n tensor2 = torch.tensor(2.0)\n result = torch_pad_and_concatenate(tensor1, tensor2)\n self.assertTrue(torch.equal(result, torch.Tensor([1.0, 2.0])))","def pad_arrays(arrays, batch_size):\n\n rows_needed = batch_size - len(arrays[\"y\"]) % batch_size\n return {k: np.pad(v, [(0,rows_needed)] + [(0,0)]*(len(v.shape)-1), \"edge\") for k,v in arrays.items()}","def pad2D(X, pad, kernel_shape=None, stride=None, dilation=0):\n\tX_pad = None\n\tp = pad\n\tif isinstance(p, int):\n\t\tp = (p, p, p, p)\n\n\tif isinstance(p, tuple):\n\t\tif len(p) == 2:\n\t\t\tp = (p[0], p[0], p[1], p[1])\n\n\t\t\tX_pad = np.pad(\n\t\t\t\tX, \n\t\t\t\tpad_width=((0, 0), (p[0], p[1]), (p[2], p[3]), (0, 0)),\n\t\t\t\tmode=\"constant\",\n\t\t\t\t# constant_values=0,\n\t\t\t\t)\n\n\t# compute the crrect padding dims for a 'same' convolution\n\tif p == 'same' and kernel_shape and stride is not None:\n\t\tp = calc_pad_dims_2D(\n\t\t\tX.shape, X.shape[1:3], kernel_shape, sride, dilation=dilation\n\t\t\t)\n\t\tX_pad, p = pad2D(X, p)\n\treturn X_pad, p","def pad_square(box):\n x, y, xw, yh = box\n w = xw-x\n h = yh-y\n if w < h:\n w = h\n elif h < w:\n h = w\n return [x, y, x+w, y+h]","def pad(self, src):\n if(self.pre_pad):\n dst = src.new(\n src.size(0),\n src.size(1),\n src.size(2),\n src.size(3),\n 2\n ).zero_()\n dst.narrow(dst.ndimension()-1, 0, 1).copy_(\n torch.unsqueeze(src, 4)\n )\n else:\n padded = self.padding_module.updateOutput(src)\n dst = src.new(\n padded.size(0),\n padded.size(1),\n padded.size(2),\n padded.size(3),\n 2\n ).zero_()\n dst.narrow(4, 0, 1).copy_(\n torch.unsqueeze(padded, 4)\n )\n return dst","def pad_1d(x, pad_left, pad_right, mode='constant', value=0.):\n if (pad_left >= x.shape[-1]) or (pad_right >= x.shape[-1]):\n if mode == 'reflect':\n raise ValueError('Indefinite padding size (larger than tensor).')\n res = F.pad(x.unsqueeze(2),\n (pad_left, pad_right, 0, 0),\n mode=mode, value=value).squeeze(2)\n return res","def pad(x, system_shape, pad_size):\n res = unpad(tf.tile(x, (1,)+(3,)*len(pad_size)),\n tuple(s-p for s, p in zip(system_shape, pad_size)))\n return res","def add_padding(x, maxlen=500):\n \n # May want to increase maxlen from 500! Not sure the total dist of chomragram lengths.\n\n for i in range(len(x)):\n x[i] = x[i][:,:maxlen]\n q = maxlen - x[i].shape[1]\n p = q//2\n# if q % 2 == 0:\n# x[i] = np.pad(x[i], ((p,p), (0,0)), 'constant', constant_values=(0,0))\n# else:\n# x[i] = np.pad(x[i], ((p,p+1), (0,0)), 'constant', constant_values=(0,0))\n\n print\n if q % 2 == 0:\n x[i] = np.pad(x[i], ((0,0), (p,p)), 'constant', constant_values=(0,0))\n else:\n x[i] = np.pad(x[i], ((0,0), (p,p+1)), 'constant', constant_values=(0,0))\n \n return x","def test_pad_8():\n paddle.disable_static()\n x = np.array([[[[1.0, 3.0], [-3.0, 1.0]]]])\n pad = [1, 1, 1, 2]\n mode = \"constant\"\n value = np.array(2.0)\n data_format = \"NCHW\"\n res = np.array(\n [\n [\n [\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 1.0, 3.0, 2.0],\n [2.0, -3.0, 1.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n [2.0, 2.0, 2.0, 2.0],\n ]\n ]\n ]\n )\n exp = paddle.nn.functional.pad(\n x=paddle.to_tensor(x), pad=pad, mode=mode, value=paddle.to_tensor(value), data_format=data_format\n )\n assert np.allclose(exp.numpy(), res)","def steppify(x, y):\n dx = 0.5 * (x[1:] + x[:-1])\n xx = np.zeros( 2 * len(dx), dtype=float)\n yy = np.zeros( 2 * len(y), dtype=float)\n xx[0::2], xx[1::2] = dx, dx\n yy[0::2], yy[1::2] = y, y\n xx = np.concatenate(([x[0] - (dx[0] - x[0])], xx, [x[-1] + (x[-1] - dx[-1])]))\n return xx, yy","def pad_shorter(a, b, ii=0):\n # global data_orig\n # global data_new\n diff = a[ii].size - b[ii].size\n # print(\"diff\", diff)\n if (diff > 0):\n b = np.concatenate((np.zeros(\n (b.shape[0], diff//2)), b, np.zeros((b.shape[0], diff - diff//2))), axis=1)\n elif (diff < 0):\n diff = -diff\n a = np.concatenate((np.zeros(\n (a.shape[0], diff//2)), a, np.zeros((a.shape[0], diff - diff//2))), axis=1)\n\n return (a, b)","def _pad(phi, det):\r\n npadx = (det.x - phi.shape[1]) // 2\r\n npady = (det.y - phi.shape[1]) // 2\r\n return np.pad(phi, ((0, 0), (npadx, npadx), (npady, npady)), mode='constant')","def pad_to(image,w,h):\n iw,ih = image.shape\n wd = int(w-iw)\n assert wd>=0\n w0 = wd/2\n w1 = wd-w0\n hd = int(h-ih)\n assert hd>=0\n h0 = hd/2\n h1 = hd-h0\n result = zeros((w,h))\n result[w0:w0+iw,h0:h0+ih] = image\n return result","def realign(self, x, dx, y, dy, ignore=set()):\n return ['', '', '']","def _set_wrap_both(padded, axis, width_pair, original_period):\n left_pad, right_pad = width_pair\n period = padded.shape[axis] - right_pad - left_pad\n # Avoid wrapping with only a subset of the original area by ensuring period\n # can only be a multiple of the original area's length.\n period = period // original_period * original_period\n\n # If the current dimension of `arr` doesn't contain enough valid values\n # (not part of the undefined pad area) we need to pad multiple times.\n # Each time the pad area shrinks on both sides which is communicated with\n # these variables.\n new_left_pad = 0\n new_right_pad = 0\n\n if left_pad > 0:\n # Pad with wrapped values on left side\n # First slice chunk from left side of the non-pad area.\n # Use min(period, left_pad) to ensure that chunk is not larger than\n # pad area.\n slice_end = left_pad + period\n slice_start = slice_end - min(period, left_pad)\n right_slice = _slice_at_axis(slice(slice_start, slice_end), axis)\n right_chunk = padded[right_slice]\n\n if left_pad > period:\n # Chunk is smaller than pad area\n pad_area = _slice_at_axis(slice(left_pad - period, left_pad), axis)\n new_left_pad = left_pad - period\n else:\n # Chunk matches pad area\n pad_area = _slice_at_axis(slice(None, left_pad), axis)\n padded[pad_area] = right_chunk\n\n if right_pad > 0:\n # Pad with wrapped values on right side\n # First slice chunk from right side of the non-pad area.\n # Use min(period, right_pad) to ensure that chunk is not larger than\n # pad area.\n slice_start = -right_pad - period\n slice_end = slice_start + min(period, right_pad)\n left_slice = _slice_at_axis(slice(slice_start, slice_end), axis)\n left_chunk = padded[left_slice]\n\n if right_pad > period:\n # Chunk is smaller than pad area\n pad_area = _slice_at_axis(\n slice(-right_pad, -right_pad + period), axis)\n new_right_pad = right_pad - period\n else:\n # Chunk matches pad area\n pad_area = _slice_at_axis(slice(-right_pad, None), axis)\n padded[pad_area] = left_chunk\n\n return new_left_pad, new_right_pad","def pad_to_size_of(a, b):\n a2 = pad_zeroes(a, 0, b.shape[0] - a.shape[0])\n return pad_zeroes(a2, 1, b.shape[1] - a.shape[1])","def pad(self, nxp, nyp):\n assert (nxp > self.nx)\n assert (nyp > self.ny)\n assert (np.mod(nxp - self.nx, 2) == 0)\n assert (np.mod(nyp - self.ny, 2) == 0)\n\n ret = tqumap(nx=nxp, dx=self.dx, ny=nyp, dy=self.dy)\n for this, that in [[self.tmap, ret.tmap], [self.qmap, ret.qmap],\n [self.umap, ret.umap]]:\n that[(nyp - self.ny) / 2:(nyp + self.ny) / 2, (nxp - self.nx) / 2:(\n nxp + self.nx) / 2] = this\n return ret","def fast_pad_shift(self, y1, y2):\n\n if len(y1) != len(y2):\n raise ValueError(\"Input sizes must be the same\")\n\n y1_contig = np.ascontiguousarray(y1, dtype=np.float64)\n y2_contig = np.ascontiguousarray(y2, dtype=np.float64)\n y1_ptr = y1_contig.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n y2_ptr = y2_contig.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n\n return self.libcalcsim.fast_pad_shift(y1_ptr, y2_ptr, len(y1))","def conv_pad(x, ks, mode):\n\tpad = (int(np.floor((ks-1)/2)), int(np.ceil((ks-1)/2)))\n\treturn F.pad(x, (*pad, *pad), mode=mode)","def pad_to_square(a):\n if a.shape[1]>a.shape[0]: # pad height\n n_to_add = a.shape[1]-a.shape[0]\n top_pad = n_to_add//2\n bottom_pad = n_to_add-top_pad\n a = np.pad(a, [(top_pad, bottom_pad), (0, 0), (0, 0)], mode='constant')\n\n elif a.shape[0]>a.shape[1]: # pad width\n n_to_add = a.shape[0]-a.shape[1]\n left_pad = n_to_add//2\n right_pad = n_to_add-left_pad\n a = np.pad(a, [(0, 0), (left_pad, right_pad), (0, 0)], mode='constant')\n else:\n pass\n return a","def prepare_data(seqs_x, seqs_y, maxlen=None):\n\n lengths_x = [len(s) for s in seqs_x]\n lengths_y = [len(s) for s in seqs_y]\n\n nb_samples = len(seqs_x)\n if maxlen is None:\n maxlen_x = numpy.max(lengths_x)\n maxlen_y = numpy.max(lengths_y)\n else:\n maxlen_x = maxlen\n maxlen_y = maxlen\n\n x_padded = pad_sequences(seqs_x, maxlen_x, nb_samples)\n y_padded = pad_sequences(seqs_y, maxlen_y, nb_samples)\n\n x_padded = numpy.asarray(x_padded)\n y_padded = numpy.asarray(y_padded)\n\n return x_padded, y_padded","def padArray(ori_array, pad_size):\n if (pad_size > 0):\n [x_size, y_size] = ori_array.shape\n lg_array = numpy.ones((x_size+2*pad_size,y_size+2*pad_size))\n lg_array[pad_size:(x_size+pad_size),pad_size:(y_size+pad_size)] = ori_array.astype(numpy.float64)\n lg_array[0:pad_size,:] = numpy.flipud(lg_array[pad_size:2*pad_size,:])\n lg_array[(x_size+pad_size):(x_size+2*pad_size),:] = numpy.flipud(lg_array[x_size:(x_size+pad_size),:])\n lg_array[:,0:pad_size] = numpy.fliplr(lg_array[:,pad_size:2*pad_size])\n lg_array[:,(y_size+pad_size):(y_size+2*pad_size)] = numpy.fliplr(lg_array[:,y_size:(y_size+pad_size)])\n return lg_array\n \n else:\n return ori_array","def test_on_conv_transpose_2d_padding(self):\n x = jn.array([[[[2., 1., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])\n y = jn.array([[[[2., 5., 5., 10.], [11., 27., 32., 46.], [24., 66., 76., 86.], [40., 106., 116., 126.]]]])\n w_init = lambda s: jn.array([[[[1., 2.], [3., 4.]]]]).transpose((2, 3, 0, 1))\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=objax.ConvPadding.SAME, w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='same', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='Same', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='SAME', w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 0), w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 0), (1, 0)], w_init=w_init)\n self.assertEqual(conv(x).tolist(), y.tolist())\n y = [[[[2., 5., 5., 10., 8.], [11., 27., 32., 46., 32.], [24., 66., 76., 86., 56.],\n [40., 106., 116., 126., 80.], [39., 94., 101., 108., 64.]]]]\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=1, w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 1), w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 1), (1, 1)], w_init=w_init)\n self.assertEqual(conv(x).tolist(), y)","def pad1D(X, pad, kernel_width=None, stride=None, dilation=0):\n\tX_pad = None\n\tp = pad\n\tif isinstance(p, int):\n\t\tp = (p, p)\n\tif isinstance(p, tuple):\n\t\tX_pad = np.pad(\n\t\t\tX, \n\t\t\tpad_width=((0, 0), (p[0], p[1]), (0, 0)),\n\t\t\tmode='constant',\n\t\t\t# constant_value = 0,\n\t\t\t)\n\n\t# compute the correct padding dims for a 'same' or 'causal' convolution\n\tif p in ['same', 'causal'] and kernel_width and stride:\n\t\tcausal = p == 'causal'\n\t\tp = calc_pad_dims_1D(\n\t\t\tX.shape, X.shape[1], kernel_width, stride, causal=causal, dilation=dilation\n\t\t\t)\n\t\tX_pad, p = pad1D(X, p)\n\n\treturn X_pad, p","def zero_pad(X, padding_width, dims):\n dims = (dims) if isinstance(dims, int) else dims\n pad = [(0, 0) if idx not in dims else (padding_width, padding_width)\n for idx in range(len(X.shape))]\n X_padded = np.pad(X, pad, 'constant')\n return X_padded","def _pad_data(data, pad_length, padding_type='same'):\n\n # get the sampling period (or distance between sampling points, for PLUX devices this is always 1)\n # it is assumed that the signals are equidistantly sampled therefore only the distance between to sampling points\n # is needed to calculate the sampling period\n T = data[:, 0][1] - data[:, 0][0]\n\n if padding_type == 'same':\n\n # create the 'same' padding array\n padding = np.tile(data[-1, 1:], (pad_length, 1))\n\n elif padding_type == 'zero':\n\n # get the number of columns for the zero padding\n num_cols = data.shape[1] - 1 # ignoring the time/sample column\n\n # create the zero padding array\n padding = np.zeros((pad_length, num_cols))\n\n else:\n\n IOError('The padding type you chose is not defined. Use either \\'same\\ or \\'zero\\'.')\n\n # create the time / sample axis that needs to be padded\n start = data[:, 0][-1] + T\n stop = start + (T * pad_length)\n time_pad = np.arange(start, stop, T)\n time_pad = time_pad[:pad_length] # crop the array if there are to many values\n\n # expand dimension for hstack operation\n time_pad = np.expand_dims(time_pad, axis=1)\n\n # hstack the time_pad and the zero_pad to get the final padding array\n pad_array = np.hstack((time_pad, padding))\n\n # vstack the pad_array and the new_array\n padded_data = np.vstack([data, pad_array])\n\n return padded_data","def box2pts(x1: int, y1: int, x2: int, y2: int) -> np.ndarray:\n return np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]])","def pad_examples(x, desired_batch_size):\n batch_pad = desired_batch_size - x.shape[0]\n tile_dims = [1] * len(x.shape)\n tile_dims[0] = batch_pad\n return np.concatenate([x, np.tile(x[-1], tile_dims)], axis=0)","def setPads(self, padx, pady):\r\n self.pack(padx=padx, pady=pady)","def setPads(self, padx, pady):\r\n self.pack(padx=padx, pady=pady)","def setPads(self, padx, pady):\r\n self.pack(padx=padx, pady=pady)","def _set_pad_area(padded, axis, width_pair, value_pair):\n left_slice = _slice_at_axis(slice(None, width_pair[0]), axis)\n padded[left_slice] = value_pair[0]\n\n right_slice = _slice_at_axis(\n slice(padded.shape[axis] - width_pair[1], None), axis)\n padded[right_slice] = value_pair[1]","def _pad(input_data):\n h = input_data['img'].shape[0]\n w = input_data['img'].shape[1]\n max_size = max([int(np.sqrt(np.power(h, 2) + np.power(w, 2))),\n int(w + h * np.cos(11 / 36)),\n int(max(h, w) * 2)\n ]) + 5\n\n up = (max_size - h) // 2\n down = max_size - up - h\n left = (max_size - w) // 2\n right = max_size - left - w\n\n input_data['img'] = np.pad(input_data['img'], ((up, down), (left, right), (0, 0)), mode='constant')\n\n if DataAugmentor._is_synthtext(input_data):\n input_data['contour'][0] = list(\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\n input_data['contour'][0]))\n input_data['contour'][1] = list(\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\n input_data['contour'][1]))\n else:\n input_data['contour'] = list(\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\n input_data['contour']))\n\n input_data['center_point'] = list(\n map(lambda x: (x[0] + up, x[1] + left),\n input_data['center_point']))\n return input_data","def slice_data_to_2D(x, y):\n if(x.shape != y.shape):\n print(\"Error: Images and Labels do not have the same shape\")\n else:\n x = np.array([(x[i, :, :, z]) for i in range(x.shape[0]) for z in range(x.shape[3])])\n y = np.array([(y[i, :, :, z]) for i in range(y.shape[0]) for z in range(y.shape[3])])\n return x,y","def _get_padded_grid_(ax):\n ax_pad = np.zeros(ax.size + 2)\n ax_pad[1:-1] = ax\n ax_pad[0] = ax[0] - (ax[2] - ax[1])\n ax_pad[-1] = ax[-1] + (ax[2] - ax[1])\n\n return ax_pad","def test_2D_padding(self):\n field_names = [\"text\"]\n mask_field_names = ['text_mask']\n data_path = \"mldp/tests/data/news.csv\"\n pad_symbol = \"<PAD>\"\n mask_field_name_suffix = \"mask\"\n padding_modes = ['left', 'right', 'both']\n symbols_to_mask = [\"The\", \"a\", \"to\", \"as\"]\n axis = 1\n\n data_chunk = read_data_from_csv_file(data_path, sep=\"\\t\")\n\n # tokenize field values\n for fn in field_names:\n data_chunk[fn] = np.array([seq.split() for seq in data_chunk[fn]])\n\n for padding_mode, symbol_to_mask in product(padding_modes,\n symbols_to_mask):\n padder = Padder(field_names, pad_symbol=pad_symbol,\n new_mask_fname=mask_field_names,\n padding_mode=padding_mode, axis=axis,\n symbol_to_mask=symbol_to_mask)\n padded_data_chunk = padder(copy.deepcopy(data_chunk))\n\n for fn, mask_fn in zip(field_names, mask_field_names):\n padded_fv = padded_data_chunk[fn]\n mask = padded_data_chunk[mask_fn]\n original_fv = data_chunk[fn]\n\n self.assertTrue(len(padded_fv.shape) == 2)\n self._test_padded_values(original_field_values=original_fv,\n padded_field_values=padded_fv,\n mask=mask, pad_symbol=pad_symbol,\n symbol_to_mask=symbol_to_mask)","def pad(self, left=0, top=0, bottom=0, right=0):\n\n self.x -= left\n self.y -= top\n self.width += left + right\n self.height += top + bottom","def _padboth(width, s):\n fmt = \"{0:^%ds}\" % width\n return fmt.format(s)","def test_pad6():\n x = np.array([[[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]])\n pad = (2, 1, 3, 0, 2, 0)\n mode = \"replicate\"\n data_format = \"NDHWC\"\n res = np.array(\n [\n [\n [\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n ],\n [\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n ],\n [\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\n ],\n ]\n ]\n )\n obj.run(res=res, x=x, pad=pad, mode=mode, data_format=data_format)","def pad(self, pad_width, mode=\"constant\", constant_values=0):\r\n destination = np.zeros(\r\n (\r\n self.dataset.count,\r\n self.__arr.shape[1] + 2 * pad_width,\r\n self.__arr.shape[2] + 2 * pad_width,\r\n ),\r\n self.__arr.dtype,\r\n )\r\n\r\n for i in range(0, self.dataset.count):\r\n destination[i], transform = rasterio.pad(\r\n self.__arr[i],\r\n self.dataset.transform,\r\n pad_width,\r\n mode,\r\n constant_values=constant_values,\r\n )\r\n\r\n self.__arr = destination\r\n self.__update_dataset(self.dataset.crs, transform, nodata=self.dataset.nodata)","def padding(src, min_size):\n # pad before put into convolutional layer\n src_dim = src.dim()\n if src_dim[0][1] >= min_size:\n return src\n pad_size = min_size - src_dim[0][1]\n channels = src_dim[0][2] if len(src_dim[0]) >= 3 else 1\n if pad_size == 1:\n return dy.concatenate([src, dy.zeroes((src_dim[0][0], 1, channels))], d=1)\n else:\n left_border = int(pad_size) / 2\n right_border = (int(pad_size)+1) / 2\n return dy.concatenate([dy.zeroes((src_dim[0][0], left_border, channels)), src, dy.zeroes((src_dim[0][0], right_border, channels))], d=1) # do concatenate along cols","def pad_edges(self, pad):\n weights=[]\n for dim, xy in zip([0, 1], [self.x, self.y]):\n xy0 = np.mean(xy)\n W = xy[-1]-xy[0]\n dist = np.abs(xy-xy0)\n wt=np.ones_like(dist)\n wt[ dist >= W/2 - pad] = 0\n weights += [wt]\n self.weight *= weights[0][:,None].dot(weights[1][None,:])","def temporal_padding(x, padding=(1, 1)):\n assert len(padding) == 2\n pattern = [[0, 0], [padding[0], padding[1]], [0, 0]]\n return tf.pad(x, pattern)","def sanitize_coordinates(_x1, _x2, img_size: int, padding: int = 0, cast: bool = True):\n _x1 = _x1 * img_size\n _x2 = _x2 * img_size\n if cast:\n _x1 = _x1.long()\n _x2 = _x2.long()\n coordinates_min = P.Minimum()\n coordinates_max = P.Maximum()\n x1 = coordinates_min(_x1, _x2)\n x2 = coordinates_max(_x1, _x2)\n\n select = P.Select()\n zeroslike = P.ZerosLike()\n oneslike = P.OnesLike()\n min_tensor = zeroslike(x1 - padding)\n x1 = select(min_tensor > x1 - padding, min_tensor, x1 - padding)\n\n max_tensor = oneslike(x2 + padding) * img_size\n x2 = select(x2 + padding > max_tensor, max_tensor, x2 + padding)\n\n\n return x1, x2","def padd_raw_board(board):\n max_length = max(len(board[0]) - 1, len(board))\n side_length = max_length + 2\n x_padding = round((max_length - (len(board[0]) - 1)) / 2) + 1\n y_padding = round((max_length - len(board)) / 2) + 1\n limit = len(board)\n padded_board = [] + [''.join(['.'] * side_length)] * y_padding\n\n for y in range(side_length - y_padding):\n if y < limit:\n row = ''.join(['.'] * x_padding) + board[y] + ''.join(['.'] * x_padding)\n else:\n row = ''.join(['.'] * side_length)\n\n padded_board.append(row)\n\n return padded_board","def padImage(image, padList):\r\n\r\n #pad along far x:<---->\r\n padFarX= np.zeros((image.shape[0], image.shape[1], padList[0]))\r\n image= np.concatenate((image, padFarX), axis=2)\r\n\r\n #pad along far y\r\n padFarY= np.zeros((image.shape[0], padList[1], image.shape[2]))\r\n image= np.concatenate((image, padFarY), axis=1)\r\n\r\n #pad along far z\r\n padFarZ= np.zeros((padList[2], image.shape[1], image.shape[2]))\r\n image= np.concatenate((image, padFarZ), axis=0)\r\n\r\n #pad along close x, adjust center\r\n padCloseX= np.zeros((image.shape[0], image.shape[1], padList[3]))\r\n image= np.concatenate((padCloseX, image), axis=2)\r\n\r\n #pad along close y adjust center\r\n padCloseY= np.zeros((image.shape[0], padList[4], image.shape[2]))\r\n image= np.concatenate((padCloseY, image), axis=1)\r\n\r\n #pad along close z, adjust center\r\n padCloseZ= np.zeros((padList[5], image.shape[1], image.shape[2]))\r\n image= np.concatenate((padCloseZ, image), axis=0)\r\n\r\n\r\n #print \"PADDED IMAGE SHAPE: \" + str(image.shape)\r\n return image","def add_padding(im, pad):\n\n return np.pad(im, pad_width=((pad, pad), (pad, pad), (0, 0)), mode='symmetric')","def test_pad2():\n x = np.array([[[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]])\n pad = (0, 1, 1, 1, 2, 0)\n mode = \"constant\"\n value = 0\n data_format = \"NCDHW\"\n res = np.array(\n [\n [\n [\n [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\n [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\n [[0.0, 0.0, 0.0, 0.0], [1.0, 2.0, 3.0, 0.0], [4.0, 5.0, 6.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\n ]\n ]\n ]\n )\n obj.run(res=res, x=x, pad=pad, mode=mode, value=value, data_format=data_format)","def augment(x: np.ndarray, y: np.ndarray):\n scipy.random.seed()\n\n # scale = np.random.normal(1, 0.1, size=3)\n alpha, theta = np.random.normal(0, 9, size=2)\n alpha = 0\n\n for i in range(1, len(x.shape) - 1):\n if np.random.binomial(1, .5):\n x = np.flip(x, -i)\n y = np.flip(y, -i)\n\n # mscan = np.array([_scale_crop(i) for i in mscan])\n # segm = _scale_crop(segm[0])[np.newaxis]\n\n x = _rotate(x, 3, theta, alpha)\n y = _rotate(y, 0, theta, alpha)\n\n # if np.random.binomial(1, .5):\n # t = np.random.choice([-90, 0, 90])\n # a = np.random.choice([-90, 0, 90])\n # mscan = _rotate(mscan, 3, t, a)\n # segm = _rotate(segm, 3, t, a)\n\n x = np.array([i * np.random.normal(1, 0.35) for i in x])\n return x, y","def _build_points(self, xs, ys):\n return np.hstack([xs, ys])","def add_padding(img, x_padding):\n w = img.shape[1] + x_padding * 2\n img_with_padding = np.zeros((img.shape[0], w, 3), dtype=img.dtype)\n img_with_padding[:, x_padding:img.shape[1] + x_padding] = img\n return img_with_padding","def _pad_traces(self, X):\n # Padding is done using using keras.preprocessing.sequence.pad_sequences(sequences, ...)\n # maxlen: Int, maximum length of all sequences.\n # truncating='pre' remove values at the beginning from sequences larger than maxlen\n # padding='pre' pads each trace at the beginning with a special integer (e.g., 0)\n X = pad_sequences(X, maxlen=self.trace_size, dtype=np.int16,\n truncating='pre', padding='pre', value=DEFAULTS['padding_symbol'])\n\n print(X)\n # Shape X is (n_traces, self.trace_size)\n # e.g., (25002, 20)\n\n return X","def pad_left(x, block_size=3, fill=0):\n if len(x) > block_size:\n return x\n else:\n right = np.array(list(str(x)))\n left = np.repeat(str(fill), block_size - right.size )\n return \"\".join(np.concatenate([left, right]))","def pad(self, *args, **kwargs):\n return _image.image_pad(self, *args, **kwargs)","def pad_same(width, kernel, slide):\n res = (width - kernel) / slide + 1\n pad = (width - res) / 2\n return pad","def call(self, x):\n return tf.pad(x, self.paddings,\n mode=self.mode)","def _get_padding(w, h):\n dim_diff = np.abs(h - w)\n pad1, pad2 = dim_diff // 2, dim_diff - dim_diff // 2\n return (0, pad1, 0, pad2) if h <= w else (pad1, 0, pad2, 0)","def pad_and_onehot(data, pad_len=None, extra_padding=200):\n if pad_len is None:\n pad_len = max(len(x) for x in data) + extra_padding\n data = [\n onehot(np.pad(trace, (0, pad_len - len(trace)), mode=\"constant\"))\n for trace in data\n ]\n return pad_len, np.array(data)","def combine_last_two_dim(self, x):\n old_shape = list(x.size())\n a, b = old_shape[-2:]\n new_shape = old_shape[:-2] + [a * b if a and b else None]\n ret = x.contiguous().view(new_shape)\n return ret","def combine_last_two_dim(self, x):\n old_shape = list(x.size())\n a, b = old_shape[-2:]\n new_shape = old_shape[:-2] + [a * b if a and b else None]\n ret = x.contiguous().view(new_shape)\n return ret","def combine_last_two_dim(self, x):\n old_shape = list(x.size())\n a, b = old_shape[-2:]\n new_shape = old_shape[:-2] + [a * b if a and b else None]\n ret = x.contiguous().view(new_shape)\n return ret","def _pad_image(self, img: ndarray, pad_width: int = 10) -> ndarray:\n self.padded_img = np.zeros(\n (img.shape[0] + pad_width*2, img.shape[1]+pad_width*2))\n self.padded_img[pad_width:-pad_width, pad_width:-pad_width] = img\n return self.padded_img","def union(self, x, y):\n \n px, py = self.find(x), self.find(y)\n if px != py:\n \n if self.size[px] > self.size[py]:\n px, py = py, px\n \n\n self.parent[px] = py\n self.size[py] += self.size[px]","def procrustes(a,target,side='both',padval=0):\n\n try:\n if len(target) != a.ndim:\n raise TypeError('Target shape must have the same number of dimensions as the input')\n except TypeError:\n raise TypeError('Target must be array-like')\n\n try:\n b = np.ones(target,a.dtype)*padval\n except TypeError:\n raise TypeError('Pad value must be numeric')\n except ValueError:\n raise ValueError('Pad value must be scalar')\n\n aind = [slice(None,None)]*a.ndim\n bind = [slice(None,None)]*a.ndim\n\n # pad/trim comes after the array in each dimension\n if side == 'after':\n for dd in xrange(a.ndim):\n if a.shape[dd] > target[dd]:\n aind[dd] = slice(None,target[dd])\n elif a.shape[dd] < target[dd]:\n bind[dd] = slice(None,a.shape[dd])\n\n # pad/trim comes before the array in each dimension\n elif side == 'before':\n for dd in xrange(a.ndim):\n if a.shape[dd] > target[dd]:\n aind[dd] = slice(a.shape[dd]-target[dd],None)\n elif a.shape[dd] < target[dd]:\n bind[dd] = slice(target[dd]-a.shape[dd],None)\n\n # pad/trim both sides of the array in each dimension\n elif side == 'both':\n for dd in xrange(a.ndim):\n if a.shape[dd] > target[dd]:\n diff = (a.shape[dd]-target[dd])/2.\n aind[dd] = slice(np.floor(diff),a.shape[dd]-np.ceil(diff))\n elif a.shape[dd] < target[dd]:\n diff = (target[dd]-a.shape[dd])/2.\n bind[dd] = slice(np.floor(diff),target[dd]-np.ceil(diff))\n\n else:\n raise Exception('Invalid choice of pad type: %s' %side)\n\n b[bind] = a[aind]\n\n return b","def make_simple_coords():\n \n x = np.array([144, 124, 97, 165, 114, 60, 165, 0, 76, 50, 147])\n y = np.array([ 0, 3, 21, 28, 34, 38, 51, 54, 58, 56, 61])\n coords = np.vstack((x,y)).T\n return coords","def transpose_coordinates(self, x, y):\n return (x, self.height - 1 - y)","def _pad_to_full_keypoint_dim(keypoint_coords, keypoint_scores, keypoint_inds,\n num_total_keypoints):\n batch_size, num_instances, _, _ = (\n shape_utils.combined_static_and_dynamic_shape(keypoint_coords))\n kpt_coords_transposed = tf.transpose(keypoint_coords, [2, 0, 1, 3])\n kpt_scores_transposed = tf.transpose(keypoint_scores, [2, 0, 1])\n kpt_inds_tensor = tf.expand_dims(keypoint_inds, axis=-1)\n kpt_coords_scattered = tf.scatter_nd(\n indices=kpt_inds_tensor,\n updates=kpt_coords_transposed,\n shape=[num_total_keypoints, batch_size, num_instances, 2])\n kpt_scores_scattered = tf.scatter_nd(\n indices=kpt_inds_tensor,\n updates=kpt_scores_transposed,\n shape=[num_total_keypoints, batch_size, num_instances])\n keypoint_coords_padded = tf.transpose(kpt_coords_scattered, [1, 2, 0, 3])\n keypoint_scores_padded = tf.transpose(kpt_scores_scattered, [1, 2, 0])\n return keypoint_coords_padded, keypoint_scores_padded","def spatial_reflection_2d_padding(x, padding=((1, 1), (1, 1)),\n data_format=None):\n assert len(padding) == 2\n assert len(padding[0]) == 2\n assert len(padding[1]) == 2\n if data_format is None:\n data_format = image_data_format()\n if data_format not in {'channels_first', 'channels_last'}:\n raise ValueError('Unknown data_format ' + str(data_format))\n\n if data_format == 'channels_first':\n pattern = [[0, 0],\n [0, 0],\n list(padding[0]),\n list(padding[1])]\n else:\n pattern = [[0, 0],\n list(padding[0]), list(padding[1]),\n [0, 0]]\n return tf.pad(x, pattern, \"REFLECT\")","def _fix_coords(x, y):\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\n return x, y\n lon1 = x[0]\n filter_ = x < lon1\n while filter_.sum():\n filter_ = x < lon1\n x[filter_] += 360\n return x, y","def augment_data(X, y):\n X_flip = np.copy(X)\n X_flip[:,:,::2] = -X_flip[:,:,::2]\n X = np.concatenate((X, X_flip))\n y = np.concatenate((y, y))\n \n return X, y","def spatial_reflection_2d_padding(x, padding=((1, 1), (1, 1)), data_format=None):\n assert len(padding) == 2\n assert len(padding[0]) == 2\n assert len(padding[1]) == 2\n if data_format is None:\n data_format = image_data_format()\n if data_format not in {'channels_first', 'channels_last'}:\n raise ValueError('Unknown data_format ' + str(data_format))\n\n if data_format == 'channels_first':\n pattern = [[0, 0],\n [0, 0],\n list(padding[0]),\n list(padding[1])]\n else:\n pattern = [[0, 0],\n list(padding[0]), list(padding[1]),\n [0, 0]]\n return tf.pad(x, pattern, \"REFLECT\")","def pad(data, *args, **kwargs): # pragma: no cover\n raise NotImplementedError()","def offset_y(self, X, y):\n X, y = self.check_consistent_params(X, y)\n if len(y.shape) == 1:\n offset = len(y) - X.shape[0]\n return y[offset:]\n else:\n offset = len(y[0]) - X.shape[0]\n return y[0, offset:]","def test_zero_pad():\r\n # Freely assume that time is the last dimension:\r\n ts1 = np.empty((64, 64, 35, 32))\r\n NFFT = 64 \r\n zp1 = utils.zero_pad(ts1, NFFT)\r\n npt.assert_equal(zp1.shape[-1], NFFT)\r\n\r\n # Try this with something with only 1 dimension:\r\n ts2 = np.empty(64)\r\n zp2 = utils.zero_pad(ts2, NFFT)\r\n npt.assert_equal(zp2.shape[-1], NFFT)","def concatenate_offset(self, X):\n return np.c_[np.ones((X.shape[0], 1)), X]","def get_pad2(s1, s2):\n return \" \" * (40 - len(s1) - len(s2))","def pad_limits(xgrid, ygrid, xpad=0., ypad=0., square=None):\n\n xmin, xmax = xgrid.min(), xgrid.max()\n ymin, ymax = ygrid.min(), ygrid.max()\n dx = xmax - xmin\n dy = ymax - ymin\n x0 = xmin - xpad*dx\n x1 = xmax + xpad*dx\n y0 = ymin - ypad*dy\n y1 = ymax + ypad*dy\n\n if square:\n axis = square\n ax_position = axis.get_position()\n ax_height = ax_position.height * axis.figure.get_figheight()\n ax_width = ax_position.width * axis.figure.get_figwidth()\n ax_aspect = ax_height / ax_width\n\n im_height = y1 - y0\n im_width = x1 - x0\n im_aspect = im_height / im_width\n\n if (im_height/im_width) > (ax_height/ax_width):\n # Image too tall\n extra_w = im_height/ax_aspect - im_width\n x0 -= extra_w / 2\n x1 += extra_w / 2\n else:\n # Image too wide\n extra_h = im_width*ax_aspect - im_height\n y0 -= extra_h / 2\n y1 += extra_h / 2\n\n return [x0, x1, y0, y1]","def adjustCoordByBorders(self, x, y):\n (x_offset, y_offset) = (0, 0)\n if (127 < x < (255+4)):\n x_offset -= 4\n \n if (31 < y < (63+4*1)):\n y_offset -= 4\n elif ( (63+4*1) < y < (95+4*2) ):\n y_offset -= 4*2\n elif ( (95+4*2) < y < (127+4*3) ):\n y_offset -= 4*3\n elif ( (127+4*3) < y < (159+4*4) ):\n y_offset -= 4*4\n elif ( (159+4*4) < y < (191+4*5) ):\n y_offset -= 4*5\n elif ( (191+4*5) < y < (223+4*6) ):\n y_offset -= 4*6\n elif ( (223+4*6) < y < (255+4*7) ):\n y_offset -= 4*7\n return x_offset, y_offset","def to_same_dim(a, b):\n\n if len(a) > len(b):\n return a, padding(b, len(a))\n\n elif len(a) < len(b):\n return padding(a, len(b)), b\n\n else:\n return a, b","def pad_bounds(\n bounds: tuple[int, int, int, int],\n padding: int | tuple[int, int] | tuple[int, int, int, int],\n) -> tuple[int, int, int, int]:\n if np.size(bounds) % 2 != 0:\n msg = \"Bounds must have an even number of elements.\"\n raise ValueError(msg)\n ndims = np.size(bounds) // 2\n\n if np.size(padding) not in [1, 2, np.size(bounds)]:\n msg = \"Invalid number of padding elements.\"\n raise ValueError(msg)\n\n if np.size(padding) == 1 or np.size(padding) == np.size(bounds):\n pass\n elif np.size(padding) == ndims: # pragma: no cover\n padding = np.tile(padding, 2)\n\n signs = np.repeat([-1, 1], ndims)\n return np.add(bounds, padding * signs)","def _pad_img(self, results):\n pad_val = self.pad_val.get('img', 0)\n for key in results.get('img_fields', ['img']):\n if self.pad_to_square:\n max_size = max(results[key].shape[:2])\n self.size = (max_size, max_size)\n if self.size is not None:\n padded_img = general_ocr.impad(\n results[key], shape=self.size, pad_val=pad_val)\n elif self.size_divisor is not None:\n padded_img = general_ocr.impad_to_multiple(\n results[key], self.size_divisor, pad_val=pad_val)\n results[key] = padded_img\n results['pad_shape'] = padded_img.shape\n results['pad_fixed_size'] = self.size\n results['pad_size_divisor'] = self.size_divisor","def pad_shift(x, shift, padv=0.0):\n if shift > 0:\n padding = torch.ones(x.size(0), shift, x.size(2)).to(x.device) * padv\n return torch.cat((padding, x[:, :-shift, :]), dim=1)\n elif shift < 0:\n padding = torch.ones(x.size(0), -shift, x.size(2)).to(x.device) * padv\n return torch.cat((x[:, -shift:, :], padding), dim=1)\n else:\n return x","def pad_sequences_2d(sequences, max_len_1=None, max_len_2=None, dtype='int32', padding='post',\n truncating='post', value=0.):\n lengths_1, lengths_2 = [], []\n for s in sequences:\n lengths_1.append(len(s))\n for t in s:\n lengths_2.append(len(t))\n if max_len_1 is None:\n max_len_1 = np.max(lengths_1)\n if max_len_2 is None:\n max_len_2 = np.max(lengths_2)\n\n num_samples = len(sequences)\n x = (np.ones((num_samples, max_len_1, max_len_2)) * value).astype(dtype)\n for i, s in enumerate(sequences):\n if not len(s):\n continue # empty list was found\n\n if truncating == 'pre':\n s = s[-max_len_1:]\n elif truncating == 'post':\n s = s[:max_len_1]\n else:\n raise ValueError('Truncating type \"%s\" not understood' % truncating)\n\n y = (np.ones((len(s), max_len_2)) * value).astype(dtype)\n for j, t in enumerate(s):\n if not len(t):\n continue\n\n if truncating == 'pre':\n trunc = t[-max_len_2:]\n elif truncating == 'post':\n trunc = t[:max_len_2]\n else:\n raise ValueError('Truncating type \"%s\" not understood' % truncating)\n\n trunc = np.asarray(trunc, dtype=dtype)\n\n if padding == 'post':\n y[j, :len(trunc)] = trunc\n elif padding == 'pre':\n y[j, -len(trunc):] = trunc\n else:\n raise ValueError('Padding type \"%s\" not understood' % padding)\n\n if padding == 'post':\n x[i, :y.shape[0], :] = y\n elif padding == 'pre':\n x[i, -y.shape[0]:, :] = y\n else:\n raise ValueError('Padding type \"%s\" not understood' % padding)\n\n return x","def pad2d_hw_shape(\n h_w: Union[int, Tuple[int, int]],\n pad_size: Union[int, Tuple[int, int], Tuple[int, int, int, int]] = 1,\n) -> Tuple[int, int]:\n h_w = replicate(h_w)\n if isinstance(pad_size, Sequence) and len(pad_size) == 4:\n pad = (pad_size[2:], pad_size[:2]) # NOTE: permuted torch quadruple pad order\n else:\n pad_size = replicate(pad_size)\n pad = (replicate(pad_size[0]), replicate(pad_size[1]))\n\n h = h_w[0] + sum(pad[0]) # Sum across pad[0] (top,bottom)\n w = h_w[1] + sum(pad[1]) # Sum across pad[1] (left,right)\n\n return h, w","def _pad_simple(array, pad_width, fill_value=None):\n # Allocate grown array\n new_shape = tuple(\n left + size + right\n for size, (left, right) in zip(array.shape, pad_width)\n )\n order = 'F' if array.flags.fnc else 'C' # Fortran and not also C-order\n padded = np.empty(new_shape, dtype=array.dtype, order=order)\n\n if fill_value is not None:\n padded.fill(fill_value)\n\n # Copy old array into correct space\n original_area_slice = tuple(\n slice(left, left + size)\n for size, (left, right) in zip(array.shape, pad_width)\n )\n padded[original_area_slice] = array\n\n return padded, original_area_slice","def pad_prediction(prediction, input_size, pad_with=-1.0):\n pad_pred = pad_with * np.ones(input_size).astype(float)\n pred_size = prediction.shape\n D = ((input_size[0]-pred_size[0])//2, (input_size[1]-pred_size[1])//2)\n pad_pred[D[0]:D[0]+pred_size[0], D[1]:D[1]+pred_size[1]] = prediction\n return pad_pred"],"string":"[\n \"def pad_vals(x, y):\\n\\n xshapes = []\\n for x_arr in x:\\n\\n x_arr = np.array(x_arr)\\n xshapes.append(x_arr.shape[0])\\n\\n x_max_shape = np.max(xshapes)\\n for i, x_arr in enumerate(x):\\n\\n pad_len = x_max_shape - x_arr.shape[0]\\n x[i] = np.pad(x_arr, (0, pad_len), mode='constant',\\n constant_values=np.NaN)\\n y[i] = np.pad(y[i], (0, pad_len), mode='constant',\\n constant_values=np.NaN)\\n\\n x = np.vstack(x).astype(np.float64)\\n y = np.vstack(y).astype(np.float64)\\n return x, y\",\n \"def pad_spatial(self, x):\\n n, t, c, h, w = x.size()\\n\\n pad_h = (4 - h % 4) % 4\\n pad_w = (4 - w % 4) % 4\\n\\n # padding\\n x = x.view(-1, c, h, w)\\n x = F.pad(x, [0, pad_w, 0, pad_h], mode='reflect')\\n\\n return x.view(n, t, c, h + pad_h, w + pad_w)\",\n \"def test_pad_coords_matrices(self):\\r\\n # first is longer\\r\\n m1 = array([[1, 0, 3, 9, 4],\\r\\n [4, 5, 6, 94, 5],\\r\\n [7, 8, 9, 6, 6],\\r\\n [10, 11, 12, 4, 6]])\\r\\n m2 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\\r\\n m2_expected = array([[1, 2, 3, 0., 0.], [4, 5, 6, 0., 0.],\\r\\n [7, 8, 9, 0., 0.], [10, 11, 12, 0., 0.]])\\r\\n actual = pad_coords_matrices(m1, m2)\\r\\n expected = (m1, m2_expected)\\r\\n assert_almost_equal(actual, expected)\\r\\n\\r\\n # second is longer\\r\\n m1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\\r\\n m2 = array(\\r\\n [[1, 2, 3, 9], [4, 5, 6, 94], [7, 8, 9, 6], [10, 11, 12, 4]])\\r\\n m1_expected = array(\\r\\n [[1, 2, 3, 0.], [4, 5, 6, 0.], [7, 8, 9, 0.], [10, 11, 12, 0.]])\\r\\n actual = pad_coords_matrices(m1, m2)\\r\\n expected = (m1_expected, m2)\\r\\n assert_almost_equal(actual, expected)\\r\\n\\r\\n # equal length, so no change\\r\\n m1 = array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\\r\\n m2 = array([[0, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])\\r\\n actual = pad_coords_matrices(m1, m2)\\r\\n expected = (m1, m2)\\r\\n assert_almost_equal(actual, expected)\",\n \"def _pad_with_zeros(self, X, margin):\\n newX = np.zeros((X.shape[0] + 2 * margin, X.shape[1] + 2 * margin, X.shape[2]))\\n x_offset = margin\\n y_offset = margin\\n newX[x_offset:X.shape[0] + x_offset, y_offset:X.shape[1] + y_offset, :] = X\\n return newX\",\n \"def test_pad():\\n x = randtool(\\\"float\\\", -10, 10, [3, 2, 1, 2])\\n pad = [1, 1, 2, 3]\\n mode = \\\"constant\\\"\\n value = 2.0\\n data_format = \\\"NCHW\\\"\\n res = np.array(\\n [\\n [\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, -8.88523461, 1.99072967, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 4.45995261, 9.40579439, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n ],\\n [\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 6.43138915, 0.55102135, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, -3.37046541, -2.92035609, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n ],\\n [\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, -8.41939397, 1.11828761, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, -6.68411074, -4.09524338, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ],\\n ],\\n ]\\n )\\n obj.run(res=res, x=x, pad=pad, mode=mode, value=value, data_format=data_format)\",\n \"def _pad(x, depth=4):\\n divisor = np.power(2, depth)\\n remainder = x.shape[0] % divisor\\n\\n # no padding because already of even shape\\n if remainder == 0:\\n return x\\n # add zero rows after 1D feature\\n elif len(x.shape) == 2:\\n return np.pad(x, [(0, divisor - remainder), (0, 0)], \\\"constant\\\")\\n # add zero columns and rows after 2D feature\\n elif len(x.shape) == 3:\\n return np.pad(x, [(0, divisor - remainder), (0, divisor - remainder),\\n (0, 0)], \\\"constant\\\")\",\n \"def reflection_pad2d(self, x, pad=1):\\n x = torch.cat([torch.flip(x[:, :, 1:pad + 1, :], [2]), x, torch.flip(x[:, :, -pad - 1:-1, :], [2])], 2)\\n x = torch.cat([torch.flip(x[:, :, :, 1:pad + 1], [3]), x, torch.flip(x[:, :, :, -pad - 1:-1], [3])], 3)\\n return x\",\n \"def pad(x, pad_left=0, pad_right=0, to_complex=True):\\n output = pad_1d(x, pad_left, pad_right, mode='reflect')\\n if to_complex:\\n output = torch.stack((output, torch.zeros_like(output)), dim=-1)\\n return output\",\n \"def _padding(self, x, shape, value=0):\\n row_padding = shape[0] - x.shape[0]\\n col_padding = shape[1] - x.shape[1]\\n return np.pad(x, [[0, row_padding], [0, col_padding]], mode=\\\"constant\\\", constant_values=value)\",\n \"def _pad1d(self, x: torch.Tensor, padding_left: int, padding_right: int, mode: str = \\\"zero\\\", value: float = 0.0):\\n length = x.shape[-1]\\n if mode == \\\"reflect\\\":\\n max_pad = max(padding_left, padding_right)\\n if length <= max_pad:\\n x = F.pad(x, (0, max_pad - length + 1))\\n return F.pad(x, (padding_left, padding_right), mode, value)\",\n \"def image_pad(image, pixel_loc_x, pixel_loc_y):\\r\\n input_size = np.shape(image)\\r\\n padded_image = np.zeros((input_size[0]+200, input_size[1]+200, 1))\\r\\n if np.size(input_size) == 2:\\r\\n padded_image[:, :, 0] = skut.pad(image[:, :], 100, mode='constant', constant_values=float(0))\\r\\n else:\\r\\n for i in range(input_size[2]):\\r\\n if i == 0:\\r\\n padded_image[:, :, 0] = skut.pad(image[:, :, i], 100, mode='constant', constant_values=float(0))\\r\\n else:\\r\\n padded_dim = np.zeros((input_size[0]+200, input_size[1]+200, 1))\\r\\n padded_dim[:, :, 0] = skut.pad(image[:, :, i], 100, mode='constant', constant_values=float(0))\\r\\n padded_image = np.append(padded_image, padded_dim, axis=2)\\r\\n pixel_loc_x = pixel_loc_x + 100\\r\\n pixel_loc_y = pixel_loc_y + 100\\r\\n return padded_image, pixel_loc_x, pixel_loc_y\",\n \"def pad(x, padding, fill_value=0):\\n input_shape = x.shape\\n output_shape = []\\n indices = []\\n\\n for dim, pad in enumerate(padding):\\n try:\\n left_pad, right_pad = pad\\n except TypeError:\\n left_pad = right_pad = pad\\n output_shape.append(left_pad + input_shape[dim] + right_pad)\\n indices.append(slice(left_pad, left_pad + input_shape[dim]))\\n\\n if fill_value:\\n out = T.ones(output_shape) * fill_value\\n else:\\n out = T.zeros(output_shape)\\n return T.set_subtensor(out[tuple(indices)], x)\",\n \"def pad_with_border(x, n_pad):\\n x_pad_list = [x[0:1]] * int(n_pad) + [x] + [x[-1:]] * int(n_pad)\\n return np.concatenate(x_pad_list, axis=0)\",\n \"def pad(self, nxp, nyp):\\n assert (nxp > self.nx)\\n assert (nyp > self.ny)\\n assert (np.mod(nxp - self.nx, 2) == 0)\\n assert (np.mod(nyp - self.ny, 2) == 0)\\n\\n ret = rmap(nx=nxp, dx=self.dx, ny=nyp, dy=self.dy)\\n ret.map[(nyp - self.ny) / 2:(nyp + self.ny) / 2, (nxp - self.nx) / 2:(\\n nxp + self.nx) / 2] = self.map\\n return ret\",\n \"def test_pad_and_concatenate_with_1d(self):\\n array1 = 1.0\\n array2 = 2.0\\n result = numpy_pad_and_concatenate(array1, array2)\\n self.assertTrue(np.array_equal(np.array([1.0, 2.0]), result))\\n\\n tensor1 = torch.tensor(1.0)\\n tensor2 = torch.tensor(2.0)\\n result = torch_pad_and_concatenate(tensor1, tensor2)\\n self.assertTrue(torch.equal(result, torch.Tensor([1.0, 2.0])))\",\n \"def pad_arrays(arrays, batch_size):\\n\\n rows_needed = batch_size - len(arrays[\\\"y\\\"]) % batch_size\\n return {k: np.pad(v, [(0,rows_needed)] + [(0,0)]*(len(v.shape)-1), \\\"edge\\\") for k,v in arrays.items()}\",\n \"def pad2D(X, pad, kernel_shape=None, stride=None, dilation=0):\\n\\tX_pad = None\\n\\tp = pad\\n\\tif isinstance(p, int):\\n\\t\\tp = (p, p, p, p)\\n\\n\\tif isinstance(p, tuple):\\n\\t\\tif len(p) == 2:\\n\\t\\t\\tp = (p[0], p[0], p[1], p[1])\\n\\n\\t\\t\\tX_pad = np.pad(\\n\\t\\t\\t\\tX, \\n\\t\\t\\t\\tpad_width=((0, 0), (p[0], p[1]), (p[2], p[3]), (0, 0)),\\n\\t\\t\\t\\tmode=\\\"constant\\\",\\n\\t\\t\\t\\t# constant_values=0,\\n\\t\\t\\t\\t)\\n\\n\\t# compute the crrect padding dims for a 'same' convolution\\n\\tif p == 'same' and kernel_shape and stride is not None:\\n\\t\\tp = calc_pad_dims_2D(\\n\\t\\t\\tX.shape, X.shape[1:3], kernel_shape, sride, dilation=dilation\\n\\t\\t\\t)\\n\\t\\tX_pad, p = pad2D(X, p)\\n\\treturn X_pad, p\",\n \"def pad_square(box):\\n x, y, xw, yh = box\\n w = xw-x\\n h = yh-y\\n if w < h:\\n w = h\\n elif h < w:\\n h = w\\n return [x, y, x+w, y+h]\",\n \"def pad(self, src):\\n if(self.pre_pad):\\n dst = src.new(\\n src.size(0),\\n src.size(1),\\n src.size(2),\\n src.size(3),\\n 2\\n ).zero_()\\n dst.narrow(dst.ndimension()-1, 0, 1).copy_(\\n torch.unsqueeze(src, 4)\\n )\\n else:\\n padded = self.padding_module.updateOutput(src)\\n dst = src.new(\\n padded.size(0),\\n padded.size(1),\\n padded.size(2),\\n padded.size(3),\\n 2\\n ).zero_()\\n dst.narrow(4, 0, 1).copy_(\\n torch.unsqueeze(padded, 4)\\n )\\n return dst\",\n \"def pad_1d(x, pad_left, pad_right, mode='constant', value=0.):\\n if (pad_left >= x.shape[-1]) or (pad_right >= x.shape[-1]):\\n if mode == 'reflect':\\n raise ValueError('Indefinite padding size (larger than tensor).')\\n res = F.pad(x.unsqueeze(2),\\n (pad_left, pad_right, 0, 0),\\n mode=mode, value=value).squeeze(2)\\n return res\",\n \"def pad(x, system_shape, pad_size):\\n res = unpad(tf.tile(x, (1,)+(3,)*len(pad_size)),\\n tuple(s-p for s, p in zip(system_shape, pad_size)))\\n return res\",\n \"def add_padding(x, maxlen=500):\\n \\n # May want to increase maxlen from 500! Not sure the total dist of chomragram lengths.\\n\\n for i in range(len(x)):\\n x[i] = x[i][:,:maxlen]\\n q = maxlen - x[i].shape[1]\\n p = q//2\\n# if q % 2 == 0:\\n# x[i] = np.pad(x[i], ((p,p), (0,0)), 'constant', constant_values=(0,0))\\n# else:\\n# x[i] = np.pad(x[i], ((p,p+1), (0,0)), 'constant', constant_values=(0,0))\\n\\n print\\n if q % 2 == 0:\\n x[i] = np.pad(x[i], ((0,0), (p,p)), 'constant', constant_values=(0,0))\\n else:\\n x[i] = np.pad(x[i], ((0,0), (p,p+1)), 'constant', constant_values=(0,0))\\n \\n return x\",\n \"def test_pad_8():\\n paddle.disable_static()\\n x = np.array([[[[1.0, 3.0], [-3.0, 1.0]]]])\\n pad = [1, 1, 1, 2]\\n mode = \\\"constant\\\"\\n value = np.array(2.0)\\n data_format = \\\"NCHW\\\"\\n res = np.array(\\n [\\n [\\n [\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 1.0, 3.0, 2.0],\\n [2.0, -3.0, 1.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n [2.0, 2.0, 2.0, 2.0],\\n ]\\n ]\\n ]\\n )\\n exp = paddle.nn.functional.pad(\\n x=paddle.to_tensor(x), pad=pad, mode=mode, value=paddle.to_tensor(value), data_format=data_format\\n )\\n assert np.allclose(exp.numpy(), res)\",\n \"def steppify(x, y):\\n dx = 0.5 * (x[1:] + x[:-1])\\n xx = np.zeros( 2 * len(dx), dtype=float)\\n yy = np.zeros( 2 * len(y), dtype=float)\\n xx[0::2], xx[1::2] = dx, dx\\n yy[0::2], yy[1::2] = y, y\\n xx = np.concatenate(([x[0] - (dx[0] - x[0])], xx, [x[-1] + (x[-1] - dx[-1])]))\\n return xx, yy\",\n \"def pad_shorter(a, b, ii=0):\\n # global data_orig\\n # global data_new\\n diff = a[ii].size - b[ii].size\\n # print(\\\"diff\\\", diff)\\n if (diff > 0):\\n b = np.concatenate((np.zeros(\\n (b.shape[0], diff//2)), b, np.zeros((b.shape[0], diff - diff//2))), axis=1)\\n elif (diff < 0):\\n diff = -diff\\n a = np.concatenate((np.zeros(\\n (a.shape[0], diff//2)), a, np.zeros((a.shape[0], diff - diff//2))), axis=1)\\n\\n return (a, b)\",\n \"def _pad(phi, det):\\r\\n npadx = (det.x - phi.shape[1]) // 2\\r\\n npady = (det.y - phi.shape[1]) // 2\\r\\n return np.pad(phi, ((0, 0), (npadx, npadx), (npady, npady)), mode='constant')\",\n \"def pad_to(image,w,h):\\n iw,ih = image.shape\\n wd = int(w-iw)\\n assert wd>=0\\n w0 = wd/2\\n w1 = wd-w0\\n hd = int(h-ih)\\n assert hd>=0\\n h0 = hd/2\\n h1 = hd-h0\\n result = zeros((w,h))\\n result[w0:w0+iw,h0:h0+ih] = image\\n return result\",\n \"def realign(self, x, dx, y, dy, ignore=set()):\\n return ['', '', '']\",\n \"def _set_wrap_both(padded, axis, width_pair, original_period):\\n left_pad, right_pad = width_pair\\n period = padded.shape[axis] - right_pad - left_pad\\n # Avoid wrapping with only a subset of the original area by ensuring period\\n # can only be a multiple of the original area's length.\\n period = period // original_period * original_period\\n\\n # If the current dimension of `arr` doesn't contain enough valid values\\n # (not part of the undefined pad area) we need to pad multiple times.\\n # Each time the pad area shrinks on both sides which is communicated with\\n # these variables.\\n new_left_pad = 0\\n new_right_pad = 0\\n\\n if left_pad > 0:\\n # Pad with wrapped values on left side\\n # First slice chunk from left side of the non-pad area.\\n # Use min(period, left_pad) to ensure that chunk is not larger than\\n # pad area.\\n slice_end = left_pad + period\\n slice_start = slice_end - min(period, left_pad)\\n right_slice = _slice_at_axis(slice(slice_start, slice_end), axis)\\n right_chunk = padded[right_slice]\\n\\n if left_pad > period:\\n # Chunk is smaller than pad area\\n pad_area = _slice_at_axis(slice(left_pad - period, left_pad), axis)\\n new_left_pad = left_pad - period\\n else:\\n # Chunk matches pad area\\n pad_area = _slice_at_axis(slice(None, left_pad), axis)\\n padded[pad_area] = right_chunk\\n\\n if right_pad > 0:\\n # Pad with wrapped values on right side\\n # First slice chunk from right side of the non-pad area.\\n # Use min(period, right_pad) to ensure that chunk is not larger than\\n # pad area.\\n slice_start = -right_pad - period\\n slice_end = slice_start + min(period, right_pad)\\n left_slice = _slice_at_axis(slice(slice_start, slice_end), axis)\\n left_chunk = padded[left_slice]\\n\\n if right_pad > period:\\n # Chunk is smaller than pad area\\n pad_area = _slice_at_axis(\\n slice(-right_pad, -right_pad + period), axis)\\n new_right_pad = right_pad - period\\n else:\\n # Chunk matches pad area\\n pad_area = _slice_at_axis(slice(-right_pad, None), axis)\\n padded[pad_area] = left_chunk\\n\\n return new_left_pad, new_right_pad\",\n \"def pad_to_size_of(a, b):\\n a2 = pad_zeroes(a, 0, b.shape[0] - a.shape[0])\\n return pad_zeroes(a2, 1, b.shape[1] - a.shape[1])\",\n \"def pad(self, nxp, nyp):\\n assert (nxp > self.nx)\\n assert (nyp > self.ny)\\n assert (np.mod(nxp - self.nx, 2) == 0)\\n assert (np.mod(nyp - self.ny, 2) == 0)\\n\\n ret = tqumap(nx=nxp, dx=self.dx, ny=nyp, dy=self.dy)\\n for this, that in [[self.tmap, ret.tmap], [self.qmap, ret.qmap],\\n [self.umap, ret.umap]]:\\n that[(nyp - self.ny) / 2:(nyp + self.ny) / 2, (nxp - self.nx) / 2:(\\n nxp + self.nx) / 2] = this\\n return ret\",\n \"def fast_pad_shift(self, y1, y2):\\n\\n if len(y1) != len(y2):\\n raise ValueError(\\\"Input sizes must be the same\\\")\\n\\n y1_contig = np.ascontiguousarray(y1, dtype=np.float64)\\n y2_contig = np.ascontiguousarray(y2, dtype=np.float64)\\n y1_ptr = y1_contig.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n y2_ptr = y2_contig.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n\\n return self.libcalcsim.fast_pad_shift(y1_ptr, y2_ptr, len(y1))\",\n \"def conv_pad(x, ks, mode):\\n\\tpad = (int(np.floor((ks-1)/2)), int(np.ceil((ks-1)/2)))\\n\\treturn F.pad(x, (*pad, *pad), mode=mode)\",\n \"def pad_to_square(a):\\n if a.shape[1]>a.shape[0]: # pad height\\n n_to_add = a.shape[1]-a.shape[0]\\n top_pad = n_to_add//2\\n bottom_pad = n_to_add-top_pad\\n a = np.pad(a, [(top_pad, bottom_pad), (0, 0), (0, 0)], mode='constant')\\n\\n elif a.shape[0]>a.shape[1]: # pad width\\n n_to_add = a.shape[0]-a.shape[1]\\n left_pad = n_to_add//2\\n right_pad = n_to_add-left_pad\\n a = np.pad(a, [(0, 0), (left_pad, right_pad), (0, 0)], mode='constant')\\n else:\\n pass\\n return a\",\n \"def prepare_data(seqs_x, seqs_y, maxlen=None):\\n\\n lengths_x = [len(s) for s in seqs_x]\\n lengths_y = [len(s) for s in seqs_y]\\n\\n nb_samples = len(seqs_x)\\n if maxlen is None:\\n maxlen_x = numpy.max(lengths_x)\\n maxlen_y = numpy.max(lengths_y)\\n else:\\n maxlen_x = maxlen\\n maxlen_y = maxlen\\n\\n x_padded = pad_sequences(seqs_x, maxlen_x, nb_samples)\\n y_padded = pad_sequences(seqs_y, maxlen_y, nb_samples)\\n\\n x_padded = numpy.asarray(x_padded)\\n y_padded = numpy.asarray(y_padded)\\n\\n return x_padded, y_padded\",\n \"def padArray(ori_array, pad_size):\\n if (pad_size > 0):\\n [x_size, y_size] = ori_array.shape\\n lg_array = numpy.ones((x_size+2*pad_size,y_size+2*pad_size))\\n lg_array[pad_size:(x_size+pad_size),pad_size:(y_size+pad_size)] = ori_array.astype(numpy.float64)\\n lg_array[0:pad_size,:] = numpy.flipud(lg_array[pad_size:2*pad_size,:])\\n lg_array[(x_size+pad_size):(x_size+2*pad_size),:] = numpy.flipud(lg_array[x_size:(x_size+pad_size),:])\\n lg_array[:,0:pad_size] = numpy.fliplr(lg_array[:,pad_size:2*pad_size])\\n lg_array[:,(y_size+pad_size):(y_size+2*pad_size)] = numpy.fliplr(lg_array[:,y_size:(y_size+pad_size)])\\n return lg_array\\n \\n else:\\n return ori_array\",\n \"def test_on_conv_transpose_2d_padding(self):\\n x = jn.array([[[[2., 1., 3., 4.], [5., 6., 7., 8.], [9., 10., 11., 12.], [13., 14., 15., 16.]]]])\\n y = jn.array([[[[2., 5., 5., 10.], [11., 27., 32., 46.], [24., 66., 76., 86.], [40., 106., 116., 126.]]]])\\n w_init = lambda s: jn.array([[[[1., 2.], [3., 4.]]]]).transpose((2, 3, 0, 1))\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=objax.ConvPadding.SAME, w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='same', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='Same', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding='SAME', w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 0), w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 0), (1, 0)], w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y.tolist())\\n y = [[[[2., 5., 5., 10., 8.], [11., 27., 32., 46., 32.], [24., 66., 76., 86., 56.],\\n [40., 106., 116., 126., 80.], [39., 94., 101., 108., 64.]]]]\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=1, w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=(1, 1), w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\\n conv = objax.nn.ConvTranspose2D(1, 1, 2, padding=[(1, 1), (1, 1)], w_init=w_init)\\n self.assertEqual(conv(x).tolist(), y)\",\n \"def pad1D(X, pad, kernel_width=None, stride=None, dilation=0):\\n\\tX_pad = None\\n\\tp = pad\\n\\tif isinstance(p, int):\\n\\t\\tp = (p, p)\\n\\tif isinstance(p, tuple):\\n\\t\\tX_pad = np.pad(\\n\\t\\t\\tX, \\n\\t\\t\\tpad_width=((0, 0), (p[0], p[1]), (0, 0)),\\n\\t\\t\\tmode='constant',\\n\\t\\t\\t# constant_value = 0,\\n\\t\\t\\t)\\n\\n\\t# compute the correct padding dims for a 'same' or 'causal' convolution\\n\\tif p in ['same', 'causal'] and kernel_width and stride:\\n\\t\\tcausal = p == 'causal'\\n\\t\\tp = calc_pad_dims_1D(\\n\\t\\t\\tX.shape, X.shape[1], kernel_width, stride, causal=causal, dilation=dilation\\n\\t\\t\\t)\\n\\t\\tX_pad, p = pad1D(X, p)\\n\\n\\treturn X_pad, p\",\n \"def zero_pad(X, padding_width, dims):\\n dims = (dims) if isinstance(dims, int) else dims\\n pad = [(0, 0) if idx not in dims else (padding_width, padding_width)\\n for idx in range(len(X.shape))]\\n X_padded = np.pad(X, pad, 'constant')\\n return X_padded\",\n \"def _pad_data(data, pad_length, padding_type='same'):\\n\\n # get the sampling period (or distance between sampling points, for PLUX devices this is always 1)\\n # it is assumed that the signals are equidistantly sampled therefore only the distance between to sampling points\\n # is needed to calculate the sampling period\\n T = data[:, 0][1] - data[:, 0][0]\\n\\n if padding_type == 'same':\\n\\n # create the 'same' padding array\\n padding = np.tile(data[-1, 1:], (pad_length, 1))\\n\\n elif padding_type == 'zero':\\n\\n # get the number of columns for the zero padding\\n num_cols = data.shape[1] - 1 # ignoring the time/sample column\\n\\n # create the zero padding array\\n padding = np.zeros((pad_length, num_cols))\\n\\n else:\\n\\n IOError('The padding type you chose is not defined. Use either \\\\'same\\\\ or \\\\'zero\\\\'.')\\n\\n # create the time / sample axis that needs to be padded\\n start = data[:, 0][-1] + T\\n stop = start + (T * pad_length)\\n time_pad = np.arange(start, stop, T)\\n time_pad = time_pad[:pad_length] # crop the array if there are to many values\\n\\n # expand dimension for hstack operation\\n time_pad = np.expand_dims(time_pad, axis=1)\\n\\n # hstack the time_pad and the zero_pad to get the final padding array\\n pad_array = np.hstack((time_pad, padding))\\n\\n # vstack the pad_array and the new_array\\n padded_data = np.vstack([data, pad_array])\\n\\n return padded_data\",\n \"def box2pts(x1: int, y1: int, x2: int, y2: int) -> np.ndarray:\\n return np.array([[x1, y1], [x2, y1], [x2, y2], [x1, y2]])\",\n \"def pad_examples(x, desired_batch_size):\\n batch_pad = desired_batch_size - x.shape[0]\\n tile_dims = [1] * len(x.shape)\\n tile_dims[0] = batch_pad\\n return np.concatenate([x, np.tile(x[-1], tile_dims)], axis=0)\",\n \"def setPads(self, padx, pady):\\r\\n self.pack(padx=padx, pady=pady)\",\n \"def setPads(self, padx, pady):\\r\\n self.pack(padx=padx, pady=pady)\",\n \"def setPads(self, padx, pady):\\r\\n self.pack(padx=padx, pady=pady)\",\n \"def _set_pad_area(padded, axis, width_pair, value_pair):\\n left_slice = _slice_at_axis(slice(None, width_pair[0]), axis)\\n padded[left_slice] = value_pair[0]\\n\\n right_slice = _slice_at_axis(\\n slice(padded.shape[axis] - width_pair[1], None), axis)\\n padded[right_slice] = value_pair[1]\",\n \"def _pad(input_data):\\n h = input_data['img'].shape[0]\\n w = input_data['img'].shape[1]\\n max_size = max([int(np.sqrt(np.power(h, 2) + np.power(w, 2))),\\n int(w + h * np.cos(11 / 36)),\\n int(max(h, w) * 2)\\n ]) + 5\\n\\n up = (max_size - h) // 2\\n down = max_size - up - h\\n left = (max_size - w) // 2\\n right = max_size - left - w\\n\\n input_data['img'] = np.pad(input_data['img'], ((up, down), (left, right), (0, 0)), mode='constant')\\n\\n if DataAugmentor._is_synthtext(input_data):\\n input_data['contour'][0] = list(\\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\\n input_data['contour'][0]))\\n input_data['contour'][1] = list(\\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\\n input_data['contour'][1]))\\n else:\\n input_data['contour'] = list(\\n map(lambda x: np.stack([x[:, :, 0] + up, x[:, :, 1] + left], axis=-1), # x: np.array(n,1,2)\\n input_data['contour']))\\n\\n input_data['center_point'] = list(\\n map(lambda x: (x[0] + up, x[1] + left),\\n input_data['center_point']))\\n return input_data\",\n \"def slice_data_to_2D(x, y):\\n if(x.shape != y.shape):\\n print(\\\"Error: Images and Labels do not have the same shape\\\")\\n else:\\n x = np.array([(x[i, :, :, z]) for i in range(x.shape[0]) for z in range(x.shape[3])])\\n y = np.array([(y[i, :, :, z]) for i in range(y.shape[0]) for z in range(y.shape[3])])\\n return x,y\",\n \"def _get_padded_grid_(ax):\\n ax_pad = np.zeros(ax.size + 2)\\n ax_pad[1:-1] = ax\\n ax_pad[0] = ax[0] - (ax[2] - ax[1])\\n ax_pad[-1] = ax[-1] + (ax[2] - ax[1])\\n\\n return ax_pad\",\n \"def test_2D_padding(self):\\n field_names = [\\\"text\\\"]\\n mask_field_names = ['text_mask']\\n data_path = \\\"mldp/tests/data/news.csv\\\"\\n pad_symbol = \\\"<PAD>\\\"\\n mask_field_name_suffix = \\\"mask\\\"\\n padding_modes = ['left', 'right', 'both']\\n symbols_to_mask = [\\\"The\\\", \\\"a\\\", \\\"to\\\", \\\"as\\\"]\\n axis = 1\\n\\n data_chunk = read_data_from_csv_file(data_path, sep=\\\"\\\\t\\\")\\n\\n # tokenize field values\\n for fn in field_names:\\n data_chunk[fn] = np.array([seq.split() for seq in data_chunk[fn]])\\n\\n for padding_mode, symbol_to_mask in product(padding_modes,\\n symbols_to_mask):\\n padder = Padder(field_names, pad_symbol=pad_symbol,\\n new_mask_fname=mask_field_names,\\n padding_mode=padding_mode, axis=axis,\\n symbol_to_mask=symbol_to_mask)\\n padded_data_chunk = padder(copy.deepcopy(data_chunk))\\n\\n for fn, mask_fn in zip(field_names, mask_field_names):\\n padded_fv = padded_data_chunk[fn]\\n mask = padded_data_chunk[mask_fn]\\n original_fv = data_chunk[fn]\\n\\n self.assertTrue(len(padded_fv.shape) == 2)\\n self._test_padded_values(original_field_values=original_fv,\\n padded_field_values=padded_fv,\\n mask=mask, pad_symbol=pad_symbol,\\n symbol_to_mask=symbol_to_mask)\",\n \"def pad(self, left=0, top=0, bottom=0, right=0):\\n\\n self.x -= left\\n self.y -= top\\n self.width += left + right\\n self.height += top + bottom\",\n \"def _padboth(width, s):\\n fmt = \\\"{0:^%ds}\\\" % width\\n return fmt.format(s)\",\n \"def test_pad6():\\n x = np.array([[[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]])\\n pad = (2, 1, 3, 0, 2, 0)\\n mode = \\\"replicate\\\"\\n data_format = \\\"NDHWC\\\"\\n res = np.array(\\n [\\n [\\n [\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n ],\\n [\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n ],\\n [\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n [[1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [4.0, 5.0, 6.0]],\\n ],\\n ]\\n ]\\n )\\n obj.run(res=res, x=x, pad=pad, mode=mode, data_format=data_format)\",\n \"def pad(self, pad_width, mode=\\\"constant\\\", constant_values=0):\\r\\n destination = np.zeros(\\r\\n (\\r\\n self.dataset.count,\\r\\n self.__arr.shape[1] + 2 * pad_width,\\r\\n self.__arr.shape[2] + 2 * pad_width,\\r\\n ),\\r\\n self.__arr.dtype,\\r\\n )\\r\\n\\r\\n for i in range(0, self.dataset.count):\\r\\n destination[i], transform = rasterio.pad(\\r\\n self.__arr[i],\\r\\n self.dataset.transform,\\r\\n pad_width,\\r\\n mode,\\r\\n constant_values=constant_values,\\r\\n )\\r\\n\\r\\n self.__arr = destination\\r\\n self.__update_dataset(self.dataset.crs, transform, nodata=self.dataset.nodata)\",\n \"def padding(src, min_size):\\n # pad before put into convolutional layer\\n src_dim = src.dim()\\n if src_dim[0][1] >= min_size:\\n return src\\n pad_size = min_size - src_dim[0][1]\\n channels = src_dim[0][2] if len(src_dim[0]) >= 3 else 1\\n if pad_size == 1:\\n return dy.concatenate([src, dy.zeroes((src_dim[0][0], 1, channels))], d=1)\\n else:\\n left_border = int(pad_size) / 2\\n right_border = (int(pad_size)+1) / 2\\n return dy.concatenate([dy.zeroes((src_dim[0][0], left_border, channels)), src, dy.zeroes((src_dim[0][0], right_border, channels))], d=1) # do concatenate along cols\",\n \"def pad_edges(self, pad):\\n weights=[]\\n for dim, xy in zip([0, 1], [self.x, self.y]):\\n xy0 = np.mean(xy)\\n W = xy[-1]-xy[0]\\n dist = np.abs(xy-xy0)\\n wt=np.ones_like(dist)\\n wt[ dist >= W/2 - pad] = 0\\n weights += [wt]\\n self.weight *= weights[0][:,None].dot(weights[1][None,:])\",\n \"def temporal_padding(x, padding=(1, 1)):\\n assert len(padding) == 2\\n pattern = [[0, 0], [padding[0], padding[1]], [0, 0]]\\n return tf.pad(x, pattern)\",\n \"def sanitize_coordinates(_x1, _x2, img_size: int, padding: int = 0, cast: bool = True):\\n _x1 = _x1 * img_size\\n _x2 = _x2 * img_size\\n if cast:\\n _x1 = _x1.long()\\n _x2 = _x2.long()\\n coordinates_min = P.Minimum()\\n coordinates_max = P.Maximum()\\n x1 = coordinates_min(_x1, _x2)\\n x2 = coordinates_max(_x1, _x2)\\n\\n select = P.Select()\\n zeroslike = P.ZerosLike()\\n oneslike = P.OnesLike()\\n min_tensor = zeroslike(x1 - padding)\\n x1 = select(min_tensor > x1 - padding, min_tensor, x1 - padding)\\n\\n max_tensor = oneslike(x2 + padding) * img_size\\n x2 = select(x2 + padding > max_tensor, max_tensor, x2 + padding)\\n\\n\\n return x1, x2\",\n \"def padd_raw_board(board):\\n max_length = max(len(board[0]) - 1, len(board))\\n side_length = max_length + 2\\n x_padding = round((max_length - (len(board[0]) - 1)) / 2) + 1\\n y_padding = round((max_length - len(board)) / 2) + 1\\n limit = len(board)\\n padded_board = [] + [''.join(['.'] * side_length)] * y_padding\\n\\n for y in range(side_length - y_padding):\\n if y < limit:\\n row = ''.join(['.'] * x_padding) + board[y] + ''.join(['.'] * x_padding)\\n else:\\n row = ''.join(['.'] * side_length)\\n\\n padded_board.append(row)\\n\\n return padded_board\",\n \"def padImage(image, padList):\\r\\n\\r\\n #pad along far x:<---->\\r\\n padFarX= np.zeros((image.shape[0], image.shape[1], padList[0]))\\r\\n image= np.concatenate((image, padFarX), axis=2)\\r\\n\\r\\n #pad along far y\\r\\n padFarY= np.zeros((image.shape[0], padList[1], image.shape[2]))\\r\\n image= np.concatenate((image, padFarY), axis=1)\\r\\n\\r\\n #pad along far z\\r\\n padFarZ= np.zeros((padList[2], image.shape[1], image.shape[2]))\\r\\n image= np.concatenate((image, padFarZ), axis=0)\\r\\n\\r\\n #pad along close x, adjust center\\r\\n padCloseX= np.zeros((image.shape[0], image.shape[1], padList[3]))\\r\\n image= np.concatenate((padCloseX, image), axis=2)\\r\\n\\r\\n #pad along close y adjust center\\r\\n padCloseY= np.zeros((image.shape[0], padList[4], image.shape[2]))\\r\\n image= np.concatenate((padCloseY, image), axis=1)\\r\\n\\r\\n #pad along close z, adjust center\\r\\n padCloseZ= np.zeros((padList[5], image.shape[1], image.shape[2]))\\r\\n image= np.concatenate((padCloseZ, image), axis=0)\\r\\n\\r\\n\\r\\n #print \\\"PADDED IMAGE SHAPE: \\\" + str(image.shape)\\r\\n return image\",\n \"def add_padding(im, pad):\\n\\n return np.pad(im, pad_width=((pad, pad), (pad, pad), (0, 0)), mode='symmetric')\",\n \"def test_pad2():\\n x = np.array([[[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]]]])\\n pad = (0, 1, 1, 1, 2, 0)\\n mode = \\\"constant\\\"\\n value = 0\\n data_format = \\\"NCDHW\\\"\\n res = np.array(\\n [\\n [\\n [\\n [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\\n [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\\n [[0.0, 0.0, 0.0, 0.0], [1.0, 2.0, 3.0, 0.0], [4.0, 5.0, 6.0, 0.0], [0.0, 0.0, 0.0, 0.0]],\\n ]\\n ]\\n ]\\n )\\n obj.run(res=res, x=x, pad=pad, mode=mode, value=value, data_format=data_format)\",\n \"def augment(x: np.ndarray, y: np.ndarray):\\n scipy.random.seed()\\n\\n # scale = np.random.normal(1, 0.1, size=3)\\n alpha, theta = np.random.normal(0, 9, size=2)\\n alpha = 0\\n\\n for i in range(1, len(x.shape) - 1):\\n if np.random.binomial(1, .5):\\n x = np.flip(x, -i)\\n y = np.flip(y, -i)\\n\\n # mscan = np.array([_scale_crop(i) for i in mscan])\\n # segm = _scale_crop(segm[0])[np.newaxis]\\n\\n x = _rotate(x, 3, theta, alpha)\\n y = _rotate(y, 0, theta, alpha)\\n\\n # if np.random.binomial(1, .5):\\n # t = np.random.choice([-90, 0, 90])\\n # a = np.random.choice([-90, 0, 90])\\n # mscan = _rotate(mscan, 3, t, a)\\n # segm = _rotate(segm, 3, t, a)\\n\\n x = np.array([i * np.random.normal(1, 0.35) for i in x])\\n return x, y\",\n \"def _build_points(self, xs, ys):\\n return np.hstack([xs, ys])\",\n \"def add_padding(img, x_padding):\\n w = img.shape[1] + x_padding * 2\\n img_with_padding = np.zeros((img.shape[0], w, 3), dtype=img.dtype)\\n img_with_padding[:, x_padding:img.shape[1] + x_padding] = img\\n return img_with_padding\",\n \"def _pad_traces(self, X):\\n # Padding is done using using keras.preprocessing.sequence.pad_sequences(sequences, ...)\\n # maxlen: Int, maximum length of all sequences.\\n # truncating='pre' remove values at the beginning from sequences larger than maxlen\\n # padding='pre' pads each trace at the beginning with a special integer (e.g., 0)\\n X = pad_sequences(X, maxlen=self.trace_size, dtype=np.int16,\\n truncating='pre', padding='pre', value=DEFAULTS['padding_symbol'])\\n\\n print(X)\\n # Shape X is (n_traces, self.trace_size)\\n # e.g., (25002, 20)\\n\\n return X\",\n \"def pad_left(x, block_size=3, fill=0):\\n if len(x) > block_size:\\n return x\\n else:\\n right = np.array(list(str(x)))\\n left = np.repeat(str(fill), block_size - right.size )\\n return \\\"\\\".join(np.concatenate([left, right]))\",\n \"def pad(self, *args, **kwargs):\\n return _image.image_pad(self, *args, **kwargs)\",\n \"def pad_same(width, kernel, slide):\\n res = (width - kernel) / slide + 1\\n pad = (width - res) / 2\\n return pad\",\n \"def call(self, x):\\n return tf.pad(x, self.paddings,\\n mode=self.mode)\",\n \"def _get_padding(w, h):\\n dim_diff = np.abs(h - w)\\n pad1, pad2 = dim_diff // 2, dim_diff - dim_diff // 2\\n return (0, pad1, 0, pad2) if h <= w else (pad1, 0, pad2, 0)\",\n \"def pad_and_onehot(data, pad_len=None, extra_padding=200):\\n if pad_len is None:\\n pad_len = max(len(x) for x in data) + extra_padding\\n data = [\\n onehot(np.pad(trace, (0, pad_len - len(trace)), mode=\\\"constant\\\"))\\n for trace in data\\n ]\\n return pad_len, np.array(data)\",\n \"def combine_last_two_dim(self, x):\\n old_shape = list(x.size())\\n a, b = old_shape[-2:]\\n new_shape = old_shape[:-2] + [a * b if a and b else None]\\n ret = x.contiguous().view(new_shape)\\n return ret\",\n \"def combine_last_two_dim(self, x):\\n old_shape = list(x.size())\\n a, b = old_shape[-2:]\\n new_shape = old_shape[:-2] + [a * b if a and b else None]\\n ret = x.contiguous().view(new_shape)\\n return ret\",\n \"def combine_last_two_dim(self, x):\\n old_shape = list(x.size())\\n a, b = old_shape[-2:]\\n new_shape = old_shape[:-2] + [a * b if a and b else None]\\n ret = x.contiguous().view(new_shape)\\n return ret\",\n \"def _pad_image(self, img: ndarray, pad_width: int = 10) -> ndarray:\\n self.padded_img = np.zeros(\\n (img.shape[0] + pad_width*2, img.shape[1]+pad_width*2))\\n self.padded_img[pad_width:-pad_width, pad_width:-pad_width] = img\\n return self.padded_img\",\n \"def union(self, x, y):\\n \\n px, py = self.find(x), self.find(y)\\n if px != py:\\n \\n if self.size[px] > self.size[py]:\\n px, py = py, px\\n \\n\\n self.parent[px] = py\\n self.size[py] += self.size[px]\",\n \"def procrustes(a,target,side='both',padval=0):\\n\\n try:\\n if len(target) != a.ndim:\\n raise TypeError('Target shape must have the same number of dimensions as the input')\\n except TypeError:\\n raise TypeError('Target must be array-like')\\n\\n try:\\n b = np.ones(target,a.dtype)*padval\\n except TypeError:\\n raise TypeError('Pad value must be numeric')\\n except ValueError:\\n raise ValueError('Pad value must be scalar')\\n\\n aind = [slice(None,None)]*a.ndim\\n bind = [slice(None,None)]*a.ndim\\n\\n # pad/trim comes after the array in each dimension\\n if side == 'after':\\n for dd in xrange(a.ndim):\\n if a.shape[dd] > target[dd]:\\n aind[dd] = slice(None,target[dd])\\n elif a.shape[dd] < target[dd]:\\n bind[dd] = slice(None,a.shape[dd])\\n\\n # pad/trim comes before the array in each dimension\\n elif side == 'before':\\n for dd in xrange(a.ndim):\\n if a.shape[dd] > target[dd]:\\n aind[dd] = slice(a.shape[dd]-target[dd],None)\\n elif a.shape[dd] < target[dd]:\\n bind[dd] = slice(target[dd]-a.shape[dd],None)\\n\\n # pad/trim both sides of the array in each dimension\\n elif side == 'both':\\n for dd in xrange(a.ndim):\\n if a.shape[dd] > target[dd]:\\n diff = (a.shape[dd]-target[dd])/2.\\n aind[dd] = slice(np.floor(diff),a.shape[dd]-np.ceil(diff))\\n elif a.shape[dd] < target[dd]:\\n diff = (target[dd]-a.shape[dd])/2.\\n bind[dd] = slice(np.floor(diff),target[dd]-np.ceil(diff))\\n\\n else:\\n raise Exception('Invalid choice of pad type: %s' %side)\\n\\n b[bind] = a[aind]\\n\\n return b\",\n \"def make_simple_coords():\\n \\n x = np.array([144, 124, 97, 165, 114, 60, 165, 0, 76, 50, 147])\\n y = np.array([ 0, 3, 21, 28, 34, 38, 51, 54, 58, 56, 61])\\n coords = np.vstack((x,y)).T\\n return coords\",\n \"def transpose_coordinates(self, x, y):\\n return (x, self.height - 1 - y)\",\n \"def _pad_to_full_keypoint_dim(keypoint_coords, keypoint_scores, keypoint_inds,\\n num_total_keypoints):\\n batch_size, num_instances, _, _ = (\\n shape_utils.combined_static_and_dynamic_shape(keypoint_coords))\\n kpt_coords_transposed = tf.transpose(keypoint_coords, [2, 0, 1, 3])\\n kpt_scores_transposed = tf.transpose(keypoint_scores, [2, 0, 1])\\n kpt_inds_tensor = tf.expand_dims(keypoint_inds, axis=-1)\\n kpt_coords_scattered = tf.scatter_nd(\\n indices=kpt_inds_tensor,\\n updates=kpt_coords_transposed,\\n shape=[num_total_keypoints, batch_size, num_instances, 2])\\n kpt_scores_scattered = tf.scatter_nd(\\n indices=kpt_inds_tensor,\\n updates=kpt_scores_transposed,\\n shape=[num_total_keypoints, batch_size, num_instances])\\n keypoint_coords_padded = tf.transpose(kpt_coords_scattered, [1, 2, 0, 3])\\n keypoint_scores_padded = tf.transpose(kpt_scores_scattered, [1, 2, 0])\\n return keypoint_coords_padded, keypoint_scores_padded\",\n \"def spatial_reflection_2d_padding(x, padding=((1, 1), (1, 1)),\\n data_format=None):\\n assert len(padding) == 2\\n assert len(padding[0]) == 2\\n assert len(padding[1]) == 2\\n if data_format is None:\\n data_format = image_data_format()\\n if data_format not in {'channels_first', 'channels_last'}:\\n raise ValueError('Unknown data_format ' + str(data_format))\\n\\n if data_format == 'channels_first':\\n pattern = [[0, 0],\\n [0, 0],\\n list(padding[0]),\\n list(padding[1])]\\n else:\\n pattern = [[0, 0],\\n list(padding[0]), list(padding[1]),\\n [0, 0]]\\n return tf.pad(x, pattern, \\\"REFLECT\\\")\",\n \"def _fix_coords(x, y):\\n if x.ndim != 1 or all(x < x[0]): # skip 2D arrays and monotonic backwards data\\n return x, y\\n lon1 = x[0]\\n filter_ = x < lon1\\n while filter_.sum():\\n filter_ = x < lon1\\n x[filter_] += 360\\n return x, y\",\n \"def augment_data(X, y):\\n X_flip = np.copy(X)\\n X_flip[:,:,::2] = -X_flip[:,:,::2]\\n X = np.concatenate((X, X_flip))\\n y = np.concatenate((y, y))\\n \\n return X, y\",\n \"def spatial_reflection_2d_padding(x, padding=((1, 1), (1, 1)), data_format=None):\\n assert len(padding) == 2\\n assert len(padding[0]) == 2\\n assert len(padding[1]) == 2\\n if data_format is None:\\n data_format = image_data_format()\\n if data_format not in {'channels_first', 'channels_last'}:\\n raise ValueError('Unknown data_format ' + str(data_format))\\n\\n if data_format == 'channels_first':\\n pattern = [[0, 0],\\n [0, 0],\\n list(padding[0]),\\n list(padding[1])]\\n else:\\n pattern = [[0, 0],\\n list(padding[0]), list(padding[1]),\\n [0, 0]]\\n return tf.pad(x, pattern, \\\"REFLECT\\\")\",\n \"def pad(data, *args, **kwargs): # pragma: no cover\\n raise NotImplementedError()\",\n \"def offset_y(self, X, y):\\n X, y = self.check_consistent_params(X, y)\\n if len(y.shape) == 1:\\n offset = len(y) - X.shape[0]\\n return y[offset:]\\n else:\\n offset = len(y[0]) - X.shape[0]\\n return y[0, offset:]\",\n \"def test_zero_pad():\\r\\n # Freely assume that time is the last dimension:\\r\\n ts1 = np.empty((64, 64, 35, 32))\\r\\n NFFT = 64 \\r\\n zp1 = utils.zero_pad(ts1, NFFT)\\r\\n npt.assert_equal(zp1.shape[-1], NFFT)\\r\\n\\r\\n # Try this with something with only 1 dimension:\\r\\n ts2 = np.empty(64)\\r\\n zp2 = utils.zero_pad(ts2, NFFT)\\r\\n npt.assert_equal(zp2.shape[-1], NFFT)\",\n \"def concatenate_offset(self, X):\\n return np.c_[np.ones((X.shape[0], 1)), X]\",\n \"def get_pad2(s1, s2):\\n return \\\" \\\" * (40 - len(s1) - len(s2))\",\n \"def pad_limits(xgrid, ygrid, xpad=0., ypad=0., square=None):\\n\\n xmin, xmax = xgrid.min(), xgrid.max()\\n ymin, ymax = ygrid.min(), ygrid.max()\\n dx = xmax - xmin\\n dy = ymax - ymin\\n x0 = xmin - xpad*dx\\n x1 = xmax + xpad*dx\\n y0 = ymin - ypad*dy\\n y1 = ymax + ypad*dy\\n\\n if square:\\n axis = square\\n ax_position = axis.get_position()\\n ax_height = ax_position.height * axis.figure.get_figheight()\\n ax_width = ax_position.width * axis.figure.get_figwidth()\\n ax_aspect = ax_height / ax_width\\n\\n im_height = y1 - y0\\n im_width = x1 - x0\\n im_aspect = im_height / im_width\\n\\n if (im_height/im_width) > (ax_height/ax_width):\\n # Image too tall\\n extra_w = im_height/ax_aspect - im_width\\n x0 -= extra_w / 2\\n x1 += extra_w / 2\\n else:\\n # Image too wide\\n extra_h = im_width*ax_aspect - im_height\\n y0 -= extra_h / 2\\n y1 += extra_h / 2\\n\\n return [x0, x1, y0, y1]\",\n \"def adjustCoordByBorders(self, x, y):\\n (x_offset, y_offset) = (0, 0)\\n if (127 < x < (255+4)):\\n x_offset -= 4\\n \\n if (31 < y < (63+4*1)):\\n y_offset -= 4\\n elif ( (63+4*1) < y < (95+4*2) ):\\n y_offset -= 4*2\\n elif ( (95+4*2) < y < (127+4*3) ):\\n y_offset -= 4*3\\n elif ( (127+4*3) < y < (159+4*4) ):\\n y_offset -= 4*4\\n elif ( (159+4*4) < y < (191+4*5) ):\\n y_offset -= 4*5\\n elif ( (191+4*5) < y < (223+4*6) ):\\n y_offset -= 4*6\\n elif ( (223+4*6) < y < (255+4*7) ):\\n y_offset -= 4*7\\n return x_offset, y_offset\",\n \"def to_same_dim(a, b):\\n\\n if len(a) > len(b):\\n return a, padding(b, len(a))\\n\\n elif len(a) < len(b):\\n return padding(a, len(b)), b\\n\\n else:\\n return a, b\",\n \"def pad_bounds(\\n bounds: tuple[int, int, int, int],\\n padding: int | tuple[int, int] | tuple[int, int, int, int],\\n) -> tuple[int, int, int, int]:\\n if np.size(bounds) % 2 != 0:\\n msg = \\\"Bounds must have an even number of elements.\\\"\\n raise ValueError(msg)\\n ndims = np.size(bounds) // 2\\n\\n if np.size(padding) not in [1, 2, np.size(bounds)]:\\n msg = \\\"Invalid number of padding elements.\\\"\\n raise ValueError(msg)\\n\\n if np.size(padding) == 1 or np.size(padding) == np.size(bounds):\\n pass\\n elif np.size(padding) == ndims: # pragma: no cover\\n padding = np.tile(padding, 2)\\n\\n signs = np.repeat([-1, 1], ndims)\\n return np.add(bounds, padding * signs)\",\n \"def _pad_img(self, results):\\n pad_val = self.pad_val.get('img', 0)\\n for key in results.get('img_fields', ['img']):\\n if self.pad_to_square:\\n max_size = max(results[key].shape[:2])\\n self.size = (max_size, max_size)\\n if self.size is not None:\\n padded_img = general_ocr.impad(\\n results[key], shape=self.size, pad_val=pad_val)\\n elif self.size_divisor is not None:\\n padded_img = general_ocr.impad_to_multiple(\\n results[key], self.size_divisor, pad_val=pad_val)\\n results[key] = padded_img\\n results['pad_shape'] = padded_img.shape\\n results['pad_fixed_size'] = self.size\\n results['pad_size_divisor'] = self.size_divisor\",\n \"def pad_shift(x, shift, padv=0.0):\\n if shift > 0:\\n padding = torch.ones(x.size(0), shift, x.size(2)).to(x.device) * padv\\n return torch.cat((padding, x[:, :-shift, :]), dim=1)\\n elif shift < 0:\\n padding = torch.ones(x.size(0), -shift, x.size(2)).to(x.device) * padv\\n return torch.cat((x[:, -shift:, :], padding), dim=1)\\n else:\\n return x\",\n \"def pad_sequences_2d(sequences, max_len_1=None, max_len_2=None, dtype='int32', padding='post',\\n truncating='post', value=0.):\\n lengths_1, lengths_2 = [], []\\n for s in sequences:\\n lengths_1.append(len(s))\\n for t in s:\\n lengths_2.append(len(t))\\n if max_len_1 is None:\\n max_len_1 = np.max(lengths_1)\\n if max_len_2 is None:\\n max_len_2 = np.max(lengths_2)\\n\\n num_samples = len(sequences)\\n x = (np.ones((num_samples, max_len_1, max_len_2)) * value).astype(dtype)\\n for i, s in enumerate(sequences):\\n if not len(s):\\n continue # empty list was found\\n\\n if truncating == 'pre':\\n s = s[-max_len_1:]\\n elif truncating == 'post':\\n s = s[:max_len_1]\\n else:\\n raise ValueError('Truncating type \\\"%s\\\" not understood' % truncating)\\n\\n y = (np.ones((len(s), max_len_2)) * value).astype(dtype)\\n for j, t in enumerate(s):\\n if not len(t):\\n continue\\n\\n if truncating == 'pre':\\n trunc = t[-max_len_2:]\\n elif truncating == 'post':\\n trunc = t[:max_len_2]\\n else:\\n raise ValueError('Truncating type \\\"%s\\\" not understood' % truncating)\\n\\n trunc = np.asarray(trunc, dtype=dtype)\\n\\n if padding == 'post':\\n y[j, :len(trunc)] = trunc\\n elif padding == 'pre':\\n y[j, -len(trunc):] = trunc\\n else:\\n raise ValueError('Padding type \\\"%s\\\" not understood' % padding)\\n\\n if padding == 'post':\\n x[i, :y.shape[0], :] = y\\n elif padding == 'pre':\\n x[i, -y.shape[0]:, :] = y\\n else:\\n raise ValueError('Padding type \\\"%s\\\" not understood' % padding)\\n\\n return x\",\n \"def pad2d_hw_shape(\\n h_w: Union[int, Tuple[int, int]],\\n pad_size: Union[int, Tuple[int, int], Tuple[int, int, int, int]] = 1,\\n) -> Tuple[int, int]:\\n h_w = replicate(h_w)\\n if isinstance(pad_size, Sequence) and len(pad_size) == 4:\\n pad = (pad_size[2:], pad_size[:2]) # NOTE: permuted torch quadruple pad order\\n else:\\n pad_size = replicate(pad_size)\\n pad = (replicate(pad_size[0]), replicate(pad_size[1]))\\n\\n h = h_w[0] + sum(pad[0]) # Sum across pad[0] (top,bottom)\\n w = h_w[1] + sum(pad[1]) # Sum across pad[1] (left,right)\\n\\n return h, w\",\n \"def _pad_simple(array, pad_width, fill_value=None):\\n # Allocate grown array\\n new_shape = tuple(\\n left + size + right\\n for size, (left, right) in zip(array.shape, pad_width)\\n )\\n order = 'F' if array.flags.fnc else 'C' # Fortran and not also C-order\\n padded = np.empty(new_shape, dtype=array.dtype, order=order)\\n\\n if fill_value is not None:\\n padded.fill(fill_value)\\n\\n # Copy old array into correct space\\n original_area_slice = tuple(\\n slice(left, left + size)\\n for size, (left, right) in zip(array.shape, pad_width)\\n )\\n padded[original_area_slice] = array\\n\\n return padded, original_area_slice\",\n \"def pad_prediction(prediction, input_size, pad_with=-1.0):\\n pad_pred = pad_with * np.ones(input_size).astype(float)\\n pred_size = prediction.shape\\n D = ((input_size[0]-pred_size[0])//2, (input_size[1]-pred_size[1])//2)\\n pad_pred[D[0]:D[0]+pred_size[0], D[1]:D[1]+pred_size[1]] = prediction\\n return pad_pred\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72084653","0.64343303","0.6101265","0.6084313","0.60171574","0.5993216","0.5956909","0.59541947","0.59405696","0.59165305","0.5867438","0.58579695","0.5835595","0.58168256","0.5816696","0.5811862","0.57709336","0.5734227","0.5715207","0.5693807","0.5685594","0.56716037","0.5655434","0.5645771","0.56332433","0.56179816","0.5614423","0.561144","0.5607164","0.5600531","0.5599556","0.55775106","0.555374","0.5534224","0.55270535","0.5523396","0.55013925","0.5481812","0.54587626","0.54567003","0.5456519","0.54403275","0.5439006","0.5439006","0.5439006","0.54378694","0.5427207","0.5426555","0.5425385","0.54189515","0.53858006","0.53691804","0.5342965","0.534195","0.53370446","0.53266704","0.53250974","0.5311615","0.530582","0.5305354","0.5296345","0.52796847","0.527375","0.5272322","0.5266368","0.5262062","0.52597326","0.5249665","0.52480847","0.52465826","0.5240129","0.52372265","0.5236879","0.5236879","0.5236879","0.5224699","0.5200131","0.51967233","0.51810575","0.5177643","0.516494","0.51535666","0.5152159","0.5150293","0.51410145","0.51361704","0.51349235","0.5129904","0.5120702","0.5118506","0.5106021","0.51042974","0.5102889","0.5089544","0.50868666","0.5086314","0.50779325","0.5062799","0.5058533","0.505475"],"string":"[\n \"0.72084653\",\n \"0.64343303\",\n \"0.6101265\",\n \"0.6084313\",\n \"0.60171574\",\n \"0.5993216\",\n \"0.5956909\",\n \"0.59541947\",\n \"0.59405696\",\n \"0.59165305\",\n \"0.5867438\",\n \"0.58579695\",\n \"0.5835595\",\n \"0.58168256\",\n \"0.5816696\",\n \"0.5811862\",\n \"0.57709336\",\n \"0.5734227\",\n \"0.5715207\",\n \"0.5693807\",\n \"0.5685594\",\n \"0.56716037\",\n \"0.5655434\",\n \"0.5645771\",\n \"0.56332433\",\n \"0.56179816\",\n \"0.5614423\",\n \"0.561144\",\n \"0.5607164\",\n \"0.5600531\",\n \"0.5599556\",\n \"0.55775106\",\n \"0.555374\",\n \"0.5534224\",\n \"0.55270535\",\n \"0.5523396\",\n \"0.55013925\",\n \"0.5481812\",\n \"0.54587626\",\n \"0.54567003\",\n \"0.5456519\",\n \"0.54403275\",\n \"0.5439006\",\n \"0.5439006\",\n \"0.5439006\",\n \"0.54378694\",\n \"0.5427207\",\n \"0.5426555\",\n \"0.5425385\",\n \"0.54189515\",\n \"0.53858006\",\n \"0.53691804\",\n \"0.5342965\",\n \"0.534195\",\n \"0.53370446\",\n \"0.53266704\",\n \"0.53250974\",\n \"0.5311615\",\n \"0.530582\",\n \"0.5305354\",\n \"0.5296345\",\n \"0.52796847\",\n \"0.527375\",\n \"0.5272322\",\n \"0.5266368\",\n \"0.5262062\",\n \"0.52597326\",\n \"0.5249665\",\n \"0.52480847\",\n \"0.52465826\",\n \"0.5240129\",\n \"0.52372265\",\n \"0.5236879\",\n \"0.5236879\",\n \"0.5236879\",\n \"0.5224699\",\n \"0.5200131\",\n \"0.51967233\",\n \"0.51810575\",\n \"0.5177643\",\n \"0.516494\",\n \"0.51535666\",\n \"0.5152159\",\n \"0.5150293\",\n \"0.51410145\",\n \"0.51361704\",\n \"0.51349235\",\n \"0.5129904\",\n \"0.5120702\",\n \"0.5118506\",\n \"0.5106021\",\n \"0.51042974\",\n \"0.5102889\",\n \"0.5089544\",\n \"0.50868666\",\n \"0.5086314\",\n \"0.50779325\",\n \"0.5062799\",\n \"0.5058533\",\n \"0.505475\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7147605"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":85158,"cells":{"query":{"kind":"string","value":"Calculate cross entropy loss while ignoring padding."},"document":{"kind":"string","value":"def padded_cross_entropy_loss(logits, labels, smoothing, vocab_size):\n with tf.compat.v1.name_scope(\"loss\", values=[logits, labels]):\n logits, labels = _pad_tensors_to_same_length(logits, labels)\n\n # Calculate smoothing cross entropy\n with tf.compat.v1.name_scope(\"smoothing_cross_entropy\", values=[logits, labels]):\n confidence = 1.0 - smoothing\n low_confidence = (1.0 - confidence) / tf.cast(vocab_size - 1, dtype=tf.float32)\n soft_targets = tf.one_hot(\n tf.cast(labels, tf.int32),\n depth=vocab_size,\n on_value=confidence,\n off_value=low_confidence)\n xentropy = tf.nn.softmax_cross_entropy_with_logits(\n logits=logits, labels=soft_targets)\n\n # Calculate the best (lowest) possible value of cross entropy, and\n # subtract from the cross entropy loss.\n normalizing_constant = -(\n confidence * tf.math.log(confidence) + tf.cast(vocab_size - 1, dtype=tf.float32) *\n low_confidence * tf.math.log(low_confidence + 1e-20))\n xentropy -= normalizing_constant\n\n weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)\n return xentropy * weights, weights"},"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 cross_entropy_loss():\n return nn.CrossEntropyLoss()","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\n y_pred = tf.cast(y_pred, 'float64')\n y_true = tf.cast(y_true, 'float64')\n # deduce weights based on true pixel value\n class_weights = weights * y_true\n # compute your (unweighted) softmax cross entropy loss\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\n ##print(unweighted_losses.dtype, weights.dtype)\n weighted_losses = unweighted_losses * class_weights\n # reduce the result to get your final loss\n loss = -tf.reduce_sum(weighted_losses)\n return loss","def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\n norm_log = log_softmax(input, 1)\n\n np_one_hot = np.eye(input.shape[1])[target.data]\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\n\n mask = -norm_log * tensor_one_hot\n mask_sum = sum(mask, 1)\n loss = sum(mask_sum, 0)\n\n return loss / input.shape[0]","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def cross_entropy(self):\n return self._cross_entropy_func","def loss_calc(pred, label, device):\n # out shape batch_size x channels x h x w -> batch_size x channels x h x w\n # label shape h x w x 1 x batch_size -> batch_size x 1 x h x w\n label = Variable(label.long()).to(device)\n criterion = CrossEntropy2d().to(device)\n\n return criterion(pred, label)","def calculate_loss(self, pred, gold, smoothing=False):\n gold = gold.contiguous().view(-1)\n if smoothing:\n epsilon = 0.1\n n_class = pred.size(1)\n one_hot = torch.zeros_like(pred).scatter(1, gold.view(-1, 1), 1)\n one_hot = one_hot * (1 - epsilon) + \\\n (1 - one_hot) * epsilon / (n_class - 1)\n\n log_prb = F.log_softmax(pred, dim=1)\n # create non-padding mask with torch.ne()\n non_pad_mask = gold.ne(self.constants.PAD)\n loss = -(one_hot * log_prb).sum(dim=1)\n # losses are averaged later\n loss = loss.masked_select(non_pad_mask).sum()\n else:\n loss = F.cross_entropy(\n pred, gold, ignore_index=self.constants.PAD, reduction='sum')\n return loss","def loss_calc(pred, label, device):\r\n # out shape batch_size x channels x h x w -> batch_size x channels x h x w\r\n # label shape h x w x 1 x batch_size -> batch_size x 1 x h x w\r\n label = label.long().to(device)\r\n return cross_entropy_2d(pred, label)","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def test_cross_entropy(self):\n loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n kl = loss.mean()\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertAlmostEqual(kl, expected_loss)","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def cross_entropy(y_observed, p):\n\n pass","def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def test_aux_softmax_cross_entropy(self):\n loss_op = listwise_losses.AuxiliarySoftmaxCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true_aux, y_pred)\n assert np.isclose(loss, 0.88127804, atol=1e-5)","def loss_sce(y_pred, y_true):\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\n\n return tf.reduce_mean(loss)","def loss(params: hk.Params, batch, label) -> jnp.ndarray:\r\n logits = net.apply(params, batch)\r\n labels = jax.nn.one_hot(label, n_classes)\r\n\r\n # Cross Entropy Loss\r\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\r\n softmax_xent /= labels.shape[0]\r\n return softmax_xent","def calculate_loss(self, train_x, train_y):\n self.log.info(\"Calculating average categorical crossentropy loss...\")\n\n num_words = np.sum([len(y) for y in train_y])\n return self.calculate_total_loss(train_x, train_y)/float(num_words)","def compute_loss(self):\n def calc_loss(inputs, outputs):\n reconstruction_loss = tf.metrics.binary_crossentropy(\n tf_flat(inputs), tf_flat(outputs))\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\n self.mu) - tf.exp(self.log_sigma), 1)\n return tf.reduce_mean(reconstruction_loss + kl_loss)\n return calc_loss","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def cross_entropy_loss(predictions, targets, epsilon=1e-12):\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n N = predictions.shape[0]\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\n return ce","def compute_cross_entropy(probs, target):\n avg_probs_per_sample = probs.mean(\n -1)\n xe = torch.nn.CrossEntropyLoss(reduction='none')\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()","def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\n if type(y_pred) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_pred)))\n if type(y_true) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_true)))\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\n # y_pred = clip(y_pred)\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\n loss = -1 * np.sum(l).item()\n if normalize:\n loss = loss / len(y_pred)\n return loss","def compute_loss(self):\n self.prototypes = self.compute_prototypes()\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.episode.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\n log_pred = ivy.log(pred)\n # noinspection PyUnresolvedReferences\n return -ivy.reduce_sum(log_pred * true, axis)","def loss_softmax_cross_entropy(self, unet, predict, ground_truth):\n\n loss = -F.mean(F.log(predict+1e-16) * ground_truth)\n\n chainer.report({\"loss\":loss}, unet)#mistery\n return loss","def test_softmax_cross_entropy(self):\n loss_op = listwise_losses.SoftmaxCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true, y_pred)\n assert np.isclose(loss, 1.306335, atol=1e-5)","def loss_fn(y_true,y_pred): \n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\n y_pred,\n axis=-1,\n )\n loss = tf.reduce_mean(loss,name=\"loss\")\n return loss","def cross_entropy(y, y_hat):\n return -tf.math.log(\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\n )","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def loss(y, y_pred):\n # assert_is_binary(y)\n # assert_is_stochastic(y_pred)\n is_binary(y)\n is_stochastic(y_pred)\n\n # prevent taking the log of 0\n eps = np.finfo(float).eps\n\n # each example is associated with a single class; sum the negative log\n # probability of the correct label over all samples in the batch.\n # observe that we are taking advantage of the fact that y is one-hot\n # encoded!\n cross_entropy = -np.sum(y * np.log(y_pred + eps))\n return cross_entropy","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def cross_entropy_loss(batch_out, batch_gt):\r\n criterion = torch.nn.CrossEntropyLoss()\r\n target = torch.argmax(batch_gt, 1)\r\n loss = criterion(batch_out, target)\r\n\r\n return loss","def crossentropy_loss(y_true, y_pred):\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \n return ce","def cross_entropy(X, y, using_onehot=True):\n\tM = y.shape[0]\n\tif using_onehot :\n\t\tlog_likelihood = -np.log(np.max(X * y, -1))\n\telse:\n\t\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\n\tloss = np.sum(log_likelihood) / M\n\treturn loss","def loss_fn(outputs, labels, wts):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\n\t\n # compute cross entropy loss for all tokens\n return loss","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def softmax_cross_entropy_loss(self, y, y_hat):\n batch_size = y.shape[0]\n return -(y - y_hat) / batch_size","def _initLoss(self):\n\n return torch.nn.CrossEntropyLoss()","def test_with_cross_entropy_loss(self):\n predict = torch.randn(self.batch, self.num_classes, self.img_size, self.img_size)\n target = self._get_default_target_tensor()\n mask = self._get_default_mask_tensor()\n\n loss_weigths = [1.0, 0.5]\n ce_crit = nn.CrossEntropyLoss(reduction=\"none\")\n mask_ce_crit = MaskAttentionLoss(criterion=ce_crit, loss_weights=loss_weigths)\n\n # expected result\n ce_loss = ce_crit(predict, target)\n _mask = mask.view_as(ce_loss)\n mask_loss = ce_loss * _mask\n mask_loss = mask_loss[_mask == 1] # consider only mask samples for mask loss computing\n expected_loss = ce_loss.mean() * loss_weigths[0] + mask_loss.mean() * loss_weigths[1]\n\n # mask ce loss result\n loss = mask_ce_crit(predict, target, mask)\n\n self._assertion_torch_values(expected_loss, loss)","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def softmax_cross_entropy(y, label):\r\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\r\n return losses\r\n pass","def loss_op(logits, labels):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name='xentropy_eval')\n\n loss = math_ops.reduce_mean(cross_entropy)\n return loss","def calculate_loss(self, y, y_hat):\r\n return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y_hat))","def calculate_loss(self, output, target, redmode = 'mean'):\n\n loss = F.cross_entropy(output, target, reduction = redmode)\n return loss","def _loss(self):\n\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\n self.loss = cross_entropy\n\n self.accuracy = tf.reduce_mean(\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))","def crossEntropyLoss(YPredict, YTrueOneHot):\n if YPredict.shape != YTrueOneHot.shape:\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))","def __test_cross_entropy_loss():\n y = np.array([[0, 1], [1, 0], [1, 0]])\n yhat = np.array([[.5, .5], [.5, .5], [.5, .5]])\n\n test1 = cross_entropy_loss(tf.constant(y, dtype=tf.int32), tf.constant(yhat, dtype=tf.float32))\n with tf.Session() as sess:\n test1 = sess.run(test1)\n expected = -3 * np.log(.5)\n __test_all_close(\"Cross-entropy test 1\", test1, expected)\n\n print(\"Basic (non-exhaustive) cross-entropy tests pass\")","def cross_entropoy_loss_vectorized(W, X, y, reg): \n loss = 0 \n dW = np.zeros_like(W)\n N, D = X.shape \n \n \n scores = X.dot(W) # [K, N]\n # for numerical stability)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[range(N),y] \n scores_exp_sum = np.sum(scores_exp, axis=1) \n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= N\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = scores_exp.T / scores_exp_sum \n scores_exp_normalized[y, range(N)] -= 1 \n dW = np.dot(scores_exp_normalized,X)\n dW = dW.T\n dW /= N \n dW += reg * W\n \n \n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def crossentropy_max_core(y_true, y_pred):\n\n # hyper param\n print(_m)\n y_pred = K.clip(y_pred, K.epsilon(), 1)\n\n # compute loss for every data point\n _loss = -K.sum(y_true * K.log(y_pred), axis=-1)\n\n # threshold\n t_m = K.max(_loss) * _m\n _mask_m = 1 - (K.cast(K.greater(_loss, t_m), 'float32'))\n _loss = _loss * _mask_m\n\n return _loss","def compute_test_loss(self, x):\n temp_training = self.training\n self.training = False\n mean, logvar = self.encode(x)\n z = self.reparameterize(mean, logvar)\n x_logit = self.decode(z)\n\n cross_ent = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_logit, labels=x)\n logpx_z = -tf.math.reduce_sum(cross_ent, axis=[1, 2, 3]) # JAH removed 3D axis=[1, 2, 3,4]\n logpz = self.log_normal_pdf(z, 0.0, 0.0)\n logqz_x = self.log_normal_pdf(z, mean, logvar)\n\n\n kl_divergence = logqz_x - logpz\n neg_log_likelihood = -logpx_z\n\n #elbo = tf.math.reduce_mean(-self.kl_weight * kl_divergence - neg_log_likelihood) # shape=()\n neg_elbo = tf.math.reduce_mean(self.kl_weight * kl_divergence + neg_log_likelihood) # shape=()\n self.training = temp_training\n return neg_elbo","def cross_entropy(self, sents):\n return (-1) * self.log_prob(sents) / len(self._count)","def setup_loss(self):\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\n #self.loss = nn.CrossEntropyLoss()","def loss(logits, labels):\n labels = tf.to_int64(labels)\n# labels = tf.to_float(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\n# y_conv = tf.nn.softmax(logits)\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def cross_entropy(input1, target, size_average=True):\n logsoftmax = nn.LogSoftmax(dim=0)\n return torch.sum(-target * logsoftmax(input1))\n # if size_average:\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\n # else:\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))","def loss(output, y):\n #Computes softmax cross entropy between logits and labels.\n xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y)\n loss = tf.reduce_mean(xentropy)\n\n return loss","def delta_cross_entropy_softmax(outputs, labels):\n \n m = labels.shape[0]\n grad = outputs\n \n grad[range(m),labels] -= torch.tensor(1.)\n\n grad = grad/m\n avg_grads = grad\n return avg_grads","def cross_entropy(Y, Y_hat, epsilon=1e-8):\n \n m = Y.shape[0]\n \n # make data safe\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\n \n # calc cost\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\n cost = np.squeeze(cost)\n \n # calc gradient\n dY_hat = -Y / Y_hat\n \n return cost, dY_hat","def classification_loss(self, logit, target):\n return F.cross_entropy(logit, target)","def compute_loss(self, x, y):\n\n self.batch_size = x.shape[0]\n self.x = x\n self.y = y\n self.soft = self.softmax(x) + 10**(-11)\n out = np.zeros(self.batch_size)\n for i in range(self.batch_size):\n out[i] = -(y[i] @ np.log(self.soft[i]))\n\n return out","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def cross_entropy_with_probs(pred_probs, target_probs, name=None):\n with tf.name_scope(name, \"SoftmaxCrossEntropyWithProb\", [pred_probs, target_probs]):\n crossent_loss = -tf.reduce_sum(target_probs * tf.log(pred_probs), reduction_indices=[1], keep_dims=False)\n return crossent_loss","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n num_train_sample = X.shape[0] #row of train data\n num_class = W.shape[1] #column of weight, plane,horse..\n for i in range(num_train_sample):\n p_score = X[i].dot(W) #a row of score corresponding to each class\n p_score -= np.max(p_score) #normalize, highest is 1\n\n ###compute softmax loss\n # sum of scores corresponding to different classes of a sample \n sum_score = np.sum(np.exp(p_score)) \n # each class's score over sum_score of a sample \n score_i = lambda k: np.exp(p_score[k]) / sum_score\n # for the correct label in each sample, find softmax loss over sum\n # iteration make loss sum up all samples\n loss = loss - np.log(score_i(y[i]))\n\n for k in range(num_class):\n p_k = score_i(k)\n # gradient of softmax\n dW[:, k] += (p_k - (k == y[i])) * X[i]\n\n loss /= num_train_sample\n loss += 0.5 * reg * np.sum(W * W)\n dW /= num_train_sample\n dW += reg*W\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def dice_loss(pred, gr_truth):\n gr_truth = tf.cast(gr_truth, dtype='int32')\n gr_truth = one_hot(gr_truth)\n dice = 0\n\n for i in range(8):\n top = tf.reduce_mean(pred[:, :, :, :, i] * gr_truth[:, :, :, :, i])\n g = tf.reduce_sum(pred[:, :, :, :, i] * pred[:, :, :, :, i])\n p = tf.reduce_sum(gr_truth[:, :, :, :, i] * gr_truth[:, :, :, :, i])\n dice += 2 * top / (g + p)\n\n return -dice","def naive_cross_entropy_loss(input, target, size_average=True):\n assert input.size() == target.size()\n input = torch.log(F.softmax(input, dim=1).clamp(1e-5, 1))\n # input = input - torch.log(torch.sum(torch.exp(input), dim=1)).view(-1, 1)\n loss = - torch.sum(input * target)\n return loss / input.size()[0] if size_average else loss","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def test_aux_one_hot_hot_cross_entropy(self):\n loss_op = listwise_losses.AuxiliaryOneHotCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true_aux, y_pred)\n assert np.isclose(loss, 0.5249801, atol=1e-5)","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def cross_entropy_fn(fc8, ground_truth_input):\n with tf.name_scope('cross_entropy') as scope:\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\n\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\n\n return cross_entropy_mean","def nonneg_crossentropy(expr, target):\n expr_replacing_0_with_1 = tf.where(expr > 0, expr,\n tf.ones(tf.shape(input=expr), tf.float32))\n cross_entropies = tf.reduce_sum(\n input_tensor=-target * tf.math.log(expr_replacing_0_with_1), axis=1)\n return tf.reduce_mean(input_tensor=cross_entropies, axis=0)","def calc_loss(self, outputs, labels):\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\n cross_entropy = F.cross_entropy(outputs, target=labels)\n total = cross_entropy + self.beta * information_loss\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\n self.info_loss.append(information_loss.cpu().detach().numpy())\n self.total_loss.append(total.cpu().detach().numpy())\n return total","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n \n\n C = W.shape[1]\n# print(\"no. of classes {}\".format(C))\n N,D = X.shape\n# print(\"no. of data {} and dimension {}\".format(N,D))\n for i in range(N):\n xi = X[i,:]\n# print(\"one record shape: {}\".format(xi.shape))\n scores = np.zeros(C)\n for c in range(C):\n w = W[:,c]\n# print(\"weight for one record {}\".format(w.shape))\n scores[c] = xi.dot(w)\n scores -= np.max(scores)\n actual_y = y[i]\n total_score = np.sum(np.exp(scores)) \n loss_i = -scores[actual_y] + np.log(total_score)\n# print('naive score : {}'.format(scores[actual_y]))\n loss += loss_i\n \n #gradient\n probability = np.exp(scores)/total_score\n for j in range(C):\n dW[:,j] += probability[j]*xi\n \n dW[:,actual_y] -= xi\n loss = loss/N\n reg_loss = 0.5*reg*np.sum(W*W)\n loss = loss + reg_loss\n print(\"loss : {}\".format(loss))\n dW = dW/N\n dW += reg*W\n \n \n \n \n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def loss(logits, targets):\n targets = tf.to_int64(targets)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=targets, logits=logits, name='Crossentropy')\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')","def loss_fn(outputs, labels):\n return nn.CrossEntropyLoss()(outputs, labels)","def test_dice_crossentropy_loss():\n assert dice_dice_crossentropy_loss() == expected_dice_crossentropy_loss","def loss(self, batch: base.Batch, key: base.RngKey) -> base.Array:","def compute_loss(self):","def get_loss(self):\n return categorical_cross_entropy.get_loss(loss_key=self.loss_key,\n output_name=self.args.output_name)","def conditional_entropy(self) -> float:\n pass","def calc_loss(predictions, labels):\n return np.mean(np.square(predictions - labels))","def crossEntropy(p_m1):\n p_m2 = 1 - p_m1\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\n return D","def grad_softmax_cross_entropy_loss(logit, labels):\n return softmax(logit) - labels","def detection_loss(predictions, labels, params):\n with tf.name_scope(\"detection_loss\"):\n # Sum all positives in a batch for normalization and avoid zero\n # num_positives_sum, which would lead to inf loss during training\n input_shape = predictions[0][0].get_shape().as_list()\n batch_size = input_shape[0]\n sequence_length = input_shape[1]\n num_positives_batch = tf.reduce_mean(labels[\"num_positives\"])\n mean_positive = tf.reshape(\n tf.tile(tf.expand_dims(num_positives_batch, 0), [\n batch_size*sequence_length,\n ]), [batch_size*sequence_length, 1])\n num_positives_sum = tf.reduce_sum(mean_positive) + 1.0\n cls_outputs, box_outputs = structure_for_loss(predictions, params)\n levels = cls_outputs.keys()\n\n cls_losses = []\n box_losses = []\n mask_flat = tf.reshape(labels[\"loss_masks\"], [-1,1,1,1])\n for level in levels:\n # Onehot encoding for classification labels.\n cls_targets_at_level = tf.one_hot(\n tools.combine_dims(labels['cls_targets'][level],[0,1]),\n params['num_classes'])\n bs, width, height, _, _ = cls_targets_at_level.get_shape().as_list()\n cls_targets_at_level = tf.reshape(cls_targets_at_level,\n [bs, width, height, -1])\n box_targets_at_level = tools.combine_dims(labels['box_targets'][level],[0,1])\n cls_losses.append(\n _classification_loss(\n cls_outputs[level],\n cls_targets_at_level,\n num_positives_sum,\n mask_flat,\n alpha=params['alpha'],\n gamma=params['gamma']))\n box_losses.append(\n _box_loss(\n box_outputs[level],\n box_targets_at_level,\n num_positives_sum,\n mask_flat,\n delta=params['delta']))\n\n cls_loss = tf.add_n(cls_losses)\n box_loss = tf.add_n(box_losses)\n total_loss = cls_loss + params['box_loss_weight'] * box_loss\n return total_loss, cls_loss, box_loss","def soft_dice_loss(y_true, y_pred, axis=(1, 2, 3), \n epsilon=0.00001):\n\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\n\n dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon\n dice_denominator = K.sum(y_true**2, axis=axis) + K.sum(y_pred**2, axis=axis) + epsilon\n dice_loss = 1 - K.mean((dice_numerator)/(dice_denominator))\n\n ### END CODE HERE ###\n\n return dice_loss","def setup_loss(self):\n with vs.variable_scope(\"loss\"):\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))","def loss(logits, labels):\n labels = tf.to_int64(labels)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n logits, labels, name='xentropy')\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')","def soft_dice_loss(y_true, y_pred, axis=(1, 2, 3), \r\n epsilon=0.00001):\r\n\r\n dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon\r\n dice_denominator = K.sum(y_true**2, axis=axis) + K.sum(y_pred**2, axis=axis) + epsilon\r\n dice_loss = 1 - K.mean((dice_numerator)/(dice_denominator))\r\n\r\n return dice_loss","def loss_function(self, targets, outputs):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\n return tf.reduce_mean(cross_entropy)","def loss_fn(outputs, labels):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n labels = labels.view(-1)\n\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\n mask = (labels >= 0).float()\n\n # indexing with negative values is not supported. Since PADded tokens have label -1, we convert them to a positive\n # number. This does not affect training, since we ignore the PADded tokens with the mask.\n labels = labels % outputs.shape[1]\n\n num_tokens = int(torch.sum(mask))\n\n # compute cross entropy loss for all tokens (except PADding tokens), by multiplying with mask.\n return -torch.sum(outputs[range(outputs.shape[0]), labels]*mask)/num_tokens","def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\n return self.descent.calc_loss(x, y)","def naive_cross_entropy_loss(input, target, size_average=True):\n assert input.size() == target.size()\n assert isinstance(input, Variable) and isinstance(target, Variable)\n input = torch.log(F.softmax(input, dim=1).clamp(1e-5, 1))\n # input = input - torch.log(torch.sum(torch.exp(input), dim=1)).view(-1, 1)\n loss = - torch.sum(input * target)\n return loss / input.size()[0] if size_average else loss","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n\n p_scores = calc_percentage_scores(W,X)\n loss += calc_loss_reg( W, reg )\n loss += calc_loss_data( p_scores, y)\n\n for idx in range(0,len(p_scores)):\n p_scores[idx, y[idx]] -= 1\n \n # p_scores = np.dot(X.T, p_scores) \n new_scores = dot_product( X.T, p_scores )\n p_scores = new_scores\n for idx in range(0,len(p_scores)):\n for i in range(0, len(p_scores[idx])):\n p_scores[idx, i] /= y.shape[0]\n dW = p_scores\n dW += reg*W\n\n return loss, dW","def cross_entropy(\n input,\n target,\n weight=None,\n size_average=None,\n ignore_index=None,\n reduce=None,\n reduction='mean',\n):\n if size_average is not None or reduce is not None:\n reduction = _reduction.legacy_get_string(size_average, reduce)\n else:\n reduction = reduction\n return FunctionLib.apply(\n 'SoftmaxCrossEntropyLoss', input.device, [input, target],\n axis=1, ignore_index=ignore_index, reduction=reduction.upper())","def ovo_crossentropy_loss(y_true, y_pred):\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\n y_true_scaled = (y_true + 1.0) / 2.0\n y_pred_scaled = (y_pred + 1.0) / 2.0\n\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\n\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\n\n # J_{OvO} aus Pawara et al. anwenden\n log_function = tf.log if tf.__version__ == \"1.13.1\" else tf.math.log # flexibel für neue / alte Version\n loss = - tf.reduce_mean(\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\n return loss"],"string":"[\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\\n y_pred = tf.cast(y_pred, 'float64')\\n y_true = tf.cast(y_true, 'float64')\\n # deduce weights based on true pixel value\\n class_weights = weights * y_true\\n # compute your (unweighted) softmax cross entropy loss\\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\\n ##print(unweighted_losses.dtype, weights.dtype)\\n weighted_losses = unweighted_losses * class_weights\\n # reduce the result to get your final loss\\n loss = -tf.reduce_sum(weighted_losses)\\n return loss\",\n \"def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\\n norm_log = log_softmax(input, 1)\\n\\n np_one_hot = np.eye(input.shape[1])[target.data]\\n tensor_one_hot = tensor(np_one_hot, 'one-hot', False, True)\\n\\n mask = -norm_log * tensor_one_hot\\n mask_sum = sum(mask, 1)\\n loss = sum(mask_sum, 0)\\n\\n return loss / input.shape[0]\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def cross_entropy(self):\\n return self._cross_entropy_func\",\n \"def loss_calc(pred, label, device):\\n # out shape batch_size x channels x h x w -> batch_size x channels x h x w\\n # label shape h x w x 1 x batch_size -> batch_size x 1 x h x w\\n label = Variable(label.long()).to(device)\\n criterion = CrossEntropy2d().to(device)\\n\\n return criterion(pred, label)\",\n \"def calculate_loss(self, pred, gold, smoothing=False):\\n gold = gold.contiguous().view(-1)\\n if smoothing:\\n epsilon = 0.1\\n n_class = pred.size(1)\\n one_hot = torch.zeros_like(pred).scatter(1, gold.view(-1, 1), 1)\\n one_hot = one_hot * (1 - epsilon) + \\\\\\n (1 - one_hot) * epsilon / (n_class - 1)\\n\\n log_prb = F.log_softmax(pred, dim=1)\\n # create non-padding mask with torch.ne()\\n non_pad_mask = gold.ne(self.constants.PAD)\\n loss = -(one_hot * log_prb).sum(dim=1)\\n # losses are averaged later\\n loss = loss.masked_select(non_pad_mask).sum()\\n else:\\n loss = F.cross_entropy(\\n pred, gold, ignore_index=self.constants.PAD, reduction='sum')\\n return loss\",\n \"def loss_calc(pred, label, device):\\r\\n # out shape batch_size x channels x h x w -> batch_size x channels x h x w\\r\\n # label shape h x w x 1 x batch_size -> batch_size x 1 x h x w\\r\\n label = label.long().to(device)\\r\\n return cross_entropy_2d(pred, label)\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def test_cross_entropy(self):\\n loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n kl = loss.mean()\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertAlmostEqual(kl, expected_loss)\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def compute_loss(self):\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.data.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def test_aux_softmax_cross_entropy(self):\\n loss_op = listwise_losses.AuxiliarySoftmaxCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true_aux, y_pred)\\n assert np.isclose(loss, 0.88127804, atol=1e-5)\",\n \"def loss_sce(y_pred, y_true):\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\\n\\n return tf.reduce_mean(loss)\",\n \"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\\r\\n logits = net.apply(params, batch)\\r\\n labels = jax.nn.one_hot(label, n_classes)\\r\\n\\r\\n # Cross Entropy Loss\\r\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\\r\\n softmax_xent /= labels.shape[0]\\r\\n return softmax_xent\",\n \"def calculate_loss(self, train_x, train_y):\\n self.log.info(\\\"Calculating average categorical crossentropy loss...\\\")\\n\\n num_words = np.sum([len(y) for y in train_y])\\n return self.calculate_total_loss(train_x, train_y)/float(num_words)\",\n \"def compute_loss(self):\\n def calc_loss(inputs, outputs):\\n reconstruction_loss = tf.metrics.binary_crossentropy(\\n tf_flat(inputs), tf_flat(outputs))\\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\\n self.mu) - tf.exp(self.log_sigma), 1)\\n return tf.reduce_mean(reconstruction_loss + kl_loss)\\n return calc_loss\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def cross_entropy_loss(predictions, targets, epsilon=1e-12):\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n N = predictions.shape[0]\\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\\n return ce\",\n \"def compute_cross_entropy(probs, target):\\n avg_probs_per_sample = probs.mean(\\n -1)\\n xe = torch.nn.CrossEntropyLoss(reduction='none')\\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()\",\n \"def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\\n if type(y_pred) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_pred)))\\n if type(y_true) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_true)))\\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\\n # y_pred = clip(y_pred)\\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\\n loss = -1 * np.sum(l).item()\\n if normalize:\\n loss = loss / len(y_pred)\\n return loss\",\n \"def compute_loss(self):\\n self.prototypes = self.compute_prototypes()\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.episode.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\\n log_pred = ivy.log(pred)\\n # noinspection PyUnresolvedReferences\\n return -ivy.reduce_sum(log_pred * true, axis)\",\n \"def loss_softmax_cross_entropy(self, unet, predict, ground_truth):\\n\\n loss = -F.mean(F.log(predict+1e-16) * ground_truth)\\n\\n chainer.report({\\\"loss\\\":loss}, unet)#mistery\\n return loss\",\n \"def test_softmax_cross_entropy(self):\\n loss_op = listwise_losses.SoftmaxCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true, y_pred)\\n assert np.isclose(loss, 1.306335, atol=1e-5)\",\n \"def loss_fn(y_true,y_pred): \\n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\\n y_pred,\\n axis=-1,\\n )\\n loss = tf.reduce_mean(loss,name=\\\"loss\\\")\\n return loss\",\n \"def cross_entropy(y, y_hat):\\n return -tf.math.log(\\n tf.gather_nd(y_hat, tf.reshape(y, (-1, 1)), batch_dims=1)\\n )\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def loss(y, y_pred):\\n # assert_is_binary(y)\\n # assert_is_stochastic(y_pred)\\n is_binary(y)\\n is_stochastic(y_pred)\\n\\n # prevent taking the log of 0\\n eps = np.finfo(float).eps\\n\\n # each example is associated with a single class; sum the negative log\\n # probability of the correct label over all samples in the batch.\\n # observe that we are taking advantage of the fact that y is one-hot\\n # encoded!\\n cross_entropy = -np.sum(y * np.log(y_pred + eps))\\n return cross_entropy\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def cross_entropy_loss(batch_out, batch_gt):\\r\\n criterion = torch.nn.CrossEntropyLoss()\\r\\n target = torch.argmax(batch_gt, 1)\\r\\n loss = criterion(batch_out, target)\\r\\n\\r\\n return loss\",\n \"def crossentropy_loss(y_true, y_pred):\\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \\n return ce\",\n \"def cross_entropy(X, y, using_onehot=True):\\n\\tM = y.shape[0]\\n\\tif using_onehot :\\n\\t\\tlog_likelihood = -np.log(np.max(X * y, -1))\\n\\telse:\\n\\t\\tlog_likelihood = -np.log(X[range(M), y]) # 找到y对应的那个类别所对应的logit\\n\\tloss = np.sum(log_likelihood) / M\\n\\treturn loss\",\n \"def loss_fn(outputs, labels, wts):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\\n\\t\\n # compute cross entropy loss for all tokens\\n return loss\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def softmax_cross_entropy_loss(self, y, y_hat):\\n batch_size = y.shape[0]\\n return -(y - y_hat) / batch_size\",\n \"def _initLoss(self):\\n\\n return torch.nn.CrossEntropyLoss()\",\n \"def test_with_cross_entropy_loss(self):\\n predict = torch.randn(self.batch, self.num_classes, self.img_size, self.img_size)\\n target = self._get_default_target_tensor()\\n mask = self._get_default_mask_tensor()\\n\\n loss_weigths = [1.0, 0.5]\\n ce_crit = nn.CrossEntropyLoss(reduction=\\\"none\\\")\\n mask_ce_crit = MaskAttentionLoss(criterion=ce_crit, loss_weights=loss_weigths)\\n\\n # expected result\\n ce_loss = ce_crit(predict, target)\\n _mask = mask.view_as(ce_loss)\\n mask_loss = ce_loss * _mask\\n mask_loss = mask_loss[_mask == 1] # consider only mask samples for mask loss computing\\n expected_loss = ce_loss.mean() * loss_weigths[0] + mask_loss.mean() * loss_weigths[1]\\n\\n # mask ce loss result\\n loss = mask_ce_crit(predict, target, mask)\\n\\n self._assertion_torch_values(expected_loss, loss)\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def cross_entropy_loss(outputs, labels): \\n# works properly\\n \\n m = labels.shape[0]\\n p = outputs\\n log_likelihood = -1*torch.log(p[range(m),labels])\\n loss = torch.sum(log_likelihood) / m\\n return loss.item()\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def softmax_cross_entropy(y, label):\\r\\n losses = np.sum((- np.log(y + g_epsilon) * label), axis=1)\\r\\n return losses\\r\\n pass\",\n \"def loss_op(logits, labels):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits, labels, name='xentropy_eval')\\n\\n loss = math_ops.reduce_mean(cross_entropy)\\n return loss\",\n \"def calculate_loss(self, y, y_hat):\\r\\n return tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y_hat))\",\n \"def calculate_loss(self, output, target, redmode = 'mean'):\\n\\n loss = F.cross_entropy(output, target, reduction = redmode)\\n return loss\",\n \"def _loss(self):\\n\\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\\n self.loss = cross_entropy\\n\\n self.accuracy = tf.reduce_mean(\\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))\",\n \"def crossEntropyLoss(YPredict, YTrueOneHot):\\n if YPredict.shape != YTrueOneHot.shape:\\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))\",\n \"def __test_cross_entropy_loss():\\n y = np.array([[0, 1], [1, 0], [1, 0]])\\n yhat = np.array([[.5, .5], [.5, .5], [.5, .5]])\\n\\n test1 = cross_entropy_loss(tf.constant(y, dtype=tf.int32), tf.constant(yhat, dtype=tf.float32))\\n with tf.Session() as sess:\\n test1 = sess.run(test1)\\n expected = -3 * np.log(.5)\\n __test_all_close(\\\"Cross-entropy test 1\\\", test1, expected)\\n\\n print(\\\"Basic (non-exhaustive) cross-entropy tests pass\\\")\",\n \"def cross_entropoy_loss_vectorized(W, X, y, reg): \\n loss = 0 \\n dW = np.zeros_like(W)\\n N, D = X.shape \\n \\n \\n scores = X.dot(W) # [K, N]\\n # for numerical stability)\\n scores -= np.max(scores)\\n scores_exp = np.exp(scores)\\n correct_scores_exp = scores_exp[range(N),y] \\n scores_exp_sum = np.sum(scores_exp, axis=1) \\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\\n loss /= N\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n scores_exp_normalized = scores_exp.T / scores_exp_sum \\n scores_exp_normalized[y, range(N)] -= 1 \\n dW = np.dot(scores_exp_normalized,X)\\n dW = dW.T\\n dW /= N \\n dW += reg * W\\n \\n \\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def crossentropy_max_core(y_true, y_pred):\\n\\n # hyper param\\n print(_m)\\n y_pred = K.clip(y_pred, K.epsilon(), 1)\\n\\n # compute loss for every data point\\n _loss = -K.sum(y_true * K.log(y_pred), axis=-1)\\n\\n # threshold\\n t_m = K.max(_loss) * _m\\n _mask_m = 1 - (K.cast(K.greater(_loss, t_m), 'float32'))\\n _loss = _loss * _mask_m\\n\\n return _loss\",\n \"def compute_test_loss(self, x):\\n temp_training = self.training\\n self.training = False\\n mean, logvar = self.encode(x)\\n z = self.reparameterize(mean, logvar)\\n x_logit = self.decode(z)\\n\\n cross_ent = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_logit, labels=x)\\n logpx_z = -tf.math.reduce_sum(cross_ent, axis=[1, 2, 3]) # JAH removed 3D axis=[1, 2, 3,4]\\n logpz = self.log_normal_pdf(z, 0.0, 0.0)\\n logqz_x = self.log_normal_pdf(z, mean, logvar)\\n\\n\\n kl_divergence = logqz_x - logpz\\n neg_log_likelihood = -logpx_z\\n\\n #elbo = tf.math.reduce_mean(-self.kl_weight * kl_divergence - neg_log_likelihood) # shape=()\\n neg_elbo = tf.math.reduce_mean(self.kl_weight * kl_divergence + neg_log_likelihood) # shape=()\\n self.training = temp_training\\n return neg_elbo\",\n \"def cross_entropy(self, sents):\\n return (-1) * self.log_prob(sents) / len(self._count)\",\n \"def setup_loss(self):\\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\\n #self.loss = nn.CrossEntropyLoss()\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n# labels = tf.to_float(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy')\\n# y_conv = tf.nn.softmax(logits)\\n# cross_entropy = -tf.reduce_sum(labels*tf.log(y_conv))\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def cross_entropy(input1, target, size_average=True):\\n logsoftmax = nn.LogSoftmax(dim=0)\\n return torch.sum(-target * logsoftmax(input1))\\n # if size_average:\\n # return torch.mean(torch.sum(-target * logsoftmax(input), dim=1))\\n # else:\\n # return torch.sum(torch.sum(-target * logsoftmax(input), dim=1))\",\n \"def loss(output, y):\\n #Computes softmax cross entropy between logits and labels.\\n xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y)\\n loss = tf.reduce_mean(xentropy)\\n\\n return loss\",\n \"def delta_cross_entropy_softmax(outputs, labels):\\n \\n m = labels.shape[0]\\n grad = outputs\\n \\n grad[range(m),labels] -= torch.tensor(1.)\\n\\n grad = grad/m\\n avg_grads = grad\\n return avg_grads\",\n \"def cross_entropy(Y, Y_hat, epsilon=1e-8):\\n \\n m = Y.shape[0]\\n \\n # make data safe\\n Y_hat = np.clip(Y_hat, a_min=epsilon, a_max=(1 - epsilon))\\n \\n # calc cost\\n cost = (-1 / m) * np.nansum(Y * np.log(Y_hat))\\n cost = np.squeeze(cost)\\n \\n # calc gradient\\n dY_hat = -Y / Y_hat\\n \\n return cost, dY_hat\",\n \"def classification_loss(self, logit, target):\\n return F.cross_entropy(logit, target)\",\n \"def compute_loss(self, x, y):\\n\\n self.batch_size = x.shape[0]\\n self.x = x\\n self.y = y\\n self.soft = self.softmax(x) + 10**(-11)\\n out = np.zeros(self.batch_size)\\n for i in range(self.batch_size):\\n out[i] = -(y[i] @ np.log(self.soft[i]))\\n\\n return out\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def cross_entropy_with_probs(pred_probs, target_probs, name=None):\\n with tf.name_scope(name, \\\"SoftmaxCrossEntropyWithProb\\\", [pred_probs, target_probs]):\\n crossent_loss = -tf.reduce_sum(target_probs * tf.log(pred_probs), reduction_indices=[1], keep_dims=False)\\n return crossent_loss\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n num_train_sample = X.shape[0] #row of train data\\n num_class = W.shape[1] #column of weight, plane,horse..\\n for i in range(num_train_sample):\\n p_score = X[i].dot(W) #a row of score corresponding to each class\\n p_score -= np.max(p_score) #normalize, highest is 1\\n\\n ###compute softmax loss\\n # sum of scores corresponding to different classes of a sample \\n sum_score = np.sum(np.exp(p_score)) \\n # each class's score over sum_score of a sample \\n score_i = lambda k: np.exp(p_score[k]) / sum_score\\n # for the correct label in each sample, find softmax loss over sum\\n # iteration make loss sum up all samples\\n loss = loss - np.log(score_i(y[i]))\\n\\n for k in range(num_class):\\n p_k = score_i(k)\\n # gradient of softmax\\n dW[:, k] += (p_k - (k == y[i])) * X[i]\\n\\n loss /= num_train_sample\\n loss += 0.5 * reg * np.sum(W * W)\\n dW /= num_train_sample\\n dW += reg*W\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def dice_loss(pred, gr_truth):\\n gr_truth = tf.cast(gr_truth, dtype='int32')\\n gr_truth = one_hot(gr_truth)\\n dice = 0\\n\\n for i in range(8):\\n top = tf.reduce_mean(pred[:, :, :, :, i] * gr_truth[:, :, :, :, i])\\n g = tf.reduce_sum(pred[:, :, :, :, i] * pred[:, :, :, :, i])\\n p = tf.reduce_sum(gr_truth[:, :, :, :, i] * gr_truth[:, :, :, :, i])\\n dice += 2 * top / (g + p)\\n\\n return -dice\",\n \"def naive_cross_entropy_loss(input, target, size_average=True):\\n assert input.size() == target.size()\\n input = torch.log(F.softmax(input, dim=1).clamp(1e-5, 1))\\n # input = input - torch.log(torch.sum(torch.exp(input), dim=1)).view(-1, 1)\\n loss = - torch.sum(input * target)\\n return loss / input.size()[0] if size_average else loss\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def test_aux_one_hot_hot_cross_entropy(self):\\n loss_op = listwise_losses.AuxiliaryOneHotCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true_aux, y_pred)\\n assert np.isclose(loss, 0.5249801, atol=1e-5)\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def cross_entropy_fn(fc8, ground_truth_input):\\n with tf.name_scope('cross_entropy') as scope:\\n cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=fc8, labels=ground_truth_input)\\n cross_entropy_mean = tf.reduce_mean(cross_entropy)\\n\\n tf.summary.scalar(scope + '/loss', cross_entropy_mean)\\n\\n return cross_entropy_mean\",\n \"def nonneg_crossentropy(expr, target):\\n expr_replacing_0_with_1 = tf.where(expr > 0, expr,\\n tf.ones(tf.shape(input=expr), tf.float32))\\n cross_entropies = tf.reduce_sum(\\n input_tensor=-target * tf.math.log(expr_replacing_0_with_1), axis=1)\\n return tf.reduce_mean(input_tensor=cross_entropies, axis=0)\",\n \"def calc_loss(self, outputs, labels):\\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\\n cross_entropy = F.cross_entropy(outputs, target=labels)\\n total = cross_entropy + self.beta * information_loss\\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\\n self.info_loss.append(information_loss.cpu().detach().numpy())\\n self.total_loss.append(total.cpu().detach().numpy())\\n return total\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n\\n C = W.shape[1]\\n# print(\\\"no. of classes {}\\\".format(C))\\n N,D = X.shape\\n# print(\\\"no. of data {} and dimension {}\\\".format(N,D))\\n for i in range(N):\\n xi = X[i,:]\\n# print(\\\"one record shape: {}\\\".format(xi.shape))\\n scores = np.zeros(C)\\n for c in range(C):\\n w = W[:,c]\\n# print(\\\"weight for one record {}\\\".format(w.shape))\\n scores[c] = xi.dot(w)\\n scores -= np.max(scores)\\n actual_y = y[i]\\n total_score = np.sum(np.exp(scores)) \\n loss_i = -scores[actual_y] + np.log(total_score)\\n# print('naive score : {}'.format(scores[actual_y]))\\n loss += loss_i\\n \\n #gradient\\n probability = np.exp(scores)/total_score\\n for j in range(C):\\n dW[:,j] += probability[j]*xi\\n \\n dW[:,actual_y] -= xi\\n loss = loss/N\\n reg_loss = 0.5*reg*np.sum(W*W)\\n loss = loss + reg_loss\\n print(\\\"loss : {}\\\".format(loss))\\n dW = dW/N\\n dW += reg*W\\n \\n \\n \\n \\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def loss(logits, targets):\\n targets = tf.to_int64(targets)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=targets, logits=logits, name='Crossentropy')\\n return tf.reduce_mean(cross_entropy, name='Crossentropy_mean')\",\n \"def loss_fn(outputs, labels):\\n return nn.CrossEntropyLoss()(outputs, labels)\",\n \"def test_dice_crossentropy_loss():\\n assert dice_dice_crossentropy_loss() == expected_dice_crossentropy_loss\",\n \"def loss(self, batch: base.Batch, key: base.RngKey) -> base.Array:\",\n \"def compute_loss(self):\",\n \"def get_loss(self):\\n return categorical_cross_entropy.get_loss(loss_key=self.loss_key,\\n output_name=self.args.output_name)\",\n \"def conditional_entropy(self) -> float:\\n pass\",\n \"def calc_loss(predictions, labels):\\n return np.mean(np.square(predictions - labels))\",\n \"def crossEntropy(p_m1):\\n p_m2 = 1 - p_m1\\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\\n return D\",\n \"def grad_softmax_cross_entropy_loss(logit, labels):\\n return softmax(logit) - labels\",\n \"def detection_loss(predictions, labels, params):\\n with tf.name_scope(\\\"detection_loss\\\"):\\n # Sum all positives in a batch for normalization and avoid zero\\n # num_positives_sum, which would lead to inf loss during training\\n input_shape = predictions[0][0].get_shape().as_list()\\n batch_size = input_shape[0]\\n sequence_length = input_shape[1]\\n num_positives_batch = tf.reduce_mean(labels[\\\"num_positives\\\"])\\n mean_positive = tf.reshape(\\n tf.tile(tf.expand_dims(num_positives_batch, 0), [\\n batch_size*sequence_length,\\n ]), [batch_size*sequence_length, 1])\\n num_positives_sum = tf.reduce_sum(mean_positive) + 1.0\\n cls_outputs, box_outputs = structure_for_loss(predictions, params)\\n levels = cls_outputs.keys()\\n\\n cls_losses = []\\n box_losses = []\\n mask_flat = tf.reshape(labels[\\\"loss_masks\\\"], [-1,1,1,1])\\n for level in levels:\\n # Onehot encoding for classification labels.\\n cls_targets_at_level = tf.one_hot(\\n tools.combine_dims(labels['cls_targets'][level],[0,1]),\\n params['num_classes'])\\n bs, width, height, _, _ = cls_targets_at_level.get_shape().as_list()\\n cls_targets_at_level = tf.reshape(cls_targets_at_level,\\n [bs, width, height, -1])\\n box_targets_at_level = tools.combine_dims(labels['box_targets'][level],[0,1])\\n cls_losses.append(\\n _classification_loss(\\n cls_outputs[level],\\n cls_targets_at_level,\\n num_positives_sum,\\n mask_flat,\\n alpha=params['alpha'],\\n gamma=params['gamma']))\\n box_losses.append(\\n _box_loss(\\n box_outputs[level],\\n box_targets_at_level,\\n num_positives_sum,\\n mask_flat,\\n delta=params['delta']))\\n\\n cls_loss = tf.add_n(cls_losses)\\n box_loss = tf.add_n(box_losses)\\n total_loss = cls_loss + params['box_loss_weight'] * box_loss\\n return total_loss, cls_loss, box_loss\",\n \"def soft_dice_loss(y_true, y_pred, axis=(1, 2, 3), \\n epsilon=0.00001):\\n\\n ### START CODE HERE (REPLACE INSTANCES OF 'None' with your code) ###\\n\\n dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon\\n dice_denominator = K.sum(y_true**2, axis=axis) + K.sum(y_pred**2, axis=axis) + epsilon\\n dice_loss = 1 - K.mean((dice_numerator)/(dice_denominator))\\n\\n ### END CODE HERE ###\\n\\n return dice_loss\",\n \"def setup_loss(self):\\n with vs.variable_scope(\\\"loss\\\"):\\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))\",\n \"def loss(logits, labels):\\n labels = tf.to_int64(labels)\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n logits, labels, name='xentropy')\\n return tf.reduce_mean(cross_entropy, name='xentropy_mean')\",\n \"def soft_dice_loss(y_true, y_pred, axis=(1, 2, 3), \\r\\n epsilon=0.00001):\\r\\n\\r\\n dice_numerator = 2. * K.sum(y_true * y_pred, axis=axis) + epsilon\\r\\n dice_denominator = K.sum(y_true**2, axis=axis) + K.sum(y_pred**2, axis=axis) + epsilon\\r\\n dice_loss = 1 - K.mean((dice_numerator)/(dice_denominator))\\r\\n\\r\\n return dice_loss\",\n \"def loss_function(self, targets, outputs):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\\n return tf.reduce_mean(cross_entropy)\",\n \"def loss_fn(outputs, labels):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n labels = labels.view(-1)\\n\\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\\n mask = (labels >= 0).float()\\n\\n # indexing with negative values is not supported. Since PADded tokens have label -1, we convert them to a positive\\n # number. This does not affect training, since we ignore the PADded tokens with the mask.\\n labels = labels % outputs.shape[1]\\n\\n num_tokens = int(torch.sum(mask))\\n\\n # compute cross entropy loss for all tokens (except PADding tokens), by multiplying with mask.\\n return -torch.sum(outputs[range(outputs.shape[0]), labels]*mask)/num_tokens\",\n \"def calc_loss(self, x: np.ndarray, y: np.ndarray) -> float:\\n return self.descent.calc_loss(x, y)\",\n \"def naive_cross_entropy_loss(input, target, size_average=True):\\n assert input.size() == target.size()\\n assert isinstance(input, Variable) and isinstance(target, Variable)\\n input = torch.log(F.softmax(input, dim=1).clamp(1e-5, 1))\\n # input = input - torch.log(torch.sum(torch.exp(input), dim=1)).view(-1, 1)\\n loss = - torch.sum(input * target)\\n return loss / input.size()[0] if size_average else loss\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n\\n p_scores = calc_percentage_scores(W,X)\\n loss += calc_loss_reg( W, reg )\\n loss += calc_loss_data( p_scores, y)\\n\\n for idx in range(0,len(p_scores)):\\n p_scores[idx, y[idx]] -= 1\\n \\n # p_scores = np.dot(X.T, p_scores) \\n new_scores = dot_product( X.T, p_scores )\\n p_scores = new_scores\\n for idx in range(0,len(p_scores)):\\n for i in range(0, len(p_scores[idx])):\\n p_scores[idx, i] /= y.shape[0]\\n dW = p_scores\\n dW += reg*W\\n\\n return loss, dW\",\n \"def cross_entropy(\\n input,\\n target,\\n weight=None,\\n size_average=None,\\n ignore_index=None,\\n reduce=None,\\n reduction='mean',\\n):\\n if size_average is not None or reduce is not None:\\n reduction = _reduction.legacy_get_string(size_average, reduce)\\n else:\\n reduction = reduction\\n return FunctionLib.apply(\\n 'SoftmaxCrossEntropyLoss', input.device, [input, target],\\n axis=1, ignore_index=ignore_index, reduction=reduction.upper())\",\n \"def ovo_crossentropy_loss(y_true, y_pred):\\n # Bei OvO wird als Aktivierungsfunktion 'tanh' verwendet. Diese produziert Werte aus (-1, 1)\\n # Auf Wertebereich [0,1] hochskalieren (eigentlich möchte man (0,1) erreichen um später im Logarithmus\\n # keine undefinierten Werte zu erhalten, aber wegen numerischen Problemen sind auch 0 und 1 denkbare Werte)\\n y_true_scaled = (y_true + 1.0) / 2.0\\n y_pred_scaled = (y_pred + 1.0) / 2.0\\n\\n # Wertebereich von y_pred_scaled von [0,1] auf [0.00001, 0.99999] einschränken wegen Logarithmen. Näherung an (0,1)\\n\\n zeroes = tf.zeros_like(y_pred_scaled) # Tensor mit gleicher Dimension wie 'y_pred_scaled' bestehend aus nur 0en\\n # Alle kleineren Werte als 0.00001 in 'y_pred_scaled' auf 0.00001 setzen (untere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled < 0.00001, zeroes + 0.00001, y_pred_scaled)\\n # Alle größeren Werte als 0.99999 in 'y_pred_scaled' auf 0.99999 setzen (obere Schranke für Wertebereich)\\n y_pred_scaled = tf.where(y_pred_scaled > 0.99999, zeroes + 0.99999, y_pred_scaled)\\n\\n # J_{OvO} aus Pawara et al. anwenden\\n log_function = tf.log if tf.__version__ == \\\"1.13.1\\\" else tf.math.log # flexibel für neue / alte Version\\n loss = - tf.reduce_mean(\\n y_true_scaled * log_function(y_pred_scaled) + (1 - y_true_scaled) * log_function(1 - y_pred_scaled))\\n return loss\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72118425","0.6977244","0.6913567","0.69001913","0.68212694","0.6808604","0.6790559","0.6770588","0.67624503","0.67545956","0.6719684","0.6712214","0.6701527","0.67001855","0.6690241","0.6655911","0.66522497","0.6647189","0.6639884","0.66260445","0.6616069","0.6574896","0.6573515","0.65661824","0.65613955","0.6529674","0.65275764","0.652165","0.6516931","0.6503773","0.6489587","0.6486378","0.6471544","0.64659387","0.64592165","0.645378","0.6444769","0.6440182","0.6424036","0.64046526","0.63969696","0.6381227","0.6359511","0.6358702","0.6356468","0.6340519","0.63229936","0.6306788","0.63028777","0.6292281","0.6290402","0.6273012","0.6266727","0.6266505","0.62664557","0.62448597","0.62402934","0.62328446","0.6215229","0.62098575","0.62035114","0.6201795","0.61917007","0.61903554","0.61891824","0.61887455","0.6185938","0.6184384","0.6182571","0.618136","0.6180525","0.6180197","0.617914","0.6172265","0.6161166","0.61596596","0.6154039","0.6141635","0.61370146","0.6130319","0.61215484","0.6121322","0.6119049","0.61126196","0.6110539","0.6109431","0.6093829","0.60911334","0.6082858","0.60778975","0.60726976","0.60705435","0.60705113","0.60701674","0.6068312","0.6065248","0.6046253","0.6045651","0.60430104","0.6032592"],"string":"[\n \"0.72118425\",\n \"0.6977244\",\n \"0.6913567\",\n \"0.69001913\",\n \"0.68212694\",\n \"0.6808604\",\n \"0.6790559\",\n \"0.6770588\",\n \"0.67624503\",\n \"0.67545956\",\n \"0.6719684\",\n \"0.6712214\",\n \"0.6701527\",\n \"0.67001855\",\n \"0.6690241\",\n \"0.6655911\",\n \"0.66522497\",\n \"0.6647189\",\n \"0.6639884\",\n \"0.66260445\",\n \"0.6616069\",\n \"0.6574896\",\n \"0.6573515\",\n \"0.65661824\",\n \"0.65613955\",\n \"0.6529674\",\n \"0.65275764\",\n \"0.652165\",\n \"0.6516931\",\n \"0.6503773\",\n \"0.6489587\",\n \"0.6486378\",\n \"0.6471544\",\n \"0.64659387\",\n \"0.64592165\",\n \"0.645378\",\n \"0.6444769\",\n \"0.6440182\",\n \"0.6424036\",\n \"0.64046526\",\n \"0.63969696\",\n \"0.6381227\",\n \"0.6359511\",\n \"0.6358702\",\n \"0.6356468\",\n \"0.6340519\",\n \"0.63229936\",\n \"0.6306788\",\n \"0.63028777\",\n \"0.6292281\",\n \"0.6290402\",\n \"0.6273012\",\n \"0.6266727\",\n \"0.6266505\",\n \"0.62664557\",\n \"0.62448597\",\n \"0.62402934\",\n \"0.62328446\",\n \"0.6215229\",\n \"0.62098575\",\n \"0.62035114\",\n \"0.6201795\",\n \"0.61917007\",\n \"0.61903554\",\n \"0.61891824\",\n \"0.61887455\",\n \"0.6185938\",\n \"0.6184384\",\n \"0.6182571\",\n \"0.618136\",\n \"0.6180525\",\n \"0.6180197\",\n \"0.617914\",\n \"0.6172265\",\n \"0.6161166\",\n \"0.61596596\",\n \"0.6154039\",\n \"0.6141635\",\n \"0.61370146\",\n \"0.6130319\",\n \"0.61215484\",\n \"0.6121322\",\n \"0.6119049\",\n \"0.61126196\",\n \"0.6110539\",\n \"0.6109431\",\n \"0.6093829\",\n \"0.60911334\",\n \"0.6082858\",\n \"0.60778975\",\n \"0.60726976\",\n \"0.60705435\",\n \"0.60705113\",\n \"0.60701674\",\n \"0.6068312\",\n \"0.6065248\",\n \"0.6046253\",\n \"0.6045651\",\n \"0.60430104\",\n \"0.6032592\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60390383"},"document_rank":{"kind":"string","value":"99"}}},{"rowIdx":85159,"cells":{"query":{"kind":"string","value":"Wrap a metric fn that returns scores and weights as an eval metric fn. The input metric_fn returns values for the current batch. The wrapper aggregates the return values collected over all of the batches evaluated."},"document":{"kind":"string","value":"def _convert_to_eval_metric(metric_fn):\n def problem_metric_fn(*args):\n \"\"\"Returns an aggregation of the metric_fn's returned values.\"\"\"\n (scores, weights) = metric_fn(*args)\n\n # The tf.metrics.mean function assures correct aggregation.\n return tf.compat.v1.metrics.mean(scores, weights)\n return problem_metric_fn"},"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 evaluate_fn(\n # The pytype below must be Any, because the code below uses internal methods\n # only present on tff.learning.from_keras_model-derived TFF models.\n model: Any,\n dataset: tf.data.Dataset,\n batch_size: int = 1,\n) -> collections.OrderedDict[str, tf.Tensor]:\n # Resets the model's local variables. This is necessary because\n # `model.report_local_unfinalized_metrics()` aggregates the metrics from *all*\n # previous calls to `forward_pass` (which include the metrics computed in\n # training). Resetting ensures that the returned metrics are computed on test\n # data. Similar to the `reset_states` method of `tf.keras.metrics.Metric`.\n model.reset_metrics()\n\n @tf.function\n def reduce_fn(num_examples_sum, batch):\n output = model.forward_pass(batch, training=False)\n return num_examples_sum + output.num_examples\n\n dataset.batch(batch_size).reduce(0, reduce_fn)\n finalized_metrics = collections.OrderedDict(\n # Note that `model.get_metrics` only works for models created via\n # `tff.learning.from_keras_model`. For non-keras based models, you can\n # apply `model.metric_finalizers` to the unfinalized metrics (returned by\n # `model.report_local_unfinalized_metrics`) to get the finalized metrics.\n (metric.name, metric.result()) for metric in model.get_metrics())\n return finalized_metrics","def _evaluate_fn(model, dataset):\n # Reset the local variables so that the returned metrics are computed using\n # the given data. Similar to the `reset_states` method of `tf.metrics.Metric`.\n for var in model.local_variables:\n if var.initial_value is not None:\n var.assign(var.initial_value)\n else:\n var.assign(tf.zeros_like(var))\n\n def eval_fn(dummy_state, batch):\n \"\"\"Evaluates the model on a batch.\"\"\"\n model.forward_pass(batch, training=False)\n return dummy_state\n\n # Evaluate on the dataset.\n dataset.reduce(initial_state=0, reduce_func=eval_fn)\n\n # Obtain the metrics.\n results = collections.OrderedDict()\n local_outputs = model.report_local_outputs()\n for name, metric in local_outputs.items():\n if isinstance(metric, list) and (len(metric) == 2):\n # Some metrics returned by `report_local_outputs()` can have two scalars:\n # one represents `sum`, and the other represents `count`. Ideally, we want\n # to return a single scalar for each metric.\n results[name] = metric[0] / metric[1]\n else:\n results[name] = metric[0] if isinstance(metric, list) else metric\n return results","def evaluate(model, loss_fn, valid_dl, metric=None):\n with torch.no_grad():\n # Pass each batch through the model\n results = [loss_batch(model, loss_fn, xb, yb, metric=metric) for xb, yb in valid_dl]\n # Separate losses, counts and metrics\n losses, nums, metrics = zip(*results)\n # Total size of the dataset\n total = np.sum(nums)\n # Avg. loss across batches\n avg_loss = np.sum(np.multiply(losses, nums)) / total\n avg_metric = None\n if metric is not None:\n # Avg. of metric across batches\n avg_metric = np.sum(np.multiply(metrics, nums)) / total\n return avg_loss, total, avg_metric","def fn(distribution, *a):\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with tf.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n tf.add_to_collections(metrics_collections, metric_value)\n return metric_value","def evaluate_with_metrics(self, dataset, metrics, *args, **kwargs):\n\n utils.assert_raise(isinstance(metrics, dict), ValueError,\n '\"metrics\" must be a dict with metric_name -> metric_function')\n result = dict()\n\n for sample in dataset:\n output = self.predict(sample)\n\n for key, call in metrics.items():\n holder = result.get(key, list())\n holder.append(call(output, sample))\n\n result[key] = holder\n\n return result","def fn(distribution, *a):\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with ops.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n ops.add_to_collections(metrics_collections, metric_value)\n return metric_value","def evaluate(self, batch: RecordBatch) -> Any:\n processed_args = self._process_arguments(self._arguments, batch)\n if self._function:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", category=RuntimeWarning)\n if self._is_binary_func:\n result = self._apply_binary_args_function(\n *processed_args\n )\n else:\n result = self._function(*processed_args)\n else:\n result = self._expr_kernel(processed_args, batch)\n\n return self._post_process_result(result)","def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\n def fn(distribution, *a):\n \"\"\"Call `metric_value_fn` in the correct control flow context.\"\"\"\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with ops.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n ops.add_to_collections(metrics_collections, metric_value)\n return metric_value\n\n return distribute_lib.get_tower_context().merge_call(fn, *args)","def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\n def fn(distribution, *a):\n \"\"\"Call `metric_value_fn` in the correct control flow context.\"\"\"\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with tf.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n tf.add_to_collections(metrics_collections, metric_value)\n return metric_value\n\n return distribution_strategy_context.get_tower_context().merge_call(fn, *args)","def call_metric_function(metric_fn,\n y_true,\n y_pred=None,\n weights=None,\n mask=None):\n if mask is not None:\n mask = math_ops.cast(mask, y_pred.dtype)\n if weights is None:\n # Use mask as sample weight.\n weights = mask\n else:\n # Update dimensions of weights to match with mask.\n weights = math_ops.cast(weights, dtype=y_pred.dtype)\n mask, _, weights = losses_utils.squeeze_or_expand_dimensions(\n mask, sample_weight=weights)\n weights *= mask\n\n if y_pred is not None:\n return metric_fn(y_true, y_pred, sample_weight=weights)\n # `Mean` metric only takes a single value.\n return metric_fn(y_true, sample_weight=weights)","def evaluate_module(\n model: nn.Module,\n dataset: Union[NumpyArrayTuple, torch.utils.data.Dataset],\n loss_fn,\n device: torch.device,\n metrics_map: MetricsMapType = None,\n batch_size: int = 64,\n verbose: bool = True,\n) -> MetricsValType:\n try:\n model = model.to(device)\n\n # if dataset is a tuple of np.ndarrays, convert to torch Dataset\n if isinstance(dataset, tuple):\n X = torch.from_numpy(dataset[0]).type(torch.FloatTensor)\n y = torch.from_numpy(dataset[1]).type(\n torch.LongTensor if dataset[1].dtype in [np.int, np.long] else torch.FloatTensor\n )\n dataset = torch.utils.data.TensorDataset(X, y)\n\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False)\n\n tot_samples, samples, num_batches = len(dataset), 0, 0\n len_tot_samples = len(str(tot_samples))\n\n # create metrics history\n history = MetricsHistory(metrics_map)\n\n with torch.no_grad():\n model.eval()\n for X, y in loader:\n X = X.to(device)\n y = y.to(device)\n\n # forward pass\n preds = model(X)\n # compute batch loss\n batch_loss = loss_fn(preds, y).item()\n history.calculate_batch_metrics(preds.to(\"cpu\"), y.to(\"cpu\"), batch_loss, val_metrics=False)\n samples += len(y)\n num_batches += 1\n if verbose:\n metricsStr = history.get_metrics_str(batch_metrics=True, include_val_metrics=False)\n print(\n \"\\rEvaluating (%*d/%*d) -> %s\"\n % (len_tot_samples, samples, len_tot_samples, tot_samples, metricsStr),\n end=\"\",\n flush=True,\n )\n else:\n # iteration over batch completed\n # calculate average metrics across all batches\n history.calculate_epoch_metrics(val_metrics=False)\n metricsStr = history.get_metrics_str(batch_metrics=False, include_val_metrics=False)\n print(\n \"\\rEvaluating (%*d/%*d) -> %s\"\n % (len_tot_samples, samples, len_tot_samples, tot_samples, metricsStr),\n flush=True,\n )\n return history.get_metric_vals(history.tracked_metrics())\n finally:\n model = model.to(\"cpu\")","def problem_metric_fn(*args):\n (scores, weights) = metric_fn(*args)\n\n # The tf.metrics.mean function assures correct aggregation.\n return tf.compat.v1.metrics.mean(scores, weights)","def calc_metric(output, metrics):\n score = []\n for metric in metrics:\n metric_mod = __import__(\"sklearn.metrics\", fromlist=[metric])\n metric_func = getattr(metric_mod, metric)\n score.append(metric_func(output[0], output[1]))\n return score, output","def batch_transform(func):\n\n @functools.wraps(func)\n def create_window(*args, **kwargs):\n # passes the user defined function to BatchTransform which it\n # will call instead of self.get_value()\n return BatchTransform(*args, func=func, **kwargs)\n\n return create_window","def evaluate(model, loss_func, dataloader, metrics):\r\n model.eval()\r\n summ = []\r\n device = utils.get_device()\r\n for data in dataloader:\r\n encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids,inputY = data\r\n inputY = inputY.to(device)\r\n output_batch = model(encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids)\r\n\r\n loss = loss_func(output_batch, inputY)\r\n output_batch = output_batch.data.cpu().numpy()\r\n inputY = inputY.data.cpu().numpy()\r\n summary_batch = {metric: metrics[metric](\r\n output_batch, inputY) for metric in metrics}\r\n summary_batch['loss'] = loss.item()\r\n summ.append(summary_batch)\r\n # print(\"summ:{}\".format(summ))\r\n metrics_mean = {metric: np.mean([x[metric]\r\n for x in summ]) for metric in summ[0]}\r\n metrics_string = \" ; \".join(\"{}: {:05.3f}\".format(k, v)\r\n for k, v in metrics_mean.items())\r\n logging.info(\"- Eval metrics : \" + metrics_string)\r\n return metrics_mean","def run_batches(self,\n fn: Callable[..., Optional[Dict[str, Any]]],\n data_generator: Iterable[ArrayTupleOrList],\n limit: Optional[int] = None,\n count: Optional[int] = None,\n metrics: Union[Sequence[str], type(ALL)] = NOT_SET,\n outputs: Union[Sequence[str], type(ALL)] = NOT_SET,\n aggregators: Optional[Mapping[str, BatchAggregator]] = None,\n excludes: Sequence[str] = ()\n ) -> Optional[Dict[str, Any]]:\n metrics, outputs = \\\n self._complete_metrics_and_outputs_arg(metrics, outputs)\n\n # the BatchAggregatorDict\n agg_dict = BatchAggregatorDict.new(\n metrics=metrics,\n outputs=outputs,\n aggregators=aggregators,\n excludes=excludes,\n )\n\n # now run the batches\n g = self.iter_batches(data_generator, limit=limit, count=count)\n try:\n for batch, batch_data in g:\n batch_size = get_array_shape(batch_data[0])[0]\n fn_out = fn(*batch_data)\n if fn_out is not None:\n if not isinstance(fn_out, dict):\n raise TypeError(f'The output of `fn` is expected to be '\n f'a dict, but got {fn_out!r}')\n\n fn_out = {\n k: to_number_or_numpy(v)\n for k, v in fn_out.items()\n }\n metrics = {}\n for key, val in fn_out.items():\n agg = agg_dict.get(key)\n if agg is not None:\n size = batch_size if np.shape(val) == () else 1.\n agg.add(val, weight=size)\n # For metrics collected by\n # ``BatchAggregator('AVERAGE', None)``, we also add\n # them to the batch metrics.\n if agg.mode == BatchAggregationMode.AVERAGE and \\\n agg.axis is None:\n metrics[key] = np.mean(val)\n self.add_metrics(metrics)\n finally:\n g.close()\n\n # return the aggregated results\n if len(agg_dict) > 0:\n return {k: v.get() for k, v in agg_dict.items()}","def evaluate(\n self,\n duration_fn: Optional[Callable[[int], int]] = None,\n ) -> dict:\n # Call the `_before_evaluate` hook.\n self._before_evaluate()\n\n if self.evaluation_dataset is not None:\n return {\"evaluation\": self._run_offline_evaluation()}\n\n # Sync weights to the evaluation WorkerSet.\n if self.evaluation_workers is not None:\n self.evaluation_workers.sync_weights(\n from_worker_or_learner_group=self.workers.local_worker()\n )\n self._sync_filters_if_needed(\n central_worker=self.workers.local_worker(),\n workers=self.evaluation_workers,\n config=self.evaluation_config,\n )\n\n self.callbacks.on_evaluate_start(algorithm=self)\n\n if self.config.custom_evaluation_function:\n logger.info(\n \"Running custom eval function {}\".format(\n self.config.custom_evaluation_function\n )\n )\n metrics = self.config.custom_evaluation_function(\n self, self.evaluation_workers\n )\n if not metrics or not isinstance(metrics, dict):\n raise ValueError(\n \"Custom eval function must return \"\n \"dict of metrics, got {}.\".format(metrics)\n )\n else:\n if (\n self.evaluation_workers is None\n and self.workers.local_worker().input_reader is None\n ):\n raise ValueError(\n \"Cannot evaluate w/o an evaluation worker set in \"\n \"the Algorithm or w/o an env on the local worker!\\n\"\n \"Try one of the following:\\n1) Set \"\n \"`evaluation_interval` >= 0 to force creating a \"\n \"separate evaluation worker set.\\n2) Set \"\n \"`create_env_on_driver=True` to force the local \"\n \"(non-eval) worker to have an environment to \"\n \"evaluate on.\"\n )\n\n # How many episodes/timesteps do we need to run?\n # In \"auto\" mode (only for parallel eval + training): Run as long\n # as training lasts.\n unit = self.config.evaluation_duration_unit\n eval_cfg = self.evaluation_config\n rollout = eval_cfg.rollout_fragment_length\n num_envs = eval_cfg.num_envs_per_worker\n auto = self.config.evaluation_duration == \"auto\"\n duration = (\n self.config.evaluation_duration\n if not auto\n else (self.config.evaluation_num_workers or 1)\n * (1 if unit == \"episodes\" else rollout)\n )\n agent_steps_this_iter = 0\n env_steps_this_iter = 0\n\n # Default done-function returns True, whenever num episodes\n # have been completed.\n if duration_fn is None:\n\n def duration_fn(num_units_done):\n return duration - num_units_done\n\n logger.info(f\"Evaluating current state of {self} for {duration} {unit}.\")\n\n metrics = None\n all_batches = []\n # No evaluation worker set ->\n # Do evaluation using the local worker. Expect error due to the\n # local worker not having an env.\n if self.evaluation_workers is None:\n # If unit=episodes -> Run n times `sample()` (each sample\n # produces exactly 1 episode).\n # If unit=ts -> Run 1 `sample()` b/c the\n # `rollout_fragment_length` is exactly the desired ts.\n iters = duration if unit == \"episodes\" else 1\n for _ in range(iters):\n batch = self.workers.local_worker().sample()\n agent_steps_this_iter += batch.agent_steps()\n env_steps_this_iter += batch.env_steps()\n if self.reward_estimators:\n all_batches.append(batch)\n metrics = collect_metrics(\n self.workers,\n keep_custom_metrics=eval_cfg.keep_per_episode_custom_metrics,\n timeout_seconds=eval_cfg.metrics_episode_collection_timeout_s,\n )\n\n # Evaluation worker set only has local worker.\n elif self.evaluation_workers.num_remote_workers() == 0:\n # If unit=episodes -> Run n times `sample()` (each sample\n # produces exactly 1 episode).\n # If unit=ts -> Run 1 `sample()` b/c the\n # `rollout_fragment_length` is exactly the desired ts.\n iters = duration if unit == \"episodes\" else 1\n for _ in range(iters):\n batch = self.evaluation_workers.local_worker().sample()\n agent_steps_this_iter += batch.agent_steps()\n env_steps_this_iter += batch.env_steps()\n if self.reward_estimators:\n all_batches.append(batch)\n\n # Evaluation worker set has n remote workers.\n elif self.evaluation_workers.num_healthy_remote_workers() > 0:\n # How many episodes have we run (across all eval workers)?\n num_units_done = 0\n _round = 0\n # In case all of the remote evaluation workers die during a round\n # of evaluation, we need to stop.\n while True and self.evaluation_workers.num_healthy_remote_workers() > 0:\n units_left_to_do = duration_fn(num_units_done)\n if units_left_to_do <= 0:\n break\n\n _round += 1\n unit_per_remote_worker = (\n 1 if unit == \"episodes\" else rollout * num_envs\n )\n # Select proper number of evaluation workers for this round.\n selected_eval_worker_ids = [\n worker_id\n for i, worker_id in enumerate(\n self.evaluation_workers.healthy_worker_ids()\n )\n if i * unit_per_remote_worker < units_left_to_do\n ]\n batches = self.evaluation_workers.foreach_worker(\n func=lambda w: w.sample(),\n local_worker=False,\n remote_worker_ids=selected_eval_worker_ids,\n timeout_seconds=self.config.evaluation_sample_timeout_s,\n )\n if len(batches) != len(selected_eval_worker_ids):\n logger.warning(\n \"Calling `sample()` on your remote evaluation worker(s) \"\n \"resulted in a timeout (after the configured \"\n f\"{self.config.evaluation_sample_timeout_s} seconds)! \"\n \"Try to set `evaluation_sample_timeout_s` in your config\"\n \" to a larger value.\"\n + (\n \" If your episodes don't terminate easily, you may \"\n \"also want to set `evaluation_duration_unit` to \"\n \"'timesteps' (instead of 'episodes').\"\n if unit == \"episodes\"\n else \"\"\n )\n )\n break\n\n _agent_steps = sum(b.agent_steps() for b in batches)\n _env_steps = sum(b.env_steps() for b in batches)\n # 1 episode per returned batch.\n if unit == \"episodes\":\n num_units_done += len(batches)\n # Make sure all batches are exactly one episode.\n for ma_batch in batches:\n ma_batch = ma_batch.as_multi_agent()\n for batch in ma_batch.policy_batches.values():\n assert batch.is_terminated_or_truncated()\n # n timesteps per returned batch.\n else:\n num_units_done += (\n _agent_steps\n if self.config.count_steps_by == \"agent_steps\"\n else _env_steps\n )\n if self.reward_estimators:\n # TODO: (kourosh) This approach will cause an OOM issue when\n # the dataset gets huge (should be ok for now).\n all_batches.extend(batches)\n\n agent_steps_this_iter += _agent_steps\n env_steps_this_iter += _env_steps\n\n logger.info(\n f\"Ran round {_round} of non-parallel evaluation \"\n f\"({num_units_done}/{duration if not auto else '?'} \"\n f\"{unit} done)\"\n )\n else:\n # Can't find a good way to run this evaluation.\n # Wait for next iteration.\n pass\n\n if metrics is None:\n metrics = collect_metrics(\n self.evaluation_workers,\n keep_custom_metrics=self.config.keep_per_episode_custom_metrics,\n timeout_seconds=eval_cfg.metrics_episode_collection_timeout_s,\n )\n\n # TODO: Don't dump sampler results into top-level.\n if not self.config.custom_evaluation_function:\n metrics = dict({\"sampler_results\": metrics}, **metrics)\n\n metrics[NUM_AGENT_STEPS_SAMPLED_THIS_ITER] = agent_steps_this_iter\n metrics[NUM_ENV_STEPS_SAMPLED_THIS_ITER] = env_steps_this_iter\n # TODO: Remove this key at some point. Here for backward compatibility.\n metrics[\"timesteps_this_iter\"] = env_steps_this_iter\n\n # Compute off-policy estimates\n estimates = defaultdict(list)\n # for each batch run the estimator's fwd pass\n for name, estimator in self.reward_estimators.items():\n for batch in all_batches:\n estimate_result = estimator.estimate(\n batch,\n split_batch_by_episode=self.config.ope_split_batch_by_episode,\n )\n estimates[name].append(estimate_result)\n\n # collate estimates from all batches\n if estimates:\n metrics[\"off_policy_estimator\"] = {}\n for name, estimate_list in estimates.items():\n avg_estimate = tree.map_structure(\n lambda *x: np.mean(x, axis=0), *estimate_list\n )\n metrics[\"off_policy_estimator\"][name] = avg_estimate\n\n # Evaluation does not run for every step.\n # Save evaluation metrics on Algorithm, so it can be attached to\n # subsequent step results as latest evaluation result.\n self.evaluation_metrics = {\"evaluation\": metrics}\n\n # Trigger `on_evaluate_end` callback.\n self.callbacks.on_evaluate_end(\n algorithm=self, evaluation_metrics=self.evaluation_metrics\n )\n\n # Also return the results here for convenience.\n return self.evaluation_metrics","def log_eval_summary(step: int,\n *,\n writer: metric_writers.MetricWriter,\n eval_metrics: Sequence[Dict[str, Tuple[float, int]]],\n extra_eval_summary: Optional[Dict[str, float]] = None,\n metrics_normalizer_fn: Optional[\n Callable[[Dict[str, Tuple[float, int]], str],\n Dict[str, float]]] = None,\n prefix: str = 'valid',\n key_separator: str = '_') -> Dict[str, float]:\n eval_metrics = stack_forest(eval_metrics)\n\n # Compute the sum over all examples in all batches.\n eval_metrics_summary = jax.tree_map(lambda x: x.sum(), eval_metrics)\n # Normalize metrics by the total number of exampels.\n metrics_normalizer_fn = metrics_normalizer_fn or normalize_metrics_summary\n eval_metrics_summary = metrics_normalizer_fn(eval_metrics_summary, 'eval')\n # If None, set to an empty dictionary.\n extra_eval_summary = extra_eval_summary or {}\n\n # Adds extra_eval_summary to the returned eval_summary.\n eval_metrics_summary.update(extra_eval_summary)\n\n writer.write_scalars(\n step, {\n key_separator.join((prefix, key)): val\n for key, val in eval_metrics_summary.items()\n })\n\n return eval_metrics_summary","def get_evaluate_fn(testset):\n x_test, y_test = testset\n\n # The `evaluate` function will be called after every round by the strategy\n def evaluate(\n server_round: int,\n parameters: fl.common.NDArrays,\n config: Dict[str, fl.common.Scalar],\n ):\n model = get_model() # Construct the model\n model.set_weights(parameters) # Update model with the latest parameters\n loss, accuracy = model.evaluate(x_test, y_test, verbose=VERBOSE)\n return loss, {\"accuracy\": accuracy}\n\n return evaluate","def build_metric_func(dataset_split_name, add_summary=True):\n\n def metric_func(labels, logits):\n \"\"\"Evaluation metric function that runs on CPU.\"\"\"\n accuracy_metric_name = 'Eval/Accuracy/%s' % dataset_split_name\n metric_map = {\n accuracy_metric_name: tf.metrics.accuracy(labels, tf.argmax(logits, 1)),\n }\n if add_summary:\n for name, value in metric_map.items():\n tf.summary.scalar(name, value)\n return metric_map\n\n return metric_func","def evaluate(model, loss_func, dataloader, metrics):\r\n model.eval()\r\n summ = []\r\n device = utils.get_device()\r\n with torch.no_grad():\r\n for data in dataloader:\r\n sentences1, starts1, ends1, sentences2, starts2, ends2, inputY = data\r\n inputY = inputY.to(device)\r\n output_batch = model(sentences1, starts1, ends1, sentences2, starts2, ends2)\r\n loss = loss_func(output_batch, inputY)\r\n output_batch = output_batch.data.cpu().numpy()\r\n inputY = inputY.data.cpu().numpy()\r\n summary_batch = {metric: metrics[metric](\r\n output_batch, inputY) for metric in metrics}\r\n summary_batch['loss'] = loss.item()\r\n summ.append(summary_batch)\r\n # print(\"summ:{}\".format(summ))\r\n metrics_mean = {metric: np.mean([x[metric]\r\n for x in summ]) for metric in summ[0]}\r\n metrics_string = \" ; \".join(\"{}: {:05.3f}\".format(k, v)\r\n for k, v in metrics_mean.items())\r\n logging.info(\"- Eval metrics : \" + metrics_string)\r\n return metrics_mean","def get_metric_fn(self, sklearn_fn, kwargs=None):\n kwargs = kwargs if kwargs else dict()\n if self.data_content is not None and self.task_id is not None:\n predictions_arff = self._generate_arff_dict()\n elif \"predictions\" in self.output_files:\n predictions_file_url = openml._api_calls._file_id_to_url(\n self.output_files[\"predictions\"],\n \"predictions.arff\",\n )\n response = openml._api_calls._download_text_file(predictions_file_url)\n predictions_arff = arff.loads(response)\n # TODO: make this a stream reader\n else:\n raise ValueError(\n \"Run should have been locally executed or \" \"contain outputfile reference.\"\n )\n\n # Need to know more about the task to compute scores correctly\n task = get_task(self.task_id)\n\n attribute_names = [att[0] for att in predictions_arff[\"attributes\"]]\n if (\n task.task_type_id in [TaskType.SUPERVISED_CLASSIFICATION, TaskType.LEARNING_CURVE]\n and \"correct\" not in attribute_names\n ):\n raise ValueError('Attribute \"correct\" should be set for ' \"classification task runs\")\n if task.task_type_id == TaskType.SUPERVISED_REGRESSION and \"truth\" not in attribute_names:\n raise ValueError('Attribute \"truth\" should be set for ' \"regression task runs\")\n if task.task_type_id != TaskType.CLUSTERING and \"prediction\" not in attribute_names:\n raise ValueError('Attribute \"predict\" should be set for ' \"supervised task runs\")\n\n def _attribute_list_to_dict(attribute_list):\n # convenience function: Creates a mapping to map from the name of\n # attributes present in the arff prediction file to their index.\n # This is necessary because the number of classes can be different\n # for different tasks.\n res = OrderedDict()\n for idx in range(len(attribute_list)):\n res[attribute_list[idx][0]] = idx\n return res\n\n attribute_dict = _attribute_list_to_dict(predictions_arff[\"attributes\"])\n\n repeat_idx = attribute_dict[\"repeat\"]\n fold_idx = attribute_dict[\"fold\"]\n predicted_idx = attribute_dict[\"prediction\"] # Assume supervised task\n\n if (\n task.task_type_id == TaskType.SUPERVISED_CLASSIFICATION\n or task.task_type_id == TaskType.LEARNING_CURVE\n ):\n correct_idx = attribute_dict[\"correct\"]\n elif task.task_type_id == TaskType.SUPERVISED_REGRESSION:\n correct_idx = attribute_dict[\"truth\"]\n has_samples = False\n if \"sample\" in attribute_dict:\n sample_idx = attribute_dict[\"sample\"]\n has_samples = True\n\n if (\n predictions_arff[\"attributes\"][predicted_idx][1]\n != predictions_arff[\"attributes\"][correct_idx][1]\n ):\n pred = predictions_arff[\"attributes\"][predicted_idx][1]\n corr = predictions_arff[\"attributes\"][correct_idx][1]\n raise ValueError(\n \"Predicted and Correct do not have equal values:\"\n \" %s Vs. %s\" % (str(pred), str(corr))\n )\n\n # TODO: these could be cached\n values_predict = {}\n values_correct = {}\n for line_idx, line in enumerate(predictions_arff[\"data\"]):\n rep = line[repeat_idx]\n fold = line[fold_idx]\n if has_samples:\n samp = line[sample_idx]\n else:\n samp = 0 # No learning curve sample, always 0\n\n if task.task_type_id in [\n TaskType.SUPERVISED_CLASSIFICATION,\n TaskType.LEARNING_CURVE,\n ]:\n prediction = predictions_arff[\"attributes\"][predicted_idx][1].index(\n line[predicted_idx]\n )\n correct = predictions_arff[\"attributes\"][predicted_idx][1].index(line[correct_idx])\n elif task.task_type_id == TaskType.SUPERVISED_REGRESSION:\n prediction = line[predicted_idx]\n correct = line[correct_idx]\n if rep not in values_predict:\n values_predict[rep] = OrderedDict()\n values_correct[rep] = OrderedDict()\n if fold not in values_predict[rep]:\n values_predict[rep][fold] = OrderedDict()\n values_correct[rep][fold] = OrderedDict()\n if samp not in values_predict[rep][fold]:\n values_predict[rep][fold][samp] = []\n values_correct[rep][fold][samp] = []\n\n values_predict[rep][fold][samp].append(prediction)\n values_correct[rep][fold][samp].append(correct)\n\n scores = []\n for rep in values_predict.keys():\n for fold in values_predict[rep].keys():\n last_sample = len(values_predict[rep][fold]) - 1\n y_pred = values_predict[rep][fold][last_sample]\n y_true = values_correct[rep][fold][last_sample]\n scores.append(sklearn_fn(y_true, y_pred, **kwargs))\n return np.array(scores)","def evaluate(self):\n iterator = self._iterators['main']\n\n if self.eval_hook:\n self.eval_hook(self)\n\n summary = reporting.DictSummary()\n\n progress = IterationStatus(len(iterator))\n if self._progress_bar:\n pbar = _IteratorProgressBar(iterator=progress)\n\n last_iter = len(iterator) - 1\n with _in_eval_mode(self._targets.values()):\n for idx, batch in enumerate(iterator):\n last_batch = idx == last_iter\n progress.current_position = idx\n observation = {}\n with reporting.report_scope(observation):\n if isinstance(batch, (tuple, list)):\n outs = self.eval_func(*batch)\n elif isinstance(batch, dict):\n outs = self.eval_func(**batch)\n else:\n outs = self.eval_func(batch)\n for metric in self._metrics:\n metric(batch, outs, last_batch)\n summary.add(observation)\n\n if self._progress_bar:\n pbar.update()\n\n if self._progress_bar:\n pbar.close()\n\n return summary.compute_mean()","def evaluate(model,loss_fn, val_dataloader):\r\n # Put the model into the evaluation mode. The dropout layers are disabled during\r\n # the test time.\r\n model.eval()\r\n\r\n # Tracking variables\r\n val_accuracy = []\r\n val_loss = []\r\n\r\n # For each batch in our validation set...\r\n for batch in val_dataloader:\r\n # Load batch to GPU\r\n b_input_ids, b_attn_mask, b_labels = tuple(t.to(device) for t in batch)\r\n\r\n # Compute logits\r\n with torch.no_grad():\r\n logits = model(b_input_ids, b_attn_mask)\r\n\r\n # Compute loss\r\n loss = loss_fn(logits, b_labels)\r\n val_loss.append(loss.item())\r\n\r\n # Get the predictions\r\n preds = torch.argmax(logits, dim=1).flatten()\r\n\r\n # Calculate the accuracy rate\r\n accuracy = (preds == b_labels).cpu().numpy().mean() * 100\r\n val_accuracy.append(accuracy)\r\n\r\n # Compute the average accuracy and loss over the validation set.\r\n val_loss = np.mean(val_loss)\r\n val_accuracy = np.mean(val_accuracy)\r\n\r\n return val_loss, val_accuracy","def _run_evaluator(self, func, stats):\n host_stats = stats['host_stats']\n host_caps = stats['host_caps']\n extra_specs = stats['extra_specs']\n share_stats = stats['share_stats']\n\n result = evaluator.evaluate(\n func,\n extra=extra_specs,\n stats=host_stats,\n capabilities=host_caps,\n share=share_stats)\n\n return result","def evaluate(self, input_fn, eval_times, checkpoint_path=None):\n if not checkpoint_path:\n checkpoint_path = self._estimator.latest_checkpoint()\n\n if self._params.eval.type == 'customized':\n metrics = self._estimator.evaluate(\n input_fn, steps=eval_times, checkpoint_path=checkpoint_path)\n else:\n if not self._evaluator:\n self.prepare_evaluation()\n if checkpoint_path:\n current_step = int(os.path.basename(checkpoint_path).split('-')[1])\n else:\n current_step = 0\n predictor = self._estimator.predict(\n input_fn=input_fn,\n checkpoint_path=checkpoint_path,\n yield_single_examples=False)\n losses = collections.defaultdict(lambda: 0.0)\n\n counter = 0\n try:\n while eval_times is None or counter < eval_times:\n outputs = six.next(predictor)\n predictions = {}\n groundtruths = {}\n for key, val in outputs.items():\n if key[0:5] == 'pred_':\n predictions[key[5::]] = val\n if key[0:3] == 'gt_':\n groundtruths[key[3::]] = val\n if key[0:5] == 'loss_':\n losses[key[5::]] += np.mean(val)\n self._evaluator.update(\n predictions,\n groundtruths=(None if self._params.eval.use_json_file\n else groundtruths))\n counter = counter + 1\n tf.logging.info(\n f'Finish eval step {counter} out of total {eval_times} steps.')\n except (tf.errors.OutOfRangeError, StopIteration):\n logging.info(\n 'Evaluation reaches the end after running %d times.', counter)\n\n for key, val in outputs.items():\n if key[0:5] == 'loss_':\n losses[key[5::]] /= counter\n metrics = self._evaluator.evaluate()\n\n # Summary writer writes out eval metrics.\n output_dir = os.path.join(self._model_dir,\n 'eval' + self._params.eval.suffix)\n tf.gfile.MakeDirs(output_dir)\n summary_writer = tf.summary.FileWriter(output_dir)\n write_summary(metrics, summary_writer, current_step)\n write_summary(losses, summary_writer, current_step)\n summary_writer.close()\n\n logging.info('Eval result: %s', metrics)\n return metrics","def evaluate(model, loss_fn, data_iterator, metrics, params, num_steps, sample_weights=None):\n\n # set model to evaluation mode\n model.eval()\n\n # summary for current eval loop\n summ = []\n out_prob=[]\n labels=np.array([])\n \n ##-----------------------------\n # compute metrics over the dataset\n \n data_iterator_iter = iter(data_iterator)\n \n for _ in range(num_steps):\n \n # fetch the next evaluation batch\n levels, children, n_inners, contents, n_level, labels_batch=next(data_iterator_iter)\n\n # shift tensors to GPU if available\n if params.cuda:\n levels = levels.cuda()\n children=children.cuda()\n n_inners=n_inners.cuda()\n contents=contents.cuda()\n n_level= n_level.cuda()\n labels_batch =labels_batch.cuda()\n\n # convert them to Variables to record operations in the computational graph\n levels=torch.autograd.Variable(levels)\n children=torch.autograd.Variable(children)\n n_inners=torch.autograd.Variable(n_inners)\n contents = torch.autograd.Variable(contents)\n n_level=torch.autograd.Variable(n_level)\n labels_batch = torch.autograd.Variable(labels_batch) \n\n ##-----------------------------\n # Feedforward pass through the NN\n output_batch = model(params, levels, children, n_inners, contents, n_level)\n \n # compute model output\n labels_batch = labels_batch.float() #Uncomment if using torch.nn.BCELoss() loss function\n output_batch=output_batch.view((params.batch_size))\n loss = loss_fn(output_batch, labels_batch)\n# print('labels for loss=',labels_batch)\n# print('y_pred=',output_batch)\n\n # extract data from torch Variable, move to cpu, convert to numpy arrays\n output_batch = output_batch.data.cpu().numpy()\n labels_batch = labels_batch.data.cpu().numpy()\n \n# print('concatenated labels before =', labels)\n labels=np.concatenate((labels,labels_batch))\n# print('concatenated labels after =', labels)\n# print('output_batch[0]=',output_batch[0:4])\n# print('output_batch shape=',output_batch.shape)\n\n# output_batch=output_batch.flatten() \n out_prob=np.concatenate((out_prob,output_batch))\n \n # We calculate a single probability of tagging the image as signal \n# for i_prob in range(len(output_batch)):\n# # out_prob.append((output_batch[i_prob][0]-output_batch[i_prob][1]+1)/2)\n# out_prob.append(output_batch[i_prob][1])\n\n# print('Predicted probability of each output neuron = \\n',output_batch[0:15])\n# print('------------'*10)\n# print('Output of tagging image as signal = \\n',np.array(out_prob)[-params.batch_size::])\n# print('------------'*10)\n\n # compute all metrics on this batch\n summary_batch = {metric: metrics[metric](output_batch, labels_batch)\n for metric in metrics}\n summary_batch['loss'] = loss.item()\n summ.append(summary_batch)\n \n ##Get the bg rejection at 30% tag eff: 0.05 + 125*(1 - 0.05)/476=0.3). That's why we pick 125\n fpr_log, tpr_log, thresholds_log = roc_curve(labels, out_prob,pos_label=1, drop_intermediate=False)\n base_tpr = np.linspace(0.05, 1, 476)\n inv_fpr = interp(base_tpr, tpr_log, 1. / fpr_log)[125]\n# print('inv_fpr at 30% tag eff=',inv_fpr)\n \n ##-----------------------------\n logging.info('Total Labels={}'.format(labels[0:10]))\n logging.info('Out prob={}'.format(out_prob[0:10]))\n logging.info('------------'*10)\n logging.info('len labels after ={}'.format(len(labels)))\n logging.info('len out_prob after{}'.format(len(out_prob)))\n \n # Get fpr, tpr, ROC curve and AUC\n roc_auc = generate_results(labels, out_prob, params,weights=sample_weights)\n# generate_results(labels, out_prob, params,weights=sample_weights)\n \n ## Save output prob and true values\n with open(out_files_dir+'yProbTrue_'+str(params.num_epochs)+'_'+sample_filename+'.pkl','wb') as f: pickle.dump(zip(out_prob, labels), f)\n \n \n # compute mean of all metrics in summary\n metrics_mean = {metric:np.mean([x[metric] for x in summ]) for metric in summ[0]} \n metrics_string = \" ; \".join(\"{}: {:05.5f}\".format(k, v) for k, v in metrics_mean.items())\n logging.info(\"- Eval metrics : \" + metrics_string)\n \n metrics_mean['auc']=roc_auc \n metrics_mean['test_bg_reject']=inv_fpr\n \n return metrics_mean","def evaluate(self) -> Dict[str, Any]:\n kwargs = {\"ids\": self._ids}\n return {\n metric.value: self._metric_funcs[metric](\n self._targets, self._preds, **kwargs\n )\n for metric in self._metrics\n }","def _compute_running_metrics(self,\n model_output: torch.Tensor,\n batch: Tuple[torch.Tensor, torch.Tensor],\n running_metrics: dict) -> None:\n for metric in self.metrics:\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\n metric_result = metric(model_output, batch, self.decoder)\n else:\n metric_result = metric(model_output, batch)\n if type(metric_result) == torch.Tensor:\n metric_result = metric_result.item()\n\n running_metrics[metric.__name__].append(metric_result)","def evaluate(self,\n x=None,\n y=None,\n input_fn=None,\n feed_fn=None,\n batch_size=None,\n steps=None,\n metrics=None,\n name=None,\n checkpoint_path=None,\n hooks=None):\n raise NotImplementedError","def __call__(self, *args, **kwargs):\n\n def replica_local_fn(*args, **kwargs):\n \"\"\"Updates the state of the metric in a replica-local context.\"\"\"\n if any(\n isinstance(arg, keras_tensor.KerasTensor)\n for arg in nest.flatten((args, kwargs))):\n update_op = None\n else:\n update_op = self.update_state(*args, **kwargs) # pylint: disable=not-callable\n update_ops = []\n if update_op is not None:\n update_ops.append(update_op)\n with ops.control_dependencies(update_ops):\n result_t = self.result() # pylint: disable=not-callable\n\n # We are adding the metric object as metadata on the result tensor.\n # This is required when we want to use a metric with `add_metric` API on\n # a Model/Layer in graph mode. This metric instance will later be used\n # to reset variable state after each epoch of training.\n # Example:\n # model = Model()\n # mean = Mean()\n # model.add_metric(mean(values), name='mean')\n result_t._metric_obj = self # pylint: disable=protected-access\n return result_t\n\n from tensorflow.python.keras.distribute import distributed_training_utils # pylint:disable=g-import-not-at-top\n return distributed_training_utils.call_replica_local_fn(\n replica_local_fn, *args, **kwargs)","def wrapper(reward_fn,\n scale: float = 1.0,\n offset: float = 0.0,\n done_bonus: float = 0.0,\n exclude_from_score: bool = False):\n\n def fn(*args, **kwargs):\n reward, done = reward_fn(*args, **kwargs)\n if exclude_from_score:\n score = jnp.zeros_like(reward)\n else:\n score = reward\n reward = (reward + offset) * scale\n score *= jnp.sign(scale)\n reward = jnp.where(done, x=reward + done_bonus, y=reward)\n score = jnp.where(done, x=score + done_bonus, y=score)\n return reward, score, done\n\n return fn","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def as_numpy(fn):\n\n def metric_fn(y_true, y_pred):\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\n new_y_true = y_true.values\n elif isinstance(y_true, np.ndarray):\n new_y_true = y_true\n else:\n new_y_true = y_true.numpy()\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\n new_y_pred = y_pred.values\n elif isinstance(y_pred, np.ndarray):\n new_y_pred = y_pred\n else:\n new_y_pred = y_pred.numpy()\n if new_y_true.ndim == 1:\n new_y_true = np.expand_dims(new_y_true, 1)\n if new_y_pred.ndim == 1:\n new_y_pred = np.expand_dims(new_y_pred, 1)\n return fn(new_y_true, new_y_pred)\n return metric_fn","def run(self,\n fn: Callable[..., Optional[Dict[str, Any]]],\n data_generator: Iterable[ArrayTupleOrList],\n metrics: Union[Sequence[str], type(ALL)] = NOT_SET,\n excludes: Sequence[str] = (),\n **kwargs\n ) -> Optional[Dict[str, Any]]:\n run_fn = self.run_batches if self.only_batch else self.run_epochs\n F = lambda: run_fn(\n fn,\n data_generator,\n metrics=metrics,\n excludes=excludes,\n **kwargs\n )\n if not self._stage.is_active:\n with self:\n return F()\n else:\n return F()","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def evaluator(evaluate):\r\n @functools.wraps(evaluate)\r\n def ecspy_evaluator(candidates, args):\r\n fitness = []\r\n for candidate in candidates:\r\n fitness.append(evaluate(candidate, args))\r\n return fitness\r\n ecspy_evaluator.single_evaluation = evaluate\r\n return ecspy_evaluator","def compute_metrics(self, results: list) -> dict:","def _wrap_func(fn):\n\n @wraps(fn)\n def wrapper(*arg, **kwargs):\n results = fn(*arg, **kwargs)\n return _convert_python_data(results)\n\n return wrapper","def valuesReducer(aggregation_fn):\n return partial(reduceWith, aggregation_fn)","def _evaluate(self,\n logits,\n predictions,\n data, evaluation_fn,\n max_eval_batches=None,\n calculate_scores=True,\n write_results=False):\n # counting the evaluation batches\n num_eval_batches = 0\n # logits and predictions from the model\n all_logits = []\n all_predictions = []\n # fetched data that led to the predictions\n # dictionary of {seq_1: [], seq_2: [], target: []}\n all_fetched_data = collections.defaultdict(list)\n try:\n while True:\n # sample predictions\n (fetched_logits,\n fetched_predictions,\n fetched_data) = self._fetch_data_batch(\n logits=logits, predictions=predictions, data=data)\n\n # Cache the data\n all_logits += fetched_logits\n all_predictions += fetched_predictions\n all_fetched_data[\"target\"] += fetched_data[\"target\"]\n\n # break the loop if max_eval_batches is set\n num_eval_batches += 1\n if (max_eval_batches and\n num_eval_batches >= max_eval_batches):\n break\n\n except tf.errors.OutOfRangeError:\n pass\n\n # Evaluate\n scores = None\n if calculate_scores:\n scores = evaluation_fn(\n all_predictions,\n all_fetched_data[\"seq_1\"], # Should be empty\n all_fetched_data[\"seq_2\"], # Should be empty\n all_fetched_data[\"target\"])\n\n if write_results:\n _write_results_to_csv(\n all_logits,\n all_predictions,\n all_fetched_data,\n output_dir=os.path.join(\n self._logdir, RESULTS_CSV_FNAME))\n\n return len(all_predictions), scores","def single_round_model_eval(train_fun, decode_fun, eval_fun, train_set,\n dev_set, metrics, metrics_weights):\n assert(len(metrics) > 0)\n assert(len(metrics) == len(metrics_weights))\n tf.reset_default_graph()\n try:\n train_fun(train_set, dev_set)\n \n tf.reset_default_graph()\n model_dir, decode_sig = decode_fun(dev_set, verbose=False)\n\n M = eval_fun(dev_set, model_dir, decode_sig, verbose=False)\n\n metrics_value = 0\n for m, m_w in zip(metrics, metrics_weights):\n metrics_value += m_w * M[m]\n except graph_utils.InfPerplexityError:\n metrics_value = -np.inf\n\n return metrics_value","def evaluate(self, batch_x, batch_y):\n raise NotImplementedError()","def evaluate(model, optimizer, loss_function, loader, device, labels, log_every_n=10):\n\n model.eval()\n\n batch_wise_true_labels = []\n batch_wise_predictions = []\n\n loss_history = []\n running_loss = 0.\n running_loss_history = []\n\n with torch.no_grad(): # Disable gradient computation - required only during training\n for i, batch in tqdm(enumerate(loader)):\n\n logits = model(batch[0].to(device), batch[1]).squeeze()\n loss = loss_function(logits, batch[2].to(device))\n loss_history.append(loss.item())\n\n running_loss += (loss_history[-1] - running_loss) / (i + 1) # Compute rolling average\n\n running_loss_history.append(running_loss)\n\n predictions = torch.sigmoid(logits)\n\n batch_wise_true_labels.append(batch[2].view(-1).tolist())\n batch_wise_predictions.append(predictions.view(-1).tolist())\n\n # flatten the list of predictions using itertools\n all_true_labels = list(chain.from_iterable(batch_wise_true_labels))\n all_predictions = list(chain.from_iterable(batch_wise_predictions))\n all_predictions = [1 if p > 0.5 else 0 for p in all_predictions]\n\n\n print(\"Evaluation Loss: \", running_loss)\n # Now we can generate a classification report\n print(\"Classification report after epoch:\")\n print(f1_score(all_true_labels, all_predictions, average='micro'))\n print(classification_report(all_true_labels, all_predictions, labels=labels))\n\n return loss_history, running_loss_history","def add_metric(self, metric_fn):\n self._metrics.append(metric_fn)","def make_loss_fn(\n cls, config: ml_collections.ConfigDict\n ) -> Callable[..., Tuple[float, MetricGroups, Dict[str, Any]]]:\n mlm_weight = config.mlm_weight\n el_im_weight = config.el_im_weight\n el_final_weight = config.el_final_weight\n el_score_mode = config.get('el_score_mode', 'dot')\n mtb_im_weight = config.get('mtb_im_weight', 0)\n mtb_final_weight = config.get('mtb_final_weight', 0)\n mtb_score_mode = config.get('mtb_score_mode', 'dot')\n\n def loss_fn(\n model_config: ml_collections.FrozenConfigDict,\n model_params: Dict[str, Any],\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\n batch: Dict[str, Any],\n deterministic: bool,\n dropout_rng: Optional[Dict[str, Array]] = None,\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\n \"\"\"Task-specific loss function. See BaseTask.\"\"\"\n\n batch_size = batch['text_ids'].shape[0]\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\n {'params': model_params},\n batch,\n deterministic=deterministic,\n rngs=dropout_rng)\n mention_target_is_masked = batch['mention_target_is_masked']\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\n mention_target_ids = batch['mention_target_ids']\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\n\n mlm_logits = loss_helpers['mlm_logits']\n\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\n\n mlm_correct_mask = jnp.equal(\n jnp.argmax(mlm_logits, axis=-1),\n batch['mlm_target_ids']) * batch['mlm_target_weights']\n mlm_acc = mlm_correct_mask.sum()\n mlm_mention_acc = (mlm_correct_mask *\n batch['mlm_target_is_mention']).sum()\n mlm_mention_denom = (batch['mlm_target_weights'] *\n batch['mlm_target_is_mention']).sum()\n mlm_non_mention_acc = (mlm_correct_mask *\n (1 - batch['mlm_target_is_mention'])).sum()\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\n (1 - batch['mlm_target_is_mention'])).sum()\n\n metrics = {\n 'mlm': {\n 'loss': mlm_loss,\n 'acc': mlm_acc,\n 'denominator': mlm_denom,\n },\n 'mlm_mention': {\n 'acc': mlm_mention_acc,\n 'denominator': mlm_mention_denom,\n },\n 'mlm_non_mention': {\n 'acc': mlm_non_mention_acc,\n 'denominator': mlm_non_mention_denom,\n },\n }\n\n if 'intermediate_mention_encodings' in loss_helpers:\n intermediate_target_mention_encodings = jut.matmul_slice(\n loss_helpers['intermediate_mention_encodings'],\n batch['mention_target_indices'])\n else:\n intermediate_target_mention_encodings = loss_helpers[\n 'im_target_mention_encodings']\n\n if model_config.encoder_config.get('no_entity_attention', False):\n (el_im_loss, el_im_metrics,\n (el_im_acc_per_mention,\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\n intermediate_target_mention_encodings,\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_im_denom = el_im_metrics['denominator']\n metrics['el_intermediate'] = el_im_metrics\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_acc_per_mention,\n el_im_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\n }\n else:\n intermediate_entity_attention = loss_helpers[\n 'intermediate_entity_attention']\n\n # Construct targets and ids for intermediate entity linking loss\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\n intermediate_target_ids = intermediate_target_ids.at[\n batch['mention_target_indices']].add(\n mention_target_ids * batch['mention_target_weights'])\n\n intermediate_target_weights = jnp.zeros_like(\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\n intermediate_target_weights = intermediate_target_weights.at[\n batch['mention_target_indices']].add(\n batch['mention_target_weights'])\n\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\n mention_is_masked = mention_is_masked.at[\n batch['mention_target_indices']].add(\n mention_target_is_masked * batch['mention_target_weights'])\n\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\n intermediate_entity_attention,\n intermediate_target_ids,\n intermediate_target_weights,\n inputs_are_prob=True)\n\n el_im_correct_mask = jnp.equal(\n jnp.argmax(intermediate_entity_attention, axis=-1),\n intermediate_target_ids) * intermediate_target_weights\n el_im_acc = el_im_correct_mask.sum()\n\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\n intermediate_entity_attention, intermediate_target_ids,\n intermediate_target_weights)\n\n intermediate_entity_cos_sim = loss_helpers[\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\n mention_target_ids]\n\n metrics['el_intermediate'] = {\n 'loss':\n el_im_loss,\n 'acc':\n el_im_acc,\n 'cos_sim':\n jnp.dot(intermediate_entity_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n el_im_denom,\n }\n metrics['el_intermediate_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, mention_is_masked),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n batch['mention_target_is_masked']),\n }\n metrics['el_intermediate_non_masked'] = {\n 'acc':\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\n 'denominator':\n jnp.dot(batch['mention_target_weights'],\n (1 - batch['mention_target_is_masked'])),\n }\n\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\n intermediate_target_mention_encodings,\n loss_helpers['target_mention_encodings'])\n metrics['im_final_mention_encodings'] = {\n 'cos_sim':\n jnp.dot(im_final_mention_encodings_cos_sim,\n batch['mention_target_weights']),\n 'denominator':\n batch['mention_target_weights'].sum(),\n }\n\n (el_final_loss, el_final_metrics,\n (el_final_acc_per_mention,\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\n loss_helpers['target_mention_encodings'],\n loss_helpers['entity_embeddings'], mention_target_ids,\n batch['mention_target_weights'], el_score_mode)\n el_final_denom = el_final_metrics['denominator']\n metrics['el_final'] = el_final_metrics\n metrics['el_final_masked'] = {\n 'acc':\n jnp.dot(el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\n }\n metrics['el_final_non_masked'] = {\n 'acc':\n jnp.dot(\n el_final_acc_per_mention,\n el_final_weight_per_mention * mention_target_is_not_masked),\n 'denominator':\n jnp.dot(el_final_weight_per_mention,\n mention_target_is_not_masked),\n }\n\n loss = mlm_weight * mlm_loss / mlm_denom\n loss += el_im_weight * el_im_loss / el_im_denom\n loss += el_final_weight * el_final_loss / el_final_denom\n\n if mtb_im_weight > 0:\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\n intermediate_target_mention_encodings,\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\n metrics.update(mtb_im_metrics)\n\n if mtb_final_weight > 0:\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\n loss_helpers['target_mention_encodings'],\n batch['mention_target_batch_positions'], mention_target_ids,\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\n metrics.update(mtb_final_metrics)\n\n metrics['agg'] = {\n 'loss': loss,\n 'denominator': 1.0,\n }\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray\n\n return loss_fn","def evaluate(self, dataset, metric='auto', verbose=True, batch_size=64):\n if(batch_size < 1):\n raise ValueError(\"'batch_size' must be greater than or equal to 1\")\n\n extracted_features = self._extract_features(dataset, verbose=verbose, batch_size=batch_size)\n extracted_features[self.target] = dataset[self.target]\n return self.classifier.evaluate(extracted_features, metric = metric)","def _get_eval_metric(self):\n raise NotImplementedError","def evaluate(self, model_idx,\n max_eval_batches=None,\n write_results=False,\n write_to_summary=True):\n \n # write_summary needs global_step\n self._step_collections[\"GlobalStep\"] = (\n self._sess.run(self._global_step_tensor))\n\n # evaluate the model\n model_name = \"%s-%d\" % (self._names[model_idx], model_idx)\n counts, scores = self._evaluate(\n data=self._data[model_idx],\n logits=self._logits_collections[model_idx],\n predictions=self._predictions_collections[model_idx],\n evaluation_fn=self._evaluation_fns[model_idx],\n max_eval_batches=max_eval_batches,\n calculate_scores=True,\n write_results=write_results)\n\n # write summary\n if write_to_summary:\n self.write_summary(\n \"TASK-%s/ValScores\" % model_name, scores)\n\n return {\"MAIN\": scores}","def make_eval_step(self):\n def eval_step(model, example):\n with flax.deprecated.nn.stateful() as state:\n logits = model(example, train=False)\n if self.info.supervised_keys[-1] == 'error_type':\n targets = example['error_type'][:, None]\n else:\n targets = example['target_output']\n state = {k: v['tag'] for k, v in state.as_dict().items()}\n return self.compute_metrics(logits, targets, None), logits, state\n\n return eval_step","def _evaluate(self, training_state, val_iter, val_metric):\n val_iter.reset()\n val_metric.reset()\n\n for nbatch, eval_batch in enumerate(val_iter):\n self.module.forward(eval_batch, is_train=False)\n self.module.update_metric(val_metric, eval_batch.label)\n\n for name, val in val_metric.get_name_value():\n logger.info('Checkpoint [%d]\\tValidation-%s=%f', training_state.checkpoint, name, val)\n\n return self.training_monitor.eval_end_callback(training_state.checkpoint, val_metric)","def metrics_collector(func):\n @functools.wraps(func)\n def wrapper_timer(*args, **kwargs):\n start_time = perf_counter()\n value = func(*args, **kwargs)\n end_time = perf_counter()\n run_time = (end_time - start_time) * 1000 # convert to milliseconds\n run_time = int(run_time) # we'll lose some accuracy here, but I think it's negligible\n if 'metrics' not in g:\n g.metrics = []\n g.metrics.append({\n func.__name__: run_time\n })\n return value\n return wrapper_timer","def get_min_or_max_values(metrics: dict, global_metrics: dict, fn2) -> dict:\n for ds_name in metrics:\n if ds_name not in global_metrics:\n global_metrics[ds_name] = {}\n\n feature_metrics = metrics[ds_name]\n for feature_name in feature_metrics:\n if feature_name not in global_metrics[ds_name]:\n global_metrics[ds_name][feature_name] = feature_metrics[feature_name]\n else:\n global_metrics[ds_name][feature_name] = fn2(\n global_metrics[ds_name][feature_name], feature_metrics[feature_name]\n )\n\n results = {}\n for ds_name in global_metrics:\n for feature_name in global_metrics[ds_name]:\n if feature_name not in results:\n results[feature_name] = global_metrics[ds_name][feature_name]\n else:\n results[feature_name] = fn2(results[feature_name], global_metrics[ds_name][feature_name])\n\n for ds_name in global_metrics:\n for feature_name in global_metrics[ds_name]:\n global_metrics[ds_name][feature_name] = results[feature_name]\n\n return global_metrics","def evaluate():\n\t\t\t\tif not hasattr(evaluate, 'value'):\n\t\t\t\t\tevaluate.value = func()\n\t\t\t\treturn evaluate.value","def function(self, scores, multilabel):\n\n # Output functions\n # pylint: disable=C3001\n identity = lambda x: x\n sigmoid = lambda x: 1.0 / (1.0 + np.exp(-x))\n softmax = lambda x: np.exp(x) / np.sum(np.exp(x))\n function = identity if multilabel is None else sigmoid if multilabel else softmax\n\n # Apply output function\n return function(np.array(scores))","def test(self, test_fn, eval_metrics):\n # Load gold and predict\n X, Y = self.load_dataset(test_fn)\n y = self.model.predict(X)\n\n # Get most probable predictions and flatten\n Y = RNN_model.consolidate_labels(self.transform_output_probs(Y).flatten())\n y = RNN_model.consolidate_labels(self.transform_output_probs(y).flatten())\n\n # Run evaluation metrics and report\n # TODO: is it possible to compare without the padding?\n ret = []\n for (metric_name, metric_func) in eval_metrics:\n ret.append((metric_name, metric_func(Y, y)))\n logging.debug(\"calculating {}\".format(ret[-1]))\n\n for (metric_name, metric_val) in ret:\n logging.info(\"{}: {:.4f}\".format(metric_name,\n metric_val))\n return Y, y, ret","def eval_step(total_loss):\n inputs = dequeue_fn()\n features, labels = inputs.features_and_labels()\n\n tpu_estimator_spec = self._call_model_fn(features, labels)\n if not isinstance(tpu_estimator_spec, TPUEstimatorSpec):\n raise RuntimeError(\n 'estimator_spec used by TPU evaluation must have type'\n '`TPUEstimatorSpec`. Got {}'.format(type(tpu_estimator_spec)))\n\n loss = tpu_estimator_spec.loss\n captured_scaffold_fn.capture(tpu_estimator_spec.scaffold_fn)\n to_record = {}\n to_record['eval_metrics'] = tpu_estimator_spec.eval_metrics\n if tpu_estimator_spec.host_call is not None:\n # We assume that evaluate won't update global step, so we don't wrap\n # this host_call.\n to_record['host_call'] = tpu_estimator_spec.host_call\n host_calls.record(to_record)\n\n with ops.control_dependencies(host_calls.create_enqueue_op()):\n return math_ops.add(total_loss, loss)","def evaluate(problem, batch_size, inference_fn, optimizer, model_dir=None):\n logging.info(\n 'Evaluating.\\nOperative config:\\n%s' % gin.operative_config_str())\n if model_dir is None:\n model_dir = default_model_dir()\n if model_dir is not None:\n model_dir = os.path.expanduser(model_dir)\n if not os.path.isdir(model_dir):\n raise RuntimeError('model_dir does not exist: %s' % model_dir)\n\n val_ds = problem.get_dataset('validation', batch_size)\n inputs = tf.nest.map_structure(\n lambda shape, dtype: tf.keras.layers.Input(\n shape=shape[1:], dtype=dtype),\n val_ds.output_shapes[0], val_ds.output_types[0])\n outputs = inference_fn(inputs, problem.output_spec())\n model = _model(inputs, outputs)\n model.compile(\n optimizer=optimizer,\n loss=problem.loss,\n metrics=problem.metrics)\n\n cb.restore_model(model, model_dir)\n validation_steps = batch_steps(\n problem.examples_per_epoch('validation'), batch_size)\n \n val_ds = val_ds.map(lambda x, y: (tuple(tf.nest.flatten(x)), y))\n\n logging.info('Running evaluation for %d steps' % validation_steps)\n return model.evaluate(val_ds, steps=validation_steps)","def evaluate_wrapper(func):\n @wraps(func)\n def wrapper(self, blackboard):\n if self.state == EvaluationState.ready:\n self.on_enter()\n\n state = func(self, blackboard)\n self.state = state\n\n if state != EvaluationState.running:\n self.on_exit()\n\n return state\n\n return wrapper","def _evaluate_async(\n self,\n duration_fn: Optional[Callable[[int], int]] = None,\n ) -> dict:\n # How many episodes/timesteps do we need to run?\n # In \"auto\" mode (only for parallel eval + training): Run as long\n # as training lasts.\n unit = self.config.evaluation_duration_unit\n eval_cfg = self.evaluation_config\n rollout = eval_cfg.rollout_fragment_length\n num_envs = eval_cfg.num_envs_per_worker\n auto = self.config.evaluation_duration == \"auto\"\n duration = (\n self.config.evaluation_duration\n if not auto\n else (self.config.evaluation_num_workers or 1)\n * (1 if unit == \"episodes\" else rollout)\n )\n\n # Call the `_before_evaluate` hook.\n self._before_evaluate()\n\n # TODO(Jun): Implement solution via connectors.\n self._sync_filters_if_needed(\n central_worker=self.workers.local_worker(),\n workers=self.evaluation_workers,\n config=eval_cfg,\n )\n\n if self.config.custom_evaluation_function:\n raise ValueError(\n \"`config.custom_evaluation_function` not supported in combination \"\n \"with `enable_async_evaluation=True` config setting!\"\n )\n if self.evaluation_workers is None and (\n self.workers.local_worker().input_reader is None\n or self.config.evaluation_num_workers == 0\n ):\n raise ValueError(\n \"Evaluation w/o eval workers (calling Algorithm.evaluate() w/o \"\n \"evaluation specifically set up) OR evaluation without input reader \"\n \"OR evaluation with only a local evaluation worker \"\n \"(`evaluation_num_workers=0`) not supported in combination \"\n \"with `enable_async_evaluation=True` config setting!\"\n )\n\n agent_steps_this_iter = 0\n env_steps_this_iter = 0\n\n logger.info(f\"Evaluating current state of {self} for {duration} {unit}.\")\n\n all_batches = []\n\n # Default done-function returns True, whenever num episodes\n # have been completed.\n if duration_fn is None:\n\n def duration_fn(num_units_done):\n return duration - num_units_done\n\n # Put weights only once into object store and use same object\n # ref to synch to all workers.\n self._evaluation_weights_seq_number += 1\n weights_ref = ray.put(self.workers.local_worker().get_weights())\n weights_seq_no = self._evaluation_weights_seq_number\n\n def remote_fn(worker):\n # Pass in seq-no so that eval workers may ignore this call if no update has\n # happened since the last call to `remote_fn` (sample).\n worker.set_weights(\n weights=ray.get(weights_ref), weights_seq_no=weights_seq_no\n )\n batch = worker.sample()\n metrics = worker.get_metrics()\n return batch, metrics, weights_seq_no\n\n rollout_metrics = []\n\n # How many episodes have we run (across all eval workers)?\n num_units_done = 0\n _round = 0\n\n while self.evaluation_workers.num_healthy_remote_workers() > 0:\n units_left_to_do = duration_fn(num_units_done)\n if units_left_to_do <= 0:\n break\n\n _round += 1\n # Get ready evaluation results and metrics asynchronously.\n self.evaluation_workers.foreach_worker_async(\n func=remote_fn,\n healthy_only=True,\n )\n eval_results = self.evaluation_workers.fetch_ready_async_reqs()\n\n batches = []\n i = 0\n for _, result in eval_results:\n batch, metrics, seq_no = result\n # Ignore results, if the weights seq-number does not match (is\n # from a previous evaluation step) OR if we have already reached\n # the configured duration (e.g. number of episodes to evaluate\n # for).\n if seq_no == self._evaluation_weights_seq_number and (\n i * (1 if unit == \"episodes\" else rollout * num_envs)\n < units_left_to_do\n ):\n batches.append(batch)\n rollout_metrics.extend(metrics)\n i += 1\n\n _agent_steps = sum(b.agent_steps() for b in batches)\n _env_steps = sum(b.env_steps() for b in batches)\n\n # 1 episode per returned batch.\n if unit == \"episodes\":\n num_units_done += len(batches)\n # Make sure all batches are exactly one episode.\n for ma_batch in batches:\n ma_batch = ma_batch.as_multi_agent()\n for batch in ma_batch.policy_batches.values():\n assert batch.is_terminated_or_truncated()\n # n timesteps per returned batch.\n else:\n num_units_done += (\n _agent_steps\n if self.config.count_steps_by == \"agent_steps\"\n else _env_steps\n )\n\n if self.reward_estimators:\n all_batches.extend(batches)\n\n agent_steps_this_iter += _agent_steps\n env_steps_this_iter += _env_steps\n\n logger.info(\n f\"Ran round {_round} of parallel evaluation \"\n f\"({num_units_done}/{duration if not auto else '?'} \"\n f\"{unit} done)\"\n )\n\n sampler_results = summarize_episodes(\n rollout_metrics,\n keep_custom_metrics=eval_cfg[\"keep_per_episode_custom_metrics\"],\n )\n\n # TODO: Don't dump sampler results into top-level.\n metrics = dict({\"sampler_results\": sampler_results}, **sampler_results)\n\n metrics[NUM_AGENT_STEPS_SAMPLED_THIS_ITER] = agent_steps_this_iter\n metrics[NUM_ENV_STEPS_SAMPLED_THIS_ITER] = env_steps_this_iter\n # TODO: Remove this key at some point. Here for backward compatibility.\n metrics[\"timesteps_this_iter\"] = env_steps_this_iter\n\n if self.reward_estimators:\n # Compute off-policy estimates\n metrics[\"off_policy_estimator\"] = {}\n total_batch = concat_samples(all_batches)\n for name, estimator in self.reward_estimators.items():\n estimates = estimator.estimate(total_batch)\n metrics[\"off_policy_estimator\"][name] = estimates\n\n # Evaluation does not run for every step.\n # Save evaluation metrics on Algorithm, so it can be attached to\n # subsequent step results as latest evaluation result.\n self.evaluation_metrics = {\"evaluation\": metrics}\n\n # Trigger `on_evaluate_end` callback.\n self.callbacks.on_evaluate_end(\n algorithm=self, evaluation_metrics=self.evaluation_metrics\n )\n\n # Return evaluation results.\n return self.evaluation_metrics","def _get_val_metrics(\n self,\n ) -> Tuple[_Metrics, torch.Tensor, torch.Tensor, torch.Tensor]:\n # Turn off batch-norm updates\n self.model.eval()\n\n with torch.no_grad():\n metrics = _Metrics()\n\n for val_img, val_gt in tqdm(\n self.val_loader, desc=\"Validating\", leave=False\n ):\n val_img = val_img.to(self.device)\n val_gt = val_gt.to(self.device)\n\n with autocast(enabled=self.config.mixed_precision):\n val_pred = self.model(val_img)[0]\n metrics.class_loss += self.class_loss_fn(val_pred, val_gt)\n\n metrics.accuracy += self._get_acc(val_pred, val_gt)\n metrics.f1_score += self._get_f1(val_pred, val_gt)\n\n metrics.class_loss /= len(self.val_loader)\n metrics.accuracy /= len(self.val_loader)\n metrics.f1_score /= len(self.val_loader)\n\n return metrics, val_img, val_gt, torch.sigmoid(val_pred)","def _evaluate(self, indices, split, session, summary_writer):\n data_iterator_val = batch_iterator(\n indices,\n batch_size=self.batch_size,\n shuffle=False,\n allow_smaller_batch=True,\n repeat=False)\n feed_dict_val = self._construct_feed_dict(data_iterator_val, split)\n cummulative_acc = 0.0\n num_samples = 0\n while feed_dict_val is not None:\n val_acc, batch_size_actual = session.run(\n (self.accuracy, self.batch_size_actual), feed_dict=feed_dict_val)\n cummulative_acc += val_acc * batch_size_actual\n num_samples += batch_size_actual\n feed_dict_val = self._construct_feed_dict(data_iterator_val, split)\n if num_samples > 0:\n cummulative_acc /= num_samples\n\n if self.enable_summaries:\n summary = tf.Summary()\n summary.value.add(\n tag='ClassificationModel/' + split + '_acc',\n simple_value=cummulative_acc)\n iter_cls_total = session.run(self.iter_cls_total)\n summary_writer.add_summary(summary, iter_cls_total)\n summary_writer.flush()\n\n return cummulative_acc","def get_validation_fn(\n test_dataset: tf.data.Dataset,\n model_fn: Callable[[], tf.keras.models.Model],\n loss_fn: Callable[[], tf.keras.losses.Loss],\n metrics_fn: Callable[[], tf.keras.metrics.Metric],\n) -> Callable[[], tf.data.Dataset]:\n\n def compiled_model() -> tf.keras.Model:\n val_model = model_fn()\n val_model.compile(\n loss=loss_fn(), optimizer=tf.keras.optimizers.Adam(), metrics=metrics_fn()\n )\n return val_model\n\n test_dataset = _convert_fn(test_dataset)\n\n def validation_fn(\n trained_model: tff.learning.Model,\n ) -> Callable[[], tf.data.Dataset]:\n val_model = compiled_model()\n trained_model_weights = tff.learning.ModelWeights(\n trainable=list(trained_model.trainable),\n non_trainable=list(trained_model.non_trainable),\n )\n\n trained_model_weights.assign_weights_to(val_model)\n metrics = val_model.evaluate(test_dataset, verbose=0)\n return dict(\n zip(val_model.metrics_names, val_model.evaluate(test_dataset, verbose=0))\n )\n\n return validation_fn","def evaluate(model, loss, val_iterator):\n\n # Initializing parameters\n loss_value = 0.0\n accuracy = 0.0\n total_samples = 0\n\n with torch.no_grad():\n\n # Iterating over validation dataloader\n for data, labels in val_iterator:\n\n # Resetting variables for calculating current batch accuracy\n correct = 0\n total = 0\n\n # Map data to GPU if available\n if use_cuda:\n data = data.cuda()\n labels = labels.cuda(non_blocking=True)\n\n n_batch_samples = labels.size()[0]\n logits = model(data)\n\n # Compute batch loss\n batch_loss = loss(logits, labels)\n\n # Compute batch accuracy\n _, predicted = logits.max(1)\n total += labels.size(0)\n correct += predicted.eq(labels).sum().item()\n batch_accuracy = 100. * correct / total\n\n # Summing up batch losses and accuracies over each step\n loss_value += batch_loss.float() * n_batch_samples\n accuracy += batch_accuracy * n_batch_samples\n total_samples += n_batch_samples\n\n return loss_value / total_samples, accuracy / total_samples","def _combine_eval(self, all_model_fn_ops):\n predictions = {}\n metrics = {}\n losses = []\n for head, m in zip(self._heads, all_model_fn_ops):\n losses.append(m.loss)\n head_name = head.head_name\n for k, v in m.predictions.items():\n predictions[(head_name, k)] = v\n for k, v in m.eval_metric_ops.items():\n # metrics[\"%s/%s\" % (k, head_name)] = v\n metrics[k] = v\n loss = self._loss_combiner(losses)\n\n return model_fn.ModelFnOps(\n mode=model_fn.ModeKeys.EVAL,\n predictions=predictions,\n loss=loss,\n eval_metric_ops=metrics)","def evaluate(\n self,\n results,\n metric=\"mAP\",\n logger=None,\n proposal_nums=(100, 300, 1000),\n iou_thr=0.75,\n scale_ranges=None,\n ):\n\n if not isinstance(metric, str):\n assert len(metric) == 1\n metric = metric[0]\n allowed_metrics = [\"mAP\", \"recall\"]\n if metric not in allowed_metrics:\n raise KeyError(f\"metric {metric} is not supported\")\n annotations = [self.get_ann_info(i) for i in range(len(self))]\n eval_results = {}\n\n if metric == \"mAP\":\n assert isinstance(iou_thr, float)\n ds_name = list(self.class_names)\n mean_ap, _ = eval_map(\n results,\n annotations,\n scale_ranges=None,\n iou_thr=iou_thr,\n dataset=ds_name,\n logger=logger,\n )\n eval_results[\"mAP\"] = mean_ap\n\n elif metric == \"recall\":\n gt_bboxes = [ann[\"bboxes\"] for ann in annotations]\n if isinstance(iou_thr, float):\n iou_thr = [iou_thr]\n recalls = eval_recalls(\n gt_bboxes, results, proposal_nums, iou_thr, logger=logger\n )\n for i, num in enumerate(proposal_nums):\n for j, iou in enumerate(iou_thr):\n eval_results[f\"recall@{num}@{iou}\"] = recalls[i, j]\n if recalls.shape[1] > 1:\n ar = recalls.mean(axis=1)\n for i, num in enumerate(proposal_nums):\n eval_results[f\"AR@{num}\"] = ar[i]\n\n return eval_results","def joblib_batch_evaluator(\n func,\n arguments,\n *,\n n_cores=N_CORES,\n error_handling=\"continue\",\n unpack_symbol=None,\n):\n _check_inputs(func, arguments, n_cores, error_handling, unpack_symbol)\n n_cores = int(n_cores) if int(n_cores) >= 2 else 1\n\n reraise = error_handling == \"raise\"\n\n @unpack(symbol=unpack_symbol)\n @catch(default=\"__traceback__\", reraise=reraise)\n def internal_func(*args, **kwargs):\n return func(*args, **kwargs)\n\n if n_cores == 1:\n res = [internal_func(arg) for arg in arguments]\n else:\n res = Parallel(n_jobs=n_cores)(delayed(internal_func)(arg) for arg in arguments)\n\n return res","def evaluate(self, prediction_fn):\n pass","def evaluate(self, X, y, metric='accuracy', get_loss=True, **kwargs):\n if metric is None:\n raise ValueError(\"Please specify a metric\") \n scorer = get_scorer(metric)\n \n scores = {}\n for name, y_pred in self.predict(X): \n score = scorer(y, y_pred) \n scores[name] = {'score': np.round(score, decimals=4), 'loss': 'N/A'} \n \n if get_loss:\n log_loss = get_scorer('log_loss') \n for name, proba in self.predict_proba(X): \n try:\n loss = log_loss(y, proba)\n scores[name]['loss'] = np.round(loss, decimals=4)\n except:\n scores[name]['loss'] = np.nan\n warnings.warn(\"Could not compute loss for {}\"\n .format(name), RuntimeWarning) \n if self.verbose>0:\n for name, score in scores.items():\n print(\"{0:18} {1}\".format(name+\":\", \", \".join(\n [\"{}={}\".format(k,v) for k,v in score.items()])),\n end=\"\\n{}\\n\".format(\"-\" * 45))\n return scores","def evaluate(self, eval_data, eval_labels, eval_input_fn=\"default\"):\n # Validations:\n # If it is of type str, make sure is a valid\n if isinstance(eval_input_fn, str):\n # We use a list in case we want to extend in the future.\n if eval_input_fn in [\"default\"]:\n if eval_input_fn == \"default\":\n # pylint: disable=no-member\n eval_input_fn = tf.estimator.inputs.numpy_input_fn(\n x={\"x\": eval_data},\n y=eval_labels,\n num_epochs=1,\n shuffle=False\n )\n\n eval_res = self.classifier.evaluate(input_fn=eval_input_fn)\n return eval_res","def make_acquisition_function(handle_multioutput=\"mean\"):\n\n def decorator(fn):\n if handle_multioutput == \"mean\": # define fn where scores are avgd\n\n @functools.wraps(fn)\n def wrapped_fn(probabilities, shuffle_prop=0.1):\n if _is_multioutput(probabilities):\n scores = np.stack(\n tuple(fn(prob) for prob in probabilities), axis=0\n ).mean(axis=0)\n else:\n scores = fn(probabilities)\n return _get_indices(scores, shuffle_prop)\n\n else: # raise error if list is passed\n\n @functools.wraps(fn)\n def wrapped_fn(probabilities, shuffle_prop=0.1):\n if _is_multioutput(probabilities):\n raise ValueError(\n \"The input probabilities is a list of arrays, \"\n + \"indicating multi-label output. \"\n + \"The {} function \".format(fn.__name__)\n + \"is not defined for these outputs. Use \"\n + \"the acquisition functions margin or certainty \"\n + \"instead.\"\n )\n else:\n scores = fn(probabilities)\n return _get_indices(scores, shuffle_prop)\n\n return wrapped_fn\n\n return decorator","def adapt_tf_streaming_metric_for_keras(tf_metric, name,\n preprocss_fn=None, postprocess_fn=None,\n **kwargs):\n\n # Inspired from snipped by Ruzhitskiy Bogdan\n # (https://github.com/keras-team/keras/issues/6050#issuecomment-329996505)\n def metric(y_true, y_pred):\n \"\"\" Wrap a TF metric, instantiating hidden variables + updating hidden states\"\"\"\n\n # First we define the metric operation:\n value, update_op = tf_metric(y_true, y_pred, **kwargs)\n\n # It is possible that the metric is relying on some local variables,\n # that we should then initialize them:\n initialize_variables()\n\n # Finally, we force the update of the metric values:\n with tf.control_dependencies([update_op]):\n value = tf.identity(value)\n return value\n\n def metric_with_pre_and_post_processing(y_true, y_pred):\n \"\"\" Wrapper to pre/post-process the data\"\"\"\n\n if preprocss_fn is not None:\n y_true, y_pred = preprocss_fn(y_true, y_pred)\n\n value = metric(y_true, y_pred)\n\n if postprocess_fn is not None:\n value = postprocess_fn(y_true, y_pred, value)\n\n return value\n\n metric_with_pre_and_post_processing.__name__ = name\n\n return metric_with_pre_and_post_processing","def process_function(engine: Engine, batch: Tuple[torch.Tensor, torch.Tensor, List[int]]) -> \\\n Tuple[float, torch.Tensor, torch.Tensor]:\n model.train()\n optimizer.zero_grad()\n x, y, lengths = batch\n x, y = x.to(model.device), y.to(model.device)\n y_pred: torch.Tensor = model(x, lengths)\n loss: torch.Tensor = loss_fn(y_pred, y)\n loss.backward()\n optimizer.step()\n return loss.item(), torch.max(y_pred, dim=1)[1], y","def test(self,test_fn, eval_metrics):\n # Load gold and predict\n X, Y = self.load_dataset(test_fn)\n y = self.model.predict(X)\n\n # Get most probable predictions and flatten\n Y = RNNOIE_model.consolidate_labels(self.transform_output_probs(Y).flatten())\n y = RNNOIE_model.consolidate_labels(self.transform_output_probs(y).flatten())\n\n # Run evaluation metrics and report\n # TODO: is it possible to compare without the padding?\n ret = []\n for (metric_name, metric_func) in eval_metrics:\n ret.append((metric_name, metric_func(Y, y)))\n # logging.debug(\"calculating {}\".format(ret[-1]))\n\n for (metric_name, metric_val) in ret:\n logging.info(\"{}: {:.4f}\".format(metric_name,\n metric_val))\n return Y, y, ret","def _get_batch_fn(dataset):\n def get_batch(idx):\n x_bat = dataset['input'][idx]\n y_bat = dataset['label'][idx]\n x_bat, y_bat = preprocess(x_bat, y_bat)\n\n return x_bat, y_bat\n\n return get_batch","def build_multi_task_metric_func(dataset_split_name, add_summary=True):\n\n def multi_task_metric_func(labels, logits):\n \"\"\"Generates metrics operations for multi-task evaluation.\n\n Args:\n labels: A dictionary of task name to label tensors of shape [num_examples,\n 1].\n logits: A dictionary of task name to logit tensors of shape [num_examples,\n num_classes].\n\n Raises:\n ValueError if labels and logits do not have the same keys.\n\n Returns:\n A dictionary of key to metrics operation.\n \"\"\"\n if labels.keys() != logits.keys():\n raise ValueError('Task names are different for labels and logits.')\n metric_ops = {}\n for task_name, label in labels.items():\n accuracy_metric_name = '{}/Eval/Accuracy/{}'.format(\n task_name, dataset_split_name)\n metric_ops[accuracy_metric_name] = tf.metrics.accuracy(\n label,\n tf.argmax(logits[task_name], 1),\n weights=build_weight_for_label(label))\n\n if add_summary:\n for name, value in metric_ops.items():\n tf.summary.scalar(name, value)\n return metric_ops\n\n return multi_task_metric_func","def make_metric_fn(*names):\n\n def metric_fn(*args):\n return {name: tf.metrics.mean(vec) for name, vec in zip(names, args)}\n\n return metric_fn","def _create_default_metrics_eval_func(self, grid_points):\n eval_func = set([self._get_default_eval_func(point.metrics) for point in grid_points])\n if len(eval_func) != 1:\n raise RuntimeError(\"Error in retrieving evaluation function\")\n return list(eval_func)[0]","def evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics","def _get_step_fn(self) -> Callable:\n\n def loss_fn(\n params: frozen_dict.FrozenDict,\n apply_fn: Callable,\n batch: Dict[str, jnp.ndarray],\n ) -> Tuple[float, Dict[str, float]]:\n \"\"\"Loss function.\"\"\"\n # map samples with the fitted map\n mapped_samples = apply_fn({\"params\": params}, batch[\"source\"])\n\n # compute the loss\n val_fitting_loss = self.fitting_loss(batch[\"target\"], mapped_samples)\n val_regularizer = self.regularizer(batch[\"source\"], mapped_samples)\n val_tot_loss = (\n val_fitting_loss + self.regularizer_strength * val_regularizer\n )\n\n # store training logs\n loss_logs = {\n \"total_loss\": val_tot_loss,\n \"fitting_loss\": val_fitting_loss,\n \"regularizer\": val_regularizer\n }\n\n return val_tot_loss, loss_logs\n\n @functools.partial(jax.jit, static_argnums=3)\n def step_fn(\n state_neural_net: train_state.TrainState,\n train_batch: Dict[str, jnp.ndarray],\n valid_batch: Optional[Dict[str, jnp.ndarray]] = None,\n is_logging_step: bool = False,\n ) -> Tuple[train_state.TrainState, Dict[str, float]]:\n \"\"\"Step function.\"\"\"\n # compute loss and gradients\n grad_fn = jax.value_and_grad(loss_fn, argnums=0, has_aux=True)\n (_, current_train_logs), grads = grad_fn(\n state_neural_net.params, state_neural_net.apply_fn, train_batch\n )\n\n # logging step\n current_logs = {\"train\": current_train_logs, \"eval\": {}}\n if is_logging_step:\n _, current_eval_logs = loss_fn(\n params=state_neural_net.params,\n apply_fn=state_neural_net.apply_fn,\n batch=valid_batch\n )\n current_logs[\"eval\"] = current_eval_logs\n\n # update state\n return state_neural_net.apply_gradients(grads=grads), current_logs\n\n return step_fn","def eval_function(engine: Engine, batch: Tuple[torch.Tensor, torch.Tensor, List[int]]) -> \\\n Tuple[torch.Tensor, torch.Tensor]:\n model.eval()\n with torch.no_grad():\n x, y, lengths = batch\n x, y = x.to(model.device), y.to(model.device)\n y_pred: torch.Tensor = model(x, lengths)\n return y_pred, y","def evaluate(self):\n results = dict()\n for metric in self.metrics:\n print('Evaluating clustering with metric %s' % metric)\n if metric in LABEL_METRICS.keys():\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\n self.results = results\n return results","def evaluate(self, eval_data, eval_labels, eval_input_fn):\n raise NotImplementedError(\"Method must be implemented by subclass\")","def next_fn(global_state, value, weight=None):\n # Weighted aggregation is not supported.\n # TODO(b/140236959): Add an assertion that weight is None here, so the\n # contract of this method is better established. Will likely cause some\n # downstream breaks.\n del weight\n\n #######################################\n # Define local tf_computations\n\n # TODO(b/129567727): Make most of these tf_computations polymorphic\n # so type manipulation isn't needed.\n\n global_state_type = initialize_fn.type_signature.result\n\n @computations.tf_computation(global_state_type)\n def derive_sample_params(global_state):\n return query.derive_sample_params(global_state)\n\n @computations.tf_computation(derive_sample_params.type_signature.result,\n value.type_signature.member)\n def preprocess_record(params, record):\n # TODO(b/123092620): Once TFF passes the expected container type (instead\n # of AnonymousTuple), we shouldn't need this.\n record = from_tff_result_fn(record)\n\n return query.preprocess_record(params, record)\n\n # TODO(b/123092620): We should have the expected container type here.\n value_type = value_type_fn(value)\n\n tensor_specs = type_conversions.type_to_tf_tensor_specs(value_type)\n\n @computations.tf_computation\n def zero():\n return query.initial_sample_state(tensor_specs)\n\n sample_state_type = zero.type_signature.result\n\n @computations.tf_computation(sample_state_type,\n preprocess_record.type_signature.result)\n def accumulate(sample_state, preprocessed_record):\n return query.accumulate_preprocessed_record(sample_state,\n preprocessed_record)\n\n @computations.tf_computation(sample_state_type, sample_state_type)\n def merge(sample_state_1, sample_state_2):\n return query.merge_sample_states(sample_state_1, sample_state_2)\n\n @computations.tf_computation(merge.type_signature.result)\n def report(sample_state):\n return sample_state\n\n @computations.tf_computation(sample_state_type, global_state_type)\n def post_process(sample_state, global_state):\n result, new_global_state = query.get_noised_result(\n sample_state, global_state)\n return new_global_state, result\n\n #######################################\n # Orchestration logic\n\n sample_params = intrinsics.federated_map(derive_sample_params, global_state)\n client_sample_params = intrinsics.federated_broadcast(sample_params)\n preprocessed_record = intrinsics.federated_map(\n preprocess_record, (client_sample_params, value))\n agg_result = intrinsics.federated_aggregate(preprocessed_record, zero(),\n accumulate, merge, report)\n\n return intrinsics.federated_map(post_process, (agg_result, global_state))","def evaluate_batch(self, batch: TorchData) -> Dict[str, Any]:\n batch = cast(Tuple[torch.Tensor, torch.Tensor], batch)\n data, labels = batch\n\n output = self.model(data)\n accuracy = accuracy_rate(output, labels)\n return {\"validation_accuracy\": accuracy, \"validation_error\": 1.0 - accuracy}","def create_multi_node_evaluator(actual_evaluator, communicator):\n\n actual_evaluator._mn_original_evaluate = actual_evaluator.evaluate\n actual_evaluator._mn_communicator = communicator\n\n def new_evaluate(self):\n local_mean_dict = self._mn_original_evaluate()\n global_mean_dict = {\n name:\n self._mn_communicator.allreduce_obj(\n value) / self._mn_communicator.size\n for name, value in sorted(local_mean_dict.items())\n }\n return global_mean_dict\n\n actual_evaluator.evaluate = six.create_bound_method(\n new_evaluate, actual_evaluator)\n return actual_evaluator","def get_eval_fn(\n testset: torchvision.datasets.CIFAR10,\n) -> Callable[[fl.common.Weights], Optional[Tuple[float, float]]]:\n\n def evaluate(weights: fl.common.Weights) -> Optional[Tuple[float, float]]:\n \"\"\"Use the entire CIFAR-10 test set for evaluation.\"\"\"\n model = models.load_model(glb.MODEL)\n model.set_weights(weights)\n model.to(DEVICE)\n testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)\n # using pytorch for central evaluation, can be tensorflow as well\n return modules.pt_test(model, testloader, device=DEVICE) \n\n return evaluate","def _eval_graph(self, context, sampled_rate=None, cached_id=0):\n results, names = context.run_eval_graph(sampled_rate, cached_id)\n metric = np.mean(results[list(names).index(self.metric_name)])\n return metric","def _self_influence_by_batches_helper(\n self_influence_batch_fn: Callable,\n instance_name: str,\n inputs_dataset: Union[Tuple[Any, ...], DataLoader],\n show_progress: bool = False,\n) -> Tensor:\n # If `inputs_dataset` is not a `DataLoader`, turn it into one.\n inputs_dataset = _format_inputs_dataset(inputs_dataset)\n\n # If `show_progress` is true, create a progress bar that keeps track of how\n # many batches have been processed\n if show_progress:\n # First, try to determine length of progress bar if possible, with a\n # default of `None`\n inputs_dataset_len = None\n try:\n inputs_dataset_len = len(inputs_dataset)\n except TypeError:\n warnings.warn(\n \"Unable to determine the number of batches in `inputs_dataset`. \"\n \"Therefore, if showing the progress of the computation of self \"\n \"influence scores, only the number of batches processed can be \"\n \"displayed, and not the percentage completion of the computation, \"\n \"nor any time estimates.\"\n )\n # then create the progress bar\n inputs_dataset = progress(\n inputs_dataset,\n desc=f\"Using {instance_name} to compute self influence. Processing batch\",\n total=inputs_dataset_len,\n )\n\n # To compute self influence scores for each batch, we use\n # `_self_influence_by_checkpoints`, which can accept a tuple representing a\n # single batch as the `inputs_dataset` argument (as well as a DataLoader).\n # Because we are already displaying progress in terms of number of batches\n # processed in this method, we will not show progress for the call to\n # `_self_influence_by_checkpoints`.\n return torch.cat(\n [\n self_influence_batch_fn(batch, show_progress=False)\n for batch in inputs_dataset\n ]\n )","def __evaluate_metric(dataset, y_act, y_pred):\n if dataset.metric == 'specific':\n if dataset.best_is_min:\n return return_specific_metrics(y_act, y_pred)\n else:\n return -return_specific_metrics(y_act, y_pred)\n else:\n return evaluate_metric(y_act, y_pred, dataset.metric, dataset.y_n_classes)","def finetune_eval_fn(\n # The pytype below must be Any, because the code below uses internal\n # methods only present on tff.learning.from_keras_model-derived TFF\n # models.\n model: Any,\n train_data: tf.data.Dataset,\n test_data: tf.data.Dataset,\n ) -> _MetricsType:\n\n @tf.function\n def train_one_batch(num_examples_sum, batch):\n \"\"\"Run gradient descent on a batch.\"\"\"\n with tf.GradientTape() as tape:\n output = model.forward_pass(batch)\n if finetune_last_layer:\n # Only works for models built via `tff.learning.from_keras_model`.\n last_layer_variables = model._keras_model.layers[-1].trainable_variables # pylint:disable=protected-access\n grads = tape.gradient(output.loss, last_layer_variables)\n optimizer.apply_gradients(zip(grads, last_layer_variables))\n else:\n grads = tape.gradient(output.loss, model.trainable_variables)\n optimizer.apply_gradients(zip(grads, model.trainable_variables))\n return num_examples_sum + output.num_examples\n\n # Starts training.\n metrics_dict = collections.OrderedDict()\n train_data = train_data.batch(batch_size)\n num_examples_sum = 0\n for idx in range(1, num_finetuning_epochs + 1):\n num_examples_sum = train_data.reduce(0, train_one_batch)\n # Evaluate the finetuned model every epoch.\n metrics_dict[f'epoch_{idx}'] = evaluate_fn(model, test_data, batch_size)\n metrics_dict[_NUM_FINETUNE_EXAMPLES] = num_examples_sum\n return metrics_dict","def batchify(fn, chunk, world_fn = lambda x:x, gather_func = None):\n if chunk is None:\n return fn\n def ret(inputs, training = False, world_fn=world_fn):\n embedded = inputs[0]\n attention_poses = inputs[1]\n intrinsic = inputs[2]\n images_features = inputs[3]\n pts = inputs[4]\n\n ret_list = [fn([embedded[i:i+chunk], gather_func( world_fn(pts[i:i+chunk]), attention_poses, intrinsic, images_features),pts[i:i+chunk] ]\n , training=training) for i in range(0, int(embedded.shape[0]), chunk)]\n #necessary to cache computed results from coarse model\n if fn.coarse:\n return tf.concat([pred[0] for pred in ret_list], 0), tf.concat([pred[1] for pred in ret_list], 0)\n else:\n return tf.concat([pred[0] for pred in ret_list], 0), None\n return ret","def def_train_and_evaluate(batch_inputs=True, prepare_filename_queues=True):\n add_flag(\"output_dir\",\n default=\"output\",\n help=\"Directory where checkpoint and event files are stored\")\n\n def_experiment_fn = def_def_experiment_fn(batch_inputs,\n prepare_filename_queues)\n\n def train_and_evaluate(model_fn, train_input_fn, eval_input_fn=None):\n \"\"\"Run `tf.contrib.learn.python.learn.learn_runner.run()`.\n\n - Args\n - `model_fn`: A function to construct a model.\n - Types of its arguments must be one of the following:\n - `Tensor, ...`\n - `Tensor, ..., mode=ModeKeys`\n - Types of its return values must be one of the following:\n - `Tensor, Tensor, Operation, eval_metric_ops=dict<str, Tensor>`\n (predictions, loss, train_op, and eval_metric_ops (if any))\n - `ModelFnOps`\n - `train_input_fn`, `eval_input_fn`: Functions to serve input\n Tensors fed into the model. If `eval_input_fn` is `None`,\n `train_input_fn` will be used instead.\n - Types of its arguments must be one of the following:\n - `QueueBase` (a filename queue)\n - `None` (No argument)\n - Types of its return values must be one of the following:\n - `Tensor, Tensor` (x and y)\n - `dict<str, Tensor>, dict<str, Tensor>` (features and labels)\n - The keys in `dict` objects must match with names of\n `model_fn`'s arguments.\n\n - Returns\n - Return value of `tf.contrib.learn.python.learn.learn_runner.run()`.\n \"\"\"\n return learn_runner.run(\n def_experiment_fn(model_fn, train_input_fn, eval_input_fn),\n FLAGS.output_dir)\n\n return train_and_evaluate","def evaluate_on_batch(self, xx, yy_true, metrics, hooks=None,\n progress=None):\n if hooks is None:\n hooks = []\n if progress is None:\n progress = {}\n\n stop = False\n for hook in hooks:\n if hook.on_eval_batch_begin(progress, xx, yy_true):\n stop = True\n if stop:\n results = None\n return results, None\n\n for i, x in enumerate(xx):\n xx[i] = Z.constant(x)\n for i, y_true in enumerate(yy_true):\n yy_true[i] = Z.constant(y_true)\n\n is_training = False\n yy_pred = self.model_forward(xx, is_training)\n results = []\n for i, (y_pred, y_true, metrics) in \\\n enumerate(zip(yy_pred, yy_true, metrics)):\n values = []\n for j, metric in enumerate(metrics):\n var = Z.mean(metric(y_true, y_pred))\n values.append(Z.to_scalar(var))\n results.append(values)\n\n stop = False\n for hook in hooks:\n if hook.on_eval_batch_end(progress, results):\n stop = True\n\n return results, stop","def __model_fn_builder(self, num_labels, learning_rate,\n num_train_steps,\n num_warmup_steps):\n\n def model_fn(features, labels, mode, params):\n input_ids = features[\"input_ids\"]\n input_mask = features[\"input_mask\"]\n segment_ids = features[\"segment_ids\"]\n label_ids = features[\"label_ids\"]\n\n is_predicting = (mode == tf.estimator.ModeKeys.PREDICT)\n\n # TRAIN and EVAL\n if not is_predicting:\n\n (loss, predicted_labels, log_probs) = self.__create_model(\n input_ids,\n input_mask, segment_ids, label_ids, num_labels,\n is_predicting=is_predicting\n )\n\n train_op = create_optimizer(\n loss, learning_rate, num_train_steps, num_warmup_steps,\n use_tpu=False)\n\n # Calculate evaluation metrics.\n def metric_fn(label_ids, predicted_labels):\n accuracy = tf.metrics.accuracy(label_ids, predicted_labels)\n f1_score = tf.contrib.metrics.f1_score(\n label_ids,\n predicted_labels)\n auc = tf.metrics.auc(\n label_ids,\n predicted_labels)\n recall = tf.metrics.recall(\n label_ids,\n predicted_labels)\n precision = tf.metrics.precision(\n label_ids,\n predicted_labels)\n true_pos = tf.metrics.true_positives(\n label_ids,\n predicted_labels)\n true_neg = tf.metrics.true_negatives(\n label_ids,\n predicted_labels)\n false_pos = tf.metrics.false_positives(\n label_ids,\n predicted_labels)\n false_neg = tf.metrics.false_negatives(\n label_ids,\n predicted_labels)\n return {\n \"eval_accuracy\": accuracy,\n \"f1_score\": f1_score,\n \"auc\": auc,\n \"precision\": precision,\n \"recall\": recall,\n \"true_positives\": true_pos,\n \"true_negatives\": true_neg,\n \"false_positives\": false_pos,\n \"false_negatives\": false_neg\n }\n\n eval_metrics = metric_fn(label_ids, predicted_labels)\n\n if mode == tf.estimator.ModeKeys.TRAIN:\n return tf.estimator.EstimatorSpec(mode=mode,\n loss=loss,\n train_op=train_op)\n else:\n return tf.estimator.EstimatorSpec(mode=mode,\n loss=loss,\n eval_metric_ops=eval_metrics)\n else:\n (predicted_labels, log_probs) = self.__create_model(\n input_ids,\n input_mask, segment_ids, label_ids, num_labels,\n is_predicting=is_predicting\n )\n\n predictions = {\n 'probabilities': log_probs,\n 'labels': predicted_labels\n }\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\n\n # Return the actual model function in the closure\n return model_fn","def replica_local_fn(*args, **kwargs):\n if any(\n isinstance(arg, keras_tensor.KerasTensor)\n for arg in nest.flatten((args, kwargs))):\n update_op = None\n else:\n update_op = self.update_state(*args, **kwargs) # pylint: disable=not-callable\n update_ops = []\n if update_op is not None:\n update_ops.append(update_op)\n with ops.control_dependencies(update_ops):\n result_t = self.result() # pylint: disable=not-callable\n\n # We are adding the metric object as metadata on the result tensor.\n # This is required when we want to use a metric with `add_metric` API on\n # a Model/Layer in graph mode. This metric instance will later be used\n # to reset variable state after each epoch of training.\n # Example:\n # model = Model()\n # mean = Mean()\n # model.add_metric(mean(values), name='mean')\n result_t._metric_obj = self # pylint: disable=protected-access\n return result_t","def get_validation_metric(val_metric: str,\n y_pred_label: np.ndarray,\n y_true: np.ndarray,\n y_pred: np.ndarray,\n val_loss: any,\n acc_metric: float,\n model_type: str,\n n_class: int = None):\n if val_metric == 'kappa':\n metric_value = cohen_kappa_score(y_pred_label, y_true, weights='linear')\n elif val_metric == 'auc':\n metric_value = 0\n n_class = y_pred.shape[-1]\n for i in range(n_class):\n metric_value += compute_roc_auc(torch.tensor(y_pred[:, i]),\n torch.tensor(label_binarize(y_true, classes=np.arange(n_class))[:, i]))\n metric_value /= n_class\n elif val_metric == 'val_loss':\n metric_value = -val_loss.item()\n # Default validation metric accuracy\n elif val_metric == 'custom_cervix':\n if model_type == 'regression':\n if n_class == 2:\n metric_value = compute_roc_auc(torch.tensor(y_pred), torch.tensor(y_true))\n else:\n norm_score = y_pred\n multi_score = np.zeros((len(norm_score), 3))\n multi_score[:, 0] = 1 - norm_score.flatten()\n multi_score[:, 2] = norm_score.flatten()\n metric_value = (compute_roc_auc(torch.tensor(multi_score[:, 0]),\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\n compute_roc_auc(torch.tensor(multi_score[:, n_class - 1]),\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:,\n n_class - 1]))) / 2\n elif model_type == 'ordinal':\n\n score = np.zeros((y_pred.shape[0], 3))\n for p_idx, p in enumerate(y_pred):\n score[p_idx, 0] = 1 - p[0]\n if p[1] <= 0.5:\n score[p_idx, 1] = p[0]\n else:\n score[p_idx, 1] = 1 - p[0]\n\n score[p_idx, 2] = p[1]\n\n pred = score / score.sum(1)[..., None]\n\n metric_value = (compute_roc_auc(torch.tensor(pred[:, 0]),\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\n compute_roc_auc(torch.tensor(pred[:, -1]),\n torch.tensor(\n label_binarize(y_true, classes=list(range(n_class)))[:, -1]))) / 2\n else:\n if y_pred.shape[1] > 1:\n metric_value = (compute_roc_auc(torch.tensor(y_pred[:, 0]),\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\n compute_roc_auc(torch.tensor(y_pred[:, -1]),\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:,\n -1]))) / 2\n else:\n metric_value = compute_roc_auc(torch.tensor(y_pred), torch.tensor(y_true))\n\n else:\n metric_value = acc_metric\n\n return metric_value","def accum_val_ops(outputs, names, global_step, output_dir, metric_summary, N):\n outs = []\n if N >= 0:\n outputs = outputs[:N]\n for i in range(len(outputs[0])):\n scalar = np.array(map(lambda x: x[i], outputs))\n assert (scalar.ndim == 1)\n add_value_to_summary(metric_summary, names[i], np.mean(scalar),\n tag_str='{:>27s}: [{:s}]: %f'.format(names[i], ''))\n outs.append(np.mean(scalar))\n return outs","def _eval_on_tpu_system(ctx, model_fn_wrapper, dequeue_fn):\n iterations_per_loop_var = _create_or_get_iterations_per_loop()\n\n single_tpu_eval_step, host_calls, captured_scaffold_fn = (\n model_fn_wrapper.convert_to_single_tpu_eval_step(dequeue_fn))\n\n def multi_tpu_eval_steps_on_single_shard():\n return training_loop.repeat(\n iterations_per_loop_var,\n single_tpu_eval_step, [_ZERO_LOSS])\n\n (loss,) = tpu.shard(\n multi_tpu_eval_steps_on_single_shard,\n inputs=[],\n num_shards=ctx.num_replicas,\n outputs_from_all_shards=False,\n device_assignment=ctx.device_assignment)\n\n scaffold = _get_scaffold(captured_scaffold_fn)\n return loss, host_calls, scaffold","def multi_gpu_online_evaluation(\n model: Module,\n data_loader: DataLoader,\n metric: Union[str, Sequence[str]] = 'EPE',\n tmpdir: Optional[str] = None,\n gpu_collect: bool = False) -> Dict[str, np.ndarray]:\n\n model.eval()\n metrics = metric if isinstance(metric, (type, list)) else [metric]\n result_metrics = []\n\n dataset = data_loader.dataset\n rank, world_size = get_dist_info()\n if rank == 0:\n prog_bar = mmcv.ProgressBar(len(dataset))\n\n for data in data_loader:\n with torch.no_grad():\n batch_results = model(test_mode=True, **data)\n # data['img_metas'] is Datacontainer\n img_metas = data['img_metas'].data[0]\n batch_flow = []\n batch_flow_gt = []\n batch_valid = []\n\n # a batch of result and a batch of img_metas\n for i in range(len(batch_results)):\n result = batch_results[i]\n img_meta = img_metas[i]\n # result.keys() is 'flow' or ['flow_fw','flow_bw']\n # img_meta.keys() is 'flow_gt' or ['flow_fw_gt','flow_bw_gt']\n for k in result.keys():\n\n if img_meta.get(k + '_gt', None) is None:\n # img_meta does not have flow_bw_gt, so just check\n # the forward predicted.\n if k == 'flow_bw':\n continue\n elif k == 'flow_fw':\n batch_flow_gt.append(img_meta['flow_gt'])\n else:\n batch_flow_gt.append(img_meta[k + '_gt'])\n\n batch_flow.append(result[k])\n batch_valid.append(\n img_meta.get('valid', np.ones_like(result[k][..., 0])))\n\n batch_results_metrics = eval_metrics(batch_flow, batch_flow_gt,\n batch_valid, metrics)\n # result_metrics is different from result_metrics in\n # `single_gpu_online_evaluation`\n # result_metrics is Sequence[Dict[str,ndarray]]\n result_metrics.append(batch_results_metrics)\n\n if rank == 0:\n batch_size = len(batch_results)\n for _ in range(batch_size * world_size):\n prog_bar.update()\n\n # collect results from all ranks\n from mmflow.apis.test import collect_results_cpu, collect_results_gpu\n if gpu_collect:\n result_metrics = collect_results_gpu(result_metrics, len(dataset))\n else:\n result_metrics = collect_results_cpu(result_metrics, len(dataset),\n tmpdir)\n rank, world_size = get_dist_info()\n if rank == 0:\n sys.stdout.write('\\n')\n # result_metrics_ is final result of evaluation with type\n # dict(metric_name=metric)\n result_metrics_ = dict()\n\n for sample_result_metrics in result_metrics:\n for k in sample_result_metrics.keys():\n if result_metrics_.get(k, None) is None:\n result_metrics_[k] = sample_result_metrics[k] / len(\n result_metrics)\n else:\n result_metrics_[k] += sample_result_metrics[k] / len(\n result_metrics)\n\n return result_metrics_"],"string":"[\n \"def evaluate_fn(\\n # The pytype below must be Any, because the code below uses internal methods\\n # only present on tff.learning.from_keras_model-derived TFF models.\\n model: Any,\\n dataset: tf.data.Dataset,\\n batch_size: int = 1,\\n) -> collections.OrderedDict[str, tf.Tensor]:\\n # Resets the model's local variables. This is necessary because\\n # `model.report_local_unfinalized_metrics()` aggregates the metrics from *all*\\n # previous calls to `forward_pass` (which include the metrics computed in\\n # training). Resetting ensures that the returned metrics are computed on test\\n # data. Similar to the `reset_states` method of `tf.keras.metrics.Metric`.\\n model.reset_metrics()\\n\\n @tf.function\\n def reduce_fn(num_examples_sum, batch):\\n output = model.forward_pass(batch, training=False)\\n return num_examples_sum + output.num_examples\\n\\n dataset.batch(batch_size).reduce(0, reduce_fn)\\n finalized_metrics = collections.OrderedDict(\\n # Note that `model.get_metrics` only works for models created via\\n # `tff.learning.from_keras_model`. For non-keras based models, you can\\n # apply `model.metric_finalizers` to the unfinalized metrics (returned by\\n # `model.report_local_unfinalized_metrics`) to get the finalized metrics.\\n (metric.name, metric.result()) for metric in model.get_metrics())\\n return finalized_metrics\",\n \"def _evaluate_fn(model, dataset):\\n # Reset the local variables so that the returned metrics are computed using\\n # the given data. Similar to the `reset_states` method of `tf.metrics.Metric`.\\n for var in model.local_variables:\\n if var.initial_value is not None:\\n var.assign(var.initial_value)\\n else:\\n var.assign(tf.zeros_like(var))\\n\\n def eval_fn(dummy_state, batch):\\n \\\"\\\"\\\"Evaluates the model on a batch.\\\"\\\"\\\"\\n model.forward_pass(batch, training=False)\\n return dummy_state\\n\\n # Evaluate on the dataset.\\n dataset.reduce(initial_state=0, reduce_func=eval_fn)\\n\\n # Obtain the metrics.\\n results = collections.OrderedDict()\\n local_outputs = model.report_local_outputs()\\n for name, metric in local_outputs.items():\\n if isinstance(metric, list) and (len(metric) == 2):\\n # Some metrics returned by `report_local_outputs()` can have two scalars:\\n # one represents `sum`, and the other represents `count`. Ideally, we want\\n # to return a single scalar for each metric.\\n results[name] = metric[0] / metric[1]\\n else:\\n results[name] = metric[0] if isinstance(metric, list) else metric\\n return results\",\n \"def evaluate(model, loss_fn, valid_dl, metric=None):\\n with torch.no_grad():\\n # Pass each batch through the model\\n results = [loss_batch(model, loss_fn, xb, yb, metric=metric) for xb, yb in valid_dl]\\n # Separate losses, counts and metrics\\n losses, nums, metrics = zip(*results)\\n # Total size of the dataset\\n total = np.sum(nums)\\n # Avg. loss across batches\\n avg_loss = np.sum(np.multiply(losses, nums)) / total\\n avg_metric = None\\n if metric is not None:\\n # Avg. of metric across batches\\n avg_metric = np.sum(np.multiply(metrics, nums)) / total\\n return avg_loss, total, avg_metric\",\n \"def fn(distribution, *a):\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with tf.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n tf.add_to_collections(metrics_collections, metric_value)\\n return metric_value\",\n \"def evaluate_with_metrics(self, dataset, metrics, *args, **kwargs):\\n\\n utils.assert_raise(isinstance(metrics, dict), ValueError,\\n '\\\"metrics\\\" must be a dict with metric_name -> metric_function')\\n result = dict()\\n\\n for sample in dataset:\\n output = self.predict(sample)\\n\\n for key, call in metrics.items():\\n holder = result.get(key, list())\\n holder.append(call(output, sample))\\n\\n result[key] = holder\\n\\n return result\",\n \"def fn(distribution, *a):\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with ops.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n ops.add_to_collections(metrics_collections, metric_value)\\n return metric_value\",\n \"def evaluate(self, batch: RecordBatch) -> Any:\\n processed_args = self._process_arguments(self._arguments, batch)\\n if self._function:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", category=RuntimeWarning)\\n if self._is_binary_func:\\n result = self._apply_binary_args_function(\\n *processed_args\\n )\\n else:\\n result = self._function(*processed_args)\\n else:\\n result = self._expr_kernel(processed_args, batch)\\n\\n return self._post_process_result(result)\",\n \"def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\\n def fn(distribution, *a):\\n \\\"\\\"\\\"Call `metric_value_fn` in the correct control flow context.\\\"\\\"\\\"\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with ops.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n ops.add_to_collections(metrics_collections, metric_value)\\n return metric_value\\n\\n return distribute_lib.get_tower_context().merge_call(fn, *args)\",\n \"def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\\n def fn(distribution, *a):\\n \\\"\\\"\\\"Call `metric_value_fn` in the correct control flow context.\\\"\\\"\\\"\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with tf.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n tf.add_to_collections(metrics_collections, metric_value)\\n return metric_value\\n\\n return distribution_strategy_context.get_tower_context().merge_call(fn, *args)\",\n \"def call_metric_function(metric_fn,\\n y_true,\\n y_pred=None,\\n weights=None,\\n mask=None):\\n if mask is not None:\\n mask = math_ops.cast(mask, y_pred.dtype)\\n if weights is None:\\n # Use mask as sample weight.\\n weights = mask\\n else:\\n # Update dimensions of weights to match with mask.\\n weights = math_ops.cast(weights, dtype=y_pred.dtype)\\n mask, _, weights = losses_utils.squeeze_or_expand_dimensions(\\n mask, sample_weight=weights)\\n weights *= mask\\n\\n if y_pred is not None:\\n return metric_fn(y_true, y_pred, sample_weight=weights)\\n # `Mean` metric only takes a single value.\\n return metric_fn(y_true, sample_weight=weights)\",\n \"def evaluate_module(\\n model: nn.Module,\\n dataset: Union[NumpyArrayTuple, torch.utils.data.Dataset],\\n loss_fn,\\n device: torch.device,\\n metrics_map: MetricsMapType = None,\\n batch_size: int = 64,\\n verbose: bool = True,\\n) -> MetricsValType:\\n try:\\n model = model.to(device)\\n\\n # if dataset is a tuple of np.ndarrays, convert to torch Dataset\\n if isinstance(dataset, tuple):\\n X = torch.from_numpy(dataset[0]).type(torch.FloatTensor)\\n y = torch.from_numpy(dataset[1]).type(\\n torch.LongTensor if dataset[1].dtype in [np.int, np.long] else torch.FloatTensor\\n )\\n dataset = torch.utils.data.TensorDataset(X, y)\\n\\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False)\\n\\n tot_samples, samples, num_batches = len(dataset), 0, 0\\n len_tot_samples = len(str(tot_samples))\\n\\n # create metrics history\\n history = MetricsHistory(metrics_map)\\n\\n with torch.no_grad():\\n model.eval()\\n for X, y in loader:\\n X = X.to(device)\\n y = y.to(device)\\n\\n # forward pass\\n preds = model(X)\\n # compute batch loss\\n batch_loss = loss_fn(preds, y).item()\\n history.calculate_batch_metrics(preds.to(\\\"cpu\\\"), y.to(\\\"cpu\\\"), batch_loss, val_metrics=False)\\n samples += len(y)\\n num_batches += 1\\n if verbose:\\n metricsStr = history.get_metrics_str(batch_metrics=True, include_val_metrics=False)\\n print(\\n \\\"\\\\rEvaluating (%*d/%*d) -> %s\\\"\\n % (len_tot_samples, samples, len_tot_samples, tot_samples, metricsStr),\\n end=\\\"\\\",\\n flush=True,\\n )\\n else:\\n # iteration over batch completed\\n # calculate average metrics across all batches\\n history.calculate_epoch_metrics(val_metrics=False)\\n metricsStr = history.get_metrics_str(batch_metrics=False, include_val_metrics=False)\\n print(\\n \\\"\\\\rEvaluating (%*d/%*d) -> %s\\\"\\n % (len_tot_samples, samples, len_tot_samples, tot_samples, metricsStr),\\n flush=True,\\n )\\n return history.get_metric_vals(history.tracked_metrics())\\n finally:\\n model = model.to(\\\"cpu\\\")\",\n \"def problem_metric_fn(*args):\\n (scores, weights) = metric_fn(*args)\\n\\n # The tf.metrics.mean function assures correct aggregation.\\n return tf.compat.v1.metrics.mean(scores, weights)\",\n \"def calc_metric(output, metrics):\\n score = []\\n for metric in metrics:\\n metric_mod = __import__(\\\"sklearn.metrics\\\", fromlist=[metric])\\n metric_func = getattr(metric_mod, metric)\\n score.append(metric_func(output[0], output[1]))\\n return score, output\",\n \"def batch_transform(func):\\n\\n @functools.wraps(func)\\n def create_window(*args, **kwargs):\\n # passes the user defined function to BatchTransform which it\\n # will call instead of self.get_value()\\n return BatchTransform(*args, func=func, **kwargs)\\n\\n return create_window\",\n \"def evaluate(model, loss_func, dataloader, metrics):\\r\\n model.eval()\\r\\n summ = []\\r\\n device = utils.get_device()\\r\\n for data in dataloader:\\r\\n encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids,inputY = data\\r\\n inputY = inputY.to(device)\\r\\n output_batch = model(encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids)\\r\\n\\r\\n loss = loss_func(output_batch, inputY)\\r\\n output_batch = output_batch.data.cpu().numpy()\\r\\n inputY = inputY.data.cpu().numpy()\\r\\n summary_batch = {metric: metrics[metric](\\r\\n output_batch, inputY) for metric in metrics}\\r\\n summary_batch['loss'] = loss.item()\\r\\n summ.append(summary_batch)\\r\\n # print(\\\"summ:{}\\\".format(summ))\\r\\n metrics_mean = {metric: np.mean([x[metric]\\r\\n for x in summ]) for metric in summ[0]}\\r\\n metrics_string = \\\" ; \\\".join(\\\"{}: {:05.3f}\\\".format(k, v)\\r\\n for k, v in metrics_mean.items())\\r\\n logging.info(\\\"- Eval metrics : \\\" + metrics_string)\\r\\n return metrics_mean\",\n \"def run_batches(self,\\n fn: Callable[..., Optional[Dict[str, Any]]],\\n data_generator: Iterable[ArrayTupleOrList],\\n limit: Optional[int] = None,\\n count: Optional[int] = None,\\n metrics: Union[Sequence[str], type(ALL)] = NOT_SET,\\n outputs: Union[Sequence[str], type(ALL)] = NOT_SET,\\n aggregators: Optional[Mapping[str, BatchAggregator]] = None,\\n excludes: Sequence[str] = ()\\n ) -> Optional[Dict[str, Any]]:\\n metrics, outputs = \\\\\\n self._complete_metrics_and_outputs_arg(metrics, outputs)\\n\\n # the BatchAggregatorDict\\n agg_dict = BatchAggregatorDict.new(\\n metrics=metrics,\\n outputs=outputs,\\n aggregators=aggregators,\\n excludes=excludes,\\n )\\n\\n # now run the batches\\n g = self.iter_batches(data_generator, limit=limit, count=count)\\n try:\\n for batch, batch_data in g:\\n batch_size = get_array_shape(batch_data[0])[0]\\n fn_out = fn(*batch_data)\\n if fn_out is not None:\\n if not isinstance(fn_out, dict):\\n raise TypeError(f'The output of `fn` is expected to be '\\n f'a dict, but got {fn_out!r}')\\n\\n fn_out = {\\n k: to_number_or_numpy(v)\\n for k, v in fn_out.items()\\n }\\n metrics = {}\\n for key, val in fn_out.items():\\n agg = agg_dict.get(key)\\n if agg is not None:\\n size = batch_size if np.shape(val) == () else 1.\\n agg.add(val, weight=size)\\n # For metrics collected by\\n # ``BatchAggregator('AVERAGE', None)``, we also add\\n # them to the batch metrics.\\n if agg.mode == BatchAggregationMode.AVERAGE and \\\\\\n agg.axis is None:\\n metrics[key] = np.mean(val)\\n self.add_metrics(metrics)\\n finally:\\n g.close()\\n\\n # return the aggregated results\\n if len(agg_dict) > 0:\\n return {k: v.get() for k, v in agg_dict.items()}\",\n \"def evaluate(\\n self,\\n duration_fn: Optional[Callable[[int], int]] = None,\\n ) -> dict:\\n # Call the `_before_evaluate` hook.\\n self._before_evaluate()\\n\\n if self.evaluation_dataset is not None:\\n return {\\\"evaluation\\\": self._run_offline_evaluation()}\\n\\n # Sync weights to the evaluation WorkerSet.\\n if self.evaluation_workers is not None:\\n self.evaluation_workers.sync_weights(\\n from_worker_or_learner_group=self.workers.local_worker()\\n )\\n self._sync_filters_if_needed(\\n central_worker=self.workers.local_worker(),\\n workers=self.evaluation_workers,\\n config=self.evaluation_config,\\n )\\n\\n self.callbacks.on_evaluate_start(algorithm=self)\\n\\n if self.config.custom_evaluation_function:\\n logger.info(\\n \\\"Running custom eval function {}\\\".format(\\n self.config.custom_evaluation_function\\n )\\n )\\n metrics = self.config.custom_evaluation_function(\\n self, self.evaluation_workers\\n )\\n if not metrics or not isinstance(metrics, dict):\\n raise ValueError(\\n \\\"Custom eval function must return \\\"\\n \\\"dict of metrics, got {}.\\\".format(metrics)\\n )\\n else:\\n if (\\n self.evaluation_workers is None\\n and self.workers.local_worker().input_reader is None\\n ):\\n raise ValueError(\\n \\\"Cannot evaluate w/o an evaluation worker set in \\\"\\n \\\"the Algorithm or w/o an env on the local worker!\\\\n\\\"\\n \\\"Try one of the following:\\\\n1) Set \\\"\\n \\\"`evaluation_interval` >= 0 to force creating a \\\"\\n \\\"separate evaluation worker set.\\\\n2) Set \\\"\\n \\\"`create_env_on_driver=True` to force the local \\\"\\n \\\"(non-eval) worker to have an environment to \\\"\\n \\\"evaluate on.\\\"\\n )\\n\\n # How many episodes/timesteps do we need to run?\\n # In \\\"auto\\\" mode (only for parallel eval + training): Run as long\\n # as training lasts.\\n unit = self.config.evaluation_duration_unit\\n eval_cfg = self.evaluation_config\\n rollout = eval_cfg.rollout_fragment_length\\n num_envs = eval_cfg.num_envs_per_worker\\n auto = self.config.evaluation_duration == \\\"auto\\\"\\n duration = (\\n self.config.evaluation_duration\\n if not auto\\n else (self.config.evaluation_num_workers or 1)\\n * (1 if unit == \\\"episodes\\\" else rollout)\\n )\\n agent_steps_this_iter = 0\\n env_steps_this_iter = 0\\n\\n # Default done-function returns True, whenever num episodes\\n # have been completed.\\n if duration_fn is None:\\n\\n def duration_fn(num_units_done):\\n return duration - num_units_done\\n\\n logger.info(f\\\"Evaluating current state of {self} for {duration} {unit}.\\\")\\n\\n metrics = None\\n all_batches = []\\n # No evaluation worker set ->\\n # Do evaluation using the local worker. Expect error due to the\\n # local worker not having an env.\\n if self.evaluation_workers is None:\\n # If unit=episodes -> Run n times `sample()` (each sample\\n # produces exactly 1 episode).\\n # If unit=ts -> Run 1 `sample()` b/c the\\n # `rollout_fragment_length` is exactly the desired ts.\\n iters = duration if unit == \\\"episodes\\\" else 1\\n for _ in range(iters):\\n batch = self.workers.local_worker().sample()\\n agent_steps_this_iter += batch.agent_steps()\\n env_steps_this_iter += batch.env_steps()\\n if self.reward_estimators:\\n all_batches.append(batch)\\n metrics = collect_metrics(\\n self.workers,\\n keep_custom_metrics=eval_cfg.keep_per_episode_custom_metrics,\\n timeout_seconds=eval_cfg.metrics_episode_collection_timeout_s,\\n )\\n\\n # Evaluation worker set only has local worker.\\n elif self.evaluation_workers.num_remote_workers() == 0:\\n # If unit=episodes -> Run n times `sample()` (each sample\\n # produces exactly 1 episode).\\n # If unit=ts -> Run 1 `sample()` b/c the\\n # `rollout_fragment_length` is exactly the desired ts.\\n iters = duration if unit == \\\"episodes\\\" else 1\\n for _ in range(iters):\\n batch = self.evaluation_workers.local_worker().sample()\\n agent_steps_this_iter += batch.agent_steps()\\n env_steps_this_iter += batch.env_steps()\\n if self.reward_estimators:\\n all_batches.append(batch)\\n\\n # Evaluation worker set has n remote workers.\\n elif self.evaluation_workers.num_healthy_remote_workers() > 0:\\n # How many episodes have we run (across all eval workers)?\\n num_units_done = 0\\n _round = 0\\n # In case all of the remote evaluation workers die during a round\\n # of evaluation, we need to stop.\\n while True and self.evaluation_workers.num_healthy_remote_workers() > 0:\\n units_left_to_do = duration_fn(num_units_done)\\n if units_left_to_do <= 0:\\n break\\n\\n _round += 1\\n unit_per_remote_worker = (\\n 1 if unit == \\\"episodes\\\" else rollout * num_envs\\n )\\n # Select proper number of evaluation workers for this round.\\n selected_eval_worker_ids = [\\n worker_id\\n for i, worker_id in enumerate(\\n self.evaluation_workers.healthy_worker_ids()\\n )\\n if i * unit_per_remote_worker < units_left_to_do\\n ]\\n batches = self.evaluation_workers.foreach_worker(\\n func=lambda w: w.sample(),\\n local_worker=False,\\n remote_worker_ids=selected_eval_worker_ids,\\n timeout_seconds=self.config.evaluation_sample_timeout_s,\\n )\\n if len(batches) != len(selected_eval_worker_ids):\\n logger.warning(\\n \\\"Calling `sample()` on your remote evaluation worker(s) \\\"\\n \\\"resulted in a timeout (after the configured \\\"\\n f\\\"{self.config.evaluation_sample_timeout_s} seconds)! \\\"\\n \\\"Try to set `evaluation_sample_timeout_s` in your config\\\"\\n \\\" to a larger value.\\\"\\n + (\\n \\\" If your episodes don't terminate easily, you may \\\"\\n \\\"also want to set `evaluation_duration_unit` to \\\"\\n \\\"'timesteps' (instead of 'episodes').\\\"\\n if unit == \\\"episodes\\\"\\n else \\\"\\\"\\n )\\n )\\n break\\n\\n _agent_steps = sum(b.agent_steps() for b in batches)\\n _env_steps = sum(b.env_steps() for b in batches)\\n # 1 episode per returned batch.\\n if unit == \\\"episodes\\\":\\n num_units_done += len(batches)\\n # Make sure all batches are exactly one episode.\\n for ma_batch in batches:\\n ma_batch = ma_batch.as_multi_agent()\\n for batch in ma_batch.policy_batches.values():\\n assert batch.is_terminated_or_truncated()\\n # n timesteps per returned batch.\\n else:\\n num_units_done += (\\n _agent_steps\\n if self.config.count_steps_by == \\\"agent_steps\\\"\\n else _env_steps\\n )\\n if self.reward_estimators:\\n # TODO: (kourosh) This approach will cause an OOM issue when\\n # the dataset gets huge (should be ok for now).\\n all_batches.extend(batches)\\n\\n agent_steps_this_iter += _agent_steps\\n env_steps_this_iter += _env_steps\\n\\n logger.info(\\n f\\\"Ran round {_round} of non-parallel evaluation \\\"\\n f\\\"({num_units_done}/{duration if not auto else '?'} \\\"\\n f\\\"{unit} done)\\\"\\n )\\n else:\\n # Can't find a good way to run this evaluation.\\n # Wait for next iteration.\\n pass\\n\\n if metrics is None:\\n metrics = collect_metrics(\\n self.evaluation_workers,\\n keep_custom_metrics=self.config.keep_per_episode_custom_metrics,\\n timeout_seconds=eval_cfg.metrics_episode_collection_timeout_s,\\n )\\n\\n # TODO: Don't dump sampler results into top-level.\\n if not self.config.custom_evaluation_function:\\n metrics = dict({\\\"sampler_results\\\": metrics}, **metrics)\\n\\n metrics[NUM_AGENT_STEPS_SAMPLED_THIS_ITER] = agent_steps_this_iter\\n metrics[NUM_ENV_STEPS_SAMPLED_THIS_ITER] = env_steps_this_iter\\n # TODO: Remove this key at some point. Here for backward compatibility.\\n metrics[\\\"timesteps_this_iter\\\"] = env_steps_this_iter\\n\\n # Compute off-policy estimates\\n estimates = defaultdict(list)\\n # for each batch run the estimator's fwd pass\\n for name, estimator in self.reward_estimators.items():\\n for batch in all_batches:\\n estimate_result = estimator.estimate(\\n batch,\\n split_batch_by_episode=self.config.ope_split_batch_by_episode,\\n )\\n estimates[name].append(estimate_result)\\n\\n # collate estimates from all batches\\n if estimates:\\n metrics[\\\"off_policy_estimator\\\"] = {}\\n for name, estimate_list in estimates.items():\\n avg_estimate = tree.map_structure(\\n lambda *x: np.mean(x, axis=0), *estimate_list\\n )\\n metrics[\\\"off_policy_estimator\\\"][name] = avg_estimate\\n\\n # Evaluation does not run for every step.\\n # Save evaluation metrics on Algorithm, so it can be attached to\\n # subsequent step results as latest evaluation result.\\n self.evaluation_metrics = {\\\"evaluation\\\": metrics}\\n\\n # Trigger `on_evaluate_end` callback.\\n self.callbacks.on_evaluate_end(\\n algorithm=self, evaluation_metrics=self.evaluation_metrics\\n )\\n\\n # Also return the results here for convenience.\\n return self.evaluation_metrics\",\n \"def log_eval_summary(step: int,\\n *,\\n writer: metric_writers.MetricWriter,\\n eval_metrics: Sequence[Dict[str, Tuple[float, int]]],\\n extra_eval_summary: Optional[Dict[str, float]] = None,\\n metrics_normalizer_fn: Optional[\\n Callable[[Dict[str, Tuple[float, int]], str],\\n Dict[str, float]]] = None,\\n prefix: str = 'valid',\\n key_separator: str = '_') -> Dict[str, float]:\\n eval_metrics = stack_forest(eval_metrics)\\n\\n # Compute the sum over all examples in all batches.\\n eval_metrics_summary = jax.tree_map(lambda x: x.sum(), eval_metrics)\\n # Normalize metrics by the total number of exampels.\\n metrics_normalizer_fn = metrics_normalizer_fn or normalize_metrics_summary\\n eval_metrics_summary = metrics_normalizer_fn(eval_metrics_summary, 'eval')\\n # If None, set to an empty dictionary.\\n extra_eval_summary = extra_eval_summary or {}\\n\\n # Adds extra_eval_summary to the returned eval_summary.\\n eval_metrics_summary.update(extra_eval_summary)\\n\\n writer.write_scalars(\\n step, {\\n key_separator.join((prefix, key)): val\\n for key, val in eval_metrics_summary.items()\\n })\\n\\n return eval_metrics_summary\",\n \"def get_evaluate_fn(testset):\\n x_test, y_test = testset\\n\\n # The `evaluate` function will be called after every round by the strategy\\n def evaluate(\\n server_round: int,\\n parameters: fl.common.NDArrays,\\n config: Dict[str, fl.common.Scalar],\\n ):\\n model = get_model() # Construct the model\\n model.set_weights(parameters) # Update model with the latest parameters\\n loss, accuracy = model.evaluate(x_test, y_test, verbose=VERBOSE)\\n return loss, {\\\"accuracy\\\": accuracy}\\n\\n return evaluate\",\n \"def build_metric_func(dataset_split_name, add_summary=True):\\n\\n def metric_func(labels, logits):\\n \\\"\\\"\\\"Evaluation metric function that runs on CPU.\\\"\\\"\\\"\\n accuracy_metric_name = 'Eval/Accuracy/%s' % dataset_split_name\\n metric_map = {\\n accuracy_metric_name: tf.metrics.accuracy(labels, tf.argmax(logits, 1)),\\n }\\n if add_summary:\\n for name, value in metric_map.items():\\n tf.summary.scalar(name, value)\\n return metric_map\\n\\n return metric_func\",\n \"def evaluate(model, loss_func, dataloader, metrics):\\r\\n model.eval()\\r\\n summ = []\\r\\n device = utils.get_device()\\r\\n with torch.no_grad():\\r\\n for data in dataloader:\\r\\n sentences1, starts1, ends1, sentences2, starts2, ends2, inputY = data\\r\\n inputY = inputY.to(device)\\r\\n output_batch = model(sentences1, starts1, ends1, sentences2, starts2, ends2)\\r\\n loss = loss_func(output_batch, inputY)\\r\\n output_batch = output_batch.data.cpu().numpy()\\r\\n inputY = inputY.data.cpu().numpy()\\r\\n summary_batch = {metric: metrics[metric](\\r\\n output_batch, inputY) for metric in metrics}\\r\\n summary_batch['loss'] = loss.item()\\r\\n summ.append(summary_batch)\\r\\n # print(\\\"summ:{}\\\".format(summ))\\r\\n metrics_mean = {metric: np.mean([x[metric]\\r\\n for x in summ]) for metric in summ[0]}\\r\\n metrics_string = \\\" ; \\\".join(\\\"{}: {:05.3f}\\\".format(k, v)\\r\\n for k, v in metrics_mean.items())\\r\\n logging.info(\\\"- Eval metrics : \\\" + metrics_string)\\r\\n return metrics_mean\",\n \"def get_metric_fn(self, sklearn_fn, kwargs=None):\\n kwargs = kwargs if kwargs else dict()\\n if self.data_content is not None and self.task_id is not None:\\n predictions_arff = self._generate_arff_dict()\\n elif \\\"predictions\\\" in self.output_files:\\n predictions_file_url = openml._api_calls._file_id_to_url(\\n self.output_files[\\\"predictions\\\"],\\n \\\"predictions.arff\\\",\\n )\\n response = openml._api_calls._download_text_file(predictions_file_url)\\n predictions_arff = arff.loads(response)\\n # TODO: make this a stream reader\\n else:\\n raise ValueError(\\n \\\"Run should have been locally executed or \\\" \\\"contain outputfile reference.\\\"\\n )\\n\\n # Need to know more about the task to compute scores correctly\\n task = get_task(self.task_id)\\n\\n attribute_names = [att[0] for att in predictions_arff[\\\"attributes\\\"]]\\n if (\\n task.task_type_id in [TaskType.SUPERVISED_CLASSIFICATION, TaskType.LEARNING_CURVE]\\n and \\\"correct\\\" not in attribute_names\\n ):\\n raise ValueError('Attribute \\\"correct\\\" should be set for ' \\\"classification task runs\\\")\\n if task.task_type_id == TaskType.SUPERVISED_REGRESSION and \\\"truth\\\" not in attribute_names:\\n raise ValueError('Attribute \\\"truth\\\" should be set for ' \\\"regression task runs\\\")\\n if task.task_type_id != TaskType.CLUSTERING and \\\"prediction\\\" not in attribute_names:\\n raise ValueError('Attribute \\\"predict\\\" should be set for ' \\\"supervised task runs\\\")\\n\\n def _attribute_list_to_dict(attribute_list):\\n # convenience function: Creates a mapping to map from the name of\\n # attributes present in the arff prediction file to their index.\\n # This is necessary because the number of classes can be different\\n # for different tasks.\\n res = OrderedDict()\\n for idx in range(len(attribute_list)):\\n res[attribute_list[idx][0]] = idx\\n return res\\n\\n attribute_dict = _attribute_list_to_dict(predictions_arff[\\\"attributes\\\"])\\n\\n repeat_idx = attribute_dict[\\\"repeat\\\"]\\n fold_idx = attribute_dict[\\\"fold\\\"]\\n predicted_idx = attribute_dict[\\\"prediction\\\"] # Assume supervised task\\n\\n if (\\n task.task_type_id == TaskType.SUPERVISED_CLASSIFICATION\\n or task.task_type_id == TaskType.LEARNING_CURVE\\n ):\\n correct_idx = attribute_dict[\\\"correct\\\"]\\n elif task.task_type_id == TaskType.SUPERVISED_REGRESSION:\\n correct_idx = attribute_dict[\\\"truth\\\"]\\n has_samples = False\\n if \\\"sample\\\" in attribute_dict:\\n sample_idx = attribute_dict[\\\"sample\\\"]\\n has_samples = True\\n\\n if (\\n predictions_arff[\\\"attributes\\\"][predicted_idx][1]\\n != predictions_arff[\\\"attributes\\\"][correct_idx][1]\\n ):\\n pred = predictions_arff[\\\"attributes\\\"][predicted_idx][1]\\n corr = predictions_arff[\\\"attributes\\\"][correct_idx][1]\\n raise ValueError(\\n \\\"Predicted and Correct do not have equal values:\\\"\\n \\\" %s Vs. %s\\\" % (str(pred), str(corr))\\n )\\n\\n # TODO: these could be cached\\n values_predict = {}\\n values_correct = {}\\n for line_idx, line in enumerate(predictions_arff[\\\"data\\\"]):\\n rep = line[repeat_idx]\\n fold = line[fold_idx]\\n if has_samples:\\n samp = line[sample_idx]\\n else:\\n samp = 0 # No learning curve sample, always 0\\n\\n if task.task_type_id in [\\n TaskType.SUPERVISED_CLASSIFICATION,\\n TaskType.LEARNING_CURVE,\\n ]:\\n prediction = predictions_arff[\\\"attributes\\\"][predicted_idx][1].index(\\n line[predicted_idx]\\n )\\n correct = predictions_arff[\\\"attributes\\\"][predicted_idx][1].index(line[correct_idx])\\n elif task.task_type_id == TaskType.SUPERVISED_REGRESSION:\\n prediction = line[predicted_idx]\\n correct = line[correct_idx]\\n if rep not in values_predict:\\n values_predict[rep] = OrderedDict()\\n values_correct[rep] = OrderedDict()\\n if fold not in values_predict[rep]:\\n values_predict[rep][fold] = OrderedDict()\\n values_correct[rep][fold] = OrderedDict()\\n if samp not in values_predict[rep][fold]:\\n values_predict[rep][fold][samp] = []\\n values_correct[rep][fold][samp] = []\\n\\n values_predict[rep][fold][samp].append(prediction)\\n values_correct[rep][fold][samp].append(correct)\\n\\n scores = []\\n for rep in values_predict.keys():\\n for fold in values_predict[rep].keys():\\n last_sample = len(values_predict[rep][fold]) - 1\\n y_pred = values_predict[rep][fold][last_sample]\\n y_true = values_correct[rep][fold][last_sample]\\n scores.append(sklearn_fn(y_true, y_pred, **kwargs))\\n return np.array(scores)\",\n \"def evaluate(self):\\n iterator = self._iterators['main']\\n\\n if self.eval_hook:\\n self.eval_hook(self)\\n\\n summary = reporting.DictSummary()\\n\\n progress = IterationStatus(len(iterator))\\n if self._progress_bar:\\n pbar = _IteratorProgressBar(iterator=progress)\\n\\n last_iter = len(iterator) - 1\\n with _in_eval_mode(self._targets.values()):\\n for idx, batch in enumerate(iterator):\\n last_batch = idx == last_iter\\n progress.current_position = idx\\n observation = {}\\n with reporting.report_scope(observation):\\n if isinstance(batch, (tuple, list)):\\n outs = self.eval_func(*batch)\\n elif isinstance(batch, dict):\\n outs = self.eval_func(**batch)\\n else:\\n outs = self.eval_func(batch)\\n for metric in self._metrics:\\n metric(batch, outs, last_batch)\\n summary.add(observation)\\n\\n if self._progress_bar:\\n pbar.update()\\n\\n if self._progress_bar:\\n pbar.close()\\n\\n return summary.compute_mean()\",\n \"def evaluate(model,loss_fn, val_dataloader):\\r\\n # Put the model into the evaluation mode. The dropout layers are disabled during\\r\\n # the test time.\\r\\n model.eval()\\r\\n\\r\\n # Tracking variables\\r\\n val_accuracy = []\\r\\n val_loss = []\\r\\n\\r\\n # For each batch in our validation set...\\r\\n for batch in val_dataloader:\\r\\n # Load batch to GPU\\r\\n b_input_ids, b_attn_mask, b_labels = tuple(t.to(device) for t in batch)\\r\\n\\r\\n # Compute logits\\r\\n with torch.no_grad():\\r\\n logits = model(b_input_ids, b_attn_mask)\\r\\n\\r\\n # Compute loss\\r\\n loss = loss_fn(logits, b_labels)\\r\\n val_loss.append(loss.item())\\r\\n\\r\\n # Get the predictions\\r\\n preds = torch.argmax(logits, dim=1).flatten()\\r\\n\\r\\n # Calculate the accuracy rate\\r\\n accuracy = (preds == b_labels).cpu().numpy().mean() * 100\\r\\n val_accuracy.append(accuracy)\\r\\n\\r\\n # Compute the average accuracy and loss over the validation set.\\r\\n val_loss = np.mean(val_loss)\\r\\n val_accuracy = np.mean(val_accuracy)\\r\\n\\r\\n return val_loss, val_accuracy\",\n \"def _run_evaluator(self, func, stats):\\n host_stats = stats['host_stats']\\n host_caps = stats['host_caps']\\n extra_specs = stats['extra_specs']\\n share_stats = stats['share_stats']\\n\\n result = evaluator.evaluate(\\n func,\\n extra=extra_specs,\\n stats=host_stats,\\n capabilities=host_caps,\\n share=share_stats)\\n\\n return result\",\n \"def evaluate(self, input_fn, eval_times, checkpoint_path=None):\\n if not checkpoint_path:\\n checkpoint_path = self._estimator.latest_checkpoint()\\n\\n if self._params.eval.type == 'customized':\\n metrics = self._estimator.evaluate(\\n input_fn, steps=eval_times, checkpoint_path=checkpoint_path)\\n else:\\n if not self._evaluator:\\n self.prepare_evaluation()\\n if checkpoint_path:\\n current_step = int(os.path.basename(checkpoint_path).split('-')[1])\\n else:\\n current_step = 0\\n predictor = self._estimator.predict(\\n input_fn=input_fn,\\n checkpoint_path=checkpoint_path,\\n yield_single_examples=False)\\n losses = collections.defaultdict(lambda: 0.0)\\n\\n counter = 0\\n try:\\n while eval_times is None or counter < eval_times:\\n outputs = six.next(predictor)\\n predictions = {}\\n groundtruths = {}\\n for key, val in outputs.items():\\n if key[0:5] == 'pred_':\\n predictions[key[5::]] = val\\n if key[0:3] == 'gt_':\\n groundtruths[key[3::]] = val\\n if key[0:5] == 'loss_':\\n losses[key[5::]] += np.mean(val)\\n self._evaluator.update(\\n predictions,\\n groundtruths=(None if self._params.eval.use_json_file\\n else groundtruths))\\n counter = counter + 1\\n tf.logging.info(\\n f'Finish eval step {counter} out of total {eval_times} steps.')\\n except (tf.errors.OutOfRangeError, StopIteration):\\n logging.info(\\n 'Evaluation reaches the end after running %d times.', counter)\\n\\n for key, val in outputs.items():\\n if key[0:5] == 'loss_':\\n losses[key[5::]] /= counter\\n metrics = self._evaluator.evaluate()\\n\\n # Summary writer writes out eval metrics.\\n output_dir = os.path.join(self._model_dir,\\n 'eval' + self._params.eval.suffix)\\n tf.gfile.MakeDirs(output_dir)\\n summary_writer = tf.summary.FileWriter(output_dir)\\n write_summary(metrics, summary_writer, current_step)\\n write_summary(losses, summary_writer, current_step)\\n summary_writer.close()\\n\\n logging.info('Eval result: %s', metrics)\\n return metrics\",\n \"def evaluate(model, loss_fn, data_iterator, metrics, params, num_steps, sample_weights=None):\\n\\n # set model to evaluation mode\\n model.eval()\\n\\n # summary for current eval loop\\n summ = []\\n out_prob=[]\\n labels=np.array([])\\n \\n ##-----------------------------\\n # compute metrics over the dataset\\n \\n data_iterator_iter = iter(data_iterator)\\n \\n for _ in range(num_steps):\\n \\n # fetch the next evaluation batch\\n levels, children, n_inners, contents, n_level, labels_batch=next(data_iterator_iter)\\n\\n # shift tensors to GPU if available\\n if params.cuda:\\n levels = levels.cuda()\\n children=children.cuda()\\n n_inners=n_inners.cuda()\\n contents=contents.cuda()\\n n_level= n_level.cuda()\\n labels_batch =labels_batch.cuda()\\n\\n # convert them to Variables to record operations in the computational graph\\n levels=torch.autograd.Variable(levels)\\n children=torch.autograd.Variable(children)\\n n_inners=torch.autograd.Variable(n_inners)\\n contents = torch.autograd.Variable(contents)\\n n_level=torch.autograd.Variable(n_level)\\n labels_batch = torch.autograd.Variable(labels_batch) \\n\\n ##-----------------------------\\n # Feedforward pass through the NN\\n output_batch = model(params, levels, children, n_inners, contents, n_level)\\n \\n # compute model output\\n labels_batch = labels_batch.float() #Uncomment if using torch.nn.BCELoss() loss function\\n output_batch=output_batch.view((params.batch_size))\\n loss = loss_fn(output_batch, labels_batch)\\n# print('labels for loss=',labels_batch)\\n# print('y_pred=',output_batch)\\n\\n # extract data from torch Variable, move to cpu, convert to numpy arrays\\n output_batch = output_batch.data.cpu().numpy()\\n labels_batch = labels_batch.data.cpu().numpy()\\n \\n# print('concatenated labels before =', labels)\\n labels=np.concatenate((labels,labels_batch))\\n# print('concatenated labels after =', labels)\\n# print('output_batch[0]=',output_batch[0:4])\\n# print('output_batch shape=',output_batch.shape)\\n\\n# output_batch=output_batch.flatten() \\n out_prob=np.concatenate((out_prob,output_batch))\\n \\n # We calculate a single probability of tagging the image as signal \\n# for i_prob in range(len(output_batch)):\\n# # out_prob.append((output_batch[i_prob][0]-output_batch[i_prob][1]+1)/2)\\n# out_prob.append(output_batch[i_prob][1])\\n\\n# print('Predicted probability of each output neuron = \\\\n',output_batch[0:15])\\n# print('------------'*10)\\n# print('Output of tagging image as signal = \\\\n',np.array(out_prob)[-params.batch_size::])\\n# print('------------'*10)\\n\\n # compute all metrics on this batch\\n summary_batch = {metric: metrics[metric](output_batch, labels_batch)\\n for metric in metrics}\\n summary_batch['loss'] = loss.item()\\n summ.append(summary_batch)\\n \\n ##Get the bg rejection at 30% tag eff: 0.05 + 125*(1 - 0.05)/476=0.3). That's why we pick 125\\n fpr_log, tpr_log, thresholds_log = roc_curve(labels, out_prob,pos_label=1, drop_intermediate=False)\\n base_tpr = np.linspace(0.05, 1, 476)\\n inv_fpr = interp(base_tpr, tpr_log, 1. / fpr_log)[125]\\n# print('inv_fpr at 30% tag eff=',inv_fpr)\\n \\n ##-----------------------------\\n logging.info('Total Labels={}'.format(labels[0:10]))\\n logging.info('Out prob={}'.format(out_prob[0:10]))\\n logging.info('------------'*10)\\n logging.info('len labels after ={}'.format(len(labels)))\\n logging.info('len out_prob after{}'.format(len(out_prob)))\\n \\n # Get fpr, tpr, ROC curve and AUC\\n roc_auc = generate_results(labels, out_prob, params,weights=sample_weights)\\n# generate_results(labels, out_prob, params,weights=sample_weights)\\n \\n ## Save output prob and true values\\n with open(out_files_dir+'yProbTrue_'+str(params.num_epochs)+'_'+sample_filename+'.pkl','wb') as f: pickle.dump(zip(out_prob, labels), f)\\n \\n \\n # compute mean of all metrics in summary\\n metrics_mean = {metric:np.mean([x[metric] for x in summ]) for metric in summ[0]} \\n metrics_string = \\\" ; \\\".join(\\\"{}: {:05.5f}\\\".format(k, v) for k, v in metrics_mean.items())\\n logging.info(\\\"- Eval metrics : \\\" + metrics_string)\\n \\n metrics_mean['auc']=roc_auc \\n metrics_mean['test_bg_reject']=inv_fpr\\n \\n return metrics_mean\",\n \"def evaluate(self) -> Dict[str, Any]:\\n kwargs = {\\\"ids\\\": self._ids}\\n return {\\n metric.value: self._metric_funcs[metric](\\n self._targets, self._preds, **kwargs\\n )\\n for metric in self._metrics\\n }\",\n \"def _compute_running_metrics(self,\\n model_output: torch.Tensor,\\n batch: Tuple[torch.Tensor, torch.Tensor],\\n running_metrics: dict) -> None:\\n for metric in self.metrics:\\n if metric.__name__ == 'word_error_rate' or metric.__name__ == 'character_error_rate':\\n metric_result = metric(model_output, batch, self.decoder)\\n else:\\n metric_result = metric(model_output, batch)\\n if type(metric_result) == torch.Tensor:\\n metric_result = metric_result.item()\\n\\n running_metrics[metric.__name__].append(metric_result)\",\n \"def evaluate(self,\\n x=None,\\n y=None,\\n input_fn=None,\\n feed_fn=None,\\n batch_size=None,\\n steps=None,\\n metrics=None,\\n name=None,\\n checkpoint_path=None,\\n hooks=None):\\n raise NotImplementedError\",\n \"def __call__(self, *args, **kwargs):\\n\\n def replica_local_fn(*args, **kwargs):\\n \\\"\\\"\\\"Updates the state of the metric in a replica-local context.\\\"\\\"\\\"\\n if any(\\n isinstance(arg, keras_tensor.KerasTensor)\\n for arg in nest.flatten((args, kwargs))):\\n update_op = None\\n else:\\n update_op = self.update_state(*args, **kwargs) # pylint: disable=not-callable\\n update_ops = []\\n if update_op is not None:\\n update_ops.append(update_op)\\n with ops.control_dependencies(update_ops):\\n result_t = self.result() # pylint: disable=not-callable\\n\\n # We are adding the metric object as metadata on the result tensor.\\n # This is required when we want to use a metric with `add_metric` API on\\n # a Model/Layer in graph mode. This metric instance will later be used\\n # to reset variable state after each epoch of training.\\n # Example:\\n # model = Model()\\n # mean = Mean()\\n # model.add_metric(mean(values), name='mean')\\n result_t._metric_obj = self # pylint: disable=protected-access\\n return result_t\\n\\n from tensorflow.python.keras.distribute import distributed_training_utils # pylint:disable=g-import-not-at-top\\n return distributed_training_utils.call_replica_local_fn(\\n replica_local_fn, *args, **kwargs)\",\n \"def wrapper(reward_fn,\\n scale: float = 1.0,\\n offset: float = 0.0,\\n done_bonus: float = 0.0,\\n exclude_from_score: bool = False):\\n\\n def fn(*args, **kwargs):\\n reward, done = reward_fn(*args, **kwargs)\\n if exclude_from_score:\\n score = jnp.zeros_like(reward)\\n else:\\n score = reward\\n reward = (reward + offset) * scale\\n score *= jnp.sign(scale)\\n reward = jnp.where(done, x=reward + done_bonus, y=reward)\\n score = jnp.where(done, x=score + done_bonus, y=score)\\n return reward, score, done\\n\\n return fn\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def as_numpy(fn):\\n\\n def metric_fn(y_true, y_pred):\\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\\n new_y_true = y_true.values\\n elif isinstance(y_true, np.ndarray):\\n new_y_true = y_true\\n else:\\n new_y_true = y_true.numpy()\\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\\n new_y_pred = y_pred.values\\n elif isinstance(y_pred, np.ndarray):\\n new_y_pred = y_pred\\n else:\\n new_y_pred = y_pred.numpy()\\n if new_y_true.ndim == 1:\\n new_y_true = np.expand_dims(new_y_true, 1)\\n if new_y_pred.ndim == 1:\\n new_y_pred = np.expand_dims(new_y_pred, 1)\\n return fn(new_y_true, new_y_pred)\\n return metric_fn\",\n \"def run(self,\\n fn: Callable[..., Optional[Dict[str, Any]]],\\n data_generator: Iterable[ArrayTupleOrList],\\n metrics: Union[Sequence[str], type(ALL)] = NOT_SET,\\n excludes: Sequence[str] = (),\\n **kwargs\\n ) -> Optional[Dict[str, Any]]:\\n run_fn = self.run_batches if self.only_batch else self.run_epochs\\n F = lambda: run_fn(\\n fn,\\n data_generator,\\n metrics=metrics,\\n excludes=excludes,\\n **kwargs\\n )\\n if not self._stage.is_active:\\n with self:\\n return F()\\n else:\\n return F()\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def evaluator(evaluate):\\r\\n @functools.wraps(evaluate)\\r\\n def ecspy_evaluator(candidates, args):\\r\\n fitness = []\\r\\n for candidate in candidates:\\r\\n fitness.append(evaluate(candidate, args))\\r\\n return fitness\\r\\n ecspy_evaluator.single_evaluation = evaluate\\r\\n return ecspy_evaluator\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def _wrap_func(fn):\\n\\n @wraps(fn)\\n def wrapper(*arg, **kwargs):\\n results = fn(*arg, **kwargs)\\n return _convert_python_data(results)\\n\\n return wrapper\",\n \"def valuesReducer(aggregation_fn):\\n return partial(reduceWith, aggregation_fn)\",\n \"def _evaluate(self,\\n logits,\\n predictions,\\n data, evaluation_fn,\\n max_eval_batches=None,\\n calculate_scores=True,\\n write_results=False):\\n # counting the evaluation batches\\n num_eval_batches = 0\\n # logits and predictions from the model\\n all_logits = []\\n all_predictions = []\\n # fetched data that led to the predictions\\n # dictionary of {seq_1: [], seq_2: [], target: []}\\n all_fetched_data = collections.defaultdict(list)\\n try:\\n while True:\\n # sample predictions\\n (fetched_logits,\\n fetched_predictions,\\n fetched_data) = self._fetch_data_batch(\\n logits=logits, predictions=predictions, data=data)\\n\\n # Cache the data\\n all_logits += fetched_logits\\n all_predictions += fetched_predictions\\n all_fetched_data[\\\"target\\\"] += fetched_data[\\\"target\\\"]\\n\\n # break the loop if max_eval_batches is set\\n num_eval_batches += 1\\n if (max_eval_batches and\\n num_eval_batches >= max_eval_batches):\\n break\\n\\n except tf.errors.OutOfRangeError:\\n pass\\n\\n # Evaluate\\n scores = None\\n if calculate_scores:\\n scores = evaluation_fn(\\n all_predictions,\\n all_fetched_data[\\\"seq_1\\\"], # Should be empty\\n all_fetched_data[\\\"seq_2\\\"], # Should be empty\\n all_fetched_data[\\\"target\\\"])\\n\\n if write_results:\\n _write_results_to_csv(\\n all_logits,\\n all_predictions,\\n all_fetched_data,\\n output_dir=os.path.join(\\n self._logdir, RESULTS_CSV_FNAME))\\n\\n return len(all_predictions), scores\",\n \"def single_round_model_eval(train_fun, decode_fun, eval_fun, train_set,\\n dev_set, metrics, metrics_weights):\\n assert(len(metrics) > 0)\\n assert(len(metrics) == len(metrics_weights))\\n tf.reset_default_graph()\\n try:\\n train_fun(train_set, dev_set)\\n \\n tf.reset_default_graph()\\n model_dir, decode_sig = decode_fun(dev_set, verbose=False)\\n\\n M = eval_fun(dev_set, model_dir, decode_sig, verbose=False)\\n\\n metrics_value = 0\\n for m, m_w in zip(metrics, metrics_weights):\\n metrics_value += m_w * M[m]\\n except graph_utils.InfPerplexityError:\\n metrics_value = -np.inf\\n\\n return metrics_value\",\n \"def evaluate(self, batch_x, batch_y):\\n raise NotImplementedError()\",\n \"def evaluate(model, optimizer, loss_function, loader, device, labels, log_every_n=10):\\n\\n model.eval()\\n\\n batch_wise_true_labels = []\\n batch_wise_predictions = []\\n\\n loss_history = []\\n running_loss = 0.\\n running_loss_history = []\\n\\n with torch.no_grad(): # Disable gradient computation - required only during training\\n for i, batch in tqdm(enumerate(loader)):\\n\\n logits = model(batch[0].to(device), batch[1]).squeeze()\\n loss = loss_function(logits, batch[2].to(device))\\n loss_history.append(loss.item())\\n\\n running_loss += (loss_history[-1] - running_loss) / (i + 1) # Compute rolling average\\n\\n running_loss_history.append(running_loss)\\n\\n predictions = torch.sigmoid(logits)\\n\\n batch_wise_true_labels.append(batch[2].view(-1).tolist())\\n batch_wise_predictions.append(predictions.view(-1).tolist())\\n\\n # flatten the list of predictions using itertools\\n all_true_labels = list(chain.from_iterable(batch_wise_true_labels))\\n all_predictions = list(chain.from_iterable(batch_wise_predictions))\\n all_predictions = [1 if p > 0.5 else 0 for p in all_predictions]\\n\\n\\n print(\\\"Evaluation Loss: \\\", running_loss)\\n # Now we can generate a classification report\\n print(\\\"Classification report after epoch:\\\")\\n print(f1_score(all_true_labels, all_predictions, average='micro'))\\n print(classification_report(all_true_labels, all_predictions, labels=labels))\\n\\n return loss_history, running_loss_history\",\n \"def add_metric(self, metric_fn):\\n self._metrics.append(metric_fn)\",\n \"def make_loss_fn(\\n cls, config: ml_collections.ConfigDict\\n ) -> Callable[..., Tuple[float, MetricGroups, Dict[str, Any]]]:\\n mlm_weight = config.mlm_weight\\n el_im_weight = config.el_im_weight\\n el_final_weight = config.el_final_weight\\n el_score_mode = config.get('el_score_mode', 'dot')\\n mtb_im_weight = config.get('mtb_im_weight', 0)\\n mtb_final_weight = config.get('mtb_final_weight', 0)\\n mtb_score_mode = config.get('mtb_score_mode', 'dot')\\n\\n def loss_fn(\\n model_config: ml_collections.FrozenConfigDict,\\n model_params: Dict[str, Any],\\n model_vars: Dict[str, Any], # pylint: disable=unused-argument\\n batch: Dict[str, Any],\\n deterministic: bool,\\n dropout_rng: Optional[Dict[str, Array]] = None,\\n ) -> Tuple[float, MetricGroups, Dict[str, Any]]:\\n \\\"\\\"\\\"Task-specific loss function. See BaseTask.\\\"\\\"\\\"\\n\\n batch_size = batch['text_ids'].shape[0]\\n loss_helpers, logging_helpers = cls.build_model(model_config).apply( # pylint: disable=unused-variable\\n {'params': model_params},\\n batch,\\n deterministic=deterministic,\\n rngs=dropout_rng)\\n mention_target_is_masked = batch['mention_target_is_masked']\\n mention_target_is_not_masked = 1 - batch['mention_target_is_masked']\\n mention_target_ids = batch['mention_target_ids']\\n mention_target_ids = mention_target_ids * batch['mention_target_weights']\\n\\n mlm_logits = loss_helpers['mlm_logits']\\n\\n mlm_loss, mlm_denom = metric_utils.compute_weighted_cross_entropy(\\n mlm_logits, batch['mlm_target_ids'], batch['mlm_target_weights'])\\n\\n mlm_correct_mask = jnp.equal(\\n jnp.argmax(mlm_logits, axis=-1),\\n batch['mlm_target_ids']) * batch['mlm_target_weights']\\n mlm_acc = mlm_correct_mask.sum()\\n mlm_mention_acc = (mlm_correct_mask *\\n batch['mlm_target_is_mention']).sum()\\n mlm_mention_denom = (batch['mlm_target_weights'] *\\n batch['mlm_target_is_mention']).sum()\\n mlm_non_mention_acc = (mlm_correct_mask *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n mlm_non_mention_denom = (batch['mlm_target_weights'] *\\n (1 - batch['mlm_target_is_mention'])).sum()\\n\\n metrics = {\\n 'mlm': {\\n 'loss': mlm_loss,\\n 'acc': mlm_acc,\\n 'denominator': mlm_denom,\\n },\\n 'mlm_mention': {\\n 'acc': mlm_mention_acc,\\n 'denominator': mlm_mention_denom,\\n },\\n 'mlm_non_mention': {\\n 'acc': mlm_non_mention_acc,\\n 'denominator': mlm_non_mention_denom,\\n },\\n }\\n\\n if 'intermediate_mention_encodings' in loss_helpers:\\n intermediate_target_mention_encodings = jut.matmul_slice(\\n loss_helpers['intermediate_mention_encodings'],\\n batch['mention_target_indices'])\\n else:\\n intermediate_target_mention_encodings = loss_helpers[\\n 'im_target_mention_encodings']\\n\\n if model_config.encoder_config.get('no_entity_attention', False):\\n (el_im_loss, el_im_metrics,\\n (el_im_acc_per_mention,\\n el_im_weight_per_mention)) = mention_losses.entity_linking_loss(\\n intermediate_target_mention_encodings,\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_im_denom = el_im_metrics['denominator']\\n metrics['el_intermediate'] = el_im_metrics\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_acc_per_mention,\\n el_im_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_im_weight_per_mention, mention_target_is_not_masked),\\n }\\n else:\\n intermediate_entity_attention = loss_helpers[\\n 'intermediate_entity_attention']\\n\\n # Construct targets and ids for intermediate entity linking loss\\n intermediate_target_ids = jnp.zeros_like(batch['mention_mask'])\\n intermediate_target_ids = intermediate_target_ids.at[\\n batch['mention_target_indices']].add(\\n mention_target_ids * batch['mention_target_weights'])\\n\\n intermediate_target_weights = jnp.zeros_like(\\n batch['mention_mask'], dtype=intermediate_entity_attention.dtype)\\n intermediate_target_weights = intermediate_target_weights.at[\\n batch['mention_target_indices']].add(\\n batch['mention_target_weights'])\\n\\n mention_is_masked = jnp.zeros_like(batch['mention_mask'])\\n mention_is_masked = mention_is_masked.at[\\n batch['mention_target_indices']].add(\\n mention_target_is_masked * batch['mention_target_weights'])\\n\\n el_im_loss, el_im_denom = metric_utils.compute_weighted_cross_entropy(\\n intermediate_entity_attention,\\n intermediate_target_ids,\\n intermediate_target_weights,\\n inputs_are_prob=True)\\n\\n el_im_correct_mask = jnp.equal(\\n jnp.argmax(intermediate_entity_attention, axis=-1),\\n intermediate_target_ids) * intermediate_target_weights\\n el_im_acc = el_im_correct_mask.sum()\\n\\n el_im_acc, _ = metric_utils.compute_weighted_accuracy(\\n intermediate_entity_attention, intermediate_target_ids,\\n intermediate_target_weights)\\n\\n intermediate_entity_cos_sim = loss_helpers[\\n 'intermediate_entity_cos_sim'][batch['mention_target_indices'],\\n mention_target_ids]\\n\\n metrics['el_intermediate'] = {\\n 'loss':\\n el_im_loss,\\n 'acc':\\n el_im_acc,\\n 'cos_sim':\\n jnp.dot(intermediate_entity_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n el_im_denom,\\n }\\n metrics['el_intermediate_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, mention_is_masked),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n batch['mention_target_is_masked']),\\n }\\n metrics['el_intermediate_non_masked'] = {\\n 'acc':\\n jnp.dot(el_im_correct_mask, (1 - mention_is_masked)),\\n 'denominator':\\n jnp.dot(batch['mention_target_weights'],\\n (1 - batch['mention_target_is_masked'])),\\n }\\n\\n im_final_mention_encodings_cos_sim = jut.cosine_similarity(\\n intermediate_target_mention_encodings,\\n loss_helpers['target_mention_encodings'])\\n metrics['im_final_mention_encodings'] = {\\n 'cos_sim':\\n jnp.dot(im_final_mention_encodings_cos_sim,\\n batch['mention_target_weights']),\\n 'denominator':\\n batch['mention_target_weights'].sum(),\\n }\\n\\n (el_final_loss, el_final_metrics,\\n (el_final_acc_per_mention,\\n el_final_weight_per_mention)) = mention_losses.entity_linking_loss(\\n loss_helpers['target_mention_encodings'],\\n loss_helpers['entity_embeddings'], mention_target_ids,\\n batch['mention_target_weights'], el_score_mode)\\n el_final_denom = el_final_metrics['denominator']\\n metrics['el_final'] = el_final_metrics\\n metrics['el_final_masked'] = {\\n 'acc':\\n jnp.dot(el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention, mention_target_is_masked),\\n }\\n metrics['el_final_non_masked'] = {\\n 'acc':\\n jnp.dot(\\n el_final_acc_per_mention,\\n el_final_weight_per_mention * mention_target_is_not_masked),\\n 'denominator':\\n jnp.dot(el_final_weight_per_mention,\\n mention_target_is_not_masked),\\n }\\n\\n loss = mlm_weight * mlm_loss / mlm_denom\\n loss += el_im_weight * el_im_loss / el_im_denom\\n loss += el_final_weight * el_final_loss / el_final_denom\\n\\n if mtb_im_weight > 0:\\n (mtb_im_loss, mtb_im_metrics) = mention_losses.mtb_loss(\\n intermediate_target_mention_encodings,\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'im_')\\n mtb_im_denom = mtb_im_metrics['im_mtb']['denominator']\\n loss += mtb_im_weight * mtb_im_loss / mtb_im_denom\\n metrics.update(mtb_im_metrics)\\n\\n if mtb_final_weight > 0:\\n (mtb_final_loss, mtb_final_metrics) = mention_losses.mtb_loss(\\n loss_helpers['target_mention_encodings'],\\n batch['mention_target_batch_positions'], mention_target_ids,\\n batch_size, mtb_score_mode, mention_target_is_masked, 'final_')\\n mtb_final_denom = mtb_final_metrics['final_mtb']['denominator']\\n loss += mtb_final_weight * mtb_final_loss / mtb_final_denom\\n metrics.update(mtb_final_metrics)\\n\\n metrics['agg'] = {\\n 'loss': loss,\\n 'denominator': 1.0,\\n }\\n return loss, metrics, {} # pytype: disable=bad-return-type # jax-ndarray\\n\\n return loss_fn\",\n \"def evaluate(self, dataset, metric='auto', verbose=True, batch_size=64):\\n if(batch_size < 1):\\n raise ValueError(\\\"'batch_size' must be greater than or equal to 1\\\")\\n\\n extracted_features = self._extract_features(dataset, verbose=verbose, batch_size=batch_size)\\n extracted_features[self.target] = dataset[self.target]\\n return self.classifier.evaluate(extracted_features, metric = metric)\",\n \"def _get_eval_metric(self):\\n raise NotImplementedError\",\n \"def evaluate(self, model_idx,\\n max_eval_batches=None,\\n write_results=False,\\n write_to_summary=True):\\n \\n # write_summary needs global_step\\n self._step_collections[\\\"GlobalStep\\\"] = (\\n self._sess.run(self._global_step_tensor))\\n\\n # evaluate the model\\n model_name = \\\"%s-%d\\\" % (self._names[model_idx], model_idx)\\n counts, scores = self._evaluate(\\n data=self._data[model_idx],\\n logits=self._logits_collections[model_idx],\\n predictions=self._predictions_collections[model_idx],\\n evaluation_fn=self._evaluation_fns[model_idx],\\n max_eval_batches=max_eval_batches,\\n calculate_scores=True,\\n write_results=write_results)\\n\\n # write summary\\n if write_to_summary:\\n self.write_summary(\\n \\\"TASK-%s/ValScores\\\" % model_name, scores)\\n\\n return {\\\"MAIN\\\": scores}\",\n \"def make_eval_step(self):\\n def eval_step(model, example):\\n with flax.deprecated.nn.stateful() as state:\\n logits = model(example, train=False)\\n if self.info.supervised_keys[-1] == 'error_type':\\n targets = example['error_type'][:, None]\\n else:\\n targets = example['target_output']\\n state = {k: v['tag'] for k, v in state.as_dict().items()}\\n return self.compute_metrics(logits, targets, None), logits, state\\n\\n return eval_step\",\n \"def _evaluate(self, training_state, val_iter, val_metric):\\n val_iter.reset()\\n val_metric.reset()\\n\\n for nbatch, eval_batch in enumerate(val_iter):\\n self.module.forward(eval_batch, is_train=False)\\n self.module.update_metric(val_metric, eval_batch.label)\\n\\n for name, val in val_metric.get_name_value():\\n logger.info('Checkpoint [%d]\\\\tValidation-%s=%f', training_state.checkpoint, name, val)\\n\\n return self.training_monitor.eval_end_callback(training_state.checkpoint, val_metric)\",\n \"def metrics_collector(func):\\n @functools.wraps(func)\\n def wrapper_timer(*args, **kwargs):\\n start_time = perf_counter()\\n value = func(*args, **kwargs)\\n end_time = perf_counter()\\n run_time = (end_time - start_time) * 1000 # convert to milliseconds\\n run_time = int(run_time) # we'll lose some accuracy here, but I think it's negligible\\n if 'metrics' not in g:\\n g.metrics = []\\n g.metrics.append({\\n func.__name__: run_time\\n })\\n return value\\n return wrapper_timer\",\n \"def get_min_or_max_values(metrics: dict, global_metrics: dict, fn2) -> dict:\\n for ds_name in metrics:\\n if ds_name not in global_metrics:\\n global_metrics[ds_name] = {}\\n\\n feature_metrics = metrics[ds_name]\\n for feature_name in feature_metrics:\\n if feature_name not in global_metrics[ds_name]:\\n global_metrics[ds_name][feature_name] = feature_metrics[feature_name]\\n else:\\n global_metrics[ds_name][feature_name] = fn2(\\n global_metrics[ds_name][feature_name], feature_metrics[feature_name]\\n )\\n\\n results = {}\\n for ds_name in global_metrics:\\n for feature_name in global_metrics[ds_name]:\\n if feature_name not in results:\\n results[feature_name] = global_metrics[ds_name][feature_name]\\n else:\\n results[feature_name] = fn2(results[feature_name], global_metrics[ds_name][feature_name])\\n\\n for ds_name in global_metrics:\\n for feature_name in global_metrics[ds_name]:\\n global_metrics[ds_name][feature_name] = results[feature_name]\\n\\n return global_metrics\",\n \"def evaluate():\\n\\t\\t\\t\\tif not hasattr(evaluate, 'value'):\\n\\t\\t\\t\\t\\tevaluate.value = func()\\n\\t\\t\\t\\treturn evaluate.value\",\n \"def function(self, scores, multilabel):\\n\\n # Output functions\\n # pylint: disable=C3001\\n identity = lambda x: x\\n sigmoid = lambda x: 1.0 / (1.0 + np.exp(-x))\\n softmax = lambda x: np.exp(x) / np.sum(np.exp(x))\\n function = identity if multilabel is None else sigmoid if multilabel else softmax\\n\\n # Apply output function\\n return function(np.array(scores))\",\n \"def test(self, test_fn, eval_metrics):\\n # Load gold and predict\\n X, Y = self.load_dataset(test_fn)\\n y = self.model.predict(X)\\n\\n # Get most probable predictions and flatten\\n Y = RNN_model.consolidate_labels(self.transform_output_probs(Y).flatten())\\n y = RNN_model.consolidate_labels(self.transform_output_probs(y).flatten())\\n\\n # Run evaluation metrics and report\\n # TODO: is it possible to compare without the padding?\\n ret = []\\n for (metric_name, metric_func) in eval_metrics:\\n ret.append((metric_name, metric_func(Y, y)))\\n logging.debug(\\\"calculating {}\\\".format(ret[-1]))\\n\\n for (metric_name, metric_val) in ret:\\n logging.info(\\\"{}: {:.4f}\\\".format(metric_name,\\n metric_val))\\n return Y, y, ret\",\n \"def eval_step(total_loss):\\n inputs = dequeue_fn()\\n features, labels = inputs.features_and_labels()\\n\\n tpu_estimator_spec = self._call_model_fn(features, labels)\\n if not isinstance(tpu_estimator_spec, TPUEstimatorSpec):\\n raise RuntimeError(\\n 'estimator_spec used by TPU evaluation must have type'\\n '`TPUEstimatorSpec`. Got {}'.format(type(tpu_estimator_spec)))\\n\\n loss = tpu_estimator_spec.loss\\n captured_scaffold_fn.capture(tpu_estimator_spec.scaffold_fn)\\n to_record = {}\\n to_record['eval_metrics'] = tpu_estimator_spec.eval_metrics\\n if tpu_estimator_spec.host_call is not None:\\n # We assume that evaluate won't update global step, so we don't wrap\\n # this host_call.\\n to_record['host_call'] = tpu_estimator_spec.host_call\\n host_calls.record(to_record)\\n\\n with ops.control_dependencies(host_calls.create_enqueue_op()):\\n return math_ops.add(total_loss, loss)\",\n \"def evaluate(problem, batch_size, inference_fn, optimizer, model_dir=None):\\n logging.info(\\n 'Evaluating.\\\\nOperative config:\\\\n%s' % gin.operative_config_str())\\n if model_dir is None:\\n model_dir = default_model_dir()\\n if model_dir is not None:\\n model_dir = os.path.expanduser(model_dir)\\n if not os.path.isdir(model_dir):\\n raise RuntimeError('model_dir does not exist: %s' % model_dir)\\n\\n val_ds = problem.get_dataset('validation', batch_size)\\n inputs = tf.nest.map_structure(\\n lambda shape, dtype: tf.keras.layers.Input(\\n shape=shape[1:], dtype=dtype),\\n val_ds.output_shapes[0], val_ds.output_types[0])\\n outputs = inference_fn(inputs, problem.output_spec())\\n model = _model(inputs, outputs)\\n model.compile(\\n optimizer=optimizer,\\n loss=problem.loss,\\n metrics=problem.metrics)\\n\\n cb.restore_model(model, model_dir)\\n validation_steps = batch_steps(\\n problem.examples_per_epoch('validation'), batch_size)\\n \\n val_ds = val_ds.map(lambda x, y: (tuple(tf.nest.flatten(x)), y))\\n\\n logging.info('Running evaluation for %d steps' % validation_steps)\\n return model.evaluate(val_ds, steps=validation_steps)\",\n \"def evaluate_wrapper(func):\\n @wraps(func)\\n def wrapper(self, blackboard):\\n if self.state == EvaluationState.ready:\\n self.on_enter()\\n\\n state = func(self, blackboard)\\n self.state = state\\n\\n if state != EvaluationState.running:\\n self.on_exit()\\n\\n return state\\n\\n return wrapper\",\n \"def _evaluate_async(\\n self,\\n duration_fn: Optional[Callable[[int], int]] = None,\\n ) -> dict:\\n # How many episodes/timesteps do we need to run?\\n # In \\\"auto\\\" mode (only for parallel eval + training): Run as long\\n # as training lasts.\\n unit = self.config.evaluation_duration_unit\\n eval_cfg = self.evaluation_config\\n rollout = eval_cfg.rollout_fragment_length\\n num_envs = eval_cfg.num_envs_per_worker\\n auto = self.config.evaluation_duration == \\\"auto\\\"\\n duration = (\\n self.config.evaluation_duration\\n if not auto\\n else (self.config.evaluation_num_workers or 1)\\n * (1 if unit == \\\"episodes\\\" else rollout)\\n )\\n\\n # Call the `_before_evaluate` hook.\\n self._before_evaluate()\\n\\n # TODO(Jun): Implement solution via connectors.\\n self._sync_filters_if_needed(\\n central_worker=self.workers.local_worker(),\\n workers=self.evaluation_workers,\\n config=eval_cfg,\\n )\\n\\n if self.config.custom_evaluation_function:\\n raise ValueError(\\n \\\"`config.custom_evaluation_function` not supported in combination \\\"\\n \\\"with `enable_async_evaluation=True` config setting!\\\"\\n )\\n if self.evaluation_workers is None and (\\n self.workers.local_worker().input_reader is None\\n or self.config.evaluation_num_workers == 0\\n ):\\n raise ValueError(\\n \\\"Evaluation w/o eval workers (calling Algorithm.evaluate() w/o \\\"\\n \\\"evaluation specifically set up) OR evaluation without input reader \\\"\\n \\\"OR evaluation with only a local evaluation worker \\\"\\n \\\"(`evaluation_num_workers=0`) not supported in combination \\\"\\n \\\"with `enable_async_evaluation=True` config setting!\\\"\\n )\\n\\n agent_steps_this_iter = 0\\n env_steps_this_iter = 0\\n\\n logger.info(f\\\"Evaluating current state of {self} for {duration} {unit}.\\\")\\n\\n all_batches = []\\n\\n # Default done-function returns True, whenever num episodes\\n # have been completed.\\n if duration_fn is None:\\n\\n def duration_fn(num_units_done):\\n return duration - num_units_done\\n\\n # Put weights only once into object store and use same object\\n # ref to synch to all workers.\\n self._evaluation_weights_seq_number += 1\\n weights_ref = ray.put(self.workers.local_worker().get_weights())\\n weights_seq_no = self._evaluation_weights_seq_number\\n\\n def remote_fn(worker):\\n # Pass in seq-no so that eval workers may ignore this call if no update has\\n # happened since the last call to `remote_fn` (sample).\\n worker.set_weights(\\n weights=ray.get(weights_ref), weights_seq_no=weights_seq_no\\n )\\n batch = worker.sample()\\n metrics = worker.get_metrics()\\n return batch, metrics, weights_seq_no\\n\\n rollout_metrics = []\\n\\n # How many episodes have we run (across all eval workers)?\\n num_units_done = 0\\n _round = 0\\n\\n while self.evaluation_workers.num_healthy_remote_workers() > 0:\\n units_left_to_do = duration_fn(num_units_done)\\n if units_left_to_do <= 0:\\n break\\n\\n _round += 1\\n # Get ready evaluation results and metrics asynchronously.\\n self.evaluation_workers.foreach_worker_async(\\n func=remote_fn,\\n healthy_only=True,\\n )\\n eval_results = self.evaluation_workers.fetch_ready_async_reqs()\\n\\n batches = []\\n i = 0\\n for _, result in eval_results:\\n batch, metrics, seq_no = result\\n # Ignore results, if the weights seq-number does not match (is\\n # from a previous evaluation step) OR if we have already reached\\n # the configured duration (e.g. number of episodes to evaluate\\n # for).\\n if seq_no == self._evaluation_weights_seq_number and (\\n i * (1 if unit == \\\"episodes\\\" else rollout * num_envs)\\n < units_left_to_do\\n ):\\n batches.append(batch)\\n rollout_metrics.extend(metrics)\\n i += 1\\n\\n _agent_steps = sum(b.agent_steps() for b in batches)\\n _env_steps = sum(b.env_steps() for b in batches)\\n\\n # 1 episode per returned batch.\\n if unit == \\\"episodes\\\":\\n num_units_done += len(batches)\\n # Make sure all batches are exactly one episode.\\n for ma_batch in batches:\\n ma_batch = ma_batch.as_multi_agent()\\n for batch in ma_batch.policy_batches.values():\\n assert batch.is_terminated_or_truncated()\\n # n timesteps per returned batch.\\n else:\\n num_units_done += (\\n _agent_steps\\n if self.config.count_steps_by == \\\"agent_steps\\\"\\n else _env_steps\\n )\\n\\n if self.reward_estimators:\\n all_batches.extend(batches)\\n\\n agent_steps_this_iter += _agent_steps\\n env_steps_this_iter += _env_steps\\n\\n logger.info(\\n f\\\"Ran round {_round} of parallel evaluation \\\"\\n f\\\"({num_units_done}/{duration if not auto else '?'} \\\"\\n f\\\"{unit} done)\\\"\\n )\\n\\n sampler_results = summarize_episodes(\\n rollout_metrics,\\n keep_custom_metrics=eval_cfg[\\\"keep_per_episode_custom_metrics\\\"],\\n )\\n\\n # TODO: Don't dump sampler results into top-level.\\n metrics = dict({\\\"sampler_results\\\": sampler_results}, **sampler_results)\\n\\n metrics[NUM_AGENT_STEPS_SAMPLED_THIS_ITER] = agent_steps_this_iter\\n metrics[NUM_ENV_STEPS_SAMPLED_THIS_ITER] = env_steps_this_iter\\n # TODO: Remove this key at some point. Here for backward compatibility.\\n metrics[\\\"timesteps_this_iter\\\"] = env_steps_this_iter\\n\\n if self.reward_estimators:\\n # Compute off-policy estimates\\n metrics[\\\"off_policy_estimator\\\"] = {}\\n total_batch = concat_samples(all_batches)\\n for name, estimator in self.reward_estimators.items():\\n estimates = estimator.estimate(total_batch)\\n metrics[\\\"off_policy_estimator\\\"][name] = estimates\\n\\n # Evaluation does not run for every step.\\n # Save evaluation metrics on Algorithm, so it can be attached to\\n # subsequent step results as latest evaluation result.\\n self.evaluation_metrics = {\\\"evaluation\\\": metrics}\\n\\n # Trigger `on_evaluate_end` callback.\\n self.callbacks.on_evaluate_end(\\n algorithm=self, evaluation_metrics=self.evaluation_metrics\\n )\\n\\n # Return evaluation results.\\n return self.evaluation_metrics\",\n \"def _get_val_metrics(\\n self,\\n ) -> Tuple[_Metrics, torch.Tensor, torch.Tensor, torch.Tensor]:\\n # Turn off batch-norm updates\\n self.model.eval()\\n\\n with torch.no_grad():\\n metrics = _Metrics()\\n\\n for val_img, val_gt in tqdm(\\n self.val_loader, desc=\\\"Validating\\\", leave=False\\n ):\\n val_img = val_img.to(self.device)\\n val_gt = val_gt.to(self.device)\\n\\n with autocast(enabled=self.config.mixed_precision):\\n val_pred = self.model(val_img)[0]\\n metrics.class_loss += self.class_loss_fn(val_pred, val_gt)\\n\\n metrics.accuracy += self._get_acc(val_pred, val_gt)\\n metrics.f1_score += self._get_f1(val_pred, val_gt)\\n\\n metrics.class_loss /= len(self.val_loader)\\n metrics.accuracy /= len(self.val_loader)\\n metrics.f1_score /= len(self.val_loader)\\n\\n return metrics, val_img, val_gt, torch.sigmoid(val_pred)\",\n \"def _evaluate(self, indices, split, session, summary_writer):\\n data_iterator_val = batch_iterator(\\n indices,\\n batch_size=self.batch_size,\\n shuffle=False,\\n allow_smaller_batch=True,\\n repeat=False)\\n feed_dict_val = self._construct_feed_dict(data_iterator_val, split)\\n cummulative_acc = 0.0\\n num_samples = 0\\n while feed_dict_val is not None:\\n val_acc, batch_size_actual = session.run(\\n (self.accuracy, self.batch_size_actual), feed_dict=feed_dict_val)\\n cummulative_acc += val_acc * batch_size_actual\\n num_samples += batch_size_actual\\n feed_dict_val = self._construct_feed_dict(data_iterator_val, split)\\n if num_samples > 0:\\n cummulative_acc /= num_samples\\n\\n if self.enable_summaries:\\n summary = tf.Summary()\\n summary.value.add(\\n tag='ClassificationModel/' + split + '_acc',\\n simple_value=cummulative_acc)\\n iter_cls_total = session.run(self.iter_cls_total)\\n summary_writer.add_summary(summary, iter_cls_total)\\n summary_writer.flush()\\n\\n return cummulative_acc\",\n \"def get_validation_fn(\\n test_dataset: tf.data.Dataset,\\n model_fn: Callable[[], tf.keras.models.Model],\\n loss_fn: Callable[[], tf.keras.losses.Loss],\\n metrics_fn: Callable[[], tf.keras.metrics.Metric],\\n) -> Callable[[], tf.data.Dataset]:\\n\\n def compiled_model() -> tf.keras.Model:\\n val_model = model_fn()\\n val_model.compile(\\n loss=loss_fn(), optimizer=tf.keras.optimizers.Adam(), metrics=metrics_fn()\\n )\\n return val_model\\n\\n test_dataset = _convert_fn(test_dataset)\\n\\n def validation_fn(\\n trained_model: tff.learning.Model,\\n ) -> Callable[[], tf.data.Dataset]:\\n val_model = compiled_model()\\n trained_model_weights = tff.learning.ModelWeights(\\n trainable=list(trained_model.trainable),\\n non_trainable=list(trained_model.non_trainable),\\n )\\n\\n trained_model_weights.assign_weights_to(val_model)\\n metrics = val_model.evaluate(test_dataset, verbose=0)\\n return dict(\\n zip(val_model.metrics_names, val_model.evaluate(test_dataset, verbose=0))\\n )\\n\\n return validation_fn\",\n \"def evaluate(model, loss, val_iterator):\\n\\n # Initializing parameters\\n loss_value = 0.0\\n accuracy = 0.0\\n total_samples = 0\\n\\n with torch.no_grad():\\n\\n # Iterating over validation dataloader\\n for data, labels in val_iterator:\\n\\n # Resetting variables for calculating current batch accuracy\\n correct = 0\\n total = 0\\n\\n # Map data to GPU if available\\n if use_cuda:\\n data = data.cuda()\\n labels = labels.cuda(non_blocking=True)\\n\\n n_batch_samples = labels.size()[0]\\n logits = model(data)\\n\\n # Compute batch loss\\n batch_loss = loss(logits, labels)\\n\\n # Compute batch accuracy\\n _, predicted = logits.max(1)\\n total += labels.size(0)\\n correct += predicted.eq(labels).sum().item()\\n batch_accuracy = 100. * correct / total\\n\\n # Summing up batch losses and accuracies over each step\\n loss_value += batch_loss.float() * n_batch_samples\\n accuracy += batch_accuracy * n_batch_samples\\n total_samples += n_batch_samples\\n\\n return loss_value / total_samples, accuracy / total_samples\",\n \"def _combine_eval(self, all_model_fn_ops):\\n predictions = {}\\n metrics = {}\\n losses = []\\n for head, m in zip(self._heads, all_model_fn_ops):\\n losses.append(m.loss)\\n head_name = head.head_name\\n for k, v in m.predictions.items():\\n predictions[(head_name, k)] = v\\n for k, v in m.eval_metric_ops.items():\\n # metrics[\\\"%s/%s\\\" % (k, head_name)] = v\\n metrics[k] = v\\n loss = self._loss_combiner(losses)\\n\\n return model_fn.ModelFnOps(\\n mode=model_fn.ModeKeys.EVAL,\\n predictions=predictions,\\n loss=loss,\\n eval_metric_ops=metrics)\",\n \"def evaluate(\\n self,\\n results,\\n metric=\\\"mAP\\\",\\n logger=None,\\n proposal_nums=(100, 300, 1000),\\n iou_thr=0.75,\\n scale_ranges=None,\\n ):\\n\\n if not isinstance(metric, str):\\n assert len(metric) == 1\\n metric = metric[0]\\n allowed_metrics = [\\\"mAP\\\", \\\"recall\\\"]\\n if metric not in allowed_metrics:\\n raise KeyError(f\\\"metric {metric} is not supported\\\")\\n annotations = [self.get_ann_info(i) for i in range(len(self))]\\n eval_results = {}\\n\\n if metric == \\\"mAP\\\":\\n assert isinstance(iou_thr, float)\\n ds_name = list(self.class_names)\\n mean_ap, _ = eval_map(\\n results,\\n annotations,\\n scale_ranges=None,\\n iou_thr=iou_thr,\\n dataset=ds_name,\\n logger=logger,\\n )\\n eval_results[\\\"mAP\\\"] = mean_ap\\n\\n elif metric == \\\"recall\\\":\\n gt_bboxes = [ann[\\\"bboxes\\\"] for ann in annotations]\\n if isinstance(iou_thr, float):\\n iou_thr = [iou_thr]\\n recalls = eval_recalls(\\n gt_bboxes, results, proposal_nums, iou_thr, logger=logger\\n )\\n for i, num in enumerate(proposal_nums):\\n for j, iou in enumerate(iou_thr):\\n eval_results[f\\\"recall@{num}@{iou}\\\"] = recalls[i, j]\\n if recalls.shape[1] > 1:\\n ar = recalls.mean(axis=1)\\n for i, num in enumerate(proposal_nums):\\n eval_results[f\\\"AR@{num}\\\"] = ar[i]\\n\\n return eval_results\",\n \"def joblib_batch_evaluator(\\n func,\\n arguments,\\n *,\\n n_cores=N_CORES,\\n error_handling=\\\"continue\\\",\\n unpack_symbol=None,\\n):\\n _check_inputs(func, arguments, n_cores, error_handling, unpack_symbol)\\n n_cores = int(n_cores) if int(n_cores) >= 2 else 1\\n\\n reraise = error_handling == \\\"raise\\\"\\n\\n @unpack(symbol=unpack_symbol)\\n @catch(default=\\\"__traceback__\\\", reraise=reraise)\\n def internal_func(*args, **kwargs):\\n return func(*args, **kwargs)\\n\\n if n_cores == 1:\\n res = [internal_func(arg) for arg in arguments]\\n else:\\n res = Parallel(n_jobs=n_cores)(delayed(internal_func)(arg) for arg in arguments)\\n\\n return res\",\n \"def evaluate(self, prediction_fn):\\n pass\",\n \"def evaluate(self, X, y, metric='accuracy', get_loss=True, **kwargs):\\n if metric is None:\\n raise ValueError(\\\"Please specify a metric\\\") \\n scorer = get_scorer(metric)\\n \\n scores = {}\\n for name, y_pred in self.predict(X): \\n score = scorer(y, y_pred) \\n scores[name] = {'score': np.round(score, decimals=4), 'loss': 'N/A'} \\n \\n if get_loss:\\n log_loss = get_scorer('log_loss') \\n for name, proba in self.predict_proba(X): \\n try:\\n loss = log_loss(y, proba)\\n scores[name]['loss'] = np.round(loss, decimals=4)\\n except:\\n scores[name]['loss'] = np.nan\\n warnings.warn(\\\"Could not compute loss for {}\\\"\\n .format(name), RuntimeWarning) \\n if self.verbose>0:\\n for name, score in scores.items():\\n print(\\\"{0:18} {1}\\\".format(name+\\\":\\\", \\\", \\\".join(\\n [\\\"{}={}\\\".format(k,v) for k,v in score.items()])),\\n end=\\\"\\\\n{}\\\\n\\\".format(\\\"-\\\" * 45))\\n return scores\",\n \"def evaluate(self, eval_data, eval_labels, eval_input_fn=\\\"default\\\"):\\n # Validations:\\n # If it is of type str, make sure is a valid\\n if isinstance(eval_input_fn, str):\\n # We use a list in case we want to extend in the future.\\n if eval_input_fn in [\\\"default\\\"]:\\n if eval_input_fn == \\\"default\\\":\\n # pylint: disable=no-member\\n eval_input_fn = tf.estimator.inputs.numpy_input_fn(\\n x={\\\"x\\\": eval_data},\\n y=eval_labels,\\n num_epochs=1,\\n shuffle=False\\n )\\n\\n eval_res = self.classifier.evaluate(input_fn=eval_input_fn)\\n return eval_res\",\n \"def make_acquisition_function(handle_multioutput=\\\"mean\\\"):\\n\\n def decorator(fn):\\n if handle_multioutput == \\\"mean\\\": # define fn where scores are avgd\\n\\n @functools.wraps(fn)\\n def wrapped_fn(probabilities, shuffle_prop=0.1):\\n if _is_multioutput(probabilities):\\n scores = np.stack(\\n tuple(fn(prob) for prob in probabilities), axis=0\\n ).mean(axis=0)\\n else:\\n scores = fn(probabilities)\\n return _get_indices(scores, shuffle_prop)\\n\\n else: # raise error if list is passed\\n\\n @functools.wraps(fn)\\n def wrapped_fn(probabilities, shuffle_prop=0.1):\\n if _is_multioutput(probabilities):\\n raise ValueError(\\n \\\"The input probabilities is a list of arrays, \\\"\\n + \\\"indicating multi-label output. \\\"\\n + \\\"The {} function \\\".format(fn.__name__)\\n + \\\"is not defined for these outputs. Use \\\"\\n + \\\"the acquisition functions margin or certainty \\\"\\n + \\\"instead.\\\"\\n )\\n else:\\n scores = fn(probabilities)\\n return _get_indices(scores, shuffle_prop)\\n\\n return wrapped_fn\\n\\n return decorator\",\n \"def adapt_tf_streaming_metric_for_keras(tf_metric, name,\\n preprocss_fn=None, postprocess_fn=None,\\n **kwargs):\\n\\n # Inspired from snipped by Ruzhitskiy Bogdan\\n # (https://github.com/keras-team/keras/issues/6050#issuecomment-329996505)\\n def metric(y_true, y_pred):\\n \\\"\\\"\\\" Wrap a TF metric, instantiating hidden variables + updating hidden states\\\"\\\"\\\"\\n\\n # First we define the metric operation:\\n value, update_op = tf_metric(y_true, y_pred, **kwargs)\\n\\n # It is possible that the metric is relying on some local variables,\\n # that we should then initialize them:\\n initialize_variables()\\n\\n # Finally, we force the update of the metric values:\\n with tf.control_dependencies([update_op]):\\n value = tf.identity(value)\\n return value\\n\\n def metric_with_pre_and_post_processing(y_true, y_pred):\\n \\\"\\\"\\\" Wrapper to pre/post-process the data\\\"\\\"\\\"\\n\\n if preprocss_fn is not None:\\n y_true, y_pred = preprocss_fn(y_true, y_pred)\\n\\n value = metric(y_true, y_pred)\\n\\n if postprocess_fn is not None:\\n value = postprocess_fn(y_true, y_pred, value)\\n\\n return value\\n\\n metric_with_pre_and_post_processing.__name__ = name\\n\\n return metric_with_pre_and_post_processing\",\n \"def process_function(engine: Engine, batch: Tuple[torch.Tensor, torch.Tensor, List[int]]) -> \\\\\\n Tuple[float, torch.Tensor, torch.Tensor]:\\n model.train()\\n optimizer.zero_grad()\\n x, y, lengths = batch\\n x, y = x.to(model.device), y.to(model.device)\\n y_pred: torch.Tensor = model(x, lengths)\\n loss: torch.Tensor = loss_fn(y_pred, y)\\n loss.backward()\\n optimizer.step()\\n return loss.item(), torch.max(y_pred, dim=1)[1], y\",\n \"def test(self,test_fn, eval_metrics):\\n # Load gold and predict\\n X, Y = self.load_dataset(test_fn)\\n y = self.model.predict(X)\\n\\n # Get most probable predictions and flatten\\n Y = RNNOIE_model.consolidate_labels(self.transform_output_probs(Y).flatten())\\n y = RNNOIE_model.consolidate_labels(self.transform_output_probs(y).flatten())\\n\\n # Run evaluation metrics and report\\n # TODO: is it possible to compare without the padding?\\n ret = []\\n for (metric_name, metric_func) in eval_metrics:\\n ret.append((metric_name, metric_func(Y, y)))\\n # logging.debug(\\\"calculating {}\\\".format(ret[-1]))\\n\\n for (metric_name, metric_val) in ret:\\n logging.info(\\\"{}: {:.4f}\\\".format(metric_name,\\n metric_val))\\n return Y, y, ret\",\n \"def _get_batch_fn(dataset):\\n def get_batch(idx):\\n x_bat = dataset['input'][idx]\\n y_bat = dataset['label'][idx]\\n x_bat, y_bat = preprocess(x_bat, y_bat)\\n\\n return x_bat, y_bat\\n\\n return get_batch\",\n \"def build_multi_task_metric_func(dataset_split_name, add_summary=True):\\n\\n def multi_task_metric_func(labels, logits):\\n \\\"\\\"\\\"Generates metrics operations for multi-task evaluation.\\n\\n Args:\\n labels: A dictionary of task name to label tensors of shape [num_examples,\\n 1].\\n logits: A dictionary of task name to logit tensors of shape [num_examples,\\n num_classes].\\n\\n Raises:\\n ValueError if labels and logits do not have the same keys.\\n\\n Returns:\\n A dictionary of key to metrics operation.\\n \\\"\\\"\\\"\\n if labels.keys() != logits.keys():\\n raise ValueError('Task names are different for labels and logits.')\\n metric_ops = {}\\n for task_name, label in labels.items():\\n accuracy_metric_name = '{}/Eval/Accuracy/{}'.format(\\n task_name, dataset_split_name)\\n metric_ops[accuracy_metric_name] = tf.metrics.accuracy(\\n label,\\n tf.argmax(logits[task_name], 1),\\n weights=build_weight_for_label(label))\\n\\n if add_summary:\\n for name, value in metric_ops.items():\\n tf.summary.scalar(name, value)\\n return metric_ops\\n\\n return multi_task_metric_func\",\n \"def make_metric_fn(*names):\\n\\n def metric_fn(*args):\\n return {name: tf.metrics.mean(vec) for name, vec in zip(names, args)}\\n\\n return metric_fn\",\n \"def _create_default_metrics_eval_func(self, grid_points):\\n eval_func = set([self._get_default_eval_func(point.metrics) for point in grid_points])\\n if len(eval_func) != 1:\\n raise RuntimeError(\\\"Error in retrieving evaluation function\\\")\\n return list(eval_func)[0]\",\n \"def evaluate(self) -> Dict[str, float]:\\n eval_dataloader = self.get_eval_dataloader()\\n\\n output = self._prediction_loop(eval_dataloader, description=\\\"Evaluation\\\")\\n return output.metrics\",\n \"def _get_step_fn(self) -> Callable:\\n\\n def loss_fn(\\n params: frozen_dict.FrozenDict,\\n apply_fn: Callable,\\n batch: Dict[str, jnp.ndarray],\\n ) -> Tuple[float, Dict[str, float]]:\\n \\\"\\\"\\\"Loss function.\\\"\\\"\\\"\\n # map samples with the fitted map\\n mapped_samples = apply_fn({\\\"params\\\": params}, batch[\\\"source\\\"])\\n\\n # compute the loss\\n val_fitting_loss = self.fitting_loss(batch[\\\"target\\\"], mapped_samples)\\n val_regularizer = self.regularizer(batch[\\\"source\\\"], mapped_samples)\\n val_tot_loss = (\\n val_fitting_loss + self.regularizer_strength * val_regularizer\\n )\\n\\n # store training logs\\n loss_logs = {\\n \\\"total_loss\\\": val_tot_loss,\\n \\\"fitting_loss\\\": val_fitting_loss,\\n \\\"regularizer\\\": val_regularizer\\n }\\n\\n return val_tot_loss, loss_logs\\n\\n @functools.partial(jax.jit, static_argnums=3)\\n def step_fn(\\n state_neural_net: train_state.TrainState,\\n train_batch: Dict[str, jnp.ndarray],\\n valid_batch: Optional[Dict[str, jnp.ndarray]] = None,\\n is_logging_step: bool = False,\\n ) -> Tuple[train_state.TrainState, Dict[str, float]]:\\n \\\"\\\"\\\"Step function.\\\"\\\"\\\"\\n # compute loss and gradients\\n grad_fn = jax.value_and_grad(loss_fn, argnums=0, has_aux=True)\\n (_, current_train_logs), grads = grad_fn(\\n state_neural_net.params, state_neural_net.apply_fn, train_batch\\n )\\n\\n # logging step\\n current_logs = {\\\"train\\\": current_train_logs, \\\"eval\\\": {}}\\n if is_logging_step:\\n _, current_eval_logs = loss_fn(\\n params=state_neural_net.params,\\n apply_fn=state_neural_net.apply_fn,\\n batch=valid_batch\\n )\\n current_logs[\\\"eval\\\"] = current_eval_logs\\n\\n # update state\\n return state_neural_net.apply_gradients(grads=grads), current_logs\\n\\n return step_fn\",\n \"def eval_function(engine: Engine, batch: Tuple[torch.Tensor, torch.Tensor, List[int]]) -> \\\\\\n Tuple[torch.Tensor, torch.Tensor]:\\n model.eval()\\n with torch.no_grad():\\n x, y, lengths = batch\\n x, y = x.to(model.device), y.to(model.device)\\n y_pred: torch.Tensor = model(x, lengths)\\n return y_pred, y\",\n \"def evaluate(self):\\n results = dict()\\n for metric in self.metrics:\\n print('Evaluating clustering with metric %s' % metric)\\n if metric in LABEL_METRICS.keys():\\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\\n self.results = results\\n return results\",\n \"def evaluate(self, eval_data, eval_labels, eval_input_fn):\\n raise NotImplementedError(\\\"Method must be implemented by subclass\\\")\",\n \"def next_fn(global_state, value, weight=None):\\n # Weighted aggregation is not supported.\\n # TODO(b/140236959): Add an assertion that weight is None here, so the\\n # contract of this method is better established. Will likely cause some\\n # downstream breaks.\\n del weight\\n\\n #######################################\\n # Define local tf_computations\\n\\n # TODO(b/129567727): Make most of these tf_computations polymorphic\\n # so type manipulation isn't needed.\\n\\n global_state_type = initialize_fn.type_signature.result\\n\\n @computations.tf_computation(global_state_type)\\n def derive_sample_params(global_state):\\n return query.derive_sample_params(global_state)\\n\\n @computations.tf_computation(derive_sample_params.type_signature.result,\\n value.type_signature.member)\\n def preprocess_record(params, record):\\n # TODO(b/123092620): Once TFF passes the expected container type (instead\\n # of AnonymousTuple), we shouldn't need this.\\n record = from_tff_result_fn(record)\\n\\n return query.preprocess_record(params, record)\\n\\n # TODO(b/123092620): We should have the expected container type here.\\n value_type = value_type_fn(value)\\n\\n tensor_specs = type_conversions.type_to_tf_tensor_specs(value_type)\\n\\n @computations.tf_computation\\n def zero():\\n return query.initial_sample_state(tensor_specs)\\n\\n sample_state_type = zero.type_signature.result\\n\\n @computations.tf_computation(sample_state_type,\\n preprocess_record.type_signature.result)\\n def accumulate(sample_state, preprocessed_record):\\n return query.accumulate_preprocessed_record(sample_state,\\n preprocessed_record)\\n\\n @computations.tf_computation(sample_state_type, sample_state_type)\\n def merge(sample_state_1, sample_state_2):\\n return query.merge_sample_states(sample_state_1, sample_state_2)\\n\\n @computations.tf_computation(merge.type_signature.result)\\n def report(sample_state):\\n return sample_state\\n\\n @computations.tf_computation(sample_state_type, global_state_type)\\n def post_process(sample_state, global_state):\\n result, new_global_state = query.get_noised_result(\\n sample_state, global_state)\\n return new_global_state, result\\n\\n #######################################\\n # Orchestration logic\\n\\n sample_params = intrinsics.federated_map(derive_sample_params, global_state)\\n client_sample_params = intrinsics.federated_broadcast(sample_params)\\n preprocessed_record = intrinsics.federated_map(\\n preprocess_record, (client_sample_params, value))\\n agg_result = intrinsics.federated_aggregate(preprocessed_record, zero(),\\n accumulate, merge, report)\\n\\n return intrinsics.federated_map(post_process, (agg_result, global_state))\",\n \"def evaluate_batch(self, batch: TorchData) -> Dict[str, Any]:\\n batch = cast(Tuple[torch.Tensor, torch.Tensor], batch)\\n data, labels = batch\\n\\n output = self.model(data)\\n accuracy = accuracy_rate(output, labels)\\n return {\\\"validation_accuracy\\\": accuracy, \\\"validation_error\\\": 1.0 - accuracy}\",\n \"def create_multi_node_evaluator(actual_evaluator, communicator):\\n\\n actual_evaluator._mn_original_evaluate = actual_evaluator.evaluate\\n actual_evaluator._mn_communicator = communicator\\n\\n def new_evaluate(self):\\n local_mean_dict = self._mn_original_evaluate()\\n global_mean_dict = {\\n name:\\n self._mn_communicator.allreduce_obj(\\n value) / self._mn_communicator.size\\n for name, value in sorted(local_mean_dict.items())\\n }\\n return global_mean_dict\\n\\n actual_evaluator.evaluate = six.create_bound_method(\\n new_evaluate, actual_evaluator)\\n return actual_evaluator\",\n \"def get_eval_fn(\\n testset: torchvision.datasets.CIFAR10,\\n) -> Callable[[fl.common.Weights], Optional[Tuple[float, float]]]:\\n\\n def evaluate(weights: fl.common.Weights) -> Optional[Tuple[float, float]]:\\n \\\"\\\"\\\"Use the entire CIFAR-10 test set for evaluation.\\\"\\\"\\\"\\n model = models.load_model(glb.MODEL)\\n model.set_weights(weights)\\n model.to(DEVICE)\\n testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False)\\n # using pytorch for central evaluation, can be tensorflow as well\\n return modules.pt_test(model, testloader, device=DEVICE) \\n\\n return evaluate\",\n \"def _eval_graph(self, context, sampled_rate=None, cached_id=0):\\n results, names = context.run_eval_graph(sampled_rate, cached_id)\\n metric = np.mean(results[list(names).index(self.metric_name)])\\n return metric\",\n \"def _self_influence_by_batches_helper(\\n self_influence_batch_fn: Callable,\\n instance_name: str,\\n inputs_dataset: Union[Tuple[Any, ...], DataLoader],\\n show_progress: bool = False,\\n) -> Tensor:\\n # If `inputs_dataset` is not a `DataLoader`, turn it into one.\\n inputs_dataset = _format_inputs_dataset(inputs_dataset)\\n\\n # If `show_progress` is true, create a progress bar that keeps track of how\\n # many batches have been processed\\n if show_progress:\\n # First, try to determine length of progress bar if possible, with a\\n # default of `None`\\n inputs_dataset_len = None\\n try:\\n inputs_dataset_len = len(inputs_dataset)\\n except TypeError:\\n warnings.warn(\\n \\\"Unable to determine the number of batches in `inputs_dataset`. \\\"\\n \\\"Therefore, if showing the progress of the computation of self \\\"\\n \\\"influence scores, only the number of batches processed can be \\\"\\n \\\"displayed, and not the percentage completion of the computation, \\\"\\n \\\"nor any time estimates.\\\"\\n )\\n # then create the progress bar\\n inputs_dataset = progress(\\n inputs_dataset,\\n desc=f\\\"Using {instance_name} to compute self influence. Processing batch\\\",\\n total=inputs_dataset_len,\\n )\\n\\n # To compute self influence scores for each batch, we use\\n # `_self_influence_by_checkpoints`, which can accept a tuple representing a\\n # single batch as the `inputs_dataset` argument (as well as a DataLoader).\\n # Because we are already displaying progress in terms of number of batches\\n # processed in this method, we will not show progress for the call to\\n # `_self_influence_by_checkpoints`.\\n return torch.cat(\\n [\\n self_influence_batch_fn(batch, show_progress=False)\\n for batch in inputs_dataset\\n ]\\n )\",\n \"def __evaluate_metric(dataset, y_act, y_pred):\\n if dataset.metric == 'specific':\\n if dataset.best_is_min:\\n return return_specific_metrics(y_act, y_pred)\\n else:\\n return -return_specific_metrics(y_act, y_pred)\\n else:\\n return evaluate_metric(y_act, y_pred, dataset.metric, dataset.y_n_classes)\",\n \"def finetune_eval_fn(\\n # The pytype below must be Any, because the code below uses internal\\n # methods only present on tff.learning.from_keras_model-derived TFF\\n # models.\\n model: Any,\\n train_data: tf.data.Dataset,\\n test_data: tf.data.Dataset,\\n ) -> _MetricsType:\\n\\n @tf.function\\n def train_one_batch(num_examples_sum, batch):\\n \\\"\\\"\\\"Run gradient descent on a batch.\\\"\\\"\\\"\\n with tf.GradientTape() as tape:\\n output = model.forward_pass(batch)\\n if finetune_last_layer:\\n # Only works for models built via `tff.learning.from_keras_model`.\\n last_layer_variables = model._keras_model.layers[-1].trainable_variables # pylint:disable=protected-access\\n grads = tape.gradient(output.loss, last_layer_variables)\\n optimizer.apply_gradients(zip(grads, last_layer_variables))\\n else:\\n grads = tape.gradient(output.loss, model.trainable_variables)\\n optimizer.apply_gradients(zip(grads, model.trainable_variables))\\n return num_examples_sum + output.num_examples\\n\\n # Starts training.\\n metrics_dict = collections.OrderedDict()\\n train_data = train_data.batch(batch_size)\\n num_examples_sum = 0\\n for idx in range(1, num_finetuning_epochs + 1):\\n num_examples_sum = train_data.reduce(0, train_one_batch)\\n # Evaluate the finetuned model every epoch.\\n metrics_dict[f'epoch_{idx}'] = evaluate_fn(model, test_data, batch_size)\\n metrics_dict[_NUM_FINETUNE_EXAMPLES] = num_examples_sum\\n return metrics_dict\",\n \"def batchify(fn, chunk, world_fn = lambda x:x, gather_func = None):\\n if chunk is None:\\n return fn\\n def ret(inputs, training = False, world_fn=world_fn):\\n embedded = inputs[0]\\n attention_poses = inputs[1]\\n intrinsic = inputs[2]\\n images_features = inputs[3]\\n pts = inputs[4]\\n\\n ret_list = [fn([embedded[i:i+chunk], gather_func( world_fn(pts[i:i+chunk]), attention_poses, intrinsic, images_features),pts[i:i+chunk] ]\\n , training=training) for i in range(0, int(embedded.shape[0]), chunk)]\\n #necessary to cache computed results from coarse model\\n if fn.coarse:\\n return tf.concat([pred[0] for pred in ret_list], 0), tf.concat([pred[1] for pred in ret_list], 0)\\n else:\\n return tf.concat([pred[0] for pred in ret_list], 0), None\\n return ret\",\n \"def def_train_and_evaluate(batch_inputs=True, prepare_filename_queues=True):\\n add_flag(\\\"output_dir\\\",\\n default=\\\"output\\\",\\n help=\\\"Directory where checkpoint and event files are stored\\\")\\n\\n def_experiment_fn = def_def_experiment_fn(batch_inputs,\\n prepare_filename_queues)\\n\\n def train_and_evaluate(model_fn, train_input_fn, eval_input_fn=None):\\n \\\"\\\"\\\"Run `tf.contrib.learn.python.learn.learn_runner.run()`.\\n\\n - Args\\n - `model_fn`: A function to construct a model.\\n - Types of its arguments must be one of the following:\\n - `Tensor, ...`\\n - `Tensor, ..., mode=ModeKeys`\\n - Types of its return values must be one of the following:\\n - `Tensor, Tensor, Operation, eval_metric_ops=dict<str, Tensor>`\\n (predictions, loss, train_op, and eval_metric_ops (if any))\\n - `ModelFnOps`\\n - `train_input_fn`, `eval_input_fn`: Functions to serve input\\n Tensors fed into the model. If `eval_input_fn` is `None`,\\n `train_input_fn` will be used instead.\\n - Types of its arguments must be one of the following:\\n - `QueueBase` (a filename queue)\\n - `None` (No argument)\\n - Types of its return values must be one of the following:\\n - `Tensor, Tensor` (x and y)\\n - `dict<str, Tensor>, dict<str, Tensor>` (features and labels)\\n - The keys in `dict` objects must match with names of\\n `model_fn`'s arguments.\\n\\n - Returns\\n - Return value of `tf.contrib.learn.python.learn.learn_runner.run()`.\\n \\\"\\\"\\\"\\n return learn_runner.run(\\n def_experiment_fn(model_fn, train_input_fn, eval_input_fn),\\n FLAGS.output_dir)\\n\\n return train_and_evaluate\",\n \"def evaluate_on_batch(self, xx, yy_true, metrics, hooks=None,\\n progress=None):\\n if hooks is None:\\n hooks = []\\n if progress is None:\\n progress = {}\\n\\n stop = False\\n for hook in hooks:\\n if hook.on_eval_batch_begin(progress, xx, yy_true):\\n stop = True\\n if stop:\\n results = None\\n return results, None\\n\\n for i, x in enumerate(xx):\\n xx[i] = Z.constant(x)\\n for i, y_true in enumerate(yy_true):\\n yy_true[i] = Z.constant(y_true)\\n\\n is_training = False\\n yy_pred = self.model_forward(xx, is_training)\\n results = []\\n for i, (y_pred, y_true, metrics) in \\\\\\n enumerate(zip(yy_pred, yy_true, metrics)):\\n values = []\\n for j, metric in enumerate(metrics):\\n var = Z.mean(metric(y_true, y_pred))\\n values.append(Z.to_scalar(var))\\n results.append(values)\\n\\n stop = False\\n for hook in hooks:\\n if hook.on_eval_batch_end(progress, results):\\n stop = True\\n\\n return results, stop\",\n \"def __model_fn_builder(self, num_labels, learning_rate,\\n num_train_steps,\\n num_warmup_steps):\\n\\n def model_fn(features, labels, mode, params):\\n input_ids = features[\\\"input_ids\\\"]\\n input_mask = features[\\\"input_mask\\\"]\\n segment_ids = features[\\\"segment_ids\\\"]\\n label_ids = features[\\\"label_ids\\\"]\\n\\n is_predicting = (mode == tf.estimator.ModeKeys.PREDICT)\\n\\n # TRAIN and EVAL\\n if not is_predicting:\\n\\n (loss, predicted_labels, log_probs) = self.__create_model(\\n input_ids,\\n input_mask, segment_ids, label_ids, num_labels,\\n is_predicting=is_predicting\\n )\\n\\n train_op = create_optimizer(\\n loss, learning_rate, num_train_steps, num_warmup_steps,\\n use_tpu=False)\\n\\n # Calculate evaluation metrics.\\n def metric_fn(label_ids, predicted_labels):\\n accuracy = tf.metrics.accuracy(label_ids, predicted_labels)\\n f1_score = tf.contrib.metrics.f1_score(\\n label_ids,\\n predicted_labels)\\n auc = tf.metrics.auc(\\n label_ids,\\n predicted_labels)\\n recall = tf.metrics.recall(\\n label_ids,\\n predicted_labels)\\n precision = tf.metrics.precision(\\n label_ids,\\n predicted_labels)\\n true_pos = tf.metrics.true_positives(\\n label_ids,\\n predicted_labels)\\n true_neg = tf.metrics.true_negatives(\\n label_ids,\\n predicted_labels)\\n false_pos = tf.metrics.false_positives(\\n label_ids,\\n predicted_labels)\\n false_neg = tf.metrics.false_negatives(\\n label_ids,\\n predicted_labels)\\n return {\\n \\\"eval_accuracy\\\": accuracy,\\n \\\"f1_score\\\": f1_score,\\n \\\"auc\\\": auc,\\n \\\"precision\\\": precision,\\n \\\"recall\\\": recall,\\n \\\"true_positives\\\": true_pos,\\n \\\"true_negatives\\\": true_neg,\\n \\\"false_positives\\\": false_pos,\\n \\\"false_negatives\\\": false_neg\\n }\\n\\n eval_metrics = metric_fn(label_ids, predicted_labels)\\n\\n if mode == tf.estimator.ModeKeys.TRAIN:\\n return tf.estimator.EstimatorSpec(mode=mode,\\n loss=loss,\\n train_op=train_op)\\n else:\\n return tf.estimator.EstimatorSpec(mode=mode,\\n loss=loss,\\n eval_metric_ops=eval_metrics)\\n else:\\n (predicted_labels, log_probs) = self.__create_model(\\n input_ids,\\n input_mask, segment_ids, label_ids, num_labels,\\n is_predicting=is_predicting\\n )\\n\\n predictions = {\\n 'probabilities': log_probs,\\n 'labels': predicted_labels\\n }\\n return tf.estimator.EstimatorSpec(mode, predictions=predictions)\\n\\n # Return the actual model function in the closure\\n return model_fn\",\n \"def replica_local_fn(*args, **kwargs):\\n if any(\\n isinstance(arg, keras_tensor.KerasTensor)\\n for arg in nest.flatten((args, kwargs))):\\n update_op = None\\n else:\\n update_op = self.update_state(*args, **kwargs) # pylint: disable=not-callable\\n update_ops = []\\n if update_op is not None:\\n update_ops.append(update_op)\\n with ops.control_dependencies(update_ops):\\n result_t = self.result() # pylint: disable=not-callable\\n\\n # We are adding the metric object as metadata on the result tensor.\\n # This is required when we want to use a metric with `add_metric` API on\\n # a Model/Layer in graph mode. This metric instance will later be used\\n # to reset variable state after each epoch of training.\\n # Example:\\n # model = Model()\\n # mean = Mean()\\n # model.add_metric(mean(values), name='mean')\\n result_t._metric_obj = self # pylint: disable=protected-access\\n return result_t\",\n \"def get_validation_metric(val_metric: str,\\n y_pred_label: np.ndarray,\\n y_true: np.ndarray,\\n y_pred: np.ndarray,\\n val_loss: any,\\n acc_metric: float,\\n model_type: str,\\n n_class: int = None):\\n if val_metric == 'kappa':\\n metric_value = cohen_kappa_score(y_pred_label, y_true, weights='linear')\\n elif val_metric == 'auc':\\n metric_value = 0\\n n_class = y_pred.shape[-1]\\n for i in range(n_class):\\n metric_value += compute_roc_auc(torch.tensor(y_pred[:, i]),\\n torch.tensor(label_binarize(y_true, classes=np.arange(n_class))[:, i]))\\n metric_value /= n_class\\n elif val_metric == 'val_loss':\\n metric_value = -val_loss.item()\\n # Default validation metric accuracy\\n elif val_metric == 'custom_cervix':\\n if model_type == 'regression':\\n if n_class == 2:\\n metric_value = compute_roc_auc(torch.tensor(y_pred), torch.tensor(y_true))\\n else:\\n norm_score = y_pred\\n multi_score = np.zeros((len(norm_score), 3))\\n multi_score[:, 0] = 1 - norm_score.flatten()\\n multi_score[:, 2] = norm_score.flatten()\\n metric_value = (compute_roc_auc(torch.tensor(multi_score[:, 0]),\\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\\n compute_roc_auc(torch.tensor(multi_score[:, n_class - 1]),\\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:,\\n n_class - 1]))) / 2\\n elif model_type == 'ordinal':\\n\\n score = np.zeros((y_pred.shape[0], 3))\\n for p_idx, p in enumerate(y_pred):\\n score[p_idx, 0] = 1 - p[0]\\n if p[1] <= 0.5:\\n score[p_idx, 1] = p[0]\\n else:\\n score[p_idx, 1] = 1 - p[0]\\n\\n score[p_idx, 2] = p[1]\\n\\n pred = score / score.sum(1)[..., None]\\n\\n metric_value = (compute_roc_auc(torch.tensor(pred[:, 0]),\\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\\n compute_roc_auc(torch.tensor(pred[:, -1]),\\n torch.tensor(\\n label_binarize(y_true, classes=list(range(n_class)))[:, -1]))) / 2\\n else:\\n if y_pred.shape[1] > 1:\\n metric_value = (compute_roc_auc(torch.tensor(y_pred[:, 0]),\\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:, 0])) +\\n compute_roc_auc(torch.tensor(y_pred[:, -1]),\\n torch.tensor(label_binarize(y_true, classes=list(range(n_class)))[:,\\n -1]))) / 2\\n else:\\n metric_value = compute_roc_auc(torch.tensor(y_pred), torch.tensor(y_true))\\n\\n else:\\n metric_value = acc_metric\\n\\n return metric_value\",\n \"def accum_val_ops(outputs, names, global_step, output_dir, metric_summary, N):\\n outs = []\\n if N >= 0:\\n outputs = outputs[:N]\\n for i in range(len(outputs[0])):\\n scalar = np.array(map(lambda x: x[i], outputs))\\n assert (scalar.ndim == 1)\\n add_value_to_summary(metric_summary, names[i], np.mean(scalar),\\n tag_str='{:>27s}: [{:s}]: %f'.format(names[i], ''))\\n outs.append(np.mean(scalar))\\n return outs\",\n \"def _eval_on_tpu_system(ctx, model_fn_wrapper, dequeue_fn):\\n iterations_per_loop_var = _create_or_get_iterations_per_loop()\\n\\n single_tpu_eval_step, host_calls, captured_scaffold_fn = (\\n model_fn_wrapper.convert_to_single_tpu_eval_step(dequeue_fn))\\n\\n def multi_tpu_eval_steps_on_single_shard():\\n return training_loop.repeat(\\n iterations_per_loop_var,\\n single_tpu_eval_step, [_ZERO_LOSS])\\n\\n (loss,) = tpu.shard(\\n multi_tpu_eval_steps_on_single_shard,\\n inputs=[],\\n num_shards=ctx.num_replicas,\\n outputs_from_all_shards=False,\\n device_assignment=ctx.device_assignment)\\n\\n scaffold = _get_scaffold(captured_scaffold_fn)\\n return loss, host_calls, scaffold\",\n \"def multi_gpu_online_evaluation(\\n model: Module,\\n data_loader: DataLoader,\\n metric: Union[str, Sequence[str]] = 'EPE',\\n tmpdir: Optional[str] = None,\\n gpu_collect: bool = False) -> Dict[str, np.ndarray]:\\n\\n model.eval()\\n metrics = metric if isinstance(metric, (type, list)) else [metric]\\n result_metrics = []\\n\\n dataset = data_loader.dataset\\n rank, world_size = get_dist_info()\\n if rank == 0:\\n prog_bar = mmcv.ProgressBar(len(dataset))\\n\\n for data in data_loader:\\n with torch.no_grad():\\n batch_results = model(test_mode=True, **data)\\n # data['img_metas'] is Datacontainer\\n img_metas = data['img_metas'].data[0]\\n batch_flow = []\\n batch_flow_gt = []\\n batch_valid = []\\n\\n # a batch of result and a batch of img_metas\\n for i in range(len(batch_results)):\\n result = batch_results[i]\\n img_meta = img_metas[i]\\n # result.keys() is 'flow' or ['flow_fw','flow_bw']\\n # img_meta.keys() is 'flow_gt' or ['flow_fw_gt','flow_bw_gt']\\n for k in result.keys():\\n\\n if img_meta.get(k + '_gt', None) is None:\\n # img_meta does not have flow_bw_gt, so just check\\n # the forward predicted.\\n if k == 'flow_bw':\\n continue\\n elif k == 'flow_fw':\\n batch_flow_gt.append(img_meta['flow_gt'])\\n else:\\n batch_flow_gt.append(img_meta[k + '_gt'])\\n\\n batch_flow.append(result[k])\\n batch_valid.append(\\n img_meta.get('valid', np.ones_like(result[k][..., 0])))\\n\\n batch_results_metrics = eval_metrics(batch_flow, batch_flow_gt,\\n batch_valid, metrics)\\n # result_metrics is different from result_metrics in\\n # `single_gpu_online_evaluation`\\n # result_metrics is Sequence[Dict[str,ndarray]]\\n result_metrics.append(batch_results_metrics)\\n\\n if rank == 0:\\n batch_size = len(batch_results)\\n for _ in range(batch_size * world_size):\\n prog_bar.update()\\n\\n # collect results from all ranks\\n from mmflow.apis.test import collect_results_cpu, collect_results_gpu\\n if gpu_collect:\\n result_metrics = collect_results_gpu(result_metrics, len(dataset))\\n else:\\n result_metrics = collect_results_cpu(result_metrics, len(dataset),\\n tmpdir)\\n rank, world_size = get_dist_info()\\n if rank == 0:\\n sys.stdout.write('\\\\n')\\n # result_metrics_ is final result of evaluation with type\\n # dict(metric_name=metric)\\n result_metrics_ = dict()\\n\\n for sample_result_metrics in result_metrics:\\n for k in sample_result_metrics.keys():\\n if result_metrics_.get(k, None) is None:\\n result_metrics_[k] = sample_result_metrics[k] / len(\\n result_metrics)\\n else:\\n result_metrics_[k] += sample_result_metrics[k] / len(\\n result_metrics)\\n\\n return result_metrics_\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6395356","0.6359279","0.629271","0.6235188","0.62173855","0.6195198","0.61704963","0.6149006","0.6123954","0.6117296","0.6049343","0.601445","0.5938186","0.5898094","0.58803093","0.58801115","0.58606005","0.58545065","0.5843001","0.58256847","0.5775458","0.5764285","0.57335764","0.5724935","0.57093185","0.5659459","0.5656262","0.56338084","0.5631317","0.56298256","0.56243485","0.5510258","0.5506427","0.54881704","0.54824376","0.54710317","0.54483676","0.54350954","0.54329556","0.5429679","0.5384026","0.5356306","0.53525347","0.5352237","0.5344214","0.5340543","0.534006","0.53329515","0.53315693","0.532925","0.5317609","0.5313779","0.52874374","0.52856606","0.5271422","0.5259309","0.5258141","0.5246274","0.52440655","0.52438843","0.5242816","0.52286005","0.5226911","0.52174425","0.52070767","0.5197688","0.5189635","0.5179505","0.5172459","0.5160089","0.5158936","0.5158518","0.5154341","0.51491416","0.51482797","0.5145927","0.5143531","0.5136147","0.513113","0.5129803","0.5112043","0.511194","0.51118004","0.5100835","0.508652","0.50794053","0.50783485","0.5075716","0.50743","0.50654066","0.5063784","0.5063","0.5058121","0.5057655","0.50569713","0.5052449","0.50425905","0.5041732","0.50405824","0.5030488"],"string":"[\n \"0.6395356\",\n \"0.6359279\",\n \"0.629271\",\n \"0.6235188\",\n \"0.62173855\",\n \"0.6195198\",\n \"0.61704963\",\n \"0.6149006\",\n \"0.6123954\",\n \"0.6117296\",\n \"0.6049343\",\n \"0.601445\",\n \"0.5938186\",\n \"0.5898094\",\n \"0.58803093\",\n \"0.58801115\",\n \"0.58606005\",\n \"0.58545065\",\n \"0.5843001\",\n \"0.58256847\",\n \"0.5775458\",\n \"0.5764285\",\n \"0.57335764\",\n \"0.5724935\",\n \"0.57093185\",\n \"0.5659459\",\n \"0.5656262\",\n \"0.56338084\",\n \"0.5631317\",\n \"0.56298256\",\n \"0.56243485\",\n \"0.5510258\",\n \"0.5506427\",\n \"0.54881704\",\n \"0.54824376\",\n \"0.54710317\",\n \"0.54483676\",\n \"0.54350954\",\n \"0.54329556\",\n \"0.5429679\",\n \"0.5384026\",\n \"0.5356306\",\n \"0.53525347\",\n \"0.5352237\",\n \"0.5344214\",\n \"0.5340543\",\n \"0.534006\",\n \"0.53329515\",\n \"0.53315693\",\n \"0.532925\",\n \"0.5317609\",\n \"0.5313779\",\n \"0.52874374\",\n \"0.52856606\",\n \"0.5271422\",\n \"0.5259309\",\n \"0.5258141\",\n \"0.5246274\",\n \"0.52440655\",\n \"0.52438843\",\n \"0.5242816\",\n \"0.52286005\",\n \"0.5226911\",\n \"0.52174425\",\n \"0.52070767\",\n \"0.5197688\",\n \"0.5189635\",\n \"0.5179505\",\n \"0.5172459\",\n \"0.5160089\",\n \"0.5158936\",\n \"0.5158518\",\n \"0.5154341\",\n \"0.51491416\",\n \"0.51482797\",\n \"0.5145927\",\n \"0.5143531\",\n \"0.5136147\",\n \"0.513113\",\n \"0.5129803\",\n \"0.5112043\",\n \"0.511194\",\n \"0.51118004\",\n \"0.5100835\",\n \"0.508652\",\n \"0.50794053\",\n \"0.50783485\",\n \"0.5075716\",\n \"0.50743\",\n \"0.50654066\",\n \"0.5063784\",\n \"0.5063\",\n \"0.5058121\",\n \"0.5057655\",\n \"0.50569713\",\n \"0.5052449\",\n \"0.50425905\",\n \"0.5041732\",\n \"0.50405824\",\n \"0.5030488\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7159342"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85160,"cells":{"query":{"kind":"string","value":"Returns an aggregation of the metric_fn's returned values."},"document":{"kind":"string","value":"def problem_metric_fn(*args):\n (scores, weights) = metric_fn(*args)\n\n # The tf.metrics.mean function assures correct aggregation.\n return tf.compat.v1.metrics.mean(scores, weights)"},"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 agg(self, values, agg_func):\n assert len(values) > 0, \"Empty list of values\"\n f = agg_func.strip().lower()\n assert f in self.__AGGREGATIONS, \"Aggregation function \" + agg_func + \" is not valid\"\n\n ret = 0 # just to avoid \"Local variable might be referenced before assignment\" warning\n if f == self.__MAX:\n ret = max(values)\n elif f == self.__SUM:\n ret = sum(values)\n elif f == self.__AVG:\n ret = mean(values)\n return ret","def _convert_to_eval_metric(metric_fn):\n def problem_metric_fn(*args):\n \"\"\"Returns an aggregation of the metric_fn's returned values.\"\"\"\n (scores, weights) = metric_fn(*args)\n\n # The tf.metrics.mean function assures correct aggregation.\n return tf.compat.v1.metrics.mean(scores, weights)\n return problem_metric_fn","def valuesReducer(aggregation_fn):\n return partial(reduceWith, aggregation_fn)","def aggregate_metrics(metrics):\n if len(metrics) == 1:\n return metrics[0]\n else:\n agg_metrics = metrics[0]\n for metric in agg_metrics.keys():\n vals = [x[metric] for x in metrics]\n agg_metrics[metric] = [np.mean(vals), np.std(vals)]\n return agg_metrics","def _aggregate_metrics(metrics, aggfunc, base):\n return base.Struct(**_UNCOMPRESSED_METRICS)(\n left_side_bearing=aggfunc(_m.left_side_bearing for _m in metrics),\n right_side_bearing=aggfunc(_m.right_side_bearing for _m in metrics),\n character_width=aggfunc(_m.character_width for _m in metrics),\n character_ascent=aggfunc(_m.character_ascent for _m in metrics),\n character_descent=aggfunc(_m.character_descent for _m in metrics),\n character_attributes=0,\n )","def aggregator():\n return Aggregator(\n agg_col=\"col_a\", values_col=\"col_b\", aggregates=[\"min\", \"max\", \"avg\", \"sum\"]\n )","def aggregateFunction():\r\n global aggFunc\r\n aggFunc = []\r\n for objFunc in P_prime:\r\n aggFunc.append(objFunc[0]*FileSettings.settingsdict['weights'][0] +\r\n objFunc[1]*FileSettings.settingsdict['weights'][1] +\r\n objFunc[2]*FileSettings.settingsdict['weights'][2] +\r\n objFunc[3]*FileSettings.settingsdict['weights'][3])\r\n return aggFunc","def aggregate(self, arg):\n return self.agg(arg)","def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\n def fn(distribution, *a):\n \"\"\"Call `metric_value_fn` in the correct control flow context.\"\"\"\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with ops.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n ops.add_to_collections(metrics_collections, metric_value)\n return metric_value\n\n return distribute_lib.get_tower_context().merge_call(fn, *args)","def aggregate(self, func, *columns):\n if not columns:\n columns = ['*']\n\n self.aggregate_ = {\n 'function': func,\n 'columns': columns\n }\n\n previous_columns = self.columns\n\n results = self.get(*columns)\n\n self.aggregate_ = None\n\n self.columns = previous_columns\n\n if len(results) > 0:\n return dict((k.lower(), v) for k, v in results[0].items())['aggregate']","def metrics_group():","def resolve_metric_bundle(\n self,\n metric_fn_bundle: Iterable[MetricComputationConfiguration],\n ) -> Dict[Tuple[str, str, str], MetricValue]:\n resolved_metrics: Dict[Tuple[str, str, str], MetricValue] = {}\n\n res: List[pyspark.Row]\n\n aggregates: Dict[Tuple[str, str, str], dict] = {}\n\n aggregate: dict\n\n domain_id: Tuple[str, str, str]\n\n bundled_metric_configuration: MetricComputationConfiguration\n for bundled_metric_configuration in metric_fn_bundle:\n metric_to_resolve: MetricConfiguration = (\n bundled_metric_configuration.metric_configuration\n )\n metric_fn: Any = bundled_metric_configuration.metric_fn\n compute_domain_kwargs: dict = (\n bundled_metric_configuration.compute_domain_kwargs or {}\n )\n if not isinstance(compute_domain_kwargs, IDDict):\n compute_domain_kwargs = IDDict(compute_domain_kwargs)\n\n domain_id = compute_domain_kwargs.to_id()\n if domain_id not in aggregates:\n aggregates[domain_id] = {\n \"column_aggregates\": [],\n \"metric_ids\": [],\n \"domain_kwargs\": compute_domain_kwargs,\n }\n\n aggregates[domain_id][\"column_aggregates\"].append(metric_fn)\n aggregates[domain_id][\"metric_ids\"].append(metric_to_resolve.id)\n\n for aggregate in aggregates.values():\n domain_kwargs: dict = aggregate[\"domain_kwargs\"]\n df: pyspark.DataFrame = self.get_domain_records(domain_kwargs=domain_kwargs)\n\n assert len(aggregate[\"column_aggregates\"]) == len(aggregate[\"metric_ids\"])\n\n res = df.agg(*aggregate[\"column_aggregates\"]).collect()\n\n logger.debug(\n f\"SparkDFExecutionEngine computed {len(res[0])} metrics on domain_id {IDDict(domain_kwargs).to_id()}\"\n )\n\n assert (\n len(res) == 1\n ), \"all bundle-computed metrics must be single-value statistics\"\n assert len(aggregate[\"metric_ids\"]) == len(\n res[0]\n ), \"unexpected number of metrics returned\"\n\n idx: int\n metric_id: Tuple[str, str, str]\n for idx, metric_id in enumerate(aggregate[\"metric_ids\"]):\n # Converting DataFrame.collect() results into JSON-serializable format produces simple data types,\n # amenable for subsequent post-processing by higher-level \"Metric\" and \"Expectation\" layers.\n resolved_metrics[metric_id] = convert_to_json_serializable(\n data=res[0][idx]\n )\n\n return resolved_metrics","def get_min_or_max_values(metrics: dict, global_metrics: dict, fn2) -> dict:\n for ds_name in metrics:\n if ds_name not in global_metrics:\n global_metrics[ds_name] = {}\n\n feature_metrics = metrics[ds_name]\n for feature_name in feature_metrics:\n if feature_name not in global_metrics[ds_name]:\n global_metrics[ds_name][feature_name] = feature_metrics[feature_name]\n else:\n global_metrics[ds_name][feature_name] = fn2(\n global_metrics[ds_name][feature_name], feature_metrics[feature_name]\n )\n\n results = {}\n for ds_name in global_metrics:\n for feature_name in global_metrics[ds_name]:\n if feature_name not in results:\n results[feature_name] = global_metrics[ds_name][feature_name]\n else:\n results[feature_name] = fn2(results[feature_name], global_metrics[ds_name][feature_name])\n\n for ds_name in global_metrics:\n for feature_name in global_metrics[ds_name]:\n global_metrics[ds_name][feature_name] = results[feature_name]\n\n return global_metrics","def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\n def fn(distribution, *a):\n \"\"\"Call `metric_value_fn` in the correct control flow context.\"\"\"\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with tf.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n tf.add_to_collections(metrics_collections, metric_value)\n return metric_value\n\n return distribution_strategy_context.get_tower_context().merge_call(fn, *args)","def agg(self):\n result = float(self.column.__getattribute__(self.formula_name)())\n return self._value_to_dframe(result)","def compute_metrics(self, results: list) -> dict:","def reduceWith(aggregation_fn, key, values ):\n yield (key, aggregation_fn(values))","def agg(self, func: Callable[[List[float]], float]) -> \"Stream[float]\":\n return ExpandingNode(func)(self).astype(\"float\")","def aggregate(all_metrics, reducer, suffix):\n # Collect metric separately\n separated_metrics = {} # type: dict[frozenset, list[dict]]\n for el in all_metrics:\n key = frozenset(el[\"metric\"][\"dimensions\"].items())\n if key not in separated_metrics:\n separated_metrics[key] = [el]\n else:\n separated_metrics[key].append(el)\n\n # Collect all dimensions\n dims = {}\n for metric_dims in separated_metrics.keys():\n for prop, val in dict(metric_dims).iteritems():\n if prop in dims:\n dims[prop].add(val)\n else:\n dims[prop] = set(val)\n\n # Sort each metric\n for _, metric in separated_metrics.iteritems():\n metric.sort(key=lambda v: v[\"metric\"][\"timestamp\"])\n\n separated_metrics = sorted(separated_metrics.values(), key=len)\n separated_metrics.reverse()\n\n # Compute the new values\n new_values = []\n all_timestamps = map(\n lambda l: map(\n lambda x: x[\"metric\"][\"timestamp\"], l),\n separated_metrics)\n metric_count = len(separated_metrics)\n for index in range(0, len(separated_metrics[0])):\n new_value = reducer[0](\n separated_metrics[0][index][\"metric\"][\"value\"],\n metric_count)\n new_timestamp = separated_metrics[0][index][\"metric\"][\"timestamp\"]\n for metric_index in range(1, metric_count):\n new_value = reducer[1](new_value, helpers.interpolate(\n new_timestamp,\n separated_metrics[metric_index],\n all_timestamps[metric_index]\n ), metric_count)\n new_values.append((new_timestamp, new_value))\n\n # Aggregate the other details:\n metric_name = separated_metrics[0][0][\"metric\"][\"name\"] + suffix\n meta = separated_metrics[0][0][\"meta\"]\n new_metrics = [\n helpers.create_agg_metric(\n metric_name,\n meta,\n dims,\n val[0],\n val[1]\n ) for val in new_values\n ]\n return new_metrics","def agg(self, arg):\n # DataFrame{'a': [1, 1, 2], 'b': [1, 2, 3], 'c': [2, 2, 1]})\n # a.groupby('a').agg('sum') -- applied on rest\n # a.groupby('a').agg(['sum', 'min']) -- both applied on rest\n # a.groupby('a').agg({'b': ['min', 'mean']}) -- applied on\n # TODO\n # a.groupby('a').aggregate( a= me['a'].mean(), b_min =me['b'].min(), b_mean=me['c'].mean()))\n # f1 = lambda x: x.quantile(0.5); f1.__name__ = \"q0.5\"\n # f2 = lambda x: x.quantile(0.75); f2.__name__ = \"q0.75\"\n # a.groupby('a').agg([f1, f2])\n\n res = {}\n for f, c in zip(self._key_fields, self._unzip_group_keys()):\n res[f.name] = c\n for agg_name, field, op in self._normalize_agg_arg(arg):\n res[agg_name] = self._apply1(field, op)\n return self._parent._fromdata(res, None)","def aggregate_results(self):\n\n raise NotImplementedError","def aggregate(self, applyfunc):\n if hasattr(applyfunc,'__iter__'):\n retVal = self._aggregate_multiple(applyfunc)\n else:\n try:\n result = self._aggregate_simple(applyfunc)\n except Exception:\n result = self._aggregate_named(applyfunc)\n\n retVal = Series(result)\n\n return retVal","def get_metrics(self) -> Dict[str, base.Number]:\n return self._metrics","def data_agg_by_mean_value(self):\n return self._data_agg_by_mean_value","def aggregate(global_params, running_aggregate, aggregation_result):\n running_ref = running_aggregate.get_ref('values')\n agg_ref = aggregation_result.get_ref('values')\n for i in range(global_params.dims):\n running_ref[i] += agg_ref[i]\n return running_aggregate","def compute_metrics(self):\n pass","def compute(self) -> Any:\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n return per_class, micro, macro, weighted","def compute(self) -> Dict[str, np.ndarray]:\n return {name: self.metrics[name].compute() for name in self.metrics}","def aggregate(self, func, field_path=None):\n return self._collection.aggregate(func, field_path)","def get_aggregations(self):\n return []","def aggregate(predictions, aggfunc):\n return [aggfunc(sublist) for sublist in np.transpose(predictions)]","def get_aggregated_values(self):\n if not self._initialized:\n raise Exception(\"To readout you must first initialize, then\"\n \"process batches!\")\n else:\n ret_vals = [q.readout() for q in self.quantities]\n return dict(zip(self.quantity_names, ret_vals))","def get_metrics(self) -> dict:\n return self.metric_dict","def accum_val_ops(outputs, names, global_step, output_dir, metric_summary, N):\n outs = []\n if N >= 0:\n outputs = outputs[:N]\n for i in range(len(outputs[0])):\n scalar = np.array(map(lambda x: x[i], outputs))\n assert (scalar.ndim == 1)\n add_value_to_summary(metric_summary, names[i], np.mean(scalar),\n tag_str='{:>27s}: [{:s}]: %f'.format(names[i], ''))\n outs.append(np.mean(scalar))\n return outs","def fn(distribution, *a):\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with ops.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n ops.add_to_collections(metrics_collections, metric_value)\n return metric_value","def get_aggr(self, attribute, aggregator=None, smooth=0., **kwargs):\n if aggregator is None:\n aggregator = np.mean\n data = self.get_all()\n itrs = {row['Iteration'] for row in data}\n itrs = sorted(list(itrs))\n vals = []\n running_avg = 0\n for itr in itrs:\n itr_data = DatasetBuilder(data).filter_itr(itr).get_all()\n val = aggregator([row[attribute] for row in itr_data], **kwargs)\n if len(vals) == 0:\n running_avg = val\n else:\n running_avg = smooth * running_avg + (1 - smooth) * val\n vals.append(running_avg)\n return np.array(itrs), np.array(vals)","def apply_aggregation(t, node_data, f=lambda x, y: x+y):\n try:\n result = dict()\n for k, v in t.iteritems():\n if type(k) is not tuple:\n result[k] = node_data[k]\n else:\n result[k] = apply_tuple(k, node_data, f)\n return result\n except:\n print(t)\n raise","def get_metrics(self):\n return None","def get_metric_info(self):\n metric_data_object = self.client.get_metric_data(\n MetricDataQueries=[\n {\n \"Id\": \"cdbdata_invocations\",\n \"MetricStat\": {\n \"Metric\": {\n \"Namespace\": \"AWS/Lambda\",\n \"MetricName\": \"Invocations\",\n \"Dimensions\": [\n {\n \"Name\": \"FunctionName\",\n \"Value\": self.function_name\n }\n ]\n },\n \"Period\": 60,\n \"Stat\": \"Sum\"\n },\n \"ReturnData\": True\n },\n {\n \"Id\": \"cdbdata_errors\",\n \"MetricStat\": {\n \"Metric\": {\n \"Namespace\": \"AWS/Lambda\",\n \"MetricName\": \"Errors\",\n \"Dimensions\": [\n {\n \"Name\": \"FunctionName\",\n \"Value\": self.function_name\n }\n ]\n },\n \"Period\": 60,\n \"Stat\": \"Sum\"\n },\n \"ReturnData\": True\n },\n {\n \"Id\": \"cdbdata_throttles\",\n \"MetricStat\": {\n \"Metric\": {\n \"Namespace\": \"AWS/Lambda\",\n \"MetricName\": \"Throttles\",\n \"Dimensions\": [\n {\n \"Name\": \"FunctionName\",\n \"Value\": self.function_name\n }\n ]\n },\n \"Period\": 60,\n \"Stat\": \"Sum\"\n },\n \"ReturnData\": True\n },\n {\n \"Id\": \"cdbdata_concurrentexec\",\n \"MetricStat\": {\n \"Metric\": {\n \"Namespace\": \"AWS/Lambda\",\n \"MetricName\": \"ConcurrentExecutions\",\n \"Dimensions\": [\n {\n \"Name\": \"FunctionName\",\n \"Value\": self.function_name\n }\n ]\n },\n \"Period\": 60,\n \"Stat\": \"Sum\"\n },\n \"ReturnData\": True\n }\n ],\n StartTime=self.start_timestamp,\n EndTime=self.end_timestamp,\n ScanBy='TimestampDescending'\n )\n\n metric_data_points = metric_data_object[DataPointsCollector.RESPONSE_KEY]\n\n return metric_data_points","def aggregate(self, **aggregations):\n # Before we iterate, reset the aggregations\n for _, agg in aggregations.items():\n agg.reset()\n # Do the accumulation\n for attrs in self:\n for _, agg in aggregations.items():\n agg.accumulate(attrs)\n # Return the results\n return {name: agg.result for name, agg in aggregations.items()}","def compute_key_value(self) -> Dict[str, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = self.compute()\n metrics = self._convert_metrics_to_kv(\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\n )\n return metrics","def _float_metric_value(metric):\n return metric.result().numpy().astype(float)","def calc_metric(output, metrics):\n score = []\n for metric in metrics:\n metric_mod = __import__(\"sklearn.metrics\", fromlist=[metric])\n metric_func = getattr(metric_mod, metric)\n score.append(metric_func(output[0], output[1]))\n return score, output","def metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsMetricArgs']]]]:\n return pulumi.get(self, \"metrics\")","def __get_aws_metric(table_name, gsi_name, time_frame, metric_name):\n return cloudwatch_connection.get_metric_statistics(\n period=time_frame,\n start_time=datetime.utcnow()-timedelta(minutes=10, seconds=time_frame),\n end_time=datetime.utcnow()-timedelta(minutes=10),\n metric_name=metric_name,\n namespace='AWS/DynamoDB',\n statistics=['Sum'],\n dimensions={\n 'TableName': table_name,\n 'GlobalSecondaryIndexName': gsi_name\n },\n unit='Count')","def fn(distribution, *a):\n if hasattr(distribution, '_outer_control_flow_context'):\n # If there was an outer context captured before this method was called,\n # then we enter that context to create the metric value op. If the\n # caputred context is `None`, ops.control_dependencies(None) gives the\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\n # captured context.\n # This special handling is needed because sometimes the metric is created\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\n # want the value op to be evaluated every step or on the TPU. So we\n # create it outside so that it can be evaluated at the end on the host,\n # once the update ops have been evaluted.\n\n # pylint: disable=protected-access\n if distribution._outer_control_flow_context is None:\n with tf.control_dependencies(None):\n metric_value = metric_value_fn(distribution, *a)\n else:\n distribution._outer_control_flow_context.Enter()\n metric_value = metric_value_fn(distribution, *a)\n distribution._outer_control_flow_context.Exit()\n # pylint: enable=protected-access\n else:\n metric_value = metric_value_fn(distribution, *a)\n if metrics_collections:\n tf.add_to_collections(metrics_collections, metric_value)\n return metric_value","def aggregate_results(self, results):\n result = dict()\n result['MAE'] = self.average_dict_items(results, 'MAE')\n result['MdAE'] = self.average_dict_items(results, 'MdAE')\n result['RMSE'] = self.average_dict_items(results, 'RMSE')\n result['SMAPE'] = self.average_dict_items(results, 'SMAPE')\n result['num_values'] = self.average_dict_items(results, 'num_values')\n return result","def _get_eval_metric(self):\n raise NotImplementedError","def summarize(requestContext, seriesList, intervalString, func='sum', alignToFrom=False):\n results = []\n delta = parseTimeOffset(intervalString)\n interval = delta.seconds + (delta.days * 86400)\n\n for series in seriesList:\n buckets = {}\n\n timestamps = range( int(series.start), int(series.end), int(series.step) )\n datapoints = zip(timestamps, series)\n\n for timestamp_, value in datapoints:\n if alignToFrom:\n bucketInterval = int((timestamp_ - series.start) / interval)\n else:\n bucketInterval = timestamp_ - (timestamp_ % interval)\n\n if bucketInterval not in buckets:\n buckets[bucketInterval] = []\n\n if value is not None:\n buckets[bucketInterval].append(value)\n\n if alignToFrom:\n newStart = series.start\n newEnd = series.end\n else:\n newStart = series.start - (series.start % interval)\n newEnd = series.end - (series.end % interval) + interval\n\n newValues = []\n for timestamp_ in range(newStart, newEnd, interval):\n if alignToFrom:\n newEnd = timestamp_\n bucketInterval = int((timestamp_ - series.start) / interval)\n else:\n bucketInterval = timestamp_ - (timestamp_ % interval)\n\n bucket = buckets.get(bucketInterval, [])\n\n if bucket:\n if func == 'avg':\n newValues.append( float(sum(bucket)) / float(len(bucket)) )\n elif func == 'last':\n newValues.append( bucket[len(bucket)-1] )\n elif func == 'max':\n newValues.append( max(bucket) )\n elif func == 'min':\n newValues.append( min(bucket) )\n else:\n newValues.append( sum(bucket) )\n else:\n newValues.append( None )\n\n if alignToFrom:\n newEnd += interval\n\n newName = \"summarize(%s, \\\"%s\\\", \\\"%s\\\"%s)\" % (series.name, intervalString, func, alignToFrom and \", true\" or \"\")\n newSeries = TimeSeries(newName, newStart, newEnd, interval, newValues)\n newSeries.pathExpression = newName\n results.append(newSeries)\n\n return results","def reduce(self, function):\n return reduce(function, self.data)","def _computeValueFunction(self, nbDims, low, high, retstep=False):\n # algorithms performing in discrete space will have a discrete\n # value function that cannot be evaluated at any point - only on the\n # ones for which they have been setup based on the problem it has been\n # setup to solve\n def __round(vec):\n return tuple(int(x) for x in vec)\n\n def __notround(vec):\n return vec\n\n _round = __notround\n if self._algo.DOMAIN['state'] == Spaces.Discrete:\n _round = __round\n\n allParams, stepSizes = self._discretizer.discretize(retstep=True)\n\n allActions = self._problem.getActionsList()\n reducer = max if self.reducer == 'max' else mean\n\n # returns a list\n data = [\n utils.extends({\n key: state[k]\n for k, key in enumerate(self.getKeys(nbDims))\n }, z=reducer([\n self._algo.actionValue(_round(state), action)\n for action in allActions]))\n for state in allParams\n ]\n if retstep:\n return data, stepSizes\n return data","def compute(\n self,\n ) -> Dict[str, Tensor]:\n results = torch.stack((self.tp, self.fp, self.tn, self.fn), dim=1)\n\n return {f\"group_{i}\": group / group.sum() for i, group in enumerate(results)}","def get_all_metrics():\n return get_overlap_metrics() + get_distance_metrics() + get_distance_metrics()","def _aggregate(y, aggfunc, weights):\n if weights is None:\n aggfunc = _check_aggfunc(aggfunc, weighted=False)\n y_agg = aggfunc(y, axis=1)\n else:\n aggfunc = _check_aggfunc(aggfunc, weighted=True)\n y_agg = aggfunc(y, axis=1, weights=np.array(weights))\n\n return pd.Series(y_agg, index=y.index)","def metrics(self):\n raise NotImplementedError(\"metrics\")","def aggregate_value(request):\n try:\n model = request.GET.get('model', 'item')\n start_date = request.GET.get('startDate', None)\n end_date = request.GET.get('endDate', None)\n\n items = __getQuerysetGivenInterval(model, start_date, end_date)\n\n agg_values = list(items.values('documented_at')\n .annotate(\n total_value=Sum(\n F('value')*F('quantity'),\n output_field=FloatField())))\n result = {'result': __castDecimalToFloat(agg_values)}\n\n return JsonResponse(result, status=200)\n except BaseException as e:\n print(e.args)\n return HttpResponseBadRequest()","def get_metric(self, data_row: pd.Series) -> float:","def calc_stat_values(self):","def calc_metric(self, agreement_indices_per_epoch, metric_evaluation, metric_name):\n\n if metric_name in metric_evaluation.columns:\n metric = []\n metric_column = metric_evaluation[metric_name]\n for epoch in range(len(agreement_indices_per_epoch)):\n metric_values = metric_column[agreement_indices_per_epoch[epoch]].to_numpy()\n if len(metric_values) > 0:\n metric.append(np.nanmean(metric_values))\n else:\n metric.append(0)\n\n else:\n metric = None\n\n return metric","def get_metric_fn_and_keys():\n\n def normalize_value(inst: dict):\n val = int(inst[\"output_layer\"][0])\n return tuple([val]) # returns a tuple.\n\n return normalize_value, [\"val\"] # key order must match.","def _aggregate(group_df, sampling_percentage=5 * 2.5):\n out = {}\n dist = []\n total_count = 0\n for i, col in enumerate(columns):\n\n n = group_df[col].sum()\n total_count += n\n dist.append(dict(min=bins[i][0], max=bins[i][1], n=n))\n\n # only aggregate if we have data!\n if total_count:\n aggval, moe = cda.approximate_median(\n dist, sampling_percentage=sampling_percentage\n )\n else:\n aggval = np.nan\n moe = np.nan\n\n result = {}\n result[\"median\"] = aggval\n result[\"median_moe\"] = moe\n result[\"geometry\"] = group_df.geometry.unary_union\n\n return pd.Series(result)","def _aggregate_func(self, aggregate):\n funcs = {\"sum\": add, \"min\": min, \"max\": max}\n func_name = aggregate.lower() if aggregate else 'sum'\n try:\n return funcs[func_name]\n except KeyError:\n raise TypeError(\"Unsupported aggregate: {}\".format(aggregate))","def agg_statistics(df, uid, value, agg_func, suffix=''):\n suffix = '_' + suffix if suffix else suffix\n tmp = df[uid + value].groupby(uid).agg(agg_func)\n tmp.columns = ['_'.join(col) for col in tmp.columns]\n tmp.columns = [col + suffix for col in tmp.columns]\n return tmp.reset_index(drop=False)","def get_valued_metrics(self):\n return self._valued_metrics","def get_metrics(event):\n return tba_session.get(BASE_URL + '/event/%s/oprs' %event).json()","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def statistic_aggregation(self, resource=None, resource_type=None,\n meter_name=None, period=300, aggregate='mean',\n granularity=300):\n\n pass","def get_evaluation_metric(self):\n\t\treturn self.metric","def aggregate_global_cache(self, global_tt_summary_cache):\n\n # Merge only statistics tensor, if it is any other tensor we simply,\n # concatenate them.\n agg_fn_map = self._parameters.get_signature_to_agg_fn_map()\n signature_idx_map = self._signature_types()\n aggregation_result = []\n for signature, idx in sorted(signature_idx_map.items(),\n key=operator.itemgetter(1)):\n if signature not in agg_fn_map:\n raise RuntimeError('No aggregation function is defined for '\n 'signature %s.' % signature)\n # The dimensions of the statistics tensor is\n # num_cores x num_traced_tensors x num_signatures\n # value[:,:,idx] will return the portion of the tensor related\n # to signature.\n signature_tensor = global_tt_summary_cache[:, :, idx]\n # Merge it along the first (core) axis.\n agg_fn = agg_fn_map[signature]\n agg_tensor = agg_fn(signature_tensor, axis=0)\n aggregation_result.append(agg_tensor)\n # Merge results corresponding to different signatures\n\n merged_signatures = array_ops_stack.stack(aggregation_result)\n # merged_signatures has dimensions\n # num_signatures x num_traced_tensors, transpose it so that it\n # will match with the original structure\n # num_traced_tensors x num_signatures.\n transposed_signatures = array_ops.transpose(merged_signatures)\n # Expand 1 more dimension so that it will match with the expected\n # structure num_cores x num_traced_tensors x num_signatures.\n return array_ops.expand_dims(transposed_signatures, axis=0)","def get_column_grouped_aggregations(column: str, agg_column: str) -> List[str]:\n config = current_app.config\n\n table_name = config['TABLE_NAME']\n db = get_db()\n\n # SQL AVG ignores NULL values\n aggregations = db.execute(f\"\"\"SELECT `{column}`, AVG({agg_column}) , COUNT(*)\n FROM {table_name}\n WHERE `{column}` IS NOT NULL\n GROUP BY `{column}`\"\"\"\n ).fetchall()\n\n return aggregations","def get_results_from_aggregation_sources(self, context):","def as_numpy(fn):\n\n def metric_fn(y_true, y_pred):\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\n new_y_true = y_true.values\n elif isinstance(y_true, np.ndarray):\n new_y_true = y_true\n else:\n new_y_true = y_true.numpy()\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\n new_y_pred = y_pred.values\n elif isinstance(y_pred, np.ndarray):\n new_y_pred = y_pred\n else:\n new_y_pred = y_pred.numpy()\n if new_y_true.ndim == 1:\n new_y_true = np.expand_dims(new_y_true, 1)\n if new_y_pred.ndim == 1:\n new_y_pred = np.expand_dims(new_y_pred, 1)\n return fn(new_y_true, new_y_pred)\n return metric_fn","def reduce(self, key, values, task):\n agg = None\n for val in values:\n record = happy.json.decode(val)\n agg = self.func(agg, record)\n if self.is_dict:\n dict = {self.aggkey: key}\n dict.update(agg)\n else:\n dict = {self.aggkey: key, self.aggfunc: agg}\n task.collect(key, happy.json.encode(dict))","def best_metric(\n self, return_step: bool = False\n ) -> Union[\n None,\n float,\n Tuple[float, int],\n Tuple[None, None],\n Dict[str, Union[float, None]],\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\n ]:\n res = self.compute_all()\n if isinstance(res, list):\n rank_zero_warn(\n \"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\"\n \" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\"\n \"Returning `None` instead. Please consider \"\n )\n if return_step:\n return None, None\n return None\n\n if isinstance(self._base_metric, Metric):\n fn = torch.max if self.maximize else torch.min\n try:\n value, idx = fn(res, 0)\n if return_step:\n return value.item(), idx.item()\n return value.item()\n except (ValueError, RuntimeError) as error:\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric: {error}\"\n \"this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n if return_step:\n return None, None\n return None\n\n else: # this is a metric collection\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\n value, idx = {}, {}\n for i, (k, v) in enumerate(res.items()):\n try:\n fn = torch.max if maximize[i] else torch.min\n out = fn(v, 0)\n value[k], idx[k] = out[0].item(), out[1].item()\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\n rank_zero_warn(\n f\"Encountered the following error when trying to get the best metric for metric {k}:\"\n f\"{error} this is probably due to the 'best' not being defined for this metric.\"\n \"Returning `None` instead.\",\n UserWarning,\n )\n value[k], idx[k] = None, None\n\n if return_step:\n return value, idx\n return value","def metric(self):\n return self.__metric","def get_metrics(self):\n self.logger.debug(\"Fetching metrics.\")\n return self._api_query(\"metrics\")['metrics']","def getReportMetrics(self):\n return self.__unwrapResults().reportMetrics","def summarize_metrics(metrics):\n summarized = {}\n for k in metrics:\n if k.endswith('mse'):\n summarized[k[:-3] + 'rmse'] = np.sqrt(np.mean(metrics[k]))\n elif k.startswith('err'):\n summarized[k + '_mean'] = np.mean(metrics[k])\n summarized[k + '_rmse'] = np.sqrt(np.mean(metrics[k]**2))\n elif k.endswith('nomean'):\n summarized[k] = metrics[k]\n else:\n summarized[k] = np.mean(metrics[k])\n\n return summarized","def calculate_metrics(metrics_data: List[Tuple[Metric, DataType]]) -> List[float]:\n pass","def smartSummarize(requestContext, seriesList, intervalString, func='sum', alignToFrom=False):\n if alignToFrom:\n log.info(\"Deprecated parameter 'alignToFrom' is being ignored.\")\n\n results = []\n delta = parseTimeOffset(intervalString)\n interval = delta.seconds + (delta.days * 86400)\n\n # Adjust the start time to fit an entire day for intervals >= 1 day\n requestContext = requestContext.copy()\n s = requestContext['startTime']\n if interval >= DAY:\n requestContext['startTime'] = datetime(s.year, s.month, s.day)\n elif interval >= HOUR:\n requestContext['startTime'] = datetime(s.year, s.month, s.day, s.hour)\n elif interval >= MINUTE:\n requestContext['startTime'] = datetime(s.year, s.month, s.day, s.hour, s.minute)\n\n for i,series in enumerate(seriesList):\n # XXX: breaks with summarize(metric.{a,b})\n # each series.pathExpression == metric.{a,b}\n newSeries = evaluateTarget(requestContext, series.pathExpression)[0]\n series[0:len(series)] = newSeries\n series.start = newSeries.start\n series.end = newSeries.end\n series.step = newSeries.step\n\n for series in seriesList:\n buckets = {} # { timestamp: [values] }\n\n timestamps = range( int(series.start), int(series.end), int(series.step) )\n datapoints = zip(timestamps, series)\n\n # Populate buckets\n for timestamp_, value in datapoints:\n bucketInterval = int((timestamp_ - series.start) / interval)\n\n if bucketInterval not in buckets:\n buckets[bucketInterval] = []\n\n if value is not None:\n buckets[bucketInterval].append(value)\n\n\n newValues = []\n for timestamp_ in range(series.start, series.end, interval):\n bucketInterval = int((timestamp_ - series.start) / interval)\n bucket = buckets.get(bucketInterval, [])\n\n if bucket:\n if func == 'avg':\n newValues.append( float(sum(bucket)) / float(len(bucket)) )\n elif func == 'last':\n newValues.append( bucket[len(bucket)-1] )\n elif func == 'max':\n newValues.append( max(bucket) )\n elif func == 'min':\n newValues.append( min(bucket) )\n else:\n newValues.append( sum(bucket) )\n else:\n newValues.append( None )\n\n newName = \"smartSummarize(%s, \\\"%s\\\", \\\"%s\\\")\" % (series.name, intervalString, func)\n alignedEnd = series.start + (bucketInterval * interval) + interval\n newSeries = TimeSeries(newName, series.start, alignedEnd, interval, newValues)\n newSeries.pathExpression = newName\n results.append(newSeries)\n\n return results","def aggregate_time(self, temporal_window, aggregationfunction) -> Series :\n pickled_lambda = cloudpickle.dumps(aggregationfunction)\n\n process_id = 'reduce_by_time'\n args = {\n 'imagery':self.graph,\n 'temporal_window': temporal_window,\n 'function': str(base64.b64encode(pickled_lambda), \"UTF-8\")\n }\n\n return self.graph_add_process(process_id, args)","def aggregate_time(self, temporal_window, aggregationfunction) -> Series :\n pickled_lambda = cloudpickle.dumps(aggregationfunction)\n\n process_id = 'reduce_by_time'\n args = {\n 'imagery':self.graph,\n 'temporal_window': temporal_window,\n 'function': str(base64.b64encode(pickled_lambda), \"UTF-8\")\n }\n\n return self.graph_add_process(process_id, args)","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def _aggregate(self, method, column, keys=None, **kwds_filter):\n fn = lambda src: getattr(src, method)(column, keys, **kwds_filter)\n results = (fn(source) for source in self._sources) # Perform aggregation.\n\n if not keys:\n return sum(results) # <- EXIT!\n\n total = defaultdict(lambda: 0)\n for result in results:\n for key, val in result.items():\n total[key] += val\n return CompareDict(total, keys)","def metric(self):\n return self._metric","def sum(self):\n return self._summarize(lambda c: c.sum)","def with_sum_mean_reduction(self):\n return self.with_reduction(lambda x: x.sum(1).mean(0))","def database_statistic(func):\n global database_statistics_registry\n database_statistics_registry.append((func.__name__, func))\n return property(func)","def get_metric(self, reset: bool = False):\n average_value = self._total_value / self._count if self._count > 0 else 0\n if reset:\n self.reset()\n return average_value","def evaluate(self) -> Dict[str, Any]:\n kwargs = {\"ids\": self._ids}\n return {\n metric.value: self._metric_funcs[metric](\n self._targets, self._preds, **kwargs\n )\n for metric in self._metrics\n }","def build_metric_func(dataset_split_name, add_summary=True):\n\n def metric_func(labels, logits):\n \"\"\"Evaluation metric function that runs on CPU.\"\"\"\n accuracy_metric_name = 'Eval/Accuracy/%s' % dataset_split_name\n metric_map = {\n accuracy_metric_name: tf.metrics.accuracy(labels, tf.argmax(logits, 1)),\n }\n if add_summary:\n for name, value in metric_map.items():\n tf.summary.scalar(name, value)\n return metric_map\n\n return metric_func","def fetch_aggregation(self):\n return None","def metrics(self):\n return self.__metrics","def metric_average(val, name, hvd):\n tensor = val.clone().detach()\n avg_tensor = hvd.allreduce(tensor, name=name)\n return avg_tensor.item()","def get_composed_metrics(\n self, column: Column, metric: Metrics, column_results: Dict\n ):\n try:\n return metric(column).fn(column_results)\n except Exception as exc:\n logger.debug(traceback.format_exc())\n logger.warning(f\"Unexpected exception computing metrics: {exc}\")\n return None","def metric(self):\n\n if not self._metric_cache:\n # Select an appropriate statistic\n cls = utils.import_class_or_module(self._metric)\n self._metric_cache = cls(self.additional)\n\n return self._metric_cache","def compute(self) -> Any:\n # ddp hotfix, could be done better\n # but metric must handle DDP on it's own\n if self._ddp_backend == \"xla\":\n device = get_device()\n for key in self.statistics:\n key_statistics = torch.tensor([self.statistics[key]], device=device)\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\n self.statistics[key] = key_statistics\n elif self._ddp_backend == \"ddp\":\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n if self.compute_per_class_metrics:\n return per_class, micro, macro, weighted\n else:\n return [], micro, macro, weighted","def compute(self) -> Any:\n # ddp hotfix, could be done better\n # but metric must handle DDP on it's own\n if self._ddp_backend == \"xla\":\n device = get_device()\n for key in self.statistics:\n key_statistics = torch.tensor([self.statistics[key]], device=device)\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\n self.statistics[key] = key_statistics\n elif self._ddp_backend == \"ddp\":\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = get_aggregated_metrics(\n tp=self.statistics[\"tp\"],\n fp=self.statistics[\"fp\"],\n fn=self.statistics[\"fn\"],\n support=self.statistics[\"support\"],\n zero_division=self.zero_division,\n )\n if self.compute_per_class_metrics:\n return per_class, micro, macro, weighted\n else:\n return [], micro, macro, weighted","def aggregate(self, func):\n axis_name = self.obj._get_axis_name(self.axis)\n getter = lambda p, group: p.reindex(**{axis_name : group})\n result_d = self._aggregate_generic(getter, func,\n axis=self.axis)\n\n result = WidePanel.fromDict(result_d, intersect=False)\n\n if self.axis > 0:\n result = result.swapaxes(0, self.axis)\n\n return result","def summary(self):\n summaries = self.summaries()\n # Reduce to a single summary with weighted averages for each\n # field except \"total_instances\", which is summed.\n total_instances = sum(d['total_instances'].value() for d in summaries)\n summary = {'total_instances': total_instances}\n for field in ('average_qps', 'average_latency', 'average_memory'):\n instance_weighted_sum = sum(\n d['total_instances'].value() * d[field].value()\n for d in summaries)\n summary[field] = float(instance_weighted_sum) / total_instances\n # Beautify rounding precision to match the App Engine UI.\n summary['average_qps'] = round(summary['average_qps'], 3)\n summary['average_latency_ms'] = round(summary['average_latency'], 1)\n summary['average_memory_mb'] = round(summary['average_memory'], 1)\n del summary['average_latency']\n del summary['average_memory']\n return summary"],"string":"[\n \"def agg(self, values, agg_func):\\n assert len(values) > 0, \\\"Empty list of values\\\"\\n f = agg_func.strip().lower()\\n assert f in self.__AGGREGATIONS, \\\"Aggregation function \\\" + agg_func + \\\" is not valid\\\"\\n\\n ret = 0 # just to avoid \\\"Local variable might be referenced before assignment\\\" warning\\n if f == self.__MAX:\\n ret = max(values)\\n elif f == self.__SUM:\\n ret = sum(values)\\n elif f == self.__AVG:\\n ret = mean(values)\\n return ret\",\n \"def _convert_to_eval_metric(metric_fn):\\n def problem_metric_fn(*args):\\n \\\"\\\"\\\"Returns an aggregation of the metric_fn's returned values.\\\"\\\"\\\"\\n (scores, weights) = metric_fn(*args)\\n\\n # The tf.metrics.mean function assures correct aggregation.\\n return tf.compat.v1.metrics.mean(scores, weights)\\n return problem_metric_fn\",\n \"def valuesReducer(aggregation_fn):\\n return partial(reduceWith, aggregation_fn)\",\n \"def aggregate_metrics(metrics):\\n if len(metrics) == 1:\\n return metrics[0]\\n else:\\n agg_metrics = metrics[0]\\n for metric in agg_metrics.keys():\\n vals = [x[metric] for x in metrics]\\n agg_metrics[metric] = [np.mean(vals), np.std(vals)]\\n return agg_metrics\",\n \"def _aggregate_metrics(metrics, aggfunc, base):\\n return base.Struct(**_UNCOMPRESSED_METRICS)(\\n left_side_bearing=aggfunc(_m.left_side_bearing for _m in metrics),\\n right_side_bearing=aggfunc(_m.right_side_bearing for _m in metrics),\\n character_width=aggfunc(_m.character_width for _m in metrics),\\n character_ascent=aggfunc(_m.character_ascent for _m in metrics),\\n character_descent=aggfunc(_m.character_descent for _m in metrics),\\n character_attributes=0,\\n )\",\n \"def aggregator():\\n return Aggregator(\\n agg_col=\\\"col_a\\\", values_col=\\\"col_b\\\", aggregates=[\\\"min\\\", \\\"max\\\", \\\"avg\\\", \\\"sum\\\"]\\n )\",\n \"def aggregateFunction():\\r\\n global aggFunc\\r\\n aggFunc = []\\r\\n for objFunc in P_prime:\\r\\n aggFunc.append(objFunc[0]*FileSettings.settingsdict['weights'][0] +\\r\\n objFunc[1]*FileSettings.settingsdict['weights'][1] +\\r\\n objFunc[2]*FileSettings.settingsdict['weights'][2] +\\r\\n objFunc[3]*FileSettings.settingsdict['weights'][3])\\r\\n return aggFunc\",\n \"def aggregate(self, arg):\\n return self.agg(arg)\",\n \"def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\\n def fn(distribution, *a):\\n \\\"\\\"\\\"Call `metric_value_fn` in the correct control flow context.\\\"\\\"\\\"\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with ops.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n ops.add_to_collections(metrics_collections, metric_value)\\n return metric_value\\n\\n return distribute_lib.get_tower_context().merge_call(fn, *args)\",\n \"def aggregate(self, func, *columns):\\n if not columns:\\n columns = ['*']\\n\\n self.aggregate_ = {\\n 'function': func,\\n 'columns': columns\\n }\\n\\n previous_columns = self.columns\\n\\n results = self.get(*columns)\\n\\n self.aggregate_ = None\\n\\n self.columns = previous_columns\\n\\n if len(results) > 0:\\n return dict((k.lower(), v) for k, v in results[0].items())['aggregate']\",\n \"def metrics_group():\",\n \"def resolve_metric_bundle(\\n self,\\n metric_fn_bundle: Iterable[MetricComputationConfiguration],\\n ) -> Dict[Tuple[str, str, str], MetricValue]:\\n resolved_metrics: Dict[Tuple[str, str, str], MetricValue] = {}\\n\\n res: List[pyspark.Row]\\n\\n aggregates: Dict[Tuple[str, str, str], dict] = {}\\n\\n aggregate: dict\\n\\n domain_id: Tuple[str, str, str]\\n\\n bundled_metric_configuration: MetricComputationConfiguration\\n for bundled_metric_configuration in metric_fn_bundle:\\n metric_to_resolve: MetricConfiguration = (\\n bundled_metric_configuration.metric_configuration\\n )\\n metric_fn: Any = bundled_metric_configuration.metric_fn\\n compute_domain_kwargs: dict = (\\n bundled_metric_configuration.compute_domain_kwargs or {}\\n )\\n if not isinstance(compute_domain_kwargs, IDDict):\\n compute_domain_kwargs = IDDict(compute_domain_kwargs)\\n\\n domain_id = compute_domain_kwargs.to_id()\\n if domain_id not in aggregates:\\n aggregates[domain_id] = {\\n \\\"column_aggregates\\\": [],\\n \\\"metric_ids\\\": [],\\n \\\"domain_kwargs\\\": compute_domain_kwargs,\\n }\\n\\n aggregates[domain_id][\\\"column_aggregates\\\"].append(metric_fn)\\n aggregates[domain_id][\\\"metric_ids\\\"].append(metric_to_resolve.id)\\n\\n for aggregate in aggregates.values():\\n domain_kwargs: dict = aggregate[\\\"domain_kwargs\\\"]\\n df: pyspark.DataFrame = self.get_domain_records(domain_kwargs=domain_kwargs)\\n\\n assert len(aggregate[\\\"column_aggregates\\\"]) == len(aggregate[\\\"metric_ids\\\"])\\n\\n res = df.agg(*aggregate[\\\"column_aggregates\\\"]).collect()\\n\\n logger.debug(\\n f\\\"SparkDFExecutionEngine computed {len(res[0])} metrics on domain_id {IDDict(domain_kwargs).to_id()}\\\"\\n )\\n\\n assert (\\n len(res) == 1\\n ), \\\"all bundle-computed metrics must be single-value statistics\\\"\\n assert len(aggregate[\\\"metric_ids\\\"]) == len(\\n res[0]\\n ), \\\"unexpected number of metrics returned\\\"\\n\\n idx: int\\n metric_id: Tuple[str, str, str]\\n for idx, metric_id in enumerate(aggregate[\\\"metric_ids\\\"]):\\n # Converting DataFrame.collect() results into JSON-serializable format produces simple data types,\\n # amenable for subsequent post-processing by higher-level \\\"Metric\\\" and \\\"Expectation\\\" layers.\\n resolved_metrics[metric_id] = convert_to_json_serializable(\\n data=res[0][idx]\\n )\\n\\n return resolved_metrics\",\n \"def get_min_or_max_values(metrics: dict, global_metrics: dict, fn2) -> dict:\\n for ds_name in metrics:\\n if ds_name not in global_metrics:\\n global_metrics[ds_name] = {}\\n\\n feature_metrics = metrics[ds_name]\\n for feature_name in feature_metrics:\\n if feature_name not in global_metrics[ds_name]:\\n global_metrics[ds_name][feature_name] = feature_metrics[feature_name]\\n else:\\n global_metrics[ds_name][feature_name] = fn2(\\n global_metrics[ds_name][feature_name], feature_metrics[feature_name]\\n )\\n\\n results = {}\\n for ds_name in global_metrics:\\n for feature_name in global_metrics[ds_name]:\\n if feature_name not in results:\\n results[feature_name] = global_metrics[ds_name][feature_name]\\n else:\\n results[feature_name] = fn2(results[feature_name], global_metrics[ds_name][feature_name])\\n\\n for ds_name in global_metrics:\\n for feature_name in global_metrics[ds_name]:\\n global_metrics[ds_name][feature_name] = results[feature_name]\\n\\n return global_metrics\",\n \"def _aggregate_across_towers(metrics_collections, metric_value_fn, *args):\\n def fn(distribution, *a):\\n \\\"\\\"\\\"Call `metric_value_fn` in the correct control flow context.\\\"\\\"\\\"\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with tf.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n tf.add_to_collections(metrics_collections, metric_value)\\n return metric_value\\n\\n return distribution_strategy_context.get_tower_context().merge_call(fn, *args)\",\n \"def agg(self):\\n result = float(self.column.__getattribute__(self.formula_name)())\\n return self._value_to_dframe(result)\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def reduceWith(aggregation_fn, key, values ):\\n yield (key, aggregation_fn(values))\",\n \"def agg(self, func: Callable[[List[float]], float]) -> \\\"Stream[float]\\\":\\n return ExpandingNode(func)(self).astype(\\\"float\\\")\",\n \"def aggregate(all_metrics, reducer, suffix):\\n # Collect metric separately\\n separated_metrics = {} # type: dict[frozenset, list[dict]]\\n for el in all_metrics:\\n key = frozenset(el[\\\"metric\\\"][\\\"dimensions\\\"].items())\\n if key not in separated_metrics:\\n separated_metrics[key] = [el]\\n else:\\n separated_metrics[key].append(el)\\n\\n # Collect all dimensions\\n dims = {}\\n for metric_dims in separated_metrics.keys():\\n for prop, val in dict(metric_dims).iteritems():\\n if prop in dims:\\n dims[prop].add(val)\\n else:\\n dims[prop] = set(val)\\n\\n # Sort each metric\\n for _, metric in separated_metrics.iteritems():\\n metric.sort(key=lambda v: v[\\\"metric\\\"][\\\"timestamp\\\"])\\n\\n separated_metrics = sorted(separated_metrics.values(), key=len)\\n separated_metrics.reverse()\\n\\n # Compute the new values\\n new_values = []\\n all_timestamps = map(\\n lambda l: map(\\n lambda x: x[\\\"metric\\\"][\\\"timestamp\\\"], l),\\n separated_metrics)\\n metric_count = len(separated_metrics)\\n for index in range(0, len(separated_metrics[0])):\\n new_value = reducer[0](\\n separated_metrics[0][index][\\\"metric\\\"][\\\"value\\\"],\\n metric_count)\\n new_timestamp = separated_metrics[0][index][\\\"metric\\\"][\\\"timestamp\\\"]\\n for metric_index in range(1, metric_count):\\n new_value = reducer[1](new_value, helpers.interpolate(\\n new_timestamp,\\n separated_metrics[metric_index],\\n all_timestamps[metric_index]\\n ), metric_count)\\n new_values.append((new_timestamp, new_value))\\n\\n # Aggregate the other details:\\n metric_name = separated_metrics[0][0][\\\"metric\\\"][\\\"name\\\"] + suffix\\n meta = separated_metrics[0][0][\\\"meta\\\"]\\n new_metrics = [\\n helpers.create_agg_metric(\\n metric_name,\\n meta,\\n dims,\\n val[0],\\n val[1]\\n ) for val in new_values\\n ]\\n return new_metrics\",\n \"def agg(self, arg):\\n # DataFrame{'a': [1, 1, 2], 'b': [1, 2, 3], 'c': [2, 2, 1]})\\n # a.groupby('a').agg('sum') -- applied on rest\\n # a.groupby('a').agg(['sum', 'min']) -- both applied on rest\\n # a.groupby('a').agg({'b': ['min', 'mean']}) -- applied on\\n # TODO\\n # a.groupby('a').aggregate( a= me['a'].mean(), b_min =me['b'].min(), b_mean=me['c'].mean()))\\n # f1 = lambda x: x.quantile(0.5); f1.__name__ = \\\"q0.5\\\"\\n # f2 = lambda x: x.quantile(0.75); f2.__name__ = \\\"q0.75\\\"\\n # a.groupby('a').agg([f1, f2])\\n\\n res = {}\\n for f, c in zip(self._key_fields, self._unzip_group_keys()):\\n res[f.name] = c\\n for agg_name, field, op in self._normalize_agg_arg(arg):\\n res[agg_name] = self._apply1(field, op)\\n return self._parent._fromdata(res, None)\",\n \"def aggregate_results(self):\\n\\n raise NotImplementedError\",\n \"def aggregate(self, applyfunc):\\n if hasattr(applyfunc,'__iter__'):\\n retVal = self._aggregate_multiple(applyfunc)\\n else:\\n try:\\n result = self._aggregate_simple(applyfunc)\\n except Exception:\\n result = self._aggregate_named(applyfunc)\\n\\n retVal = Series(result)\\n\\n return retVal\",\n \"def get_metrics(self) -> Dict[str, base.Number]:\\n return self._metrics\",\n \"def data_agg_by_mean_value(self):\\n return self._data_agg_by_mean_value\",\n \"def aggregate(global_params, running_aggregate, aggregation_result):\\n running_ref = running_aggregate.get_ref('values')\\n agg_ref = aggregation_result.get_ref('values')\\n for i in range(global_params.dims):\\n running_ref[i] += agg_ref[i]\\n return running_aggregate\",\n \"def compute_metrics(self):\\n pass\",\n \"def compute(self) -> Any:\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n return per_class, micro, macro, weighted\",\n \"def compute(self) -> Dict[str, np.ndarray]:\\n return {name: self.metrics[name].compute() for name in self.metrics}\",\n \"def aggregate(self, func, field_path=None):\\n return self._collection.aggregate(func, field_path)\",\n \"def get_aggregations(self):\\n return []\",\n \"def aggregate(predictions, aggfunc):\\n return [aggfunc(sublist) for sublist in np.transpose(predictions)]\",\n \"def get_aggregated_values(self):\\n if not self._initialized:\\n raise Exception(\\\"To readout you must first initialize, then\\\"\\n \\\"process batches!\\\")\\n else:\\n ret_vals = [q.readout() for q in self.quantities]\\n return dict(zip(self.quantity_names, ret_vals))\",\n \"def get_metrics(self) -> dict:\\n return self.metric_dict\",\n \"def accum_val_ops(outputs, names, global_step, output_dir, metric_summary, N):\\n outs = []\\n if N >= 0:\\n outputs = outputs[:N]\\n for i in range(len(outputs[0])):\\n scalar = np.array(map(lambda x: x[i], outputs))\\n assert (scalar.ndim == 1)\\n add_value_to_summary(metric_summary, names[i], np.mean(scalar),\\n tag_str='{:>27s}: [{:s}]: %f'.format(names[i], ''))\\n outs.append(np.mean(scalar))\\n return outs\",\n \"def fn(distribution, *a):\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with ops.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n ops.add_to_collections(metrics_collections, metric_value)\\n return metric_value\",\n \"def get_aggr(self, attribute, aggregator=None, smooth=0., **kwargs):\\n if aggregator is None:\\n aggregator = np.mean\\n data = self.get_all()\\n itrs = {row['Iteration'] for row in data}\\n itrs = sorted(list(itrs))\\n vals = []\\n running_avg = 0\\n for itr in itrs:\\n itr_data = DatasetBuilder(data).filter_itr(itr).get_all()\\n val = aggregator([row[attribute] for row in itr_data], **kwargs)\\n if len(vals) == 0:\\n running_avg = val\\n else:\\n running_avg = smooth * running_avg + (1 - smooth) * val\\n vals.append(running_avg)\\n return np.array(itrs), np.array(vals)\",\n \"def apply_aggregation(t, node_data, f=lambda x, y: x+y):\\n try:\\n result = dict()\\n for k, v in t.iteritems():\\n if type(k) is not tuple:\\n result[k] = node_data[k]\\n else:\\n result[k] = apply_tuple(k, node_data, f)\\n return result\\n except:\\n print(t)\\n raise\",\n \"def get_metrics(self):\\n return None\",\n \"def get_metric_info(self):\\n metric_data_object = self.client.get_metric_data(\\n MetricDataQueries=[\\n {\\n \\\"Id\\\": \\\"cdbdata_invocations\\\",\\n \\\"MetricStat\\\": {\\n \\\"Metric\\\": {\\n \\\"Namespace\\\": \\\"AWS/Lambda\\\",\\n \\\"MetricName\\\": \\\"Invocations\\\",\\n \\\"Dimensions\\\": [\\n {\\n \\\"Name\\\": \\\"FunctionName\\\",\\n \\\"Value\\\": self.function_name\\n }\\n ]\\n },\\n \\\"Period\\\": 60,\\n \\\"Stat\\\": \\\"Sum\\\"\\n },\\n \\\"ReturnData\\\": True\\n },\\n {\\n \\\"Id\\\": \\\"cdbdata_errors\\\",\\n \\\"MetricStat\\\": {\\n \\\"Metric\\\": {\\n \\\"Namespace\\\": \\\"AWS/Lambda\\\",\\n \\\"MetricName\\\": \\\"Errors\\\",\\n \\\"Dimensions\\\": [\\n {\\n \\\"Name\\\": \\\"FunctionName\\\",\\n \\\"Value\\\": self.function_name\\n }\\n ]\\n },\\n \\\"Period\\\": 60,\\n \\\"Stat\\\": \\\"Sum\\\"\\n },\\n \\\"ReturnData\\\": True\\n },\\n {\\n \\\"Id\\\": \\\"cdbdata_throttles\\\",\\n \\\"MetricStat\\\": {\\n \\\"Metric\\\": {\\n \\\"Namespace\\\": \\\"AWS/Lambda\\\",\\n \\\"MetricName\\\": \\\"Throttles\\\",\\n \\\"Dimensions\\\": [\\n {\\n \\\"Name\\\": \\\"FunctionName\\\",\\n \\\"Value\\\": self.function_name\\n }\\n ]\\n },\\n \\\"Period\\\": 60,\\n \\\"Stat\\\": \\\"Sum\\\"\\n },\\n \\\"ReturnData\\\": True\\n },\\n {\\n \\\"Id\\\": \\\"cdbdata_concurrentexec\\\",\\n \\\"MetricStat\\\": {\\n \\\"Metric\\\": {\\n \\\"Namespace\\\": \\\"AWS/Lambda\\\",\\n \\\"MetricName\\\": \\\"ConcurrentExecutions\\\",\\n \\\"Dimensions\\\": [\\n {\\n \\\"Name\\\": \\\"FunctionName\\\",\\n \\\"Value\\\": self.function_name\\n }\\n ]\\n },\\n \\\"Period\\\": 60,\\n \\\"Stat\\\": \\\"Sum\\\"\\n },\\n \\\"ReturnData\\\": True\\n }\\n ],\\n StartTime=self.start_timestamp,\\n EndTime=self.end_timestamp,\\n ScanBy='TimestampDescending'\\n )\\n\\n metric_data_points = metric_data_object[DataPointsCollector.RESPONSE_KEY]\\n\\n return metric_data_points\",\n \"def aggregate(self, **aggregations):\\n # Before we iterate, reset the aggregations\\n for _, agg in aggregations.items():\\n agg.reset()\\n # Do the accumulation\\n for attrs in self:\\n for _, agg in aggregations.items():\\n agg.accumulate(attrs)\\n # Return the results\\n return {name: agg.result for name, agg in aggregations.items()}\",\n \"def compute_key_value(self) -> Dict[str, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = self.compute()\\n metrics = self._convert_metrics_to_kv(\\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\\n )\\n return metrics\",\n \"def _float_metric_value(metric):\\n return metric.result().numpy().astype(float)\",\n \"def calc_metric(output, metrics):\\n score = []\\n for metric in metrics:\\n metric_mod = __import__(\\\"sklearn.metrics\\\", fromlist=[metric])\\n metric_func = getattr(metric_mod, metric)\\n score.append(metric_func(output[0], output[1]))\\n return score, output\",\n \"def metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ElastigroupMultipleMetricsMetricArgs']]]]:\\n return pulumi.get(self, \\\"metrics\\\")\",\n \"def __get_aws_metric(table_name, gsi_name, time_frame, metric_name):\\n return cloudwatch_connection.get_metric_statistics(\\n period=time_frame,\\n start_time=datetime.utcnow()-timedelta(minutes=10, seconds=time_frame),\\n end_time=datetime.utcnow()-timedelta(minutes=10),\\n metric_name=metric_name,\\n namespace='AWS/DynamoDB',\\n statistics=['Sum'],\\n dimensions={\\n 'TableName': table_name,\\n 'GlobalSecondaryIndexName': gsi_name\\n },\\n unit='Count')\",\n \"def fn(distribution, *a):\\n if hasattr(distribution, '_outer_control_flow_context'):\\n # If there was an outer context captured before this method was called,\\n # then we enter that context to create the metric value op. If the\\n # caputred context is `None`, ops.control_dependencies(None) gives the\\n # desired behavior. Else we use `Enter` and `Exit` to enter and exit the\\n # captured context.\\n # This special handling is needed because sometimes the metric is created\\n # inside a while_loop (and perhaps a TPU rewrite context). But we don't\\n # want the value op to be evaluated every step or on the TPU. So we\\n # create it outside so that it can be evaluated at the end on the host,\\n # once the update ops have been evaluted.\\n\\n # pylint: disable=protected-access\\n if distribution._outer_control_flow_context is None:\\n with tf.control_dependencies(None):\\n metric_value = metric_value_fn(distribution, *a)\\n else:\\n distribution._outer_control_flow_context.Enter()\\n metric_value = metric_value_fn(distribution, *a)\\n distribution._outer_control_flow_context.Exit()\\n # pylint: enable=protected-access\\n else:\\n metric_value = metric_value_fn(distribution, *a)\\n if metrics_collections:\\n tf.add_to_collections(metrics_collections, metric_value)\\n return metric_value\",\n \"def aggregate_results(self, results):\\n result = dict()\\n result['MAE'] = self.average_dict_items(results, 'MAE')\\n result['MdAE'] = self.average_dict_items(results, 'MdAE')\\n result['RMSE'] = self.average_dict_items(results, 'RMSE')\\n result['SMAPE'] = self.average_dict_items(results, 'SMAPE')\\n result['num_values'] = self.average_dict_items(results, 'num_values')\\n return result\",\n \"def _get_eval_metric(self):\\n raise NotImplementedError\",\n \"def summarize(requestContext, seriesList, intervalString, func='sum', alignToFrom=False):\\n results = []\\n delta = parseTimeOffset(intervalString)\\n interval = delta.seconds + (delta.days * 86400)\\n\\n for series in seriesList:\\n buckets = {}\\n\\n timestamps = range( int(series.start), int(series.end), int(series.step) )\\n datapoints = zip(timestamps, series)\\n\\n for timestamp_, value in datapoints:\\n if alignToFrom:\\n bucketInterval = int((timestamp_ - series.start) / interval)\\n else:\\n bucketInterval = timestamp_ - (timestamp_ % interval)\\n\\n if bucketInterval not in buckets:\\n buckets[bucketInterval] = []\\n\\n if value is not None:\\n buckets[bucketInterval].append(value)\\n\\n if alignToFrom:\\n newStart = series.start\\n newEnd = series.end\\n else:\\n newStart = series.start - (series.start % interval)\\n newEnd = series.end - (series.end % interval) + interval\\n\\n newValues = []\\n for timestamp_ in range(newStart, newEnd, interval):\\n if alignToFrom:\\n newEnd = timestamp_\\n bucketInterval = int((timestamp_ - series.start) / interval)\\n else:\\n bucketInterval = timestamp_ - (timestamp_ % interval)\\n\\n bucket = buckets.get(bucketInterval, [])\\n\\n if bucket:\\n if func == 'avg':\\n newValues.append( float(sum(bucket)) / float(len(bucket)) )\\n elif func == 'last':\\n newValues.append( bucket[len(bucket)-1] )\\n elif func == 'max':\\n newValues.append( max(bucket) )\\n elif func == 'min':\\n newValues.append( min(bucket) )\\n else:\\n newValues.append( sum(bucket) )\\n else:\\n newValues.append( None )\\n\\n if alignToFrom:\\n newEnd += interval\\n\\n newName = \\\"summarize(%s, \\\\\\\"%s\\\\\\\", \\\\\\\"%s\\\\\\\"%s)\\\" % (series.name, intervalString, func, alignToFrom and \\\", true\\\" or \\\"\\\")\\n newSeries = TimeSeries(newName, newStart, newEnd, interval, newValues)\\n newSeries.pathExpression = newName\\n results.append(newSeries)\\n\\n return results\",\n \"def reduce(self, function):\\n return reduce(function, self.data)\",\n \"def _computeValueFunction(self, nbDims, low, high, retstep=False):\\n # algorithms performing in discrete space will have a discrete\\n # value function that cannot be evaluated at any point - only on the\\n # ones for which they have been setup based on the problem it has been\\n # setup to solve\\n def __round(vec):\\n return tuple(int(x) for x in vec)\\n\\n def __notround(vec):\\n return vec\\n\\n _round = __notround\\n if self._algo.DOMAIN['state'] == Spaces.Discrete:\\n _round = __round\\n\\n allParams, stepSizes = self._discretizer.discretize(retstep=True)\\n\\n allActions = self._problem.getActionsList()\\n reducer = max if self.reducer == 'max' else mean\\n\\n # returns a list\\n data = [\\n utils.extends({\\n key: state[k]\\n for k, key in enumerate(self.getKeys(nbDims))\\n }, z=reducer([\\n self._algo.actionValue(_round(state), action)\\n for action in allActions]))\\n for state in allParams\\n ]\\n if retstep:\\n return data, stepSizes\\n return data\",\n \"def compute(\\n self,\\n ) -> Dict[str, Tensor]:\\n results = torch.stack((self.tp, self.fp, self.tn, self.fn), dim=1)\\n\\n return {f\\\"group_{i}\\\": group / group.sum() for i, group in enumerate(results)}\",\n \"def get_all_metrics():\\n return get_overlap_metrics() + get_distance_metrics() + get_distance_metrics()\",\n \"def _aggregate(y, aggfunc, weights):\\n if weights is None:\\n aggfunc = _check_aggfunc(aggfunc, weighted=False)\\n y_agg = aggfunc(y, axis=1)\\n else:\\n aggfunc = _check_aggfunc(aggfunc, weighted=True)\\n y_agg = aggfunc(y, axis=1, weights=np.array(weights))\\n\\n return pd.Series(y_agg, index=y.index)\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def aggregate_value(request):\\n try:\\n model = request.GET.get('model', 'item')\\n start_date = request.GET.get('startDate', None)\\n end_date = request.GET.get('endDate', None)\\n\\n items = __getQuerysetGivenInterval(model, start_date, end_date)\\n\\n agg_values = list(items.values('documented_at')\\n .annotate(\\n total_value=Sum(\\n F('value')*F('quantity'),\\n output_field=FloatField())))\\n result = {'result': __castDecimalToFloat(agg_values)}\\n\\n return JsonResponse(result, status=200)\\n except BaseException as e:\\n print(e.args)\\n return HttpResponseBadRequest()\",\n \"def get_metric(self, data_row: pd.Series) -> float:\",\n \"def calc_stat_values(self):\",\n \"def calc_metric(self, agreement_indices_per_epoch, metric_evaluation, metric_name):\\n\\n if metric_name in metric_evaluation.columns:\\n metric = []\\n metric_column = metric_evaluation[metric_name]\\n for epoch in range(len(agreement_indices_per_epoch)):\\n metric_values = metric_column[agreement_indices_per_epoch[epoch]].to_numpy()\\n if len(metric_values) > 0:\\n metric.append(np.nanmean(metric_values))\\n else:\\n metric.append(0)\\n\\n else:\\n metric = None\\n\\n return metric\",\n \"def get_metric_fn_and_keys():\\n\\n def normalize_value(inst: dict):\\n val = int(inst[\\\"output_layer\\\"][0])\\n return tuple([val]) # returns a tuple.\\n\\n return normalize_value, [\\\"val\\\"] # key order must match.\",\n \"def _aggregate(group_df, sampling_percentage=5 * 2.5):\\n out = {}\\n dist = []\\n total_count = 0\\n for i, col in enumerate(columns):\\n\\n n = group_df[col].sum()\\n total_count += n\\n dist.append(dict(min=bins[i][0], max=bins[i][1], n=n))\\n\\n # only aggregate if we have data!\\n if total_count:\\n aggval, moe = cda.approximate_median(\\n dist, sampling_percentage=sampling_percentage\\n )\\n else:\\n aggval = np.nan\\n moe = np.nan\\n\\n result = {}\\n result[\\\"median\\\"] = aggval\\n result[\\\"median_moe\\\"] = moe\\n result[\\\"geometry\\\"] = group_df.geometry.unary_union\\n\\n return pd.Series(result)\",\n \"def _aggregate_func(self, aggregate):\\n funcs = {\\\"sum\\\": add, \\\"min\\\": min, \\\"max\\\": max}\\n func_name = aggregate.lower() if aggregate else 'sum'\\n try:\\n return funcs[func_name]\\n except KeyError:\\n raise TypeError(\\\"Unsupported aggregate: {}\\\".format(aggregate))\",\n \"def agg_statistics(df, uid, value, agg_func, suffix=''):\\n suffix = '_' + suffix if suffix else suffix\\n tmp = df[uid + value].groupby(uid).agg(agg_func)\\n tmp.columns = ['_'.join(col) for col in tmp.columns]\\n tmp.columns = [col + suffix for col in tmp.columns]\\n return tmp.reset_index(drop=False)\",\n \"def get_valued_metrics(self):\\n return self._valued_metrics\",\n \"def get_metrics(event):\\n return tba_session.get(BASE_URL + '/event/%s/oprs' %event).json()\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def statistic_aggregation(self, resource=None, resource_type=None,\\n meter_name=None, period=300, aggregate='mean',\\n granularity=300):\\n\\n pass\",\n \"def get_evaluation_metric(self):\\n\\t\\treturn self.metric\",\n \"def aggregate_global_cache(self, global_tt_summary_cache):\\n\\n # Merge only statistics tensor, if it is any other tensor we simply,\\n # concatenate them.\\n agg_fn_map = self._parameters.get_signature_to_agg_fn_map()\\n signature_idx_map = self._signature_types()\\n aggregation_result = []\\n for signature, idx in sorted(signature_idx_map.items(),\\n key=operator.itemgetter(1)):\\n if signature not in agg_fn_map:\\n raise RuntimeError('No aggregation function is defined for '\\n 'signature %s.' % signature)\\n # The dimensions of the statistics tensor is\\n # num_cores x num_traced_tensors x num_signatures\\n # value[:,:,idx] will return the portion of the tensor related\\n # to signature.\\n signature_tensor = global_tt_summary_cache[:, :, idx]\\n # Merge it along the first (core) axis.\\n agg_fn = agg_fn_map[signature]\\n agg_tensor = agg_fn(signature_tensor, axis=0)\\n aggregation_result.append(agg_tensor)\\n # Merge results corresponding to different signatures\\n\\n merged_signatures = array_ops_stack.stack(aggregation_result)\\n # merged_signatures has dimensions\\n # num_signatures x num_traced_tensors, transpose it so that it\\n # will match with the original structure\\n # num_traced_tensors x num_signatures.\\n transposed_signatures = array_ops.transpose(merged_signatures)\\n # Expand 1 more dimension so that it will match with the expected\\n # structure num_cores x num_traced_tensors x num_signatures.\\n return array_ops.expand_dims(transposed_signatures, axis=0)\",\n \"def get_column_grouped_aggregations(column: str, agg_column: str) -> List[str]:\\n config = current_app.config\\n\\n table_name = config['TABLE_NAME']\\n db = get_db()\\n\\n # SQL AVG ignores NULL values\\n aggregations = db.execute(f\\\"\\\"\\\"SELECT `{column}`, AVG({agg_column}) , COUNT(*)\\n FROM {table_name}\\n WHERE `{column}` IS NOT NULL\\n GROUP BY `{column}`\\\"\\\"\\\"\\n ).fetchall()\\n\\n return aggregations\",\n \"def get_results_from_aggregation_sources(self, context):\",\n \"def as_numpy(fn):\\n\\n def metric_fn(y_true, y_pred):\\n if isinstance(y_true, (pd.Series, pd.DataFrame)):\\n new_y_true = y_true.values\\n elif isinstance(y_true, np.ndarray):\\n new_y_true = y_true\\n else:\\n new_y_true = y_true.numpy()\\n if isinstance(y_pred, (pd.Series, pd.DataFrame)):\\n new_y_pred = y_pred.values\\n elif isinstance(y_pred, np.ndarray):\\n new_y_pred = y_pred\\n else:\\n new_y_pred = y_pred.numpy()\\n if new_y_true.ndim == 1:\\n new_y_true = np.expand_dims(new_y_true, 1)\\n if new_y_pred.ndim == 1:\\n new_y_pred = np.expand_dims(new_y_pred, 1)\\n return fn(new_y_true, new_y_pred)\\n return metric_fn\",\n \"def reduce(self, key, values, task):\\n agg = None\\n for val in values:\\n record = happy.json.decode(val)\\n agg = self.func(agg, record)\\n if self.is_dict:\\n dict = {self.aggkey: key}\\n dict.update(agg)\\n else:\\n dict = {self.aggkey: key, self.aggfunc: agg}\\n task.collect(key, happy.json.encode(dict))\",\n \"def best_metric(\\n self, return_step: bool = False\\n ) -> Union[\\n None,\\n float,\\n Tuple[float, int],\\n Tuple[None, None],\\n Dict[str, Union[float, None]],\\n Tuple[Dict[str, Union[float, None]], Dict[str, Union[int, None]]],\\n ]:\\n res = self.compute_all()\\n if isinstance(res, list):\\n rank_zero_warn(\\n \\\"Encounted nested structure. You are probably using a metric collection inside a metric collection, or\\\"\\n \\\" a metric wrapper inside a metric collection, which is not supported by `.best_metric()` method.\\\"\\n \\\"Returning `None` instead. Please consider \\\"\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n if isinstance(self._base_metric, Metric):\\n fn = torch.max if self.maximize else torch.min\\n try:\\n value, idx = fn(res, 0)\\n if return_step:\\n return value.item(), idx.item()\\n return value.item()\\n except (ValueError, RuntimeError) as error:\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric: {error}\\\"\\n \\\"this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n if return_step:\\n return None, None\\n return None\\n\\n else: # this is a metric collection\\n maximize = self.maximize if isinstance(self.maximize, list) else len(res) * [self.maximize]\\n value, idx = {}, {}\\n for i, (k, v) in enumerate(res.items()):\\n try:\\n fn = torch.max if maximize[i] else torch.min\\n out = fn(v, 0)\\n value[k], idx[k] = out[0].item(), out[1].item()\\n except (ValueError, RuntimeError) as error: # noqa: PERF203 # todo\\n rank_zero_warn(\\n f\\\"Encountered the following error when trying to get the best metric for metric {k}:\\\"\\n f\\\"{error} this is probably due to the 'best' not being defined for this metric.\\\"\\n \\\"Returning `None` instead.\\\",\\n UserWarning,\\n )\\n value[k], idx[k] = None, None\\n\\n if return_step:\\n return value, idx\\n return value\",\n \"def metric(self):\\n return self.__metric\",\n \"def get_metrics(self):\\n self.logger.debug(\\\"Fetching metrics.\\\")\\n return self._api_query(\\\"metrics\\\")['metrics']\",\n \"def getReportMetrics(self):\\n return self.__unwrapResults().reportMetrics\",\n \"def summarize_metrics(metrics):\\n summarized = {}\\n for k in metrics:\\n if k.endswith('mse'):\\n summarized[k[:-3] + 'rmse'] = np.sqrt(np.mean(metrics[k]))\\n elif k.startswith('err'):\\n summarized[k + '_mean'] = np.mean(metrics[k])\\n summarized[k + '_rmse'] = np.sqrt(np.mean(metrics[k]**2))\\n elif k.endswith('nomean'):\\n summarized[k] = metrics[k]\\n else:\\n summarized[k] = np.mean(metrics[k])\\n\\n return summarized\",\n \"def calculate_metrics(metrics_data: List[Tuple[Metric, DataType]]) -> List[float]:\\n pass\",\n \"def smartSummarize(requestContext, seriesList, intervalString, func='sum', alignToFrom=False):\\n if alignToFrom:\\n log.info(\\\"Deprecated parameter 'alignToFrom' is being ignored.\\\")\\n\\n results = []\\n delta = parseTimeOffset(intervalString)\\n interval = delta.seconds + (delta.days * 86400)\\n\\n # Adjust the start time to fit an entire day for intervals >= 1 day\\n requestContext = requestContext.copy()\\n s = requestContext['startTime']\\n if interval >= DAY:\\n requestContext['startTime'] = datetime(s.year, s.month, s.day)\\n elif interval >= HOUR:\\n requestContext['startTime'] = datetime(s.year, s.month, s.day, s.hour)\\n elif interval >= MINUTE:\\n requestContext['startTime'] = datetime(s.year, s.month, s.day, s.hour, s.minute)\\n\\n for i,series in enumerate(seriesList):\\n # XXX: breaks with summarize(metric.{a,b})\\n # each series.pathExpression == metric.{a,b}\\n newSeries = evaluateTarget(requestContext, series.pathExpression)[0]\\n series[0:len(series)] = newSeries\\n series.start = newSeries.start\\n series.end = newSeries.end\\n series.step = newSeries.step\\n\\n for series in seriesList:\\n buckets = {} # { timestamp: [values] }\\n\\n timestamps = range( int(series.start), int(series.end), int(series.step) )\\n datapoints = zip(timestamps, series)\\n\\n # Populate buckets\\n for timestamp_, value in datapoints:\\n bucketInterval = int((timestamp_ - series.start) / interval)\\n\\n if bucketInterval not in buckets:\\n buckets[bucketInterval] = []\\n\\n if value is not None:\\n buckets[bucketInterval].append(value)\\n\\n\\n newValues = []\\n for timestamp_ in range(series.start, series.end, interval):\\n bucketInterval = int((timestamp_ - series.start) / interval)\\n bucket = buckets.get(bucketInterval, [])\\n\\n if bucket:\\n if func == 'avg':\\n newValues.append( float(sum(bucket)) / float(len(bucket)) )\\n elif func == 'last':\\n newValues.append( bucket[len(bucket)-1] )\\n elif func == 'max':\\n newValues.append( max(bucket) )\\n elif func == 'min':\\n newValues.append( min(bucket) )\\n else:\\n newValues.append( sum(bucket) )\\n else:\\n newValues.append( None )\\n\\n newName = \\\"smartSummarize(%s, \\\\\\\"%s\\\\\\\", \\\\\\\"%s\\\\\\\")\\\" % (series.name, intervalString, func)\\n alignedEnd = series.start + (bucketInterval * interval) + interval\\n newSeries = TimeSeries(newName, series.start, alignedEnd, interval, newValues)\\n newSeries.pathExpression = newName\\n results.append(newSeries)\\n\\n return results\",\n \"def aggregate_time(self, temporal_window, aggregationfunction) -> Series :\\n pickled_lambda = cloudpickle.dumps(aggregationfunction)\\n\\n process_id = 'reduce_by_time'\\n args = {\\n 'imagery':self.graph,\\n 'temporal_window': temporal_window,\\n 'function': str(base64.b64encode(pickled_lambda), \\\"UTF-8\\\")\\n }\\n\\n return self.graph_add_process(process_id, args)\",\n \"def aggregate_time(self, temporal_window, aggregationfunction) -> Series :\\n pickled_lambda = cloudpickle.dumps(aggregationfunction)\\n\\n process_id = 'reduce_by_time'\\n args = {\\n 'imagery':self.graph,\\n 'temporal_window': temporal_window,\\n 'function': str(base64.b64encode(pickled_lambda), \\\"UTF-8\\\")\\n }\\n\\n return self.graph_add_process(process_id, args)\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def _aggregate(self, method, column, keys=None, **kwds_filter):\\n fn = lambda src: getattr(src, method)(column, keys, **kwds_filter)\\n results = (fn(source) for source in self._sources) # Perform aggregation.\\n\\n if not keys:\\n return sum(results) # <- EXIT!\\n\\n total = defaultdict(lambda: 0)\\n for result in results:\\n for key, val in result.items():\\n total[key] += val\\n return CompareDict(total, keys)\",\n \"def metric(self):\\n return self._metric\",\n \"def sum(self):\\n return self._summarize(lambda c: c.sum)\",\n \"def with_sum_mean_reduction(self):\\n return self.with_reduction(lambda x: x.sum(1).mean(0))\",\n \"def database_statistic(func):\\n global database_statistics_registry\\n database_statistics_registry.append((func.__name__, func))\\n return property(func)\",\n \"def get_metric(self, reset: bool = False):\\n average_value = self._total_value / self._count if self._count > 0 else 0\\n if reset:\\n self.reset()\\n return average_value\",\n \"def evaluate(self) -> Dict[str, Any]:\\n kwargs = {\\\"ids\\\": self._ids}\\n return {\\n metric.value: self._metric_funcs[metric](\\n self._targets, self._preds, **kwargs\\n )\\n for metric in self._metrics\\n }\",\n \"def build_metric_func(dataset_split_name, add_summary=True):\\n\\n def metric_func(labels, logits):\\n \\\"\\\"\\\"Evaluation metric function that runs on CPU.\\\"\\\"\\\"\\n accuracy_metric_name = 'Eval/Accuracy/%s' % dataset_split_name\\n metric_map = {\\n accuracy_metric_name: tf.metrics.accuracy(labels, tf.argmax(logits, 1)),\\n }\\n if add_summary:\\n for name, value in metric_map.items():\\n tf.summary.scalar(name, value)\\n return metric_map\\n\\n return metric_func\",\n \"def fetch_aggregation(self):\\n return None\",\n \"def metrics(self):\\n return self.__metrics\",\n \"def metric_average(val, name, hvd):\\n tensor = val.clone().detach()\\n avg_tensor = hvd.allreduce(tensor, name=name)\\n return avg_tensor.item()\",\n \"def get_composed_metrics(\\n self, column: Column, metric: Metrics, column_results: Dict\\n ):\\n try:\\n return metric(column).fn(column_results)\\n except Exception as exc:\\n logger.debug(traceback.format_exc())\\n logger.warning(f\\\"Unexpected exception computing metrics: {exc}\\\")\\n return None\",\n \"def metric(self):\\n\\n if not self._metric_cache:\\n # Select an appropriate statistic\\n cls = utils.import_class_or_module(self._metric)\\n self._metric_cache = cls(self.additional)\\n\\n return self._metric_cache\",\n \"def compute(self) -> Any:\\n # ddp hotfix, could be done better\\n # but metric must handle DDP on it's own\\n if self._ddp_backend == \\\"xla\\\":\\n device = get_device()\\n for key in self.statistics:\\n key_statistics = torch.tensor([self.statistics[key]], device=device)\\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\\n self.statistics[key] = key_statistics\\n elif self._ddp_backend == \\\"ddp\\\":\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n if self.compute_per_class_metrics:\\n return per_class, micro, macro, weighted\\n else:\\n return [], micro, macro, weighted\",\n \"def compute(self) -> Any:\\n # ddp hotfix, could be done better\\n # but metric must handle DDP on it's own\\n if self._ddp_backend == \\\"xla\\\":\\n device = get_device()\\n for key in self.statistics:\\n key_statistics = torch.tensor([self.statistics[key]], device=device)\\n key_statistics = xm.all_gather(key_statistics).sum(dim=0).cpu().numpy()\\n self.statistics[key] = key_statistics\\n elif self._ddp_backend == \\\"ddp\\\":\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = get_aggregated_metrics(\\n tp=self.statistics[\\\"tp\\\"],\\n fp=self.statistics[\\\"fp\\\"],\\n fn=self.statistics[\\\"fn\\\"],\\n support=self.statistics[\\\"support\\\"],\\n zero_division=self.zero_division,\\n )\\n if self.compute_per_class_metrics:\\n return per_class, micro, macro, weighted\\n else:\\n return [], micro, macro, weighted\",\n \"def aggregate(self, func):\\n axis_name = self.obj._get_axis_name(self.axis)\\n getter = lambda p, group: p.reindex(**{axis_name : group})\\n result_d = self._aggregate_generic(getter, func,\\n axis=self.axis)\\n\\n result = WidePanel.fromDict(result_d, intersect=False)\\n\\n if self.axis > 0:\\n result = result.swapaxes(0, self.axis)\\n\\n return result\",\n \"def summary(self):\\n summaries = self.summaries()\\n # Reduce to a single summary with weighted averages for each\\n # field except \\\"total_instances\\\", which is summed.\\n total_instances = sum(d['total_instances'].value() for d in summaries)\\n summary = {'total_instances': total_instances}\\n for field in ('average_qps', 'average_latency', 'average_memory'):\\n instance_weighted_sum = sum(\\n d['total_instances'].value() * d[field].value()\\n for d in summaries)\\n summary[field] = float(instance_weighted_sum) / total_instances\\n # Beautify rounding precision to match the App Engine UI.\\n summary['average_qps'] = round(summary['average_qps'], 3)\\n summary['average_latency_ms'] = round(summary['average_latency'], 1)\\n summary['average_memory_mb'] = round(summary['average_memory'], 1)\\n del summary['average_latency']\\n del summary['average_memory']\\n return summary\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6408343","0.63543737","0.62959653","0.62449336","0.6215591","0.61848396","0.6074576","0.60159856","0.5993007","0.59578437","0.5943741","0.593868","0.59344465","0.59140265","0.5911688","0.5882706","0.58362037","0.5827314","0.5803448","0.5791047","0.5774229","0.5765365","0.57446474","0.57104844","0.56938475","0.5645896","0.5638439","0.56369746","0.55916506","0.5591511","0.5583419","0.55833745","0.55724126","0.55607677","0.5552704","0.55264026","0.55218774","0.54840237","0.5473852","0.546249","0.54469484","0.5430726","0.5419409","0.54152334","0.5412143","0.54100496","0.53787565","0.5378188","0.53755414","0.53557956","0.5348466","0.533602","0.5326736","0.5323956","0.53206795","0.53060853","0.5301709","0.5300294","0.5299529","0.5297858","0.5294686","0.5290195","0.52756953","0.52718157","0.5266873","0.52547425","0.52527326","0.5245886","0.5241794","0.52373034","0.52371967","0.5231707","0.52291435","0.52165425","0.52120686","0.51989454","0.5196003","0.51917","0.51911914","0.5191107","0.51860714","0.51860714","0.51855993","0.51817393","0.5173863","0.5169798","0.5168119","0.51640105","0.51630914","0.5161032","0.51579094","0.5155784","0.51516724","0.5141787","0.51410604","0.51294535","0.5128503","0.5128503","0.5118414","0.5109993"],"string":"[\n \"0.6408343\",\n \"0.63543737\",\n \"0.62959653\",\n \"0.62449336\",\n \"0.6215591\",\n \"0.61848396\",\n \"0.6074576\",\n \"0.60159856\",\n \"0.5993007\",\n \"0.59578437\",\n \"0.5943741\",\n \"0.593868\",\n \"0.59344465\",\n \"0.59140265\",\n \"0.5911688\",\n \"0.5882706\",\n \"0.58362037\",\n \"0.5827314\",\n \"0.5803448\",\n \"0.5791047\",\n \"0.5774229\",\n \"0.5765365\",\n \"0.57446474\",\n \"0.57104844\",\n \"0.56938475\",\n \"0.5645896\",\n \"0.5638439\",\n \"0.56369746\",\n \"0.55916506\",\n \"0.5591511\",\n \"0.5583419\",\n \"0.55833745\",\n \"0.55724126\",\n \"0.55607677\",\n \"0.5552704\",\n \"0.55264026\",\n \"0.55218774\",\n \"0.54840237\",\n \"0.5473852\",\n \"0.546249\",\n \"0.54469484\",\n \"0.5430726\",\n \"0.5419409\",\n \"0.54152334\",\n \"0.5412143\",\n \"0.54100496\",\n \"0.53787565\",\n \"0.5378188\",\n \"0.53755414\",\n \"0.53557956\",\n \"0.5348466\",\n \"0.533602\",\n \"0.5326736\",\n \"0.5323956\",\n \"0.53206795\",\n \"0.53060853\",\n \"0.5301709\",\n \"0.5300294\",\n \"0.5299529\",\n \"0.5297858\",\n \"0.5294686\",\n \"0.5290195\",\n \"0.52756953\",\n \"0.52718157\",\n \"0.5266873\",\n \"0.52547425\",\n \"0.52527326\",\n \"0.5245886\",\n \"0.5241794\",\n \"0.52373034\",\n \"0.52371967\",\n \"0.5231707\",\n \"0.52291435\",\n \"0.52165425\",\n \"0.52120686\",\n \"0.51989454\",\n \"0.5196003\",\n \"0.51917\",\n \"0.51911914\",\n \"0.5191107\",\n \"0.51860714\",\n \"0.51860714\",\n \"0.51855993\",\n \"0.51817393\",\n \"0.5173863\",\n \"0.5169798\",\n \"0.5168119\",\n \"0.51640105\",\n \"0.51630914\",\n \"0.5161032\",\n \"0.51579094\",\n \"0.5155784\",\n \"0.51516724\",\n \"0.5141787\",\n \"0.51410604\",\n \"0.51294535\",\n \"0.5128503\",\n \"0.5128503\",\n \"0.5118414\",\n \"0.5109993\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5814285"},"document_rank":{"kind":"string","value":"18"}}},{"rowIdx":85161,"cells":{"query":{"kind":"string","value":"Return dictionary of model evaluation metrics."},"document":{"kind":"string","value":"def get_eval_metrics(logits, labels, params):\n metrics = {\n \"accuracy\": _convert_to_eval_metric(padded_accuracy)(logits, labels),\n \"accuracy_top5\": _convert_to_eval_metric(padded_accuracy_top5)(\n logits, labels),\n \"accuracy_per_sequence\": _convert_to_eval_metric(\n padded_sequence_accuracy)(logits, labels),\n \"neg_log_perplexity\": _convert_to_eval_metric(padded_neg_log_perplexity)(\n logits, labels, params.vocab_size),\n \"approx_bleu_score\": _convert_to_eval_metric(bleu_score)(logits, labels),\n \"rouge_2_fscore\": _convert_to_eval_metric(rouge_2_fscore)(logits, labels),\n \"rouge_L_fscore\": _convert_to_eval_metric(rouge_l_fscore)(logits, labels),\n }\n\n # Prefix each of the metric names with \"metrics/\". This allows the metric\n # graphs to display under the \"metrics\" category in TensorBoard.\n metrics = {\"metrics/%s\" % k: v for k, v in six.iteritems(metrics)}\n return metrics"},"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 evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics","def calc_metrics(model, X, y):\n\n # Get model predictions\n y_predict_r = model.predict(X)\n\n # Calculate evaluation metrics for assesing performance of the model.\n roc = roc_auc_score(y, y_predict_r)\n acc = accuracy_score(y, y_predict_r)\n prec = precision_score(y, y_predict_r)\n rec = recall_score(y, y_predict_r)\n f1 = f1_score(y, y_predict_r)\n\n return {\"acc\": acc, \"roc\": roc, \"prec\": prec, \"rec\": rec, \"f1\": f1}","def evaluate(self) -> Dict[str, Any]:\n kwargs = {\"ids\": self._ids}\n return {\n metric.value: self._metric_funcs[metric](\n self._targets, self._preds, **kwargs\n )\n for metric in self._metrics\n }","def get_model_evaluations(self):\n return self._model_evaluations","def evaluate(self, test):\r\n self.logger.info(\"Testing model over test set\")\r\n metrics = self.run_evaluate(test)\r\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\r\n for k, v in metrics.items()])\r\n self.logger.info(msg)\r\n return metrics","def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\n return self._metric_tests","def evaluate(self, test):\n self.logger.info(\"Testing model over test set\")\n metrics = self.run_evaluate(test)\n msg = \" - \".join([\"{} {:04.2f}\".format(k, v)\n for k, v in metrics.items()])\n self.logger.info(msg)\n return metrics","def validate(self):\n stats = {}\n evaluate_config = {\"verbose\": self.verbose}\n evaluate_config.update(self.config.get(\"evaluate_config\", {}))\n\n results = self.model.evaluate(self.test_dataset, **evaluate_config)\n if results is None:\n # Using local Model since model.evaluate() returns None\n # for MultiWorkerMirroredStrategy\n logger.warning(\"Running a local model to get validation score.\")\n self.local_model = self.model_creator(self.config)\n self.local_model.set_weights(self.model.get_weights())\n results = self.local_model.evaluate(self.test_dataset,\n **evaluate_config)\n\n if isinstance(results, list):\n stats = {\n \"validation_\" + k: v\n for k, v in zip(self.model.metrics_names, results)\n }\n else:\n stats = {\"loss\": results}\n\n return stats","def evaluate(self, X: np.ndarray, y: list, X_train=None, y_train=None) -> dict:\n metrics = self.compute_metrics(X, y)\n\n print(\"evaluation: \", metrics)\n return metrics","def _build_eval_metrics(self, results, features, labels):\n metrics = {}\n for metric in self.metrics:\n metrics[metric.IDENTIFIER] = getters.get_metric(\n metric.IDENTIFIER, results, labels, **metric.to_dict())\n return metrics","def model_evaluate(self, test):\n features = {name: np.array(value) for name, value in test.items()}\n labels = {name: features.pop(name) for name in self.label_names}\n metrics = self.model.evaluate(x=features, y=labels, batch_size=5)\n return metrics","def get_model_evaluation(self):\n\n self.log(f\"{self.cur_file_path}\\t\\tInfo: model_evaluation method invoked for {self.model.__class__.__name__}!\")\n\n evaluation = ModelEvaluation(self.model, (self.trainX, self.trainY), (self.testX, self.testY))\n return evaluation.get_evaluation_report()","def report(self):\n m = {}\n num_tok = self.metrics['num_tokens']\n if num_tok > 0:\n if self.metrics['correct_tokens'] > 0:\n m['token_acc'] = self.metrics['correct_tokens'] / num_tok\n m['loss'] = self.metrics['loss'] / num_tok\n if self.metrics['pred_count'] > 0:\n m['pred'] = self.metrics['correct_pred'] / self.metrics['pred_count']\n try:\n m['ppl'] = math.exp(m['loss'])\n except OverflowError:\n m['ppl'] = float('inf')\n if self.metrics['total_skipped_batches'] > 0:\n m['total_skipped_batches'] = self.metrics['total_skipped_batches']\n for k, v in m.items():\n # clean up: rounds to sigfigs and converts tensors to floats\n m[k] = round_sigfigs(v, 4)\n return m","def get_val_metrics(self, metrics_type=\"classification\"):\n assert self.is_trained, \"You need to train the models before getting validation metrics\"\n # Get the set of metrics adapted to the task\n metrics = METRICS[metrics_type]\n # Train the model\n preds = self.preds\n score = {}\n for k, v in metrics.items():\n score[k] = v(self.true_labels.values, preds)\n return score","def evaluate(self):\n results = dict()\n for metric in self.metrics:\n print('Evaluating clustering with metric %s' % metric)\n if metric in LABEL_METRICS.keys():\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\n self.results = results\n return results","def get_metrics(self, x, y):\n metrics = dict()\n y_predicted = self.predict(x)\n metrics['Accuracy'] = accuracy_score(y, y_predicted)\n metrics['F1'] = f1_score(y, y_predicted)\n metrics['Precision'] = precision_score(y, y_predicted)\n\n return metrics","def metrics(self) -> dict:\n if not self.exp_metadata.metrics:\n self.exp_metadata.metrics = {}\n return self.exp_metadata.metrics","def _monitor_metrics(self):\n metrics = [\"loss\"]\n try:\n m = U.metrics_from_model(self.model)\n if isinstance(m, list):\n metrics.extend(m)\n except:\n pass\n if self.val_data is not None:\n for m in metrics[:]:\n metrics.append(\"val_%s\" % (m))\n return metrics","def compute_metrics(self):\n self.finalize_output_dict()\n self.metric_dict = {\n key: value(self.output_dict[\"labels\"], self.output_dict[\"pred_probs\"])\n for key, value in self.metric_fns.items()\n }","def metrics(self, weights=None):\n yt = self.ytrue\n yp = self.ypred\n w = weights\n\n if yt.size > 0:\n mse = skm.mean_squared_error(yt, yp, sample_weight=w)\n rmse = np.sqrt(mse)\n mae = skm.mean_absolute_error(yt, yp, sample_weight=w)\n median_absolute_error = skm.median_absolute_error(yt, yp)\n r2_score = skm.r2_score(yt, yp, sample_weight=w)\n ev_score = skm.explained_variance_score(yt, yp, sample_weight=w)\n max_error = skm.max_error(yt, yp)\n support = len(yt)\n else:\n mse = 0.0\n rmse = 0.0\n mae = 0.0\n median_absolute_error = 0.0\n r2_score = 0.0\n ev_score = 0.0\n max_error = 0.0\n support = 0\n\n return {\n \"mean_squared_error\": mse,\n \"root_mean_squared_error\": rmse,\n \"mean_absolute_error\": mae,\n \"median_absolute_error\": median_absolute_error,\n \"r2_score\": r2_score,\n \"explained_variance_score\": ev_score,\n \"max_error\": max_error,\n \"support\": support,\n }","def evaluate(self, params):\n model = self.train(params)\n Y_pred = model.predict(self.X_test)\n\n if self.dataset_type == PROBLEM.CLASSIFICATION:\n return {\n 'score': accuracy_score(self.Y_test, Y_pred),\n 'matrix': confusion_matrix(self.Y_test, Y_pred).tolist(),\n 'report': classification_report(self.Y_test, Y_pred,\n target_names=self.labels,\n zero_division=1)\n }\n else:\n return {\n 'max_error': max_error(self.Y_test, Y_pred),\n 'mae': mean_absolute_error(self.Y_test, Y_pred),\n 'mse': mean_squared_error(self.Y_test, Y_pred)\n }","def metrics(self):\n \n if self.mse.shape[0]>1:\n raise ValueError('Metrics can only handle single observations.')\n \n if self.N==1:\n pred = float('nan')\n err = float('nan')\n y_true = float('nan')\n else:\n pred = int(self._predictions[-1])\n err = self._mse[-1]\n y_true = int(self.label[0])\n \n is_outlier = {\"type\":\"GAUGE\",\"key\":\"is_outlier\",\"value\":pred}\n mse = {\"type\":\"GAUGE\",\"key\":\"mse\",\"value\":err}\n obs = {\"type\":\"GAUGE\",\"key\":\"observation\",\"value\":self.N - 1}\n threshold = {\"type\":\"GAUGE\",\"key\":\"threshold\",\"value\":self.threshold}\n \n label = {\"type\":\"GAUGE\",\"key\":\"label\",\"value\":y_true}\n \n accuracy_tot = {\"type\":\"GAUGE\",\"key\":\"accuracy_tot\",\"value\":self.metric[4]}\n precision_tot = {\"type\":\"GAUGE\",\"key\":\"precision_tot\",\"value\":self.metric[5]}\n recall_tot = {\"type\":\"GAUGE\",\"key\":\"recall_tot\",\"value\":self.metric[6]}\n f1_score_tot = {\"type\":\"GAUGE\",\"key\":\"f1_tot\",\"value\":self.metric[7]}\n f2_score_tot = {\"type\":\"GAUGE\",\"key\":\"f2_tot\",\"value\":self.metric[8]}\n \n accuracy_roll = {\"type\":\"GAUGE\",\"key\":\"accuracy_roll\",\"value\":self.metric[9]}\n precision_roll = {\"type\":\"GAUGE\",\"key\":\"precision_roll\",\"value\":self.metric[10]}\n recall_roll = {\"type\":\"GAUGE\",\"key\":\"recall_roll\",\"value\":self.metric[11]}\n f1_score_roll = {\"type\":\"GAUGE\",\"key\":\"f1_roll\",\"value\":self.metric[12]}\n f2_score_roll = {\"type\":\"GAUGE\",\"key\":\"f2_roll\",\"value\":self.metric[13]}\n \n true_negative = {\"type\":\"GAUGE\",\"key\":\"true_negative\",\"value\":self.metric[0]}\n false_positive = {\"type\":\"GAUGE\",\"key\":\"false_positive\",\"value\":self.metric[1]}\n false_negative = {\"type\":\"GAUGE\",\"key\":\"false_negative\",\"value\":self.metric[2]}\n true_positive = {\"type\":\"GAUGE\",\"key\":\"true_positive\",\"value\":self.metric[3]}\n \n nb_outliers_roll = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_roll\",\"value\":self.metric[14]}\n nb_labels_roll = {\"type\":\"GAUGE\",\"key\":\"nb_labels_roll\",\"value\":self.metric[15]}\n nb_outliers_tot = {\"type\":\"GAUGE\",\"key\":\"nb_outliers_tot\",\"value\":self.metric[16]}\n nb_labels_tot = {\"type\":\"GAUGE\",\"key\":\"nb_labels_tot\",\"value\":self.metric[17]}\n \n return [is_outlier,mse,obs,threshold,label,\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\n true_negative,false_positive,false_negative,true_positive,\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]","def _get_eval_metric(self):\n raise NotImplementedError","def evaluate(self, dataset):\n logging.info('Start evaluation')\n\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\n\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\n\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\n\n logging.info(eval_info)\n\n logging.info('Evaluation finished')\n\n return metrics_dict","def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\n r_temp = {}\n for metric_name in self.metrics:\n r_temp.update({f\"{metric_name}_Model\": name, f\"{metric_name}_Sum\": 0,\n f\"{metric_name}_Min\": 1000000, f\"{metric_name}_Max\": 0})\n\n for i in range(self.repetitions):\n is_nan = True\n while (is_nan):\n model = self.get_model(train_x.shape[1], n_targets)\n model.fit(train_x, train_y, **self.fit_kwargs)\n result = model.predict(test_x)\n is_nan = np.any(np.isnan(result))\n del model\n\n for metric_name in self.metrics:\n metric = self.get_metrics(metric_name)\n value = metric(result, test_y)\n r_temp[f\"{metric_name}_Sum\"] += value\n if r_temp[f\"{metric_name}_Min\"] > value:\n r_temp[f\"{metric_name}_Min\"] = value\n if r_temp[f\"{metric_name}_Max\"] < value:\n r_temp[f\"{metric_name}_Max\"] = value\n keras.backend.clear_session()\n for metric_name in self.metrics:\n r_temp[f\"{metric_name}_Mean\"] = r_temp[f\"{metric_name}_Sum\"] / self.repetitions\n return r_temp","def compute_metrics(self, results: list) -> dict:","def get_metrics(self) -> dict:\n return self.metric_dict","def get_metrics(self) -> Dict[str, base.Number]:\n return self._metrics","def get_evaluations(self):\r\n return self.evaluations","def compute_metrics(self):\n pass","def compute_and_print_eval_metrics(self):\n s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')\n precision, recall, f1, mean_precision, mean_recall, map50, map = 0., 0., 0., 0., 0., 0., 0.\n ap = []\n eval_stats = [np.concatenate(x, 0) for x in zip(*self.eval_stats)]\n if len(eval_stats) and eval_stats[0].any():\n precision, recall, ap, f1, ap_class = ap_per_class(*eval_stats)\n precision, recall, ap50, ap = precision[:, 0], recall[:, 0], ap[:, 0], ap.mean(1)\n mean_precision, mean_recall, map50, map = precision.mean(), recall.mean(), ap50.mean(), ap.mean()\n nt = np.bincount(eval_stats[3].astype(np.int64), minlength=len(self.class_names)) # number of targets per class\n else:\n nt = np.zeros(1)\n\n pf = '%20s' + '%12.5g' * 6 # print format\n print(\"\\n EVALUTAION \\n\")\n print(s)\n print(pf % ('all', self.seen, nt.sum(), mean_precision, mean_recall, map50, map))\n if self.cfg.eval.verbose:\n for indx, cls in enumerate(ap_class):\n print(pf % (self.class_names[cls], self.seen, nt[cls], precision[indx], recall[indx], ap50[indx], ap[indx]))","def get_evaluation_metric(self):\n\t\treturn self.metric","def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\n\n scores = model.evaluate(x_train, n_y_array, verbose=1)\n\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\n\n\n print(\"for traininf set\")\n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores[0]))\n\n\n\n print(\"for validation set : \") \n\n print(\"%s: %.2f%%\" % (model.metrics_names[1], scores2[1]*100))\n\n print(\"%s: %.2f%%\" % (model.metrics_names[0], scores2[0]))","def metrics(self) -> list[dict[str, dict[str, float | int]]]:\n return self.performance[\"performances\"]","def evaluate(self, csls, evals, mode=\"csls\"):\n metrics = {}\n for eval_func in evals:\n assert hasattr(self, eval_func), \\\n \"Eval Function {0} not found\".format(eval_func)\n metrics = getattr(self, eval_func)(csls, metrics, mode=mode)\n return metrics","def evaluate_model(model,\n xs: list, ys: list, labels: list,\n metrics: list):\n\n metrics_summary = {}\n\n for x, y, label in zip(xs, ys, labels):\n\n y_pred = model.predict(x)\n\n for metric in metrics:\n try:\n value = metrics_map[metric](y, y_pred)\n except Exception as e:\n logger.error(f\"Error during metric calculation: {e}\")\n print(f\"Error during metric calculation: {e}\\n\"\n \"metric value set to np.nan \")\n value = np.nan\n\n metrics_summary[f\"{metric} {label}\"] = value\n\n logger.info(\"Evaluate Model process is finished\")\n\n return metrics_summary","def evaluate(self):\n\n\t\tself.model_score = self.model.evaluate(self.x_test, self.y_test, batch_size=2048)\n\t\tprint(\"%s score = %f\\n\" %(self.modelName, self.model_score[1]))\n\t\treturn self.model_score","def compute(self) -> Dict[str, np.ndarray]:\n return {name: self.metrics[name].compute() for name in self.metrics}","def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy","def metrics(self):\n return self.verificationRun.metrics()","def metrics(self):\n return self.__metrics","def _getMetrics(self):\n metric = None\n if self.metrics is not None:\n metric = self.metrics(self._currentRecordIndex+1)\n elif self.metricValue is not None:\n metric = self.metricValue\n else:\n raise RuntimeError('No metrics or metric value specified for dummy model')\n\n return {self._optimizeKeyPattern:metric}","def metrics(self):\n return self._metrics","def metrics(self):\n return self._metrics","def metrics(self):\n return {**self.prepend_name_dict(self._prefixes[0], self._train_metrics),\n **self.prepend_name_dict(self._prefixes[1], self.validator.metrics)}","def get_metrics(self, reset: bool = False) -> Dict[str, float]:\n return {'accuracy' : self.accuracy.get_metric(reset)}","def evaluate(self, model, X_train, X_test, y_train, y_test):\n\n model.fit(X_train,y_train)\n y_pred = model.predict(X_test)\n R2 = r2_score(y_test, y_pred)\n MAE = round(mape(y_test, y_pred), 2)\n RMSE = round(rmse(y_test, y_pred), 2)\n\n res = {'Model': self.model, 'R2' : R2, 'MAPE': MAE, 'RMSE': RMSE}\n return res","def evaluated_data(self) -> Dict:\n if not self.eval_data:\n raise Exception(\"Evaluation Failed\")\n\n statistics = [stat['statistics'] for stat in self.eval_data]\n for count, stat in enumerate(statistics):\n if stat:\n eval_data = stat.split(\"=\")\n char_error = re.findall(r\"\\d+\\.\\d+\", eval_data[-2])[0]\n word_error = eval_data[-1]\n\n self.eval_data[count]['character_error'] = float(char_error)\n self.eval_data[count]['word_error'] = float(word_error)\n del self.eval_data[count]['statistics']\n\n return self.eval_data","def get_scores(self):\n return SklearnModel.evaluate_no_ground_truth_classifier_metrics(self.X_test, self.predictions)","def evaluate(self, model_idx,\n max_eval_batches=None,\n write_results=False,\n write_to_summary=True):\n \n # write_summary needs global_step\n self._step_collections[\"GlobalStep\"] = (\n self._sess.run(self._global_step_tensor))\n\n # evaluate the model\n model_name = \"%s-%d\" % (self._names[model_idx], model_idx)\n counts, scores = self._evaluate(\n data=self._data[model_idx],\n logits=self._logits_collections[model_idx],\n predictions=self._predictions_collections[model_idx],\n evaluation_fn=self._evaluation_fns[model_idx],\n max_eval_batches=max_eval_batches,\n calculate_scores=True,\n write_results=write_results)\n\n # write summary\n if write_to_summary:\n self.write_summary(\n \"TASK-%s/ValScores\" % model_name, scores)\n\n return {\"MAIN\": scores}","def compute_metrics(self, results: list) -> dict:\n dump(results, self.out_file_path)\n print_log(\n f'Results has been saved to {self.out_file_path}.',\n logger='current')\n return {}","def metrics(self):\n raise NotImplementedError(\"metrics\")","def get_evaluation_metric(config, logger, device):\r\n metrics = config['eval']['metrics']\r\n if not isinstance(metrics, list):\r\n metrics = [metrics]\r\n curves = config['eval'].get('curves', list())\r\n threshold = config['eval'].get('probability_threshold', 0.5)\r\n num_classes = config['model']['num_classes']\r\n\r\n metrics_dict = {}\r\n curves_dict = {}\r\n cm = _ConfusionMatrix(num_classes=num_classes, threshold=threshold).to(device)\r\n cm_per_target = None\r\n cms = None\r\n cms_per_target = None\r\n if any([item.startswith('per_target_') for item in metrics]):\r\n cm_per_target = _ConfusionMatrix(num_classes=num_classes, threshold=threshold).to(device)\r\n if any(['auc' in item for item in metrics]) or any(['ap' in item for item in metrics]) \\\r\n or any(['pr' in item for item in curves]) or any(['pr' in item for item in curves]):\r\n thresholds_type = config['eval'].get('thresholds_type', 'logspace')\r\n if thresholds_type == 'logspace':\r\n thresholds = ((np.logspace(0, 1, config['eval']['num_thresholds'] + 2) - 1) / 9)[1: -1]\r\n elif thresholds_type == 'logspace_pro':\r\n thresholds = ((np.logspace(0, 1, config['eval']['num_thresholds'] + 2, base=100) - 1) / 99)[1: -1]\r\n elif thresholds_type == 'linspace':\r\n thresholds = np.linspace(0.0, 1.0, config['eval']['num_thresholds'] + 2)[1: -1]\r\n elif thresholds_type == 'uline':\r\n thresholds = (((np.logspace(0, 1, config['eval']['num_thresholds'] // 2 + 2,\r\n base=10000000000) - 1) / 9999999999)[1: -1]) / 2\r\n if config['eval']['num_thresholds'] % 2 == 1:\r\n thresholds = np.append(thresholds, 0.5)\r\n for i in range(config['eval']['num_thresholds'] // 2 - 1, -1, -1):\r\n thresholds = np.append(thresholds, 1.0 - thresholds[i])\r\n else:\r\n logger.critical('thresholds_type is not supported: %s' % thresholds_type)\r\n exit(1)\r\n cms = [_ConfusionMatrix(num_classes, t, True).to(device) for t in thresholds]\r\n cms_per_target = None\r\n if any([item.startswith('per_target_') for item in curves]) or any(\r\n item.startswith('per_target_') for item in metrics):\r\n cms_per_target = [_ConfusionMatrix(num_classes, t, True).to(device) for t in thresholds]\r\n update_flags = [True, True, True, True] # single, multiple, per_target_single, per_target_multiple\r\n for metric_name in metrics:\r\n if metric_name.startswith('per_target_'):\r\n callback_fn = per_target_transform\r\n update_flag_id = 2\r\n used_cm = cm_per_target\r\n used_cms = cms_per_target\r\n else:\r\n callback_fn = None\r\n update_flag_id = 0\r\n used_cm = cm\r\n used_cms = cms\r\n if metric_name.endswith('tp'):\r\n metrics_dict[metric_name] = TruePositive(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('fp'):\r\n metrics_dict[metric_name] = FalsePositive(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('fn'):\r\n metrics_dict[metric_name] = FalseNegative(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('tn'):\r\n metrics_dict[metric_name] = TrueNegative(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('precision'):\r\n metrics_dict[metric_name] = Precision(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(\r\n device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('recall'):\r\n metrics_dict[metric_name] = Recall(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(\r\n device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('sensitivity'):\r\n metrics_dict[metric_name] = Sensitivity(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('specificity'):\r\n metrics_dict[metric_name] = Specificity(used_cm, update=update_flags[update_flag_id],\r\n callback_fn=callback_fn).to(device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('dsc'):\r\n metrics_dict[metric_name] = DSC(used_cm, update=update_flags[update_flag_id], callback_fn=callback_fn).to(\r\n device)\r\n update_flags[update_flag_id] = False\r\n elif metric_name.endswith('auc'):\r\n metrics_dict[metric_name] = AUC(used_cms, update=update_flags[update_flag_id + 1],\r\n callback_fn=callback_fn).to(\r\n device)\r\n update_flags[update_flag_id + 1] = False\r\n elif metric_name.endswith('ap'):\r\n metrics_dict[metric_name] = AP(used_cms, update=update_flags[update_flag_id + 1],\r\n callback_fn=callback_fn).to(\r\n device)\r\n update_flags[update_flag_id + 1] = False\r\n elif metric_name.endswith('hd95'):\r\n metrics_dict[metric_name] = HD95(threshold).to(device)\r\n else:\r\n logger.error('Unrecognized metric: %s' % metric_name)\r\n continue\r\n for curve_name in curves:\r\n if curve_name.startswith('per_target_'):\r\n callback_fn = per_target_transform\r\n update_flag_id = 2\r\n used_cm = cm_per_target\r\n used_cms = cms_per_target\r\n else:\r\n callback_fn = None\r\n update_flag_id = 0\r\n used_cm = cm\r\n used_cms = cms\r\n if curve_name.endswith('roc'):\r\n if curve_name.replace('roc', 'auc') not in metrics_dict:\r\n logger.warning('%s not in metrics but %s in curves. Adding %s to metrics'\r\n % (curve_name.replace('roc', 'auc'), curve_name, curve_name.replace('roc', 'auc')))\r\n metrics_dict[curve_name.replace('roc', 'auc')] = AUC(used_cms, update=update_flags[update_flag_id + 1],\r\n callback_fn=callback_fn)\r\n update_flags[update_flag_id + 1] = False\r\n curves_dict[curve_name] = metrics_dict[curve_name.replace('roc', 'auc')]\r\n elif curve_name.endswith('pr'):\r\n if curve_name.replace('pr', 'ap') not in metrics_dict:\r\n logger.warning('%s not in metrics but %s in curves. Adding %s to metrics'\r\n % (curve_name.replace('pr', 'ap'), curve_name, curve_name.replace('pr', 'ap')))\r\n metrics_dict[curve_name.replace('pr', 'ap')] = AP(used_cms, update=update_flags[update_flag_id + 1],\r\n callback_fn=callback_fn)\r\n update_flags[update_flag_id + 1] = False\r\n curves_dict[curve_name] = metrics_dict[curve_name.replace('pr', 'ap')]\r\n if len(metrics_dict) == 0:\r\n logger.critical('No metric is added')\r\n exit(1)\r\n return metrics_dict, curves_dict","def _get_val_metrics(\n self,\n ) -> Tuple[_Metrics, torch.Tensor, torch.Tensor, torch.Tensor]:\n # Turn off batch-norm updates\n self.model.eval()\n\n with torch.no_grad():\n metrics = _Metrics()\n\n for val_img, val_gt in tqdm(\n self.val_loader, desc=\"Validating\", leave=False\n ):\n val_img = val_img.to(self.device)\n val_gt = val_gt.to(self.device)\n\n with autocast(enabled=self.config.mixed_precision):\n val_pred = self.model(val_img)[0]\n metrics.class_loss += self.class_loss_fn(val_pred, val_gt)\n\n metrics.accuracy += self._get_acc(val_pred, val_gt)\n metrics.f1_score += self._get_f1(val_pred, val_gt)\n\n metrics.class_loss /= len(self.val_loader)\n metrics.accuracy /= len(self.val_loader)\n metrics.f1_score /= len(self.val_loader)\n\n return metrics, val_img, val_gt, torch.sigmoid(val_pred)","def training_metrics(self):\r\n if self._training_metrics is None:\r\n # Builds the per-task metrics and losses.\r\n self._training_metrics = {}\r\n for name, task in self.multi_task.tasks.items():\r\n self._training_metrics[name] = task.build_metrics(training=True)\r\n return self._training_metrics","def _calculate_metrics(self):\n metrics = {}\n precision, recall = self.calc_precision_recall()\n metrics[\"precision\"] = precision\n metrics[\"recall\"] = recall\n metrics[\"entropy\"] = self.calc_entropy()\n metrics[\"component_entropy\"] = self.calc_component_entropy()\n metrics[\"num_comps\"] = len(self.get_components())\n metrics[\"num_diagnoses\"] = len(self.diagnoses)\n metrics[\"distinct_diagnoses_scores\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\n metrics[\"num_tests\"] = len(self.get_tests())\n metrics[\"num_distinct_traces\"] = len(self.get_distinct_traces())\n metrics[\"num_failed_tests\"] = len(self._get_tests_by_error(1))\n metrics[\"num_passed_tests\"] = len(self._get_tests_by_error(0))\n passed_comps = set(self._get_components_by_error(0))\n failed_comps = set(self.get_components_in_failed_tests())\n metrics[\"num_failed_comps\"] = len(failed_comps)\n metrics[\"only_failed_comps\"] = len(failed_comps - passed_comps)\n metrics[\"only_passed_comps\"] = len(passed_comps - failed_comps)\n metrics[\"num_bugs\"] = len(self.get_bugs())\n metrics[\"wasted\"] = self.calc_wasted_components()\n metrics[\"top_k\"] = self.calc_top_k()\n metrics[\"num_comps_in_diagnoses\"] = len(self._get_comps_in_diagnoses())\n metrics[\"bugs_cover_ratio\"] = self._get_bugs_cover_ratio()\n metrics[\"average_trace_size\"] = self._get_average_trace_size()\n metrics[\"average_component_activity\"] = self._get_average_component_activity()\n metrics[\"average_diagnosis_size\"] = self._get_average_diagnosis_size()\n metrics[\"bugs_scores_average\"], metrics[\"bugs_scores_std\"], metrics[\"bugs_scores_entropy\"] = self._get_bugs_scores()\n metrics[\"non_bugs_scores_average\"], metrics[\"non_bugs_scores_std\"], metrics[\"non_bugs_scores_entropy\"] = self._get_non_bugs_scores()\n metrics.update(self.cardinality())\n # metrics[\"ochiai\"] = self.calc_ochiai_values()\n return metrics","def _evaluate_fn(model, dataset):\n # Reset the local variables so that the returned metrics are computed using\n # the given data. Similar to the `reset_states` method of `tf.metrics.Metric`.\n for var in model.local_variables:\n if var.initial_value is not None:\n var.assign(var.initial_value)\n else:\n var.assign(tf.zeros_like(var))\n\n def eval_fn(dummy_state, batch):\n \"\"\"Evaluates the model on a batch.\"\"\"\n model.forward_pass(batch, training=False)\n return dummy_state\n\n # Evaluate on the dataset.\n dataset.reduce(initial_state=0, reduce_func=eval_fn)\n\n # Obtain the metrics.\n results = collections.OrderedDict()\n local_outputs = model.report_local_outputs()\n for name, metric in local_outputs.items():\n if isinstance(metric, list) and (len(metric) == 2):\n # Some metrics returned by `report_local_outputs()` can have two scalars:\n # one represents `sum`, and the other represents `count`. Ideally, we want\n # to return a single scalar for each metric.\n results[name] = metric[0] / metric[1]\n else:\n results[name] = metric[0] if isinstance(metric, list) else metric\n return results","def get_safety_evaluator(self):\n constraint_names = self._meta['safety_constraints']\n safety_stats = self._stats['safety_stats']\n violations = np.sum(safety_stats['total_violations'], axis=0)\n evaluator_results = collections.OrderedDict([\n (key, violations[idx]) for idx, key in enumerate(constraint_names)\n ])\n return evaluator_results","def evaluate(self,**kwargs):\n # setup model\n self.optimizer = SGD(lr = 0,momentum=0,decay = 0)\n self.createModel()\n self.setGenerators()\n self.printParameters()\n output = {}\n\n if kwargs['validationOnly'] != None:\n if kwargs['validationOnly'] == True:\n valOnly = True\n else:\n valOnly = False\n else:\n valOnly = False\n\n if valOnly == False:\n trainOutput = self.model.evaluate_generator(\n generator = self.trainGen,\n steps=self.steps_per_epoch,\n use_multiprocessing=True,\n verbose=1\n )\n output['loss'] = trainOutput[0]\n for i in range(len(self.metricsAsString)):\n output[self.metricsAsString[i]] = trainOutput[i+1]\n\n print(\"loss : \" + str(output['loss']))\n for i in range(len(self.metricsAsString)):\n tmp = self.metricsAsString[i] \n print(tmp + \" : \" + str(output[tmp])) \n\n validationOutput = self.model.evaluate_generator(\n generator = self.validateGen,\n steps=self.validation_steps, \n use_multiprocessing=True, \n verbose=1)\n \n output['val_loss'] = validationOutput[0]\n for i in range(len(self.metricsAsString)):\n output[\"val_\" + self.metricsAsString[i]] = validationOutput[i+1]\n \n\n print(\"val_loss : \" + str(output['val_loss']))\n for i in range(len(self.metricsAsString)):\n tmp = \"val_\" + self.metricsAsString[i] \n print(tmp + \" : \" + str(output[tmp]))","def _evaluation():\n return {\n 'type' : 'class',\n 'name' : 'evaluation',\n 'base' : None,\n 'is_abstract' : False,\n 'doc' : None,\n 'properties' : [\n ('date', 'datetime', '0.1', None),\n ('description', 'str', '0.1', None),\n ('did_pass', 'bool', '0.1', None),\n ('explanation', 'str', '0.1', None),\n ('specification', 'str', '0.1', None),\n ('specification_hyperlink', 'str', '0.1', None),\n ('type', 'str', '0.1', None),\n ('type_hyperlink', 'str', '0.1', None),\n ('title', 'str', '0.1', None),\n ],\n 'decodings' : [\n ('date', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/gmd:CI_Citation/gmd:date/gmd:CI_Date/gmd:date/gco:Date'),\n ('description', 'gmd:evaluationMethodDescription/gco:CharacterString'),\n ('did_pass', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:pass/gco:Boolean'),\n ('explanation', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:explanation/gco:CharacterString'),\n ('type', 'child::gmd:result/@xlink:title'),\n ('type_hyperlink', 'child::gmd:result/@xlink:href'),\n ('specification', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/@xlink:title'),\n ('specification_hyperlink', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/@xlink:href'),\n ('title', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/gmd:CI_Citation/gmd:title/gco:CharacterString'),\n ]\n }","def get_metrics(model, test_data):\n feats = test_data[:, :-1]\n gold_labels = test_data[:, -1]\n preds = model.predict_y(feats)\n preds_mean = preds[0].flatten()\n preds_var = preds[1]\n #print preds_mean[:10]\n #print gold_labels[:10]\n mae = MAE(preds_mean, gold_labels)\n rmse = np.sqrt(MSE(preds_mean, gold_labels))\n prs = pearson(preds_mean, gold_labels)\n nlpd = - np.mean(model.predict_density(feats, gold_labels[:, None]))\n return mae, rmse, prs, nlpd","def validate(self):\n self.set_model_mode('eval')\n self.evaluator.reset()\n losses = MetricMeter()\n\n print('Do evaluation on {} set'.format('valid set'))\n data_loader = self.val_loader\n assert data_loader is not None\n for batch_idx, batch in enumerate(data_loader):\n input, label = self.parse_batch_test(batch)\n loss = self.forward_backward(batch, backprob=False)\n losses.update(loss)\n # total_loss += loss['loss']\n output = self.model_inference(input)\n self.evaluator.process(output, label)\n\n results = self.evaluator.evaluate()\n total_loss = losses.meters['loss_x'].avg\n\n for k, v in results.items():\n tag = '{}/{}'.format('validation', k)\n self.write_scalar(tag, v, self.epoch)\n # if full_results:\n return [total_loss,losses.dict_results(),results]\n # return total_loss","def metrics(self) -> pulumi.Output['outputs.RuntimeMetricsResponse']:\n return pulumi.get(self, \"metrics\")","def get_metrics(model, X, y, scoring_list={'accuracy':make_scorer(accuracy_score)}):\n\n metrics = {}\n for metric in scoring_list:\n score = scoring_list[metric](model, X, y)\n metrics[metric] = score\n print(\"%s\\t%s\" %(metric, score))\n\n return metrics","def metrics():\n\tmetrics = pd.DataFrame(index=['accuracy', 'precision', 'recall'],\n\t\t\t\t\t\t columns=['LogisticReg', 'NeuralNetwork'])\n\treturn metrics","def evaluate_model(estimator: es.Estimator, speech_labels: List[str], entries, input_fn_eval) -> Dict[str, float]:\n # Get predictions\n predictions = estimator.predict(input_fn=input_fn_eval)\n\n # Get probabilities of each predicted class\n probs = [pred[\"probabilities\"] for pred in predictions]\n num_of_examples = len(probs)\n targets = [entry[1] for entry in entries] # The ground truth transcript\n\n total_wer, total_cer = 0., 0.\n greedy_decoder = decoder.DeepSpeechDecoder(speech_labels, blank_index=28)\n for prob, target in zip(probs, targets):\n decode = greedy_decoder.decode(prob)\n total_cer += greedy_decoder.cer(decode, target)\n total_wer += greedy_decoder.wer(decode, target)\n\n total_cer /= num_of_examples\n total_wer /= num_of_examples\n global_step = estimator.get_variable_value(tf.GraphKeys.GLOBAL_STEP)\n eval_results = {\n _WER_KEY: total_wer,\n _CER_KEY: total_cer,\n tf.GraphKeys.GLOBAL_STEP: global_step\n }\n return eval_results","def evaluate(model, data_pars=None, compute_pars=None, out_pars=None, **kw):\n ddict = {}\n \n return ddict","def evaluate(self, batches):\n total_batches = batches.batches_per_epoch()\n logs = dict()\n for batch in range(total_batches):\n X_batch, y_batch = batches.get_batch()\n feed_dict = {\n self.x: X_batch,\n self.y: y_batch,\n self.keep_prob: 1.0}\n fetch_dict = {\n \"loss\": self.loss_op,\n \"accuracy\": self.accuracy_op}\n result = self.session.run(fetch_dict, feed_dict)\n for metric in result:\n if not metric in logs:\n logs[metric] = []\n logs[metric].append(result[metric])\n for metric in logs:\n logs[metric] = sum(logs[metric]) / len(logs[metric])\n return logs","def evaluate_model(model, X_test, Y_test, category_names):\n y_pred = pd.DataFrame(data = model.predict(X_test), columns = category_names)\n\n precision, recall, f1_score = [], [], []\n\n for category in category_names:\n scores = classification_report(Y_test[category], y_pred[category])\n precision.append([x for x in scores.strip().split(\"avg / total\")[1].strip().split(\" \") \n if len(x) > 0][:3][0])\n recall.append([x for x in scores.strip().split(\"avg / total\")[1].strip().split(\" \") \n if len(x) > 0][:3][1])\n \n model_metric = pd.concat([\n pd.DataFrame(data = [precision, recall], index = [\"precision\", \"recall\"], \n columns = category_names),\n (Y_test.reset_index() == y_pred.reset_index()).mean()[1:].to_frame(\"accuracy\").T\n ])\n\n for col in model_metric.columns:\n model_metric[col] = model_metric[col].astype(float)\n\n return model_metric","def evaluate_model(model, eval_path):\n with msg.loading(f\"Loading model '{model}'...\"):\n nlp = spacy.load(model)\n data, _ = format_data(srsly.read_jsonl(eval_path))\n sc = nlp.evaluate(data)\n result = [\n (\"Precision\", f\"{sc.ents_p:.3f}\"),\n (\"Recall\", f\"{sc.ents_r:.3f}\"),\n (\"F-Score\", f\"{sc.ents_f:.3f}\"),\n ]\n msg.table(result)","def evaluate(model, loss_func, dataloader, metrics):\r\n model.eval()\r\n summ = []\r\n device = utils.get_device()\r\n with torch.no_grad():\r\n for data in dataloader:\r\n sentences1, starts1, ends1, sentences2, starts2, ends2, inputY = data\r\n inputY = inputY.to(device)\r\n output_batch = model(sentences1, starts1, ends1, sentences2, starts2, ends2)\r\n loss = loss_func(output_batch, inputY)\r\n output_batch = output_batch.data.cpu().numpy()\r\n inputY = inputY.data.cpu().numpy()\r\n summary_batch = {metric: metrics[metric](\r\n output_batch, inputY) for metric in metrics}\r\n summary_batch['loss'] = loss.item()\r\n summ.append(summary_batch)\r\n # print(\"summ:{}\".format(summ))\r\n metrics_mean = {metric: np.mean([x[metric]\r\n for x in summ]) for metric in summ[0]}\r\n metrics_string = \" ; \".join(\"{}: {:05.3f}\".format(k, v)\r\n for k, v in metrics_mean.items())\r\n logging.info(\"- Eval metrics : \" + metrics_string)\r\n return metrics_mean","def model_metrics(X, y, model, data_set = 'data_set'):\n score = model.score(X, y)\n matrix = confusion_matrix(y, model.predict(X))\n tpr = matrix[1,1] / (matrix[1,1] + matrix[1,0])\n fpr = matrix[0,1] / (matrix[0,1] + matrix[0,0])\n tnr = matrix[0,0] / (matrix[0,0] + matrix[0,1])\n fnr = matrix[1,0] / (matrix[1,1] + matrix[1,0])\n prc = matrix[1,1] / (matrix[1,1] + matrix[0,1])\n \n print(f'{data_set} accuracy score: {score:.2%}')\n print(f'{data_set} precision score {prc:.2%}')\n print(f'{data_set} recall score: {tpr:.2%}\\n')\n class_report = classification_report(y, model.predict(X), zero_division=True)\n print('-------------------------------')\n print(f'classification report')\n print(class_report)\n print ('-------------------------------\\n')\n print('confusion matrix')\n print(f'{matrix}\\n')\n print(f'{data_set} model metrics')\n print('---------------------------------')\n print(f'True positive rate for the model is {tpr:.2%}')\n print(f'False positive rate for the model is {fpr:.2%}')\n print(f'True negative rate for the model is {tnr:.2%}')\n print(f'False negative rate for the model is {fnr:.2%}\\n')","def train_scores(self) -> np.ndarray:\n return np.asarray(self.train_metric_dict[self.metric_name])","def evaluate_model(self, test_data, test_labels,verbose=2):\n test_loss, test_acc = self.model.evaluate(test_data, test_labels, verbose=verbose)\n return test_loss, test_acc","def get_metrics(self):\n \n # Get the model from cache or disk based on the model_name in request\n self._get_model_by_name()\n \n # Prepare the response data frame\n self.response = self.model.metrics_df\n \n # Send the reponse table description to Qlik\n if self.model.validation == \"hold-out\":\n if self.model.estimator_type == \"classifier\":\n self._send_table_description(\"metrics_clf\")\n elif self.model.estimator_type == \"regressor\":\n self._send_table_description(\"metrics_reg\")\n elif self.model.validation in [\"k-fold\", \"timeseries\"]:\n if self.model.estimator_type == \"classifier\":\n self._send_table_description(\"metrics_clf_cv\")\n elif self.model.estimator_type == \"regressor\":\n self._send_table_description(\"metrics_reg_cv\")\n else:\n err = \"Metrics are not available. Make sure the machine learning pipeline includes K-fold cross validation or hold-out testing.\"\n raise Exception(err)\n \n # Debug information is printed to the terminal and logs if the paramater debug = true\n if self.model.debug:\n self._print_log(4)\n \n # Finally send the response\n return self.response","def getAllMetrics(self):\n result = self.getReportMetrics()\n result.update(self.getOptimizationMetrics())\n return result","def evaluate(model, X, y):\n\tmodel.eval()\n\n\t# make the predictions\n\ty_hat = predict(model,X)\n\n\t# convert to cpu\n\ty_hat = y_hat.detach().cpu()\n\ty = y.detach().cpu()\n\n\t# compute evaluation metrics\n\taccuracy = accuracy_score(y, y_hat)\n\tprf \t = precision_recall_fscore_support(y, y_hat, labels=[0,1], average='macro')\n\n\treturn accuracy, prf","def compute_metrics(self, results: list) -> Dict[str, float]:\n logger: MMLogger = MMLogger.get_current_instance()\n\n # pred_coords: [N, K, D]\n pred_coords = np.concatenate(\n [result['pred_coords'] for result in results])\n if pred_coords.ndim == 4 and pred_coords.shape[1] == 1:\n pred_coords = np.squeeze(pred_coords, axis=1)\n # gt_coords: [N, K, D]\n gt_coords = np.stack([result['gt_coords'] for result in results])\n # mask: [N, K]\n mask = np.concatenate([result['mask'] for result in results])\n # action_category_indices: Dict[List[int]]\n action_category_indices = defaultdict(list)\n for idx, result in enumerate(results):\n action_category = result['action'].split('_')[0]\n action_category_indices[action_category].append(idx)\n\n error_name = self.mode.upper()\n\n logger.info(f'Evaluating {self.mode.upper()}...')\n metrics = dict()\n\n metrics[error_name] = keypoint_mpjpe(pred_coords, gt_coords, mask,\n self.ALIGNMENT[self.mode])\n\n for action_category, indices in action_category_indices.items():\n metrics[f'{error_name}_{action_category}'] = keypoint_mpjpe(\n pred_coords[indices], gt_coords[indices], mask[indices])\n\n return metrics","def evaluate(model, loss_func, dataloader, metrics):\r\n model.eval()\r\n summ = []\r\n device = utils.get_device()\r\n for data in dataloader:\r\n encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids,inputY = data\r\n inputY = inputY.to(device)\r\n output_batch = model(encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids)\r\n\r\n loss = loss_func(output_batch, inputY)\r\n output_batch = output_batch.data.cpu().numpy()\r\n inputY = inputY.data.cpu().numpy()\r\n summary_batch = {metric: metrics[metric](\r\n output_batch, inputY) for metric in metrics}\r\n summary_batch['loss'] = loss.item()\r\n summ.append(summary_batch)\r\n # print(\"summ:{}\".format(summ))\r\n metrics_mean = {metric: np.mean([x[metric]\r\n for x in summ]) for metric in summ[0]}\r\n metrics_string = \" ; \".join(\"{}: {:05.3f}\".format(k, v)\r\n for k, v in metrics_mean.items())\r\n logging.info(\"- Eval metrics : \" + metrics_string)\r\n return metrics_mean","def calculate_metrics(self):\n sensitivity = TP + FN\n sensitivity = TP / sensitivity\n\n specificity = TN + FP\n specificity = TN / specificity\n\n accuracy = TP + FP + TN + FN\n divisor = TP + TN\n accuracy = divisor / accuracy\n\n positive_predictive = TP + FP\n positive_predictive = TP / positive_predictive\n\n negative_predictive = TN + FN\n negative_predictive = TN / negative_predictive\n\n # This is for format decimal in metrics\n sensitivity = float(\"{0:.4f}\".format(sensitivity))\n specificity = float(\"{0:.4f}\".format(specificity))\n accuracy = float(\"{0:.4f}\".format(accuracy))\n positive_predictive = float(\"{0:.4f}\".format(positive_predictive))\n negative_predictive = float(\"{0:.4f}\".format(negative_predictive))\n\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\n\n average = float(\"{0:.4f}\".format(average))\n\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\n\n return metrics","def _results(self):\n results = {}\n results[\"coeff\"] = self._coeff_to_dict()\n results[\"coeff_path\"] = dict(\n zip(\n [f\"{col}\" for col in self.X_train_.columns.tolist()],\n (\n self.model_.coef_path_.reshape(-1, self.model_.coef_path_.shape[-1])\n ).tolist(),\n )\n )\n results[\"cv_standard_error\"] = self.model_.cv_standard_error_.tolist()\n results[\"cv_mean_score\"] = self.model_.cv_mean_score_.tolist()\n results[\"lambda_path\"] = self.model_.lambda_path_.tolist()\n results[\"lambda_best\"] = self.model_.lambda_best_[0]\n results[\"lambda_max\"] = self.model_.lambda_max_\n results[\"n_lambda\"] = self.model_.n_lambda_\n results[\"intercept\"] = self.model_.intercept_\n results[\"intercept_path\"] = self.model_.intercept_path_.tolist()[0]\n results[\"params\"] = self.model_.get_params()\n results[\"module\"] = self.model_.__module__\n\n return results","def model_fit_and_evaluate(model, train_ds, val_ds, test_ds,\n epochs, class_weights, job_name, model_saving=False):\n\n # to avoid overfitting stop when validation loss doesn't improve further\n early_stop = tf.keras.callbacks.EarlyStopping(\n monitor='val_loss', patience=6)\n \n model.fit(train_ds, verbose=1, validation_data=val_ds, callbacks=[early_stop],\n class_weight=class_weights, epochs=epochs, steps_per_epoch=6)\n logging.info('done fitting')\n\n\n logging.info('going to evaluate')\n results = model.evaluate(test_ds, verbose=1)\n summary_results = {name: value for name,\n value in zip(model.metrics_names, results)}\n summary_results['job_name'] = job_name\n summary_results['completion_time'] = datetime.datetime.now().strftime(\n '%Y-%m-%d_%H:%M:%S')\n return summary_results, model","def evaluate_model(model_name, y_true, y_pred):\n\n # Calculate performance metrics\n rmse_eval = evaluate_rmse(y_true, y_pred)\n mae_eval = evaluate_mae(y_true, y_pred) \n r2_eval = evaluate_r2(y_true, y_pred)\n\n # Print results\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)","def evaluate_model():\n\n # Get the processed data (in proper format to evaluate the NER model)\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\n # Split the dataset for training and test as we did for training\n train_data, test_data = train_test_split(data, train_size=0.7, \n random_state=4)\n\n # Load the model trained\n try:\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\n except Exception as err:\n msg = f'Could not load the model. Error: {err}'\n raise Exception(msg)\n\n # Compute evaluation scores\n print('Computing metrics...')\n scores = evaluate(ner_model, test_data)\n # General metrics of the model\n f_score = scores.get('ents_f')\n precision = scores.get('ents_p')\n recall = scores.get('ents_r')\n print('\\nScoring:')\n print(f'F-score: {f_score}')\n print(f'Precision: {precision}')\n print(f'Recall: {recall}')\n\n # Get the specific scores for each entity \n scores_per_entity = scores.get('ents_per_type')\n # Get the F-score of the entities\n f_scores_of_entities = []\n for entity_scores in scores_per_entity.values():\n f_scores_of_entities.append(entity_scores['f'])\n # Compute the macro averaged F-score\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\n print(f'Macro averaged F-score: {macro_avg_f_score}')\n \n print('\\nScores per entity;')\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\n for key, value in scores_per_entity.items():\n entity = key\n f, p, r = value['f'], value['p'], value['r']\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))","def result(self) -> Dict[int, float]:\n return {t: self._mean_accuracy[t].result() for t in self._mean_accuracy}","def metrics(self):\n\n data = requests.get(\n f\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\"\n ).content.decode()\n lines = [line for line in data.split(\"\\n\") if not line.startswith(\"#\")]\n metrics = {}\n for line in lines:\n if not line:\n continue\n\n name, value = line.split(\" \")\n\n try:\n value = int(value) # type: ignore\n except ValueError:\n value = float(value) # type: ignore\n\n if \"{\" in name and \"}\" in name:\n base = name[: name.index(\"{\")]\n tags = name[name.index(\"{\") + 1 : -1]\n tags = [tag.split(\"=\") for tag in tags.split(\",\")]\n tags = [(key, val.replace('\"', \"\")) for key, val in tags]\n\n name = base + \"#\" + \",\".join(f\"{k}:{v}\" for k, v in sorted(tags))\n\n metrics[name] = value\n\n return metrics","def build_evaluation(self, predictions, examples, **kwargs):\n return {}","def get_metrics(self) -> np.ndarray:\n dice = np.mean(self.dice_scores)\n iou = np.mean(self.iou_scores)\n sens = np.mean(self.sens_scores)\n spec = np.mean(self.spec_scores)\n accu = np.mean(self.accu_scores)\n return dice, iou, sens, spec, accu","def metrics(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\r\n\r\n return http.Request('GET', url), parsers.parse_json","def metrics(logger, model, X_train, y_train, X_test, y_test):\n\n results = dict()\n y_preds = model.predict(X_test)\n results['Train Accuracy'] = model.score(X_train, y_train)\n results['Test Accuracy'] = accuracy_score(y_test, y_preds)\n results['Precision'] = precision_score(y_test, y_preds)\n results['Recall'] = recall_score(y_test, y_preds)\n\n metric_cols = data_config['params']['metrics_cols']\n res_df = pd.DataFrame(results.items(), columns=metric_cols)\n\n metrics_path = data_config['outputs']['logreg_metrics']\n res_df.to_csv(metrics_path, index=False)\n print(f'Metrics saved to {metrics_path}')\n\n return","def get_metrics(self):\n return None","def init_metrics():\n metrics = defaultdict(list)\n metrics['best_acc'] = 0.0\n metrics['best_loss'] = float('inf')\n metrics['best_epoch'] = 0\n return metrics","def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\n\n y_pred = (y_prob>=threshold).astype(int)\n \n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\n\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\n precision_scr = metrics.precision_score(y_true, y_pred)\n recall_scr = metrics.recall_score(y_true, y_pred)\n f1_scr = metrics.f1_score(y_true, y_pred)\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\n\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\n\n return result","def eval_perf_total(model, X_train, y_train, X_test, y_test):\n\n y_hat_train = model.predict(X_train)\n y_hat_test = model.predict(X_test)\n \n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\n train_r = metrics.r2_score(y_train, y_hat_train)\n\n print('Evaluating Performance on Training Data:\\n')\n print(f' Train Mean Absolute Error: {train_mae:,.2f}')\n print(f' Train Mean Squared Error: {train_mse:,.2f}\\n')\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\n print(f'Train R-Square Value: {round(train_r,2)}')\n\n print('\\n'+'---'*25+'\\n')\n\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\n test_r = metrics.r2_score(y_test, y_hat_test)\n\n print('Evaluating Performance on Testing Data:\\n')\n print(f' Test Mean Absolute Error: {test_mae:,.2f}')\n print(f' Test Mean Squared Error: {test_mse:,.2f}\\n')\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\n print(f'Test R-Square Value: {round(test_r,2)}')","def evaluation(self):\n return self._evaluation","def get_regression_metrics(model, actual, predicted):\n regr_metrics = {\n 'Root Mean Squared Error' : metrics.mean_squared_error(actual, predicted)**0.5,\n 'Mean Absolute Error' : metrics.mean_absolute_error(actual, predicted),\n 'R^2' : metrics.r2_score(actual, predicted),\n 'Explained Variance' : metrics.explained_variance_score(actual, predicted)\n }\n\n #return reg_metrics\n df_regr_metrics = pd.DataFrame.from_dict(regr_metrics, orient='index')\n df_regr_metrics.columns = [model]\n return df_regr_metrics","def evaluate_model(model, X_train, y_train, X_test, y_test):\n model = model\n model.fit(X_train, y_train)\n\n y_pred = model.predict(X_test)\n\n report = classificationreport(y_test, y_pred, target_names= [\"0\", \"1\"], output_dict=True)\n\n return report","def get_model_evaluation(client, model_name):\n model_evaluations = [e for e in client.list_model_evaluations(model_name)]\n model_evaluation = model_evaluations[0]\n print(\"Model evaluation:\")\n print(model_evaluation)\n return model_evaluation","def metrics(self):\r\n if not hasattr(self, '_observable_metrics'):\r\n self._observable_metrics = Metrics()\r\n return self._observable_metrics","def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\n all_predictions_table: pd.DataFrame) -> Dict:\n\n viewed = viewed_table.to_numpy()\n predictions = predictions_table.to_numpy()\n all_predictions = all_predictions_table.to_numpy()\n ratings = ratings_table.to_numpy()\n test = test_table.to_numpy(copy=True)\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\n\n result = dict()\n\n # Test set evaluation\n test_predictions = np.multiply(all_predictions, test_set)\n diff = np.subtract(test_predictions, test_demeaned)\n rmse = np.sqrt(np.mean(np.square(diff)))\n result.update({\"RMSE\": rmse})\n mae = np.mean(np.absolute(diff))\n result.update({\"MAE\": mae})\n\n # overall evaluation\n movies_recommended = set()\n i = 0\n for index, row in predictions_table.iterrows():\n if i > 10000: break\n else: i += 1\n\n labels = row.nlargest(20).keys().tolist()\n for movie in labels:\n movies_recommended.update(movie)\n\n result.update({\"Coverage\": len(movies_recommended)})\n\n return result"],"string":"[\n \"def evaluate(self) -> Dict[str, float]:\\n eval_dataloader = self.get_eval_dataloader()\\n\\n output = self._prediction_loop(eval_dataloader, description=\\\"Evaluation\\\")\\n return output.metrics\",\n \"def calc_metrics(model, X, y):\\n\\n # Get model predictions\\n y_predict_r = model.predict(X)\\n\\n # Calculate evaluation metrics for assesing performance of the model.\\n roc = roc_auc_score(y, y_predict_r)\\n acc = accuracy_score(y, y_predict_r)\\n prec = precision_score(y, y_predict_r)\\n rec = recall_score(y, y_predict_r)\\n f1 = f1_score(y, y_predict_r)\\n\\n return {\\\"acc\\\": acc, \\\"roc\\\": roc, \\\"prec\\\": prec, \\\"rec\\\": rec, \\\"f1\\\": f1}\",\n \"def evaluate(self) -> Dict[str, Any]:\\n kwargs = {\\\"ids\\\": self._ids}\\n return {\\n metric.value: self._metric_funcs[metric](\\n self._targets, self._preds, **kwargs\\n )\\n for metric in self._metrics\\n }\",\n \"def get_model_evaluations(self):\\n return self._model_evaluations\",\n \"def evaluate(self, test):\\r\\n self.logger.info(\\\"Testing model over test set\\\")\\r\\n metrics = self.run_evaluate(test)\\r\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\r\\n for k, v in metrics.items()])\\r\\n self.logger.info(msg)\\r\\n return metrics\",\n \"def metric_tests(self) -> Dict[str, FAIRResultEvaluationCriterium]:\\n return self._metric_tests\",\n \"def evaluate(self, test):\\n self.logger.info(\\\"Testing model over test set\\\")\\n metrics = self.run_evaluate(test)\\n msg = \\\" - \\\".join([\\\"{} {:04.2f}\\\".format(k, v)\\n for k, v in metrics.items()])\\n self.logger.info(msg)\\n return metrics\",\n \"def validate(self):\\n stats = {}\\n evaluate_config = {\\\"verbose\\\": self.verbose}\\n evaluate_config.update(self.config.get(\\\"evaluate_config\\\", {}))\\n\\n results = self.model.evaluate(self.test_dataset, **evaluate_config)\\n if results is None:\\n # Using local Model since model.evaluate() returns None\\n # for MultiWorkerMirroredStrategy\\n logger.warning(\\\"Running a local model to get validation score.\\\")\\n self.local_model = self.model_creator(self.config)\\n self.local_model.set_weights(self.model.get_weights())\\n results = self.local_model.evaluate(self.test_dataset,\\n **evaluate_config)\\n\\n if isinstance(results, list):\\n stats = {\\n \\\"validation_\\\" + k: v\\n for k, v in zip(self.model.metrics_names, results)\\n }\\n else:\\n stats = {\\\"loss\\\": results}\\n\\n return stats\",\n \"def evaluate(self, X: np.ndarray, y: list, X_train=None, y_train=None) -> dict:\\n metrics = self.compute_metrics(X, y)\\n\\n print(\\\"evaluation: \\\", metrics)\\n return metrics\",\n \"def _build_eval_metrics(self, results, features, labels):\\n metrics = {}\\n for metric in self.metrics:\\n metrics[metric.IDENTIFIER] = getters.get_metric(\\n metric.IDENTIFIER, results, labels, **metric.to_dict())\\n return metrics\",\n \"def model_evaluate(self, test):\\n features = {name: np.array(value) for name, value in test.items()}\\n labels = {name: features.pop(name) for name in self.label_names}\\n metrics = self.model.evaluate(x=features, y=labels, batch_size=5)\\n return metrics\",\n \"def get_model_evaluation(self):\\n\\n self.log(f\\\"{self.cur_file_path}\\\\t\\\\tInfo: model_evaluation method invoked for {self.model.__class__.__name__}!\\\")\\n\\n evaluation = ModelEvaluation(self.model, (self.trainX, self.trainY), (self.testX, self.testY))\\n return evaluation.get_evaluation_report()\",\n \"def report(self):\\n m = {}\\n num_tok = self.metrics['num_tokens']\\n if num_tok > 0:\\n if self.metrics['correct_tokens'] > 0:\\n m['token_acc'] = self.metrics['correct_tokens'] / num_tok\\n m['loss'] = self.metrics['loss'] / num_tok\\n if self.metrics['pred_count'] > 0:\\n m['pred'] = self.metrics['correct_pred'] / self.metrics['pred_count']\\n try:\\n m['ppl'] = math.exp(m['loss'])\\n except OverflowError:\\n m['ppl'] = float('inf')\\n if self.metrics['total_skipped_batches'] > 0:\\n m['total_skipped_batches'] = self.metrics['total_skipped_batches']\\n for k, v in m.items():\\n # clean up: rounds to sigfigs and converts tensors to floats\\n m[k] = round_sigfigs(v, 4)\\n return m\",\n \"def get_val_metrics(self, metrics_type=\\\"classification\\\"):\\n assert self.is_trained, \\\"You need to train the models before getting validation metrics\\\"\\n # Get the set of metrics adapted to the task\\n metrics = METRICS[metrics_type]\\n # Train the model\\n preds = self.preds\\n score = {}\\n for k, v in metrics.items():\\n score[k] = v(self.true_labels.values, preds)\\n return score\",\n \"def evaluate(self):\\n results = dict()\\n for metric in self.metrics:\\n print('Evaluating clustering with metric %s' % metric)\\n if metric in LABEL_METRICS.keys():\\n results[metric] = LABEL_METRICS[metric](self.X, self.model.labels_)\\n results['adjusted_rand_score'] = SCORE_METRICS['adjusted_rand_score'](self.Y[:, 0], self.model.labels_)\\n self.results = results\\n return results\",\n \"def get_metrics(self, x, y):\\n metrics = dict()\\n y_predicted = self.predict(x)\\n metrics['Accuracy'] = accuracy_score(y, y_predicted)\\n metrics['F1'] = f1_score(y, y_predicted)\\n metrics['Precision'] = precision_score(y, y_predicted)\\n\\n return metrics\",\n \"def metrics(self) -> dict:\\n if not self.exp_metadata.metrics:\\n self.exp_metadata.metrics = {}\\n return self.exp_metadata.metrics\",\n \"def _monitor_metrics(self):\\n metrics = [\\\"loss\\\"]\\n try:\\n m = U.metrics_from_model(self.model)\\n if isinstance(m, list):\\n metrics.extend(m)\\n except:\\n pass\\n if self.val_data is not None:\\n for m in metrics[:]:\\n metrics.append(\\\"val_%s\\\" % (m))\\n return metrics\",\n \"def compute_metrics(self):\\n self.finalize_output_dict()\\n self.metric_dict = {\\n key: value(self.output_dict[\\\"labels\\\"], self.output_dict[\\\"pred_probs\\\"])\\n for key, value in self.metric_fns.items()\\n }\",\n \"def metrics(self, weights=None):\\n yt = self.ytrue\\n yp = self.ypred\\n w = weights\\n\\n if yt.size > 0:\\n mse = skm.mean_squared_error(yt, yp, sample_weight=w)\\n rmse = np.sqrt(mse)\\n mae = skm.mean_absolute_error(yt, yp, sample_weight=w)\\n median_absolute_error = skm.median_absolute_error(yt, yp)\\n r2_score = skm.r2_score(yt, yp, sample_weight=w)\\n ev_score = skm.explained_variance_score(yt, yp, sample_weight=w)\\n max_error = skm.max_error(yt, yp)\\n support = len(yt)\\n else:\\n mse = 0.0\\n rmse = 0.0\\n mae = 0.0\\n median_absolute_error = 0.0\\n r2_score = 0.0\\n ev_score = 0.0\\n max_error = 0.0\\n support = 0\\n\\n return {\\n \\\"mean_squared_error\\\": mse,\\n \\\"root_mean_squared_error\\\": rmse,\\n \\\"mean_absolute_error\\\": mae,\\n \\\"median_absolute_error\\\": median_absolute_error,\\n \\\"r2_score\\\": r2_score,\\n \\\"explained_variance_score\\\": ev_score,\\n \\\"max_error\\\": max_error,\\n \\\"support\\\": support,\\n }\",\n \"def evaluate(self, params):\\n model = self.train(params)\\n Y_pred = model.predict(self.X_test)\\n\\n if self.dataset_type == PROBLEM.CLASSIFICATION:\\n return {\\n 'score': accuracy_score(self.Y_test, Y_pred),\\n 'matrix': confusion_matrix(self.Y_test, Y_pred).tolist(),\\n 'report': classification_report(self.Y_test, Y_pred,\\n target_names=self.labels,\\n zero_division=1)\\n }\\n else:\\n return {\\n 'max_error': max_error(self.Y_test, Y_pred),\\n 'mae': mean_absolute_error(self.Y_test, Y_pred),\\n 'mse': mean_squared_error(self.Y_test, Y_pred)\\n }\",\n \"def metrics(self):\\n \\n if self.mse.shape[0]>1:\\n raise ValueError('Metrics can only handle single observations.')\\n \\n if self.N==1:\\n pred = float('nan')\\n err = float('nan')\\n y_true = float('nan')\\n else:\\n pred = int(self._predictions[-1])\\n err = self._mse[-1]\\n y_true = int(self.label[0])\\n \\n is_outlier = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"is_outlier\\\",\\\"value\\\":pred}\\n mse = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"mse\\\",\\\"value\\\":err}\\n obs = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"observation\\\",\\\"value\\\":self.N - 1}\\n threshold = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"threshold\\\",\\\"value\\\":self.threshold}\\n \\n label = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"label\\\",\\\"value\\\":y_true}\\n \\n accuracy_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_tot\\\",\\\"value\\\":self.metric[4]}\\n precision_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_tot\\\",\\\"value\\\":self.metric[5]}\\n recall_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_tot\\\",\\\"value\\\":self.metric[6]}\\n f1_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_tot\\\",\\\"value\\\":self.metric[7]}\\n f2_score_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_tot\\\",\\\"value\\\":self.metric[8]}\\n \\n accuracy_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"accuracy_roll\\\",\\\"value\\\":self.metric[9]}\\n precision_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"precision_roll\\\",\\\"value\\\":self.metric[10]}\\n recall_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"recall_roll\\\",\\\"value\\\":self.metric[11]}\\n f1_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f1_roll\\\",\\\"value\\\":self.metric[12]}\\n f2_score_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"f2_roll\\\",\\\"value\\\":self.metric[13]}\\n \\n true_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_negative\\\",\\\"value\\\":self.metric[0]}\\n false_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_positive\\\",\\\"value\\\":self.metric[1]}\\n false_negative = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"false_negative\\\",\\\"value\\\":self.metric[2]}\\n true_positive = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"true_positive\\\",\\\"value\\\":self.metric[3]}\\n \\n nb_outliers_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_roll\\\",\\\"value\\\":self.metric[14]}\\n nb_labels_roll = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_roll\\\",\\\"value\\\":self.metric[15]}\\n nb_outliers_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_outliers_tot\\\",\\\"value\\\":self.metric[16]}\\n nb_labels_tot = {\\\"type\\\":\\\"GAUGE\\\",\\\"key\\\":\\\"nb_labels_tot\\\",\\\"value\\\":self.metric[17]}\\n \\n return [is_outlier,mse,obs,threshold,label,\\n accuracy_tot,precision_tot,recall_tot,f1_score_tot,f2_score_tot,\\n accuracy_roll,precision_roll,recall_roll,f1_score_roll,f2_score_roll,\\n true_negative,false_positive,false_negative,true_positive,\\n nb_outliers_roll,nb_labels_roll,nb_outliers_tot,nb_labels_tot]\",\n \"def _get_eval_metric(self):\\n raise NotImplementedError\",\n \"def evaluate(self, dataset):\\n logging.info('Start evaluation')\\n\\n loss, predictions, labels = self.run_one_epoch(dataset, RunnerPhase.VALIDATE)\\n\\n metrics_dict = self.metric_class.get_metrics_dict(predictions, labels)\\n\\n eval_info = self.metric_class.metrics_dict_to_str(metrics_dict)\\n\\n logging.info(eval_info)\\n\\n logging.info('Evaluation finished')\\n\\n return metrics_dict\",\n \"def _evaluate(self, train_x, train_y, test_x, test_y, n_targets, name):\\n r_temp = {}\\n for metric_name in self.metrics:\\n r_temp.update({f\\\"{metric_name}_Model\\\": name, f\\\"{metric_name}_Sum\\\": 0,\\n f\\\"{metric_name}_Min\\\": 1000000, f\\\"{metric_name}_Max\\\": 0})\\n\\n for i in range(self.repetitions):\\n is_nan = True\\n while (is_nan):\\n model = self.get_model(train_x.shape[1], n_targets)\\n model.fit(train_x, train_y, **self.fit_kwargs)\\n result = model.predict(test_x)\\n is_nan = np.any(np.isnan(result))\\n del model\\n\\n for metric_name in self.metrics:\\n metric = self.get_metrics(metric_name)\\n value = metric(result, test_y)\\n r_temp[f\\\"{metric_name}_Sum\\\"] += value\\n if r_temp[f\\\"{metric_name}_Min\\\"] > value:\\n r_temp[f\\\"{metric_name}_Min\\\"] = value\\n if r_temp[f\\\"{metric_name}_Max\\\"] < value:\\n r_temp[f\\\"{metric_name}_Max\\\"] = value\\n keras.backend.clear_session()\\n for metric_name in self.metrics:\\n r_temp[f\\\"{metric_name}_Mean\\\"] = r_temp[f\\\"{metric_name}_Sum\\\"] / self.repetitions\\n return r_temp\",\n \"def compute_metrics(self, results: list) -> dict:\",\n \"def get_metrics(self) -> dict:\\n return self.metric_dict\",\n \"def get_metrics(self) -> Dict[str, base.Number]:\\n return self._metrics\",\n \"def get_evaluations(self):\\r\\n return self.evaluations\",\n \"def compute_metrics(self):\\n pass\",\n \"def compute_and_print_eval_metrics(self):\\n s = ('%20s' + '%12s' * 6) % ('Class', 'Images', 'Targets', 'P', 'R', 'mAP@.5', 'mAP@.5:.95')\\n precision, recall, f1, mean_precision, mean_recall, map50, map = 0., 0., 0., 0., 0., 0., 0.\\n ap = []\\n eval_stats = [np.concatenate(x, 0) for x in zip(*self.eval_stats)]\\n if len(eval_stats) and eval_stats[0].any():\\n precision, recall, ap, f1, ap_class = ap_per_class(*eval_stats)\\n precision, recall, ap50, ap = precision[:, 0], recall[:, 0], ap[:, 0], ap.mean(1)\\n mean_precision, mean_recall, map50, map = precision.mean(), recall.mean(), ap50.mean(), ap.mean()\\n nt = np.bincount(eval_stats[3].astype(np.int64), minlength=len(self.class_names)) # number of targets per class\\n else:\\n nt = np.zeros(1)\\n\\n pf = '%20s' + '%12.5g' * 6 # print format\\n print(\\\"\\\\n EVALUTAION \\\\n\\\")\\n print(s)\\n print(pf % ('all', self.seen, nt.sum(), mean_precision, mean_recall, map50, map))\\n if self.cfg.eval.verbose:\\n for indx, cls in enumerate(ap_class):\\n print(pf % (self.class_names[cls], self.seen, nt[cls], precision[indx], recall[indx], ap50[indx], ap[indx]))\",\n \"def get_evaluation_metric(self):\\n\\t\\treturn self.metric\",\n \"def model_evaluate(model,x_train,n_y_array,x_val, vald_array):\\n\\n scores = model.evaluate(x_train, n_y_array, verbose=1)\\n\\n scores2 = model.evaluate(x_val, vald_array, verbose=1)\\n\\n\\n print(\\\"for traininf set\\\")\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores[0]))\\n\\n\\n\\n print(\\\"for validation set : \\\") \\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[1], scores2[1]*100))\\n\\n print(\\\"%s: %.2f%%\\\" % (model.metrics_names[0], scores2[0]))\",\n \"def metrics(self) -> list[dict[str, dict[str, float | int]]]:\\n return self.performance[\\\"performances\\\"]\",\n \"def evaluate(self, csls, evals, mode=\\\"csls\\\"):\\n metrics = {}\\n for eval_func in evals:\\n assert hasattr(self, eval_func), \\\\\\n \\\"Eval Function {0} not found\\\".format(eval_func)\\n metrics = getattr(self, eval_func)(csls, metrics, mode=mode)\\n return metrics\",\n \"def evaluate_model(model,\\n xs: list, ys: list, labels: list,\\n metrics: list):\\n\\n metrics_summary = {}\\n\\n for x, y, label in zip(xs, ys, labels):\\n\\n y_pred = model.predict(x)\\n\\n for metric in metrics:\\n try:\\n value = metrics_map[metric](y, y_pred)\\n except Exception as e:\\n logger.error(f\\\"Error during metric calculation: {e}\\\")\\n print(f\\\"Error during metric calculation: {e}\\\\n\\\"\\n \\\"metric value set to np.nan \\\")\\n value = np.nan\\n\\n metrics_summary[f\\\"{metric} {label}\\\"] = value\\n\\n logger.info(\\\"Evaluate Model process is finished\\\")\\n\\n return metrics_summary\",\n \"def evaluate(self):\\n\\n\\t\\tself.model_score = self.model.evaluate(self.x_test, self.y_test, batch_size=2048)\\n\\t\\tprint(\\\"%s score = %f\\\\n\\\" %(self.modelName, self.model_score[1]))\\n\\t\\treturn self.model_score\",\n \"def compute(self) -> Dict[str, np.ndarray]:\\n return {name: self.metrics[name].compute() for name in self.metrics}\",\n \"def evaluate(model, eval_data, num_labels): \\n # Turn on the evaluation state to ignore dropouts\\n model.eval()\\n results = [predict(model, x) for x, y in eval_data]\\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\\n return f1_score, accuracy\",\n \"def metrics(self):\\n return self.verificationRun.metrics()\",\n \"def metrics(self):\\n return self.__metrics\",\n \"def _getMetrics(self):\\n metric = None\\n if self.metrics is not None:\\n metric = self.metrics(self._currentRecordIndex+1)\\n elif self.metricValue is not None:\\n metric = self.metricValue\\n else:\\n raise RuntimeError('No metrics or metric value specified for dummy model')\\n\\n return {self._optimizeKeyPattern:metric}\",\n \"def metrics(self):\\n return self._metrics\",\n \"def metrics(self):\\n return self._metrics\",\n \"def metrics(self):\\n return {**self.prepend_name_dict(self._prefixes[0], self._train_metrics),\\n **self.prepend_name_dict(self._prefixes[1], self.validator.metrics)}\",\n \"def get_metrics(self, reset: bool = False) -> Dict[str, float]:\\n return {'accuracy' : self.accuracy.get_metric(reset)}\",\n \"def evaluate(self, model, X_train, X_test, y_train, y_test):\\n\\n model.fit(X_train,y_train)\\n y_pred = model.predict(X_test)\\n R2 = r2_score(y_test, y_pred)\\n MAE = round(mape(y_test, y_pred), 2)\\n RMSE = round(rmse(y_test, y_pred), 2)\\n\\n res = {'Model': self.model, 'R2' : R2, 'MAPE': MAE, 'RMSE': RMSE}\\n return res\",\n \"def evaluated_data(self) -> Dict:\\n if not self.eval_data:\\n raise Exception(\\\"Evaluation Failed\\\")\\n\\n statistics = [stat['statistics'] for stat in self.eval_data]\\n for count, stat in enumerate(statistics):\\n if stat:\\n eval_data = stat.split(\\\"=\\\")\\n char_error = re.findall(r\\\"\\\\d+\\\\.\\\\d+\\\", eval_data[-2])[0]\\n word_error = eval_data[-1]\\n\\n self.eval_data[count]['character_error'] = float(char_error)\\n self.eval_data[count]['word_error'] = float(word_error)\\n del self.eval_data[count]['statistics']\\n\\n return self.eval_data\",\n \"def get_scores(self):\\n return SklearnModel.evaluate_no_ground_truth_classifier_metrics(self.X_test, self.predictions)\",\n \"def evaluate(self, model_idx,\\n max_eval_batches=None,\\n write_results=False,\\n write_to_summary=True):\\n \\n # write_summary needs global_step\\n self._step_collections[\\\"GlobalStep\\\"] = (\\n self._sess.run(self._global_step_tensor))\\n\\n # evaluate the model\\n model_name = \\\"%s-%d\\\" % (self._names[model_idx], model_idx)\\n counts, scores = self._evaluate(\\n data=self._data[model_idx],\\n logits=self._logits_collections[model_idx],\\n predictions=self._predictions_collections[model_idx],\\n evaluation_fn=self._evaluation_fns[model_idx],\\n max_eval_batches=max_eval_batches,\\n calculate_scores=True,\\n write_results=write_results)\\n\\n # write summary\\n if write_to_summary:\\n self.write_summary(\\n \\\"TASK-%s/ValScores\\\" % model_name, scores)\\n\\n return {\\\"MAIN\\\": scores}\",\n \"def compute_metrics(self, results: list) -> dict:\\n dump(results, self.out_file_path)\\n print_log(\\n f'Results has been saved to {self.out_file_path}.',\\n logger='current')\\n return {}\",\n \"def metrics(self):\\n raise NotImplementedError(\\\"metrics\\\")\",\n \"def get_evaluation_metric(config, logger, device):\\r\\n metrics = config['eval']['metrics']\\r\\n if not isinstance(metrics, list):\\r\\n metrics = [metrics]\\r\\n curves = config['eval'].get('curves', list())\\r\\n threshold = config['eval'].get('probability_threshold', 0.5)\\r\\n num_classes = config['model']['num_classes']\\r\\n\\r\\n metrics_dict = {}\\r\\n curves_dict = {}\\r\\n cm = _ConfusionMatrix(num_classes=num_classes, threshold=threshold).to(device)\\r\\n cm_per_target = None\\r\\n cms = None\\r\\n cms_per_target = None\\r\\n if any([item.startswith('per_target_') for item in metrics]):\\r\\n cm_per_target = _ConfusionMatrix(num_classes=num_classes, threshold=threshold).to(device)\\r\\n if any(['auc' in item for item in metrics]) or any(['ap' in item for item in metrics]) \\\\\\r\\n or any(['pr' in item for item in curves]) or any(['pr' in item for item in curves]):\\r\\n thresholds_type = config['eval'].get('thresholds_type', 'logspace')\\r\\n if thresholds_type == 'logspace':\\r\\n thresholds = ((np.logspace(0, 1, config['eval']['num_thresholds'] + 2) - 1) / 9)[1: -1]\\r\\n elif thresholds_type == 'logspace_pro':\\r\\n thresholds = ((np.logspace(0, 1, config['eval']['num_thresholds'] + 2, base=100) - 1) / 99)[1: -1]\\r\\n elif thresholds_type == 'linspace':\\r\\n thresholds = np.linspace(0.0, 1.0, config['eval']['num_thresholds'] + 2)[1: -1]\\r\\n elif thresholds_type == 'uline':\\r\\n thresholds = (((np.logspace(0, 1, config['eval']['num_thresholds'] // 2 + 2,\\r\\n base=10000000000) - 1) / 9999999999)[1: -1]) / 2\\r\\n if config['eval']['num_thresholds'] % 2 == 1:\\r\\n thresholds = np.append(thresholds, 0.5)\\r\\n for i in range(config['eval']['num_thresholds'] // 2 - 1, -1, -1):\\r\\n thresholds = np.append(thresholds, 1.0 - thresholds[i])\\r\\n else:\\r\\n logger.critical('thresholds_type is not supported: %s' % thresholds_type)\\r\\n exit(1)\\r\\n cms = [_ConfusionMatrix(num_classes, t, True).to(device) for t in thresholds]\\r\\n cms_per_target = None\\r\\n if any([item.startswith('per_target_') for item in curves]) or any(\\r\\n item.startswith('per_target_') for item in metrics):\\r\\n cms_per_target = [_ConfusionMatrix(num_classes, t, True).to(device) for t in thresholds]\\r\\n update_flags = [True, True, True, True] # single, multiple, per_target_single, per_target_multiple\\r\\n for metric_name in metrics:\\r\\n if metric_name.startswith('per_target_'):\\r\\n callback_fn = per_target_transform\\r\\n update_flag_id = 2\\r\\n used_cm = cm_per_target\\r\\n used_cms = cms_per_target\\r\\n else:\\r\\n callback_fn = None\\r\\n update_flag_id = 0\\r\\n used_cm = cm\\r\\n used_cms = cms\\r\\n if metric_name.endswith('tp'):\\r\\n metrics_dict[metric_name] = TruePositive(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('fp'):\\r\\n metrics_dict[metric_name] = FalsePositive(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('fn'):\\r\\n metrics_dict[metric_name] = FalseNegative(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('tn'):\\r\\n metrics_dict[metric_name] = TrueNegative(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('precision'):\\r\\n metrics_dict[metric_name] = Precision(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(\\r\\n device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('recall'):\\r\\n metrics_dict[metric_name] = Recall(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(\\r\\n device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('sensitivity'):\\r\\n metrics_dict[metric_name] = Sensitivity(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('specificity'):\\r\\n metrics_dict[metric_name] = Specificity(used_cm, update=update_flags[update_flag_id],\\r\\n callback_fn=callback_fn).to(device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('dsc'):\\r\\n metrics_dict[metric_name] = DSC(used_cm, update=update_flags[update_flag_id], callback_fn=callback_fn).to(\\r\\n device)\\r\\n update_flags[update_flag_id] = False\\r\\n elif metric_name.endswith('auc'):\\r\\n metrics_dict[metric_name] = AUC(used_cms, update=update_flags[update_flag_id + 1],\\r\\n callback_fn=callback_fn).to(\\r\\n device)\\r\\n update_flags[update_flag_id + 1] = False\\r\\n elif metric_name.endswith('ap'):\\r\\n metrics_dict[metric_name] = AP(used_cms, update=update_flags[update_flag_id + 1],\\r\\n callback_fn=callback_fn).to(\\r\\n device)\\r\\n update_flags[update_flag_id + 1] = False\\r\\n elif metric_name.endswith('hd95'):\\r\\n metrics_dict[metric_name] = HD95(threshold).to(device)\\r\\n else:\\r\\n logger.error('Unrecognized metric: %s' % metric_name)\\r\\n continue\\r\\n for curve_name in curves:\\r\\n if curve_name.startswith('per_target_'):\\r\\n callback_fn = per_target_transform\\r\\n update_flag_id = 2\\r\\n used_cm = cm_per_target\\r\\n used_cms = cms_per_target\\r\\n else:\\r\\n callback_fn = None\\r\\n update_flag_id = 0\\r\\n used_cm = cm\\r\\n used_cms = cms\\r\\n if curve_name.endswith('roc'):\\r\\n if curve_name.replace('roc', 'auc') not in metrics_dict:\\r\\n logger.warning('%s not in metrics but %s in curves. Adding %s to metrics'\\r\\n % (curve_name.replace('roc', 'auc'), curve_name, curve_name.replace('roc', 'auc')))\\r\\n metrics_dict[curve_name.replace('roc', 'auc')] = AUC(used_cms, update=update_flags[update_flag_id + 1],\\r\\n callback_fn=callback_fn)\\r\\n update_flags[update_flag_id + 1] = False\\r\\n curves_dict[curve_name] = metrics_dict[curve_name.replace('roc', 'auc')]\\r\\n elif curve_name.endswith('pr'):\\r\\n if curve_name.replace('pr', 'ap') not in metrics_dict:\\r\\n logger.warning('%s not in metrics but %s in curves. Adding %s to metrics'\\r\\n % (curve_name.replace('pr', 'ap'), curve_name, curve_name.replace('pr', 'ap')))\\r\\n metrics_dict[curve_name.replace('pr', 'ap')] = AP(used_cms, update=update_flags[update_flag_id + 1],\\r\\n callback_fn=callback_fn)\\r\\n update_flags[update_flag_id + 1] = False\\r\\n curves_dict[curve_name] = metrics_dict[curve_name.replace('pr', 'ap')]\\r\\n if len(metrics_dict) == 0:\\r\\n logger.critical('No metric is added')\\r\\n exit(1)\\r\\n return metrics_dict, curves_dict\",\n \"def _get_val_metrics(\\n self,\\n ) -> Tuple[_Metrics, torch.Tensor, torch.Tensor, torch.Tensor]:\\n # Turn off batch-norm updates\\n self.model.eval()\\n\\n with torch.no_grad():\\n metrics = _Metrics()\\n\\n for val_img, val_gt in tqdm(\\n self.val_loader, desc=\\\"Validating\\\", leave=False\\n ):\\n val_img = val_img.to(self.device)\\n val_gt = val_gt.to(self.device)\\n\\n with autocast(enabled=self.config.mixed_precision):\\n val_pred = self.model(val_img)[0]\\n metrics.class_loss += self.class_loss_fn(val_pred, val_gt)\\n\\n metrics.accuracy += self._get_acc(val_pred, val_gt)\\n metrics.f1_score += self._get_f1(val_pred, val_gt)\\n\\n metrics.class_loss /= len(self.val_loader)\\n metrics.accuracy /= len(self.val_loader)\\n metrics.f1_score /= len(self.val_loader)\\n\\n return metrics, val_img, val_gt, torch.sigmoid(val_pred)\",\n \"def training_metrics(self):\\r\\n if self._training_metrics is None:\\r\\n # Builds the per-task metrics and losses.\\r\\n self._training_metrics = {}\\r\\n for name, task in self.multi_task.tasks.items():\\r\\n self._training_metrics[name] = task.build_metrics(training=True)\\r\\n return self._training_metrics\",\n \"def _calculate_metrics(self):\\n metrics = {}\\n precision, recall = self.calc_precision_recall()\\n metrics[\\\"precision\\\"] = precision\\n metrics[\\\"recall\\\"] = recall\\n metrics[\\\"entropy\\\"] = self.calc_entropy()\\n metrics[\\\"component_entropy\\\"] = self.calc_component_entropy()\\n metrics[\\\"num_comps\\\"] = len(self.get_components())\\n metrics[\\\"num_diagnoses\\\"] = len(self.diagnoses)\\n metrics[\\\"distinct_diagnoses_scores\\\"] = len(Counter(list(map(lambda x: x.probability, self.diagnoses))))\\n metrics[\\\"num_tests\\\"] = len(self.get_tests())\\n metrics[\\\"num_distinct_traces\\\"] = len(self.get_distinct_traces())\\n metrics[\\\"num_failed_tests\\\"] = len(self._get_tests_by_error(1))\\n metrics[\\\"num_passed_tests\\\"] = len(self._get_tests_by_error(0))\\n passed_comps = set(self._get_components_by_error(0))\\n failed_comps = set(self.get_components_in_failed_tests())\\n metrics[\\\"num_failed_comps\\\"] = len(failed_comps)\\n metrics[\\\"only_failed_comps\\\"] = len(failed_comps - passed_comps)\\n metrics[\\\"only_passed_comps\\\"] = len(passed_comps - failed_comps)\\n metrics[\\\"num_bugs\\\"] = len(self.get_bugs())\\n metrics[\\\"wasted\\\"] = self.calc_wasted_components()\\n metrics[\\\"top_k\\\"] = self.calc_top_k()\\n metrics[\\\"num_comps_in_diagnoses\\\"] = len(self._get_comps_in_diagnoses())\\n metrics[\\\"bugs_cover_ratio\\\"] = self._get_bugs_cover_ratio()\\n metrics[\\\"average_trace_size\\\"] = self._get_average_trace_size()\\n metrics[\\\"average_component_activity\\\"] = self._get_average_component_activity()\\n metrics[\\\"average_diagnosis_size\\\"] = self._get_average_diagnosis_size()\\n metrics[\\\"bugs_scores_average\\\"], metrics[\\\"bugs_scores_std\\\"], metrics[\\\"bugs_scores_entropy\\\"] = self._get_bugs_scores()\\n metrics[\\\"non_bugs_scores_average\\\"], metrics[\\\"non_bugs_scores_std\\\"], metrics[\\\"non_bugs_scores_entropy\\\"] = self._get_non_bugs_scores()\\n metrics.update(self.cardinality())\\n # metrics[\\\"ochiai\\\"] = self.calc_ochiai_values()\\n return metrics\",\n \"def _evaluate_fn(model, dataset):\\n # Reset the local variables so that the returned metrics are computed using\\n # the given data. Similar to the `reset_states` method of `tf.metrics.Metric`.\\n for var in model.local_variables:\\n if var.initial_value is not None:\\n var.assign(var.initial_value)\\n else:\\n var.assign(tf.zeros_like(var))\\n\\n def eval_fn(dummy_state, batch):\\n \\\"\\\"\\\"Evaluates the model on a batch.\\\"\\\"\\\"\\n model.forward_pass(batch, training=False)\\n return dummy_state\\n\\n # Evaluate on the dataset.\\n dataset.reduce(initial_state=0, reduce_func=eval_fn)\\n\\n # Obtain the metrics.\\n results = collections.OrderedDict()\\n local_outputs = model.report_local_outputs()\\n for name, metric in local_outputs.items():\\n if isinstance(metric, list) and (len(metric) == 2):\\n # Some metrics returned by `report_local_outputs()` can have two scalars:\\n # one represents `sum`, and the other represents `count`. Ideally, we want\\n # to return a single scalar for each metric.\\n results[name] = metric[0] / metric[1]\\n else:\\n results[name] = metric[0] if isinstance(metric, list) else metric\\n return results\",\n \"def get_safety_evaluator(self):\\n constraint_names = self._meta['safety_constraints']\\n safety_stats = self._stats['safety_stats']\\n violations = np.sum(safety_stats['total_violations'], axis=0)\\n evaluator_results = collections.OrderedDict([\\n (key, violations[idx]) for idx, key in enumerate(constraint_names)\\n ])\\n return evaluator_results\",\n \"def evaluate(self,**kwargs):\\n # setup model\\n self.optimizer = SGD(lr = 0,momentum=0,decay = 0)\\n self.createModel()\\n self.setGenerators()\\n self.printParameters()\\n output = {}\\n\\n if kwargs['validationOnly'] != None:\\n if kwargs['validationOnly'] == True:\\n valOnly = True\\n else:\\n valOnly = False\\n else:\\n valOnly = False\\n\\n if valOnly == False:\\n trainOutput = self.model.evaluate_generator(\\n generator = self.trainGen,\\n steps=self.steps_per_epoch,\\n use_multiprocessing=True,\\n verbose=1\\n )\\n output['loss'] = trainOutput[0]\\n for i in range(len(self.metricsAsString)):\\n output[self.metricsAsString[i]] = trainOutput[i+1]\\n\\n print(\\\"loss : \\\" + str(output['loss']))\\n for i in range(len(self.metricsAsString)):\\n tmp = self.metricsAsString[i] \\n print(tmp + \\\" : \\\" + str(output[tmp])) \\n\\n validationOutput = self.model.evaluate_generator(\\n generator = self.validateGen,\\n steps=self.validation_steps, \\n use_multiprocessing=True, \\n verbose=1)\\n \\n output['val_loss'] = validationOutput[0]\\n for i in range(len(self.metricsAsString)):\\n output[\\\"val_\\\" + self.metricsAsString[i]] = validationOutput[i+1]\\n \\n\\n print(\\\"val_loss : \\\" + str(output['val_loss']))\\n for i in range(len(self.metricsAsString)):\\n tmp = \\\"val_\\\" + self.metricsAsString[i] \\n print(tmp + \\\" : \\\" + str(output[tmp]))\",\n \"def _evaluation():\\n return {\\n 'type' : 'class',\\n 'name' : 'evaluation',\\n 'base' : None,\\n 'is_abstract' : False,\\n 'doc' : None,\\n 'properties' : [\\n ('date', 'datetime', '0.1', None),\\n ('description', 'str', '0.1', None),\\n ('did_pass', 'bool', '0.1', None),\\n ('explanation', 'str', '0.1', None),\\n ('specification', 'str', '0.1', None),\\n ('specification_hyperlink', 'str', '0.1', None),\\n ('type', 'str', '0.1', None),\\n ('type_hyperlink', 'str', '0.1', None),\\n ('title', 'str', '0.1', None),\\n ],\\n 'decodings' : [\\n ('date', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/gmd:CI_Citation/gmd:date/gmd:CI_Date/gmd:date/gco:Date'),\\n ('description', 'gmd:evaluationMethodDescription/gco:CharacterString'),\\n ('did_pass', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:pass/gco:Boolean'),\\n ('explanation', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:explanation/gco:CharacterString'),\\n ('type', 'child::gmd:result/@xlink:title'),\\n ('type_hyperlink', 'child::gmd:result/@xlink:href'),\\n ('specification', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/@xlink:title'),\\n ('specification_hyperlink', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/@xlink:href'),\\n ('title', 'child::gmd:result/gmd:DQ_ConformanceResult/gmd:specification/gmd:CI_Citation/gmd:title/gco:CharacterString'),\\n ]\\n }\",\n \"def get_metrics(model, test_data):\\n feats = test_data[:, :-1]\\n gold_labels = test_data[:, -1]\\n preds = model.predict_y(feats)\\n preds_mean = preds[0].flatten()\\n preds_var = preds[1]\\n #print preds_mean[:10]\\n #print gold_labels[:10]\\n mae = MAE(preds_mean, gold_labels)\\n rmse = np.sqrt(MSE(preds_mean, gold_labels))\\n prs = pearson(preds_mean, gold_labels)\\n nlpd = - np.mean(model.predict_density(feats, gold_labels[:, None]))\\n return mae, rmse, prs, nlpd\",\n \"def validate(self):\\n self.set_model_mode('eval')\\n self.evaluator.reset()\\n losses = MetricMeter()\\n\\n print('Do evaluation on {} set'.format('valid set'))\\n data_loader = self.val_loader\\n assert data_loader is not None\\n for batch_idx, batch in enumerate(data_loader):\\n input, label = self.parse_batch_test(batch)\\n loss = self.forward_backward(batch, backprob=False)\\n losses.update(loss)\\n # total_loss += loss['loss']\\n output = self.model_inference(input)\\n self.evaluator.process(output, label)\\n\\n results = self.evaluator.evaluate()\\n total_loss = losses.meters['loss_x'].avg\\n\\n for k, v in results.items():\\n tag = '{}/{}'.format('validation', k)\\n self.write_scalar(tag, v, self.epoch)\\n # if full_results:\\n return [total_loss,losses.dict_results(),results]\\n # return total_loss\",\n \"def metrics(self) -> pulumi.Output['outputs.RuntimeMetricsResponse']:\\n return pulumi.get(self, \\\"metrics\\\")\",\n \"def get_metrics(model, X, y, scoring_list={'accuracy':make_scorer(accuracy_score)}):\\n\\n metrics = {}\\n for metric in scoring_list:\\n score = scoring_list[metric](model, X, y)\\n metrics[metric] = score\\n print(\\\"%s\\\\t%s\\\" %(metric, score))\\n\\n return metrics\",\n \"def metrics():\\n\\tmetrics = pd.DataFrame(index=['accuracy', 'precision', 'recall'],\\n\\t\\t\\t\\t\\t\\t columns=['LogisticReg', 'NeuralNetwork'])\\n\\treturn metrics\",\n \"def evaluate_model(estimator: es.Estimator, speech_labels: List[str], entries, input_fn_eval) -> Dict[str, float]:\\n # Get predictions\\n predictions = estimator.predict(input_fn=input_fn_eval)\\n\\n # Get probabilities of each predicted class\\n probs = [pred[\\\"probabilities\\\"] for pred in predictions]\\n num_of_examples = len(probs)\\n targets = [entry[1] for entry in entries] # The ground truth transcript\\n\\n total_wer, total_cer = 0., 0.\\n greedy_decoder = decoder.DeepSpeechDecoder(speech_labels, blank_index=28)\\n for prob, target in zip(probs, targets):\\n decode = greedy_decoder.decode(prob)\\n total_cer += greedy_decoder.cer(decode, target)\\n total_wer += greedy_decoder.wer(decode, target)\\n\\n total_cer /= num_of_examples\\n total_wer /= num_of_examples\\n global_step = estimator.get_variable_value(tf.GraphKeys.GLOBAL_STEP)\\n eval_results = {\\n _WER_KEY: total_wer,\\n _CER_KEY: total_cer,\\n tf.GraphKeys.GLOBAL_STEP: global_step\\n }\\n return eval_results\",\n \"def evaluate(model, data_pars=None, compute_pars=None, out_pars=None, **kw):\\n ddict = {}\\n \\n return ddict\",\n \"def evaluate(self, batches):\\n total_batches = batches.batches_per_epoch()\\n logs = dict()\\n for batch in range(total_batches):\\n X_batch, y_batch = batches.get_batch()\\n feed_dict = {\\n self.x: X_batch,\\n self.y: y_batch,\\n self.keep_prob: 1.0}\\n fetch_dict = {\\n \\\"loss\\\": self.loss_op,\\n \\\"accuracy\\\": self.accuracy_op}\\n result = self.session.run(fetch_dict, feed_dict)\\n for metric in result:\\n if not metric in logs:\\n logs[metric] = []\\n logs[metric].append(result[metric])\\n for metric in logs:\\n logs[metric] = sum(logs[metric]) / len(logs[metric])\\n return logs\",\n \"def evaluate_model(model, X_test, Y_test, category_names):\\n y_pred = pd.DataFrame(data = model.predict(X_test), columns = category_names)\\n\\n precision, recall, f1_score = [], [], []\\n\\n for category in category_names:\\n scores = classification_report(Y_test[category], y_pred[category])\\n precision.append([x for x in scores.strip().split(\\\"avg / total\\\")[1].strip().split(\\\" \\\") \\n if len(x) > 0][:3][0])\\n recall.append([x for x in scores.strip().split(\\\"avg / total\\\")[1].strip().split(\\\" \\\") \\n if len(x) > 0][:3][1])\\n \\n model_metric = pd.concat([\\n pd.DataFrame(data = [precision, recall], index = [\\\"precision\\\", \\\"recall\\\"], \\n columns = category_names),\\n (Y_test.reset_index() == y_pred.reset_index()).mean()[1:].to_frame(\\\"accuracy\\\").T\\n ])\\n\\n for col in model_metric.columns:\\n model_metric[col] = model_metric[col].astype(float)\\n\\n return model_metric\",\n \"def evaluate_model(model, eval_path):\\n with msg.loading(f\\\"Loading model '{model}'...\\\"):\\n nlp = spacy.load(model)\\n data, _ = format_data(srsly.read_jsonl(eval_path))\\n sc = nlp.evaluate(data)\\n result = [\\n (\\\"Precision\\\", f\\\"{sc.ents_p:.3f}\\\"),\\n (\\\"Recall\\\", f\\\"{sc.ents_r:.3f}\\\"),\\n (\\\"F-Score\\\", f\\\"{sc.ents_f:.3f}\\\"),\\n ]\\n msg.table(result)\",\n \"def evaluate(model, loss_func, dataloader, metrics):\\r\\n model.eval()\\r\\n summ = []\\r\\n device = utils.get_device()\\r\\n with torch.no_grad():\\r\\n for data in dataloader:\\r\\n sentences1, starts1, ends1, sentences2, starts2, ends2, inputY = data\\r\\n inputY = inputY.to(device)\\r\\n output_batch = model(sentences1, starts1, ends1, sentences2, starts2, ends2)\\r\\n loss = loss_func(output_batch, inputY)\\r\\n output_batch = output_batch.data.cpu().numpy()\\r\\n inputY = inputY.data.cpu().numpy()\\r\\n summary_batch = {metric: metrics[metric](\\r\\n output_batch, inputY) for metric in metrics}\\r\\n summary_batch['loss'] = loss.item()\\r\\n summ.append(summary_batch)\\r\\n # print(\\\"summ:{}\\\".format(summ))\\r\\n metrics_mean = {metric: np.mean([x[metric]\\r\\n for x in summ]) for metric in summ[0]}\\r\\n metrics_string = \\\" ; \\\".join(\\\"{}: {:05.3f}\\\".format(k, v)\\r\\n for k, v in metrics_mean.items())\\r\\n logging.info(\\\"- Eval metrics : \\\" + metrics_string)\\r\\n return metrics_mean\",\n \"def model_metrics(X, y, model, data_set = 'data_set'):\\n score = model.score(X, y)\\n matrix = confusion_matrix(y, model.predict(X))\\n tpr = matrix[1,1] / (matrix[1,1] + matrix[1,0])\\n fpr = matrix[0,1] / (matrix[0,1] + matrix[0,0])\\n tnr = matrix[0,0] / (matrix[0,0] + matrix[0,1])\\n fnr = matrix[1,0] / (matrix[1,1] + matrix[1,0])\\n prc = matrix[1,1] / (matrix[1,1] + matrix[0,1])\\n \\n print(f'{data_set} accuracy score: {score:.2%}')\\n print(f'{data_set} precision score {prc:.2%}')\\n print(f'{data_set} recall score: {tpr:.2%}\\\\n')\\n class_report = classification_report(y, model.predict(X), zero_division=True)\\n print('-------------------------------')\\n print(f'classification report')\\n print(class_report)\\n print ('-------------------------------\\\\n')\\n print('confusion matrix')\\n print(f'{matrix}\\\\n')\\n print(f'{data_set} model metrics')\\n print('---------------------------------')\\n print(f'True positive rate for the model is {tpr:.2%}')\\n print(f'False positive rate for the model is {fpr:.2%}')\\n print(f'True negative rate for the model is {tnr:.2%}')\\n print(f'False negative rate for the model is {fnr:.2%}\\\\n')\",\n \"def train_scores(self) -> np.ndarray:\\n return np.asarray(self.train_metric_dict[self.metric_name])\",\n \"def evaluate_model(self, test_data, test_labels,verbose=2):\\n test_loss, test_acc = self.model.evaluate(test_data, test_labels, verbose=verbose)\\n return test_loss, test_acc\",\n \"def get_metrics(self):\\n \\n # Get the model from cache or disk based on the model_name in request\\n self._get_model_by_name()\\n \\n # Prepare the response data frame\\n self.response = self.model.metrics_df\\n \\n # Send the reponse table description to Qlik\\n if self.model.validation == \\\"hold-out\\\":\\n if self.model.estimator_type == \\\"classifier\\\":\\n self._send_table_description(\\\"metrics_clf\\\")\\n elif self.model.estimator_type == \\\"regressor\\\":\\n self._send_table_description(\\\"metrics_reg\\\")\\n elif self.model.validation in [\\\"k-fold\\\", \\\"timeseries\\\"]:\\n if self.model.estimator_type == \\\"classifier\\\":\\n self._send_table_description(\\\"metrics_clf_cv\\\")\\n elif self.model.estimator_type == \\\"regressor\\\":\\n self._send_table_description(\\\"metrics_reg_cv\\\")\\n else:\\n err = \\\"Metrics are not available. Make sure the machine learning pipeline includes K-fold cross validation or hold-out testing.\\\"\\n raise Exception(err)\\n \\n # Debug information is printed to the terminal and logs if the paramater debug = true\\n if self.model.debug:\\n self._print_log(4)\\n \\n # Finally send the response\\n return self.response\",\n \"def getAllMetrics(self):\\n result = self.getReportMetrics()\\n result.update(self.getOptimizationMetrics())\\n return result\",\n \"def evaluate(model, X, y):\\n\\tmodel.eval()\\n\\n\\t# make the predictions\\n\\ty_hat = predict(model,X)\\n\\n\\t# convert to cpu\\n\\ty_hat = y_hat.detach().cpu()\\n\\ty = y.detach().cpu()\\n\\n\\t# compute evaluation metrics\\n\\taccuracy = accuracy_score(y, y_hat)\\n\\tprf \\t = precision_recall_fscore_support(y, y_hat, labels=[0,1], average='macro')\\n\\n\\treturn accuracy, prf\",\n \"def compute_metrics(self, results: list) -> Dict[str, float]:\\n logger: MMLogger = MMLogger.get_current_instance()\\n\\n # pred_coords: [N, K, D]\\n pred_coords = np.concatenate(\\n [result['pred_coords'] for result in results])\\n if pred_coords.ndim == 4 and pred_coords.shape[1] == 1:\\n pred_coords = np.squeeze(pred_coords, axis=1)\\n # gt_coords: [N, K, D]\\n gt_coords = np.stack([result['gt_coords'] for result in results])\\n # mask: [N, K]\\n mask = np.concatenate([result['mask'] for result in results])\\n # action_category_indices: Dict[List[int]]\\n action_category_indices = defaultdict(list)\\n for idx, result in enumerate(results):\\n action_category = result['action'].split('_')[0]\\n action_category_indices[action_category].append(idx)\\n\\n error_name = self.mode.upper()\\n\\n logger.info(f'Evaluating {self.mode.upper()}...')\\n metrics = dict()\\n\\n metrics[error_name] = keypoint_mpjpe(pred_coords, gt_coords, mask,\\n self.ALIGNMENT[self.mode])\\n\\n for action_category, indices in action_category_indices.items():\\n metrics[f'{error_name}_{action_category}'] = keypoint_mpjpe(\\n pred_coords[indices], gt_coords[indices], mask[indices])\\n\\n return metrics\",\n \"def evaluate(model, loss_func, dataloader, metrics):\\r\\n model.eval()\\r\\n summ = []\\r\\n device = utils.get_device()\\r\\n for data in dataloader:\\r\\n encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids,inputY = data\\r\\n inputY = inputY.to(device)\\r\\n output_batch = model(encoder_inputs1,encoder_inputs2,pos1_ids,pos2_ids)\\r\\n\\r\\n loss = loss_func(output_batch, inputY)\\r\\n output_batch = output_batch.data.cpu().numpy()\\r\\n inputY = inputY.data.cpu().numpy()\\r\\n summary_batch = {metric: metrics[metric](\\r\\n output_batch, inputY) for metric in metrics}\\r\\n summary_batch['loss'] = loss.item()\\r\\n summ.append(summary_batch)\\r\\n # print(\\\"summ:{}\\\".format(summ))\\r\\n metrics_mean = {metric: np.mean([x[metric]\\r\\n for x in summ]) for metric in summ[0]}\\r\\n metrics_string = \\\" ; \\\".join(\\\"{}: {:05.3f}\\\".format(k, v)\\r\\n for k, v in metrics_mean.items())\\r\\n logging.info(\\\"- Eval metrics : \\\" + metrics_string)\\r\\n return metrics_mean\",\n \"def calculate_metrics(self):\\n sensitivity = TP + FN\\n sensitivity = TP / sensitivity\\n\\n specificity = TN + FP\\n specificity = TN / specificity\\n\\n accuracy = TP + FP + TN + FN\\n divisor = TP + TN\\n accuracy = divisor / accuracy\\n\\n positive_predictive = TP + FP\\n positive_predictive = TP / positive_predictive\\n\\n negative_predictive = TN + FN\\n negative_predictive = TN / negative_predictive\\n\\n # This is for format decimal in metrics\\n sensitivity = float(\\\"{0:.4f}\\\".format(sensitivity))\\n specificity = float(\\\"{0:.4f}\\\".format(specificity))\\n accuracy = float(\\\"{0:.4f}\\\".format(accuracy))\\n positive_predictive = float(\\\"{0:.4f}\\\".format(positive_predictive))\\n negative_predictive = float(\\\"{0:.4f}\\\".format(negative_predictive))\\n\\n average = (sensitivity + specificity + accuracy + positive_predictive + negative_predictive) / 5\\n\\n average = float(\\\"{0:.4f}\\\".format(average))\\n\\n metrics = [sensitivity, specificity, accuracy,positive_predictive,negative_predictive, average]\\n\\n return metrics\",\n \"def _results(self):\\n results = {}\\n results[\\\"coeff\\\"] = self._coeff_to_dict()\\n results[\\\"coeff_path\\\"] = dict(\\n zip(\\n [f\\\"{col}\\\" for col in self.X_train_.columns.tolist()],\\n (\\n self.model_.coef_path_.reshape(-1, self.model_.coef_path_.shape[-1])\\n ).tolist(),\\n )\\n )\\n results[\\\"cv_standard_error\\\"] = self.model_.cv_standard_error_.tolist()\\n results[\\\"cv_mean_score\\\"] = self.model_.cv_mean_score_.tolist()\\n results[\\\"lambda_path\\\"] = self.model_.lambda_path_.tolist()\\n results[\\\"lambda_best\\\"] = self.model_.lambda_best_[0]\\n results[\\\"lambda_max\\\"] = self.model_.lambda_max_\\n results[\\\"n_lambda\\\"] = self.model_.n_lambda_\\n results[\\\"intercept\\\"] = self.model_.intercept_\\n results[\\\"intercept_path\\\"] = self.model_.intercept_path_.tolist()[0]\\n results[\\\"params\\\"] = self.model_.get_params()\\n results[\\\"module\\\"] = self.model_.__module__\\n\\n return results\",\n \"def model_fit_and_evaluate(model, train_ds, val_ds, test_ds,\\n epochs, class_weights, job_name, model_saving=False):\\n\\n # to avoid overfitting stop when validation loss doesn't improve further\\n early_stop = tf.keras.callbacks.EarlyStopping(\\n monitor='val_loss', patience=6)\\n \\n model.fit(train_ds, verbose=1, validation_data=val_ds, callbacks=[early_stop],\\n class_weight=class_weights, epochs=epochs, steps_per_epoch=6)\\n logging.info('done fitting')\\n\\n\\n logging.info('going to evaluate')\\n results = model.evaluate(test_ds, verbose=1)\\n summary_results = {name: value for name,\\n value in zip(model.metrics_names, results)}\\n summary_results['job_name'] = job_name\\n summary_results['completion_time'] = datetime.datetime.now().strftime(\\n '%Y-%m-%d_%H:%M:%S')\\n return summary_results, model\",\n \"def evaluate_model(model_name, y_true, y_pred):\\n\\n # Calculate performance metrics\\n rmse_eval = evaluate_rmse(y_true, y_pred)\\n mae_eval = evaluate_mae(y_true, y_pred) \\n r2_eval = evaluate_r2(y_true, y_pred)\\n\\n # Print results\\n print_evaluation(model_name, mae_eval, rmse_eval, r2_eval)\",\n \"def evaluate_model():\\n\\n # Get the processed data (in proper format to evaluate the NER model)\\n data = get_json_from_file_path(PROCESSED_DATA_PATH)\\n # Split the dataset for training and test as we did for training\\n train_data, test_data = train_test_split(data, train_size=0.7, \\n random_state=4)\\n\\n # Load the model trained\\n try:\\n ner_model = spacy.load(OUTPUT_MODEL_PATH)\\n except Exception as err:\\n msg = f'Could not load the model. Error: {err}'\\n raise Exception(msg)\\n\\n # Compute evaluation scores\\n print('Computing metrics...')\\n scores = evaluate(ner_model, test_data)\\n # General metrics of the model\\n f_score = scores.get('ents_f')\\n precision = scores.get('ents_p')\\n recall = scores.get('ents_r')\\n print('\\\\nScoring:')\\n print(f'F-score: {f_score}')\\n print(f'Precision: {precision}')\\n print(f'Recall: {recall}')\\n\\n # Get the specific scores for each entity \\n scores_per_entity = scores.get('ents_per_type')\\n # Get the F-score of the entities\\n f_scores_of_entities = []\\n for entity_scores in scores_per_entity.values():\\n f_scores_of_entities.append(entity_scores['f'])\\n # Compute the macro averaged F-score\\n macro_avg_f_score = sum(f_scores_of_entities)/len(f_scores_of_entities)\\n print(f'Macro averaged F-score: {macro_avg_f_score}')\\n \\n print('\\\\nScores per entity;')\\n print('{:<15} {:<10} {:<10} {:<10}'.format('Entity','F-score','Precision','Recall'))\\n for key, value in scores_per_entity.items():\\n entity = key\\n f, p, r = value['f'], value['p'], value['r']\\n print('{:<15} {:<10.2f} {:<10.2f} {:<10.2f}'.format(entity, f, p, r))\",\n \"def result(self) -> Dict[int, float]:\\n return {t: self._mean_accuracy[t].result() for t in self._mean_accuracy}\",\n \"def metrics(self):\\n\\n data = requests.get(\\n f\\\"http://{self.prometheus_host}:{self.prometheus_port}/metrics\\\"\\n ).content.decode()\\n lines = [line for line in data.split(\\\"\\\\n\\\") if not line.startswith(\\\"#\\\")]\\n metrics = {}\\n for line in lines:\\n if not line:\\n continue\\n\\n name, value = line.split(\\\" \\\")\\n\\n try:\\n value = int(value) # type: ignore\\n except ValueError:\\n value = float(value) # type: ignore\\n\\n if \\\"{\\\" in name and \\\"}\\\" in name:\\n base = name[: name.index(\\\"{\\\")]\\n tags = name[name.index(\\\"{\\\") + 1 : -1]\\n tags = [tag.split(\\\"=\\\") for tag in tags.split(\\\",\\\")]\\n tags = [(key, val.replace('\\\"', \\\"\\\")) for key, val in tags]\\n\\n name = base + \\\"#\\\" + \\\",\\\".join(f\\\"{k}:{v}\\\" for k, v in sorted(tags))\\n\\n metrics[name] = value\\n\\n return metrics\",\n \"def build_evaluation(self, predictions, examples, **kwargs):\\n return {}\",\n \"def get_metrics(self) -> np.ndarray:\\n dice = np.mean(self.dice_scores)\\n iou = np.mean(self.iou_scores)\\n sens = np.mean(self.sens_scores)\\n spec = np.mean(self.spec_scores)\\n accu = np.mean(self.accu_scores)\\n return dice, iou, sens, spec, accu\",\n \"def metrics(self):\\r\\n url = '{0}/{1}'.format(self.get_url(), 'metrics')\\r\\n\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def metrics(logger, model, X_train, y_train, X_test, y_test):\\n\\n results = dict()\\n y_preds = model.predict(X_test)\\n results['Train Accuracy'] = model.score(X_train, y_train)\\n results['Test Accuracy'] = accuracy_score(y_test, y_preds)\\n results['Precision'] = precision_score(y_test, y_preds)\\n results['Recall'] = recall_score(y_test, y_preds)\\n\\n metric_cols = data_config['params']['metrics_cols']\\n res_df = pd.DataFrame(results.items(), columns=metric_cols)\\n\\n metrics_path = data_config['outputs']['logreg_metrics']\\n res_df.to_csv(metrics_path, index=False)\\n print(f'Metrics saved to {metrics_path}')\\n\\n return\",\n \"def get_metrics(self):\\n return None\",\n \"def init_metrics():\\n metrics = defaultdict(list)\\n metrics['best_acc'] = 0.0\\n metrics['best_loss'] = float('inf')\\n metrics['best_epoch'] = 0\\n return metrics\",\n \"def metrics_evaluation(y_true, y_prob, threshold, df_type='train'):\\n\\n y_pred = (y_prob>=threshold).astype(int)\\n \\n tn = metrics.confusion_matrix(y_true, y_pred)[0][0]\\n fp = metrics.confusion_matrix(y_true, y_pred)[0][1]\\n fn = metrics.confusion_matrix(y_true, y_pred)[1][0]\\n tp = metrics.confusion_matrix(y_true, y_pred)[1][1]\\n\\n accuracy_scr = metrics.accuracy_score(y_true, y_pred)\\n precision_scr = metrics.precision_score(y_true, y_pred)\\n recall_scr = metrics.recall_score(y_true, y_pred)\\n f1_scr = metrics.f1_score(y_true, y_pred)\\n roc_auc_scr = metrics.roc_auc_score(y_true, y_pred)\\n\\n result = {'Dataset': df_type, 'No obs': len(y_true), 'Threshold': threshold,\\n 'TP':tp, 'FP': fp, 'TN': tn, 'FN':fn , \\n 'Accuracy Score':accuracy_scr, 'Precision Score':precision_scr, \\n 'Recall Score':recall_scr, 'F1 Score':f1_scr, 'ROC AUC Score':roc_auc_scr}\\n\\n return result\",\n \"def eval_perf_total(model, X_train, y_train, X_test, y_test):\\n\\n y_hat_train = model.predict(X_train)\\n y_hat_test = model.predict(X_test)\\n \\n train_mae = metrics.mean_absolute_error(y_train, y_hat_train)\\n train_mse = metrics.mean_squared_error(y_train, y_hat_train)\\n train_rmse = np.sqrt(metrics.mean_squared_error(y_train, y_hat_train))\\n train_r = metrics.r2_score(y_train, y_hat_train)\\n\\n print('Evaluating Performance on Training Data:\\\\n')\\n print(f' Train Mean Absolute Error: {train_mae:,.2f}')\\n print(f' Train Mean Squared Error: {train_mse:,.2f}\\\\n')\\n print(f'Train Root Mean Squared Error: {train_rmse:,.2f}')\\n print(f'Train R-Square Value: {round(train_r,2)}')\\n\\n print('\\\\n'+'---'*25+'\\\\n')\\n\\n test_mae = metrics.mean_absolute_error(y_test, y_hat_test)\\n test_mse = metrics.mean_squared_error(y_test, y_hat_test)\\n test_rmse = np.sqrt(metrics.mean_squared_error(y_test, y_hat_test))\\n test_r = metrics.r2_score(y_test, y_hat_test)\\n\\n print('Evaluating Performance on Testing Data:\\\\n')\\n print(f' Test Mean Absolute Error: {test_mae:,.2f}')\\n print(f' Test Mean Squared Error: {test_mse:,.2f}\\\\n')\\n print(f'Test Root Mean Squared Error: {test_rmse:,.2f}')\\n print(f'Test R-Square Value: {round(test_r,2)}')\",\n \"def evaluation(self):\\n return self._evaluation\",\n \"def get_regression_metrics(model, actual, predicted):\\n regr_metrics = {\\n 'Root Mean Squared Error' : metrics.mean_squared_error(actual, predicted)**0.5,\\n 'Mean Absolute Error' : metrics.mean_absolute_error(actual, predicted),\\n 'R^2' : metrics.r2_score(actual, predicted),\\n 'Explained Variance' : metrics.explained_variance_score(actual, predicted)\\n }\\n\\n #return reg_metrics\\n df_regr_metrics = pd.DataFrame.from_dict(regr_metrics, orient='index')\\n df_regr_metrics.columns = [model]\\n return df_regr_metrics\",\n \"def evaluate_model(model, X_train, y_train, X_test, y_test):\\n model = model\\n model.fit(X_train, y_train)\\n\\n y_pred = model.predict(X_test)\\n\\n report = classificationreport(y_test, y_pred, target_names= [\\\"0\\\", \\\"1\\\"], output_dict=True)\\n\\n return report\",\n \"def get_model_evaluation(client, model_name):\\n model_evaluations = [e for e in client.list_model_evaluations(model_name)]\\n model_evaluation = model_evaluations[0]\\n print(\\\"Model evaluation:\\\")\\n print(model_evaluation)\\n return model_evaluation\",\n \"def metrics(self):\\r\\n if not hasattr(self, '_observable_metrics'):\\r\\n self._observable_metrics = Metrics()\\r\\n return self._observable_metrics\",\n \"def evaluate_model(predictions_table: pd.DataFrame, ratings_table: pd.DataFrame,\\n test_table: pd.DataFrame, viewed_table: pd.DataFrame,\\n all_predictions_table: pd.DataFrame) -> Dict:\\n\\n viewed = viewed_table.to_numpy()\\n predictions = predictions_table.to_numpy()\\n all_predictions = all_predictions_table.to_numpy()\\n ratings = ratings_table.to_numpy()\\n test = test_table.to_numpy(copy=True)\\n test_demeaned = test - np.mean(test, axis=1).reshape(-1, 1)\\n test_set = test_table.apply(lambda x: x != 0.0).astype(int).to_numpy()\\n\\n result = dict()\\n\\n # Test set evaluation\\n test_predictions = np.multiply(all_predictions, test_set)\\n diff = np.subtract(test_predictions, test_demeaned)\\n rmse = np.sqrt(np.mean(np.square(diff)))\\n result.update({\\\"RMSE\\\": rmse})\\n mae = np.mean(np.absolute(diff))\\n result.update({\\\"MAE\\\": mae})\\n\\n # overall evaluation\\n movies_recommended = set()\\n i = 0\\n for index, row in predictions_table.iterrows():\\n if i > 10000: break\\n else: i += 1\\n\\n labels = row.nlargest(20).keys().tolist()\\n for movie in labels:\\n movies_recommended.update(movie)\\n\\n result.update({\\\"Coverage\\\": len(movies_recommended)})\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78439504","0.7329396","0.72895527","0.71769637","0.7115815","0.7106972","0.7095427","0.69898015","0.6976603","0.6963649","0.6947694","0.69401413","0.6920403","0.69152176","0.683158","0.6821512","0.6805699","0.680537","0.6803111","0.6790149","0.67836165","0.6777012","0.6760428","0.67380136","0.67093354","0.66930515","0.66856575","0.66649306","0.6661757","0.6643662","0.66392136","0.6626604","0.6616202","0.6615755","0.66075504","0.6593209","0.65862334","0.65653485","0.65285856","0.65273255","0.65192753","0.65081656","0.64791864","0.64791864","0.64729095","0.6470524","0.6465653","0.6465424","0.64296305","0.6394765","0.63933355","0.6379343","0.6351178","0.6346381","0.6344194","0.6338111","0.6335145","0.6333709","0.6332642","0.631896","0.6306849","0.6300963","0.6291309","0.62790567","0.6275888","0.6264988","0.6260572","0.6251811","0.6216062","0.620421","0.61905277","0.6185071","0.61777425","0.61500156","0.6142365","0.61231655","0.61170787","0.6116083","0.61121804","0.61097395","0.61083204","0.6107053","0.61024463","0.6096615","0.60935664","0.60929304","0.60875124","0.60857916","0.60790575","0.6076256","0.6074774","0.605394","0.6053883","0.60537565","0.60533816","0.6037125","0.603581","0.6034676","0.60210884","0.60207146"],"string":"[\n \"0.78439504\",\n \"0.7329396\",\n \"0.72895527\",\n \"0.71769637\",\n \"0.7115815\",\n \"0.7106972\",\n \"0.7095427\",\n \"0.69898015\",\n \"0.6976603\",\n \"0.6963649\",\n \"0.6947694\",\n \"0.69401413\",\n \"0.6920403\",\n \"0.69152176\",\n \"0.683158\",\n \"0.6821512\",\n \"0.6805699\",\n \"0.680537\",\n \"0.6803111\",\n \"0.6790149\",\n \"0.67836165\",\n \"0.6777012\",\n \"0.6760428\",\n \"0.67380136\",\n \"0.67093354\",\n \"0.66930515\",\n \"0.66856575\",\n \"0.66649306\",\n \"0.6661757\",\n \"0.6643662\",\n \"0.66392136\",\n \"0.6626604\",\n \"0.6616202\",\n \"0.6615755\",\n \"0.66075504\",\n \"0.6593209\",\n \"0.65862334\",\n \"0.65653485\",\n \"0.65285856\",\n \"0.65273255\",\n \"0.65192753\",\n \"0.65081656\",\n \"0.64791864\",\n \"0.64791864\",\n \"0.64729095\",\n \"0.6470524\",\n \"0.6465653\",\n \"0.6465424\",\n \"0.64296305\",\n \"0.6394765\",\n \"0.63933355\",\n \"0.6379343\",\n \"0.6351178\",\n \"0.6346381\",\n \"0.6344194\",\n \"0.6338111\",\n \"0.6335145\",\n \"0.6333709\",\n \"0.6332642\",\n \"0.631896\",\n \"0.6306849\",\n \"0.6300963\",\n \"0.6291309\",\n \"0.62790567\",\n \"0.6275888\",\n \"0.6264988\",\n \"0.6260572\",\n \"0.6251811\",\n \"0.6216062\",\n \"0.620421\",\n \"0.61905277\",\n \"0.6185071\",\n \"0.61777425\",\n \"0.61500156\",\n \"0.6142365\",\n \"0.61231655\",\n \"0.61170787\",\n \"0.6116083\",\n \"0.61121804\",\n \"0.61097395\",\n \"0.61083204\",\n \"0.6107053\",\n \"0.61024463\",\n \"0.6096615\",\n \"0.60935664\",\n \"0.60929304\",\n \"0.60875124\",\n \"0.60857916\",\n \"0.60790575\",\n \"0.6076256\",\n \"0.6074774\",\n \"0.605394\",\n \"0.6053883\",\n \"0.60537565\",\n \"0.60533816\",\n \"0.6037125\",\n \"0.603581\",\n \"0.6034676\",\n \"0.60210884\",\n \"0.60207146\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6120414"},"document_rank":{"kind":"string","value":"76"}}},{"rowIdx":85162,"cells":{"query":{"kind":"string","value":"Percentage of times that predictions matches labels on non0s."},"document":{"kind":"string","value":"def padded_accuracy(logits, labels):\n with tf.compat.v1.variable_scope(\"padded_accuracy\", values=[logits, labels]):\n logits, labels = _pad_tensors_to_same_length(logits, labels)\n weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)\n outputs = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)\n padded_labels = tf.cast(labels, dtype=tf.int32)\n return tf.cast(tf.equal(outputs, padded_labels), dtype=tf.float32), weights"},"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 label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0","def percent_accuracy(self, true_values, predicted_values):\n\n correct = 0\n size = len(true_values)\n for i in range(len(true_values)):\n true_labels = true_values[i]\n predicted_labels = predicted_values[i]\n predicted_index = np.argmax(predicted_labels)\n\n if true_labels[predicted_index] == 1:\n correct += 1","def error_rate(predictions, labels):\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))","def accuracy(predictions, labels):\n predictions = list(predictions)\n labels = list(labels)\n count = 0\n for i in range(len(labels)):\n if labels[i] == predictions[i]:\n count += 1\n\n return count / len(labels)","def accuracy(labels, predictions):\n if len(labels) != len(predictions):\n return -1\n\n correct = 0\n total = 0\n\n for i,v in enumerate(predictions):\n if labels[i] == str(v):\n correct += 1\n total += 1\n\n return (float(correct) / float(total)) * 100.0","def accuracy(predictions, labels):\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def label_errors(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (1.0 - num_correct / preds.size(0)) * 100.0","def accuracy(self, probabilities, labels):\n # TODO: calculate the batch accuracy\n count = 0\n for x in range(len(probabilities)):\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\n count += 1\n return count/len(probabilities)","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n numpy.sum(numpy.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\n predictions.shape[0])","def accuracy(self, X_train, y_train):\n y_train_pred = self.predict(X_train)\n diffs = y_train_pred - y_train\n count = 0.\n for i in range(y_train.shape[0]):\n if diffs[i] != 0:\n count+=1\n return 100 - count*100/y_train.shape[0]","def accuracy(outputs, labels):\n predicted = outputs.argmax(dim=1)\n correct = (predicted == labels).sum().item()\n return correct / labels.size(0)","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\n predictions.shape[0])","def score(self, predictions):\n return 0.","def accuracy(pred, labels):\n pred = torch.sigmoid(pred)\n predicted = (pred > 0.5).int()\n correct = (predicted == labels).sum().item()\n return correct / labels.shape[0]","def accuracy(preds, labels):\n correct = preds == labels\n return correct.sum().float() / correct.shape[0]","def get_percentage_false_class(arr_of_results):\n\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\n count_correct_prediction = 0\n\n for i in range(len(arr_of_results[0])):\n use = True\n for result in arr_of_results[:,i]:\n if result[\"image_target\"] != result[\"prediction_image\"] or result[\"std_noise\"] == 0:\n use = False\n if use:\n count_correct_prediction += 1\n i2 = 0\n for result in arr_of_results[:,i]:\n if result[\"success\"]:\n count_success[i2] += 1\n i2 += 1\n\n\n errors = proportion_confint(count_success, count_correct_prediction)\n count_success = count_success/count_correct_prediction\n errors = np.array(errors)\n\n errors[0] = np.abs(count_success - errors[0])\n errors[1] = np.abs(count_success - errors[1])\n\n return count_success, errors","def realistic_error_rate(predictions, labels, predicted_hardness):\n # # print (predicted_hardness)\n # predicted_hardness = predicted_hardness / np.sum(predicted_hardness)\n # # print (np.argmax(predictions, 1) == labels)\n # # print (np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\n # return 100.0 - 100 * np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\n # # return 100.0 - (\n # # 100.0 *\n # # np.sum(np.argmax(predictions, 1) == labels) /\n # # predictions.shape[0])\n print (np.sum(predicted_hardness))\n return 100.0 - 100 * (np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness))) / np.sum(predicted_hardness))","def precision(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_pos = 0 #gold neg sys pos\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"0\" and predicted_labels[i] == \"1\"):\n false_pos += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_pos))","def check_accuracy (data, labels, weights):\n\tcount = 0\n\tgs = []\n\trs = []\n\tfor x in range(0,len(data)):\n\t\tresults = dot(data[x], weights)\n\t\tguess = unit_step(results)\n\t\tgs.append(guess) # append prediction\n\t\trs.append(labels[x]) # append result\n\t\tif guess - labels[x] == 0:\n\t\t\tcount += 1\n\n\tpercentage = ((float(count) / len(data)) * 100)\n\n\treturn percentage","def accuracy(targets: List[List[float]], predict: List[List[float]]):\r\n correct = 0\r\n for i in range(len(targets)):\r\n if predict[i] == targets[i]:\r\n correct += 1\r\n return correct / len(targets) * 100","def accuracy(labels, preds):\n\tassert labels.shape[0]==preds.shape[0]\n\treturn np.sum(preds==labels)/float(labels.shape[0])","def percent_accuracy(self, test_set, predicted_values):\r\n\r\n correct = 0\r\n for i in range(len(test_set)):\r\n if test_set[i].classification == predicted_values[i]:\r\n correct += 1\r\n return correct / len(test_set)","def accuracy(predictions, targets):\n correct_count = 0\n for prediction, target in zip(predictions, targets):\n if prediction == target:\n correct_count += 1\n return correct_count / len(predictions)","def accuracy(outputs, labels):\r\n outputs = np.argmax(outputs, axis=1)\r\n return np.sum(outputs == labels) / float(labels.size)","def precision_score(y_true, y_pred):\n return ((y_true == 1) * (y_pred == 1)).sum() / (y_pred == 1).sum()","def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\n assert len(predictions) == len(labels), \"Predictions and labels must have the same length.\"\n assert len(labels.shape) == 1, \"Labels must be a column vector.\"\n\n return ( # type: ignore\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\n )","def compare(predictions, truth):\n comp = predictions - truth\n return 1 - (np.count_nonzero(comp) / len(predictions))","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels)/float(labels.size)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels) / float(labels.size)","def masked_accuracy(preds, labels, mask):\n preds = preds[mask]\n labels = labels[mask]\n num_correct_pred = np.sum(np.argmax(preds, 1) == np.argmax(labels, 1))\n\n return num_correct_pred / np.sum(mask)","def find_prediction_success_rate(decision_tree, test_examples, attributes):\n totalCorrect = 0\n for example in test_examples:\n actualResult = example[14]\n prediction = decision_tree_prediction(example, decision_tree, attributes)\n if prediction == actualResult:\n totalCorrect = totalCorrect + 1\n return totalCorrect / len(test_examples)","def get_percentage_false_class_for_resultset(results):\n count_success = 0\n count_correct_prediction = 0\n for result in results:\n if result[\"image_target\"] == result[\"prediction_image\"] and result[\"std_noise\"] != 0:\n count_correct_prediction += 1\n if result[\"success\"] == True:\n count_success += 1\n\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\n\n return np.array([count_success/count_correct_prediction, error])","def sentence_accuracy(references, predictions):\n count = 0.0\n match = 0.0\n for label, pred in zip(references, predictions):\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)","def accuracy(labels, predictions, n_classes):\n\t\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\n\t\treturn tf.reduce_mean(tf.cast(equality, tf.float32))","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def report_prediction_accuracy(y, tx, w_best, verbose=True):\n predictions = tx.dot(w_best)\n predictions[predictions >= 0] = 1\n predictions[predictions < 0] = -1\n correct_percentage = np.sum(predictions == y) / float(len(predictions))\n if verbose:\n print('Percentage of correct predictions is: ', correct_percentage * 100, '%')\n return correct_percentage","def evaluate(self, dataset):\n success = 0\n for sample, labelVector, label in dataset.tests:\n if self.guessLabel(sample) == label:\n success += 1\n return success / len(dataset.tests)","def accuracy(outputs, labels):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n labels = labels.ravel()\n\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\n mask = (labels >= 0)\n\n # np.argmax gives us the class predicted for each token by the model\n outputs = np.argmax(outputs, axis=1)\n\n # compare outputs with labels and divide by number of tokens (excluding PADding tokens)\n return np.sum(outputs == labels)/float(np.sum(mask))","def accuracy(self, logits, labels):\r\n preds = tf.map_fn(tf.math.round, logits)\r\n diff = tf.math.abs(preds - labels)\r\n return 1 - tf.reduce_mean(diff, axis=0)","def compute_accuracy(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor):\n pad_pred = pad_pred.argmax(2)\n mask = pad_targets != self.ignore_label\n numerator = torch.sum(\n pad_pred.masked_select(mask) == pad_targets.masked_select(mask)\n )\n denominator = torch.sum(mask)\n return float(numerator) / float(denominator)","def check_correctness_statistics(classifier_out, mode, image_type):\n labels = image_type.image_data[mode].labels\n num_correct = 0\n total = len(classifier_out)\n for index, label in classifier_out:\n if labels[index] == label:\n num_correct += 1\n return (num_correct / total) * 100","def precision(y, ypred):\n return len(set(y).intersection(set(ypred))) / len(ypred)","def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\n # [batch_size]\n predictions = probabilities.argmax(axis=1)\n # [batch_size]\n labels = labels.argmax(axis=1)\n return (predictions == labels).astype(int).mean()","def evaluate(labels, predictions):\n\n true_positives = 0\n label_positives = 0\n\n true_negatives = 0\n label_negatives = 0\n\n for i in range(len(predictions)):\n if labels[i] == predictions[i] == 1:\n true_positives += 1\n if labels[i] == 1:\n label_positives += 1\n\n if labels[i] == predictions[i] == 0:\n true_negatives += 1\n if labels[i] == 0:\n label_negatives += 1\n\n return true_positives / label_positives, true_negatives / label_negatives\n\n # raise NotImplementedError","def accuracy(predictions, test_labels):\n return f1_score(test_labels, predictions, average='micro') * 100","def accuracy(predicted, ground_truth):\n predicted_labels_decoded = np.argmax(predicted, axis=1)\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\n return accuracy * 100","def evaluate(labels, predictions):\n actual_positive = 0\n actual_negative = 0\n predicted_positive = 0\n predicted_negative = 0\n for i, j in zip(labels, predictions):\n if i == 1:\n actual_positive += i\n predicted_positive += j\n else:\n actual_negative += 1\n if j == 0:\n predicted_negative += 1\n return predicted_positive/actual_positive, predicted_negative/actual_negative","def accuracy_score(Y_true, Y_predict):\n \n true = 0\n\n for i in range(len(Y_predict)):\n if Y_true[i] == Y_predict[i]:\n true+=1\n acc = true/float(len(Y_true))* 100.0\n return acc","def calc_accuracy(true, predicted):\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))","def calc_ac_score(labels_true, labels_pred):\n nclass = len(np.unique(labels_true))\n labels_size = len(labels_true)\n mat = labels_size * np.ones((nclass, nclass))\n \n idx = 0\n \n for i in range(labels_size):\n mat[labels_pred[i], labels_true[i]] -= 1.0\n \n munkres = Munkres()\n mapping = munkres.compute(mat)\n \n ac = 0.0\n\n for i in range(labels_size):\n val = mapping[labels_pred[i]][1]\n if val == labels_true[i]:\n ac += 1.0\n\n ac = ac / labels_size \n \n return ac","def model_accuracy(predict, y):\n true_predict = (predict.argmax(1) == y.argmax(1)).float()\n acc = true_predict.sum() / len(true_predict)\n return acc","def accuracy(predictions, targets):\n\n compare = predictions == targets\n # compare = (predictions.argmax(dim=1)) == (targets)\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\n # summed = compare.sum().item()\n summed = compare.sum()\n # print(summed, compare.size())\n # print(compare.size()[0])\n return summed/compare.size","def calculate_accuracy(mod_pred, y):\n count = 0\n for i, y_true in enumerate(y):\n if y_true == mod_pred[i]:\n count += 1\n\n return count/len(y)","def accuracy(actual, predicted):\n return np.sum(predicted == actual) / actual.shape[0]","def get_accuracy(self, gold, predicted):\n # Exercise 3: calculate accuracy\n i = 0\n j = 0\n for labels in gold:\n if labels == predicted[i]:\n j +=1\n i +=1\n return j / i * 100","def mape(true, predictions):\n true = np.array(true)\n predictions = np.array(predictions) \n return np.mean(np.abs((true - predictions)) / true) * 100","def calculateResults(predictions, answers):\r\n t = 0\r\n f = 0\r\n for i in range(len(answers)):\r\n if predictions[i] == answers[i]:\r\n t += 1\r\n else:\r\n f += 1\r\n\r\n print(\"The Percent of Correct Predictions is {t}%\".format(t=round((t * 100 / len(answers)), 1)))\r\n print(\"The Percent of Incorrect Predictions is {f}%\\n\".format(f=round((f * 100 / len(answers)), 1)))","def compute_accuracy(Y_test, Y_pred):\n number_correct_prediction = 0\n for i in range(len(Y_pred)): # They have the same length\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\n if id_test == id_pred:\n number_correct_prediction += 1\n\n percentage_correct = number_correct_prediction / len(Y_pred)\n\n return percentage_correct","def get_accuracy(output, labels):\n \n correct = 0\n \n for idx in range(len(output)):\n if torch.argmax(output[idx]).item() == labels[idx].item():\n correct += 1\n \n acc = correct / len(output)\n return acc","def accuracy(self, x, t):\n\n y = self.predict(x)\n y_labels = np.argmax(y, axis=1)\n t_labels = np.argmax(t, axis=1)\n\n num_all = x.shape[0]\n num_hit = np.sum(y_labels == t_labels)\n return num_hit / float(num_all)","def compute_accuracy(labels=None, predictions=None):\n labels = np.array(labels, dtype=np.int32)\n if len(labels.shape) == 2:\n labels = np.argmax(labels, -1)\n return np.sum(np.equal(labels, predictions)) / np.size(labels)","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def true_negative_rate(y_true, y_pred):\n n = np.sum(y_true == 0)\n tn = np.sum((y_pred == y_true) & (y_true == 0))\n return tn / n","def naive_prediction(\n y_test:np.array) -> float:\n yhat = np.concatenate((np.zeros(1),y_test[:-1]))\n \n return np.sqrt(np.sum(np.square(yhat-y_test)))","def accuracy(predictions, targets):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n correct = 0\n for i in range(len(targets)):\n if(predictions[i] == targets[i]):\n correct += 1\n accuracy = correct/len(targets)\n #raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return accuracy","def recall(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_neg = 0 #gold pos sys neg\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"1\" and predicted_labels[i] == \"0\"):\n false_neg += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_neg))","def num_correct_fun(preds, labels):\n assert preds.size(0) == labels.size(\n 0\n ), \"Batch dim of predictions and labels must match\"\n # Find number of correct predictions\n num_correct = (preds == labels).float().sum()\n return num_correct","def evaluate(labels, predictions):\n\n truePositiveCounter = 0\n trueNegativeCounter = 0\n truePositiveCorrect = 0\n trueNegativeCorrect = 0\n \n sensitivity = 0\n specificity = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n truePositiveCounter += 1\n if(labels[i] == predictions[i]):\n truePositiveCorrect += 1\n elif labels[i] == 0:\n trueNegativeCounter += 1\n if(labels[i] == predictions[i]):\n trueNegativeCorrect += 1\n\n sensitivity = truePositiveCorrect / truePositiveCounter\n specificity = trueNegativeCorrect / trueNegativeCounter\n\n return sensitivity, specificity","def evaluate(predicted, actual):\r\n assert(len(predicted) == len(actual))\r\n total = len(actual)\r\n correct = len([x for x in range(total) if predicted[x] == actual[x]])\r\n return (float(correct) / float(total)) * 100.0","def accuracy_with_gap(y_true, y_pred, gap):\n true_predictions = 0\n for i in range(len(y_pred)):\n if abs(y_pred[i] - y_true[i]) <= gap:\n true_predictions += 1\n return true_predictions/len(y_true)","def accuracy(pred, target):\n N = pred.shape[0]\n return (pred == target).sum() * 1.0 / N","def accuracy_on_zero(y_true, y_pred):\n \n y_true_flipped = 1 - y_true\n y_pred_flipped = 1- y_pred\n \n sum_true_negatives = K.sum(K.round(K.clip( y_true_flipped * y_pred_flipped, 0, 1)))\n \n sum_all_negatives = K.sum(K.round(K.clip(y_true_flipped, 0, 1)))\n \n acc_on_zero = sum_true_negatives / (sum_all_negatives + K.epsilon())\n return acc_on_zero","def compute_accuracy(self):\n if not self.is_training:\n logits = self.test_logits\n labels = self.data.test_labels\n else:\n logits = self.train_logits\n labels = self.data.labels\n\n predictions = tf.cast(tf.argmax(logits, 1), tf.int32)\n correct = tf.equal(labels, predictions)\n return tf.reduce_mean(tf.cast(correct, tf.float32))","def one_zero_loss(self, test_set, predicted_values):\r\n\r\n incorrect=0\r\n for i in range(len(test_set)):\r\n if test_set[i].classification != predicted_values[i]:\r\n incorrect += 1\r\n self.performance += incorrect / len(test_set)\r\n self.num_performances += 1\r\n return incorrect / len(test_set)","def accuracy(outputs, targets):\n\n batch_size = targets.size(0)\n\n _, pred = torch.max(outputs.data, 1)\n correct = (pred == targets).sum().item()\n\n res = 100 * correct / batch_size\n return res","def binary_accuracy(preds, y):\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division \n acc = correct.sum() / len(correct)\n return acc","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def label_accuracy_score(label_true, label_pred, n_class):\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\n check_vector_format(labels_true, labels_pred)\n mask = (labels_true >= 0) & (labels_pred >= 0)\n if np.sum(mask):\n return np.mean(labels_true[mask] == labels_pred[mask])\n else:\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def kaggle_metric(predictions, exact_values):\n norm = 70.*len(predictions)\n \n score = 0.\n for p,e in zip(predictions,exact_values):\n score += N.sum((heaviside(p)-heaviside(e))**2)\n\n return score/norm","def get_precision(y_true, y_pred):\n model_entities_filter = (y_pred != 3).astype(\"int\") # of the words our model say has a NER class\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\"int\")\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \n return precision","def calc_nmi_score(labels_true, labels_pred):\n H_true = drv.entropy(labels_true, base=2)\n H_pred = drv.entropy(labels_pred, base=2)\n H_joint = drv.entropy_joint([labels_true, labels_pred], base=2)\n mi = H_true + H_pred - H_joint\n nmi = mi / max(H_true, H_pred)\n return nmi","def overall_accuracy(y_true, y_pred):\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\n intersection = list(pred_flat == true_flat).count(True)\n sum_ = len(true_flat)\n accuracy = round(intersection/sum_, 4)\n return accuracy","def accuracy_fn(y_true, y_pred):\n correct = torch.eq(y_true, y_pred).sum().item()\n acc = (correct / len(y_pred)) * 100\n return acc","def accuracy_score(y_true, y_predict):\n assert y_true.shape[0] == y_predict.shape[0], \\\n \"The size of y_true must be equal to y_predict\"\n\n return sum(y_true == y_predict) / len(y_true)","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def label_accuracy_score(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n # 一个batch里面可能有多个数据\n # 通过迭代器将一个个数据进行计算\n for lt, lp in zip(label_trues, label_preds):\n # numpy.ndarray.flatten将numpy对象拉成1维\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\n \"\"\"\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\n iu是召回率Recall，公式上面给出了\n mean_iu就是对iu求了一个平均\n freq是每一类被预测到的频率\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\n \"\"\"\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n # nanmean会自动忽略nan的元素求平均\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def flat_accuracy(logits, labels):\n\n pred_flat = np.argmax(logits, axis=1).flatten()\n labels_flat = labels.flatten()\n return np.sum(pred_flat == labels_flat) / len(labels_flat)","def calculate_accuracy(actual_list, predicted_list):\n valid_part_len = sum(i == j for i, j in zip(actual_list, predicted_list))\n return (100.0 / len(actual_list)) * valid_part_len","def _count_correct_prediction(\n self, logits: Dict[str, torch.Tensor], labels: torch.Tensor\n ) -> None:\n if len(labels.size()) != 1: # For e.g., CutMix labels\n return\n for module_name, logit in logits.items():\n _, predicted = torch.max(F.softmax(logit, dim=1).data, 1)\n n_correct = int((predicted == labels).sum().cpu())\n self.n_correct_epoch[module_name] += n_correct","def accuracy(outputs, labels):\n N, C, H, W = outputs.shape\n# outputs = unnormalize(outputs, mean=[0.51371954, 0.40949144, 0.35572536], std= [0.2926419, 0.26180502, 0.25512055])\n # check if we normalize label images #labels = unnormalize(labels, mean=[0.53459634,0.39673596,0.33788489], std= [0.29101071,0.26140346,0.25485687])\n \n nume = np.max(outputs, axis = (1, 2, 3), keepdims = True) #(N,)\n deno = np.sum((outputs.reshape(-1,3,144,144) - labels.reshape(-1,3,144,144))**2, axis = (1, 2, 3), keepdims = True) / C\n deno *= 255 * 255 / H / W # (N,) range from 0-255, pixel avg\n \n psnr = (nume * 255) ** 2 / deno # (N,)\n psnr = np.log(psnr)\n psnr = 10 * np.sum(psnr) \n psnr /= math.log(10) * N\n #print(outputs.shape)\n #print(psnr)\n \n return psnr","def evaluate(labels, predictions):\n positive_count = 0\n positive = 0\n negative_count = 0\n negative = 0\n for i in range(len(labels)):\n if labels[i] == 1:\n positive_count+=1\n if predictions[i] == 1:\n positive +=1\n else:\n negative_count+=1\n if predictions[i] == 0:\n negative +=1\n\n sensitivity = positive / positive_count\n specificity = negative / negative_count\n\n return (sensitivity, specificity)"],"string":"[\n \"def label_accuracies(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (num_correct / preds.size(0)) * 100.0\",\n \"def percent_accuracy(self, true_values, predicted_values):\\n\\n correct = 0\\n size = len(true_values)\\n for i in range(len(true_values)):\\n true_labels = true_values[i]\\n predicted_labels = predicted_values[i]\\n predicted_index = np.argmax(predicted_labels)\\n\\n if true_labels[predicted_index] == 1:\\n correct += 1\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))\",\n \"def accuracy(predictions, labels):\\n predictions = list(predictions)\\n labels = list(labels)\\n count = 0\\n for i in range(len(labels)):\\n if labels[i] == predictions[i]:\\n count += 1\\n\\n return count / len(labels)\",\n \"def accuracy(labels, predictions):\\n if len(labels) != len(predictions):\\n return -1\\n\\n correct = 0\\n total = 0\\n\\n for i,v in enumerate(predictions):\\n if labels[i] == str(v):\\n correct += 1\\n total += 1\\n\\n return (float(correct) / float(total)) * 100.0\",\n \"def accuracy(predictions, labels):\\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def label_errors(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (1.0 - num_correct / preds.size(0)) * 100.0\",\n \"def accuracy(self, probabilities, labels):\\n # TODO: calculate the batch accuracy\\n count = 0\\n for x in range(len(probabilities)):\\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\\n count += 1\\n return count/len(probabilities)\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n numpy.sum(numpy.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\\n predictions.shape[0])\",\n \"def accuracy(self, X_train, y_train):\\n y_train_pred = self.predict(X_train)\\n diffs = y_train_pred - y_train\\n count = 0.\\n for i in range(y_train.shape[0]):\\n if diffs[i] != 0:\\n count+=1\\n return 100 - count*100/y_train.shape[0]\",\n \"def accuracy(outputs, labels):\\n predicted = outputs.argmax(dim=1)\\n correct = (predicted == labels).sum().item()\\n return correct / labels.size(0)\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\\n predictions.shape[0])\",\n \"def score(self, predictions):\\n return 0.\",\n \"def accuracy(pred, labels):\\n pred = torch.sigmoid(pred)\\n predicted = (pred > 0.5).int()\\n correct = (predicted == labels).sum().item()\\n return correct / labels.shape[0]\",\n \"def accuracy(preds, labels):\\n correct = preds == labels\\n return correct.sum().float() / correct.shape[0]\",\n \"def get_percentage_false_class(arr_of_results):\\n\\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\\n count_correct_prediction = 0\\n\\n for i in range(len(arr_of_results[0])):\\n use = True\\n for result in arr_of_results[:,i]:\\n if result[\\\"image_target\\\"] != result[\\\"prediction_image\\\"] or result[\\\"std_noise\\\"] == 0:\\n use = False\\n if use:\\n count_correct_prediction += 1\\n i2 = 0\\n for result in arr_of_results[:,i]:\\n if result[\\\"success\\\"]:\\n count_success[i2] += 1\\n i2 += 1\\n\\n\\n errors = proportion_confint(count_success, count_correct_prediction)\\n count_success = count_success/count_correct_prediction\\n errors = np.array(errors)\\n\\n errors[0] = np.abs(count_success - errors[0])\\n errors[1] = np.abs(count_success - errors[1])\\n\\n return count_success, errors\",\n \"def realistic_error_rate(predictions, labels, predicted_hardness):\\n # # print (predicted_hardness)\\n # predicted_hardness = predicted_hardness / np.sum(predicted_hardness)\\n # # print (np.argmax(predictions, 1) == labels)\\n # # print (np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\\n # return 100.0 - 100 * np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\\n # # return 100.0 - (\\n # # 100.0 *\\n # # np.sum(np.argmax(predictions, 1) == labels) /\\n # # predictions.shape[0])\\n print (np.sum(predicted_hardness))\\n return 100.0 - 100 * (np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness))) / np.sum(predicted_hardness))\",\n \"def precision(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_pos = 0 #gold neg sys pos\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"0\\\" and predicted_labels[i] == \\\"1\\\"):\\n false_pos += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_pos))\",\n \"def check_accuracy (data, labels, weights):\\n\\tcount = 0\\n\\tgs = []\\n\\trs = []\\n\\tfor x in range(0,len(data)):\\n\\t\\tresults = dot(data[x], weights)\\n\\t\\tguess = unit_step(results)\\n\\t\\tgs.append(guess) # append prediction\\n\\t\\trs.append(labels[x]) # append result\\n\\t\\tif guess - labels[x] == 0:\\n\\t\\t\\tcount += 1\\n\\n\\tpercentage = ((float(count) / len(data)) * 100)\\n\\n\\treturn percentage\",\n \"def accuracy(targets: List[List[float]], predict: List[List[float]]):\\r\\n correct = 0\\r\\n for i in range(len(targets)):\\r\\n if predict[i] == targets[i]:\\r\\n correct += 1\\r\\n return correct / len(targets) * 100\",\n \"def accuracy(labels, preds):\\n\\tassert labels.shape[0]==preds.shape[0]\\n\\treturn np.sum(preds==labels)/float(labels.shape[0])\",\n \"def percent_accuracy(self, test_set, predicted_values):\\r\\n\\r\\n correct = 0\\r\\n for i in range(len(test_set)):\\r\\n if test_set[i].classification == predicted_values[i]:\\r\\n correct += 1\\r\\n return correct / len(test_set)\",\n \"def accuracy(predictions, targets):\\n correct_count = 0\\n for prediction, target in zip(predictions, targets):\\n if prediction == target:\\n correct_count += 1\\n return correct_count / len(predictions)\",\n \"def accuracy(outputs, labels):\\r\\n outputs = np.argmax(outputs, axis=1)\\r\\n return np.sum(outputs == labels) / float(labels.size)\",\n \"def precision_score(y_true, y_pred):\\n return ((y_true == 1) * (y_pred == 1)).sum() / (y_pred == 1).sum()\",\n \"def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\\n assert len(predictions) == len(labels), \\\"Predictions and labels must have the same length.\\\"\\n assert len(labels.shape) == 1, \\\"Labels must be a column vector.\\\"\\n\\n return ( # type: ignore\\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\\n )\",\n \"def compare(predictions, truth):\\n comp = predictions - truth\\n return 1 - (np.count_nonzero(comp) / len(predictions))\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs == labels)/float(labels.size)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs == labels) / float(labels.size)\",\n \"def masked_accuracy(preds, labels, mask):\\n preds = preds[mask]\\n labels = labels[mask]\\n num_correct_pred = np.sum(np.argmax(preds, 1) == np.argmax(labels, 1))\\n\\n return num_correct_pred / np.sum(mask)\",\n \"def find_prediction_success_rate(decision_tree, test_examples, attributes):\\n totalCorrect = 0\\n for example in test_examples:\\n actualResult = example[14]\\n prediction = decision_tree_prediction(example, decision_tree, attributes)\\n if prediction == actualResult:\\n totalCorrect = totalCorrect + 1\\n return totalCorrect / len(test_examples)\",\n \"def get_percentage_false_class_for_resultset(results):\\n count_success = 0\\n count_correct_prediction = 0\\n for result in results:\\n if result[\\\"image_target\\\"] == result[\\\"prediction_image\\\"] and result[\\\"std_noise\\\"] != 0:\\n count_correct_prediction += 1\\n if result[\\\"success\\\"] == True:\\n count_success += 1\\n\\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\\n\\n return np.array([count_success/count_correct_prediction, error])\",\n \"def sentence_accuracy(references, predictions):\\n count = 0.0\\n match = 0.0\\n for label, pred in zip(references, predictions):\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\",\n \"def accuracy(labels, predictions, n_classes):\\n\\t\\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\\n\\t\\treturn tf.reduce_mean(tf.cast(equality, tf.float32))\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def report_prediction_accuracy(y, tx, w_best, verbose=True):\\n predictions = tx.dot(w_best)\\n predictions[predictions >= 0] = 1\\n predictions[predictions < 0] = -1\\n correct_percentage = np.sum(predictions == y) / float(len(predictions))\\n if verbose:\\n print('Percentage of correct predictions is: ', correct_percentage * 100, '%')\\n return correct_percentage\",\n \"def evaluate(self, dataset):\\n success = 0\\n for sample, labelVector, label in dataset.tests:\\n if self.guessLabel(sample) == label:\\n success += 1\\n return success / len(dataset.tests)\",\n \"def accuracy(outputs, labels):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n labels = labels.ravel()\\n\\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\\n mask = (labels >= 0)\\n\\n # np.argmax gives us the class predicted for each token by the model\\n outputs = np.argmax(outputs, axis=1)\\n\\n # compare outputs with labels and divide by number of tokens (excluding PADding tokens)\\n return np.sum(outputs == labels)/float(np.sum(mask))\",\n \"def accuracy(self, logits, labels):\\r\\n preds = tf.map_fn(tf.math.round, logits)\\r\\n diff = tf.math.abs(preds - labels)\\r\\n return 1 - tf.reduce_mean(diff, axis=0)\",\n \"def compute_accuracy(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor):\\n pad_pred = pad_pred.argmax(2)\\n mask = pad_targets != self.ignore_label\\n numerator = torch.sum(\\n pad_pred.masked_select(mask) == pad_targets.masked_select(mask)\\n )\\n denominator = torch.sum(mask)\\n return float(numerator) / float(denominator)\",\n \"def check_correctness_statistics(classifier_out, mode, image_type):\\n labels = image_type.image_data[mode].labels\\n num_correct = 0\\n total = len(classifier_out)\\n for index, label in classifier_out:\\n if labels[index] == label:\\n num_correct += 1\\n return (num_correct / total) * 100\",\n \"def precision(y, ypred):\\n return len(set(y).intersection(set(ypred))) / len(ypred)\",\n \"def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\\n # [batch_size]\\n predictions = probabilities.argmax(axis=1)\\n # [batch_size]\\n labels = labels.argmax(axis=1)\\n return (predictions == labels).astype(int).mean()\",\n \"def evaluate(labels, predictions):\\n\\n true_positives = 0\\n label_positives = 0\\n\\n true_negatives = 0\\n label_negatives = 0\\n\\n for i in range(len(predictions)):\\n if labels[i] == predictions[i] == 1:\\n true_positives += 1\\n if labels[i] == 1:\\n label_positives += 1\\n\\n if labels[i] == predictions[i] == 0:\\n true_negatives += 1\\n if labels[i] == 0:\\n label_negatives += 1\\n\\n return true_positives / label_positives, true_negatives / label_negatives\\n\\n # raise NotImplementedError\",\n \"def accuracy(predictions, test_labels):\\n return f1_score(test_labels, predictions, average='micro') * 100\",\n \"def accuracy(predicted, ground_truth):\\n predicted_labels_decoded = np.argmax(predicted, axis=1)\\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\\n return accuracy * 100\",\n \"def evaluate(labels, predictions):\\n actual_positive = 0\\n actual_negative = 0\\n predicted_positive = 0\\n predicted_negative = 0\\n for i, j in zip(labels, predictions):\\n if i == 1:\\n actual_positive += i\\n predicted_positive += j\\n else:\\n actual_negative += 1\\n if j == 0:\\n predicted_negative += 1\\n return predicted_positive/actual_positive, predicted_negative/actual_negative\",\n \"def accuracy_score(Y_true, Y_predict):\\n \\n true = 0\\n\\n for i in range(len(Y_predict)):\\n if Y_true[i] == Y_predict[i]:\\n true+=1\\n acc = true/float(len(Y_true))* 100.0\\n return acc\",\n \"def calc_accuracy(true, predicted):\\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))\",\n \"def calc_ac_score(labels_true, labels_pred):\\n nclass = len(np.unique(labels_true))\\n labels_size = len(labels_true)\\n mat = labels_size * np.ones((nclass, nclass))\\n \\n idx = 0\\n \\n for i in range(labels_size):\\n mat[labels_pred[i], labels_true[i]] -= 1.0\\n \\n munkres = Munkres()\\n mapping = munkres.compute(mat)\\n \\n ac = 0.0\\n\\n for i in range(labels_size):\\n val = mapping[labels_pred[i]][1]\\n if val == labels_true[i]:\\n ac += 1.0\\n\\n ac = ac / labels_size \\n \\n return ac\",\n \"def model_accuracy(predict, y):\\n true_predict = (predict.argmax(1) == y.argmax(1)).float()\\n acc = true_predict.sum() / len(true_predict)\\n return acc\",\n \"def accuracy(predictions, targets):\\n\\n compare = predictions == targets\\n # compare = (predictions.argmax(dim=1)) == (targets)\\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\\n # summed = compare.sum().item()\\n summed = compare.sum()\\n # print(summed, compare.size())\\n # print(compare.size()[0])\\n return summed/compare.size\",\n \"def calculate_accuracy(mod_pred, y):\\n count = 0\\n for i, y_true in enumerate(y):\\n if y_true == mod_pred[i]:\\n count += 1\\n\\n return count/len(y)\",\n \"def accuracy(actual, predicted):\\n return np.sum(predicted == actual) / actual.shape[0]\",\n \"def get_accuracy(self, gold, predicted):\\n # Exercise 3: calculate accuracy\\n i = 0\\n j = 0\\n for labels in gold:\\n if labels == predicted[i]:\\n j +=1\\n i +=1\\n return j / i * 100\",\n \"def mape(true, predictions):\\n true = np.array(true)\\n predictions = np.array(predictions) \\n return np.mean(np.abs((true - predictions)) / true) * 100\",\n \"def calculateResults(predictions, answers):\\r\\n t = 0\\r\\n f = 0\\r\\n for i in range(len(answers)):\\r\\n if predictions[i] == answers[i]:\\r\\n t += 1\\r\\n else:\\r\\n f += 1\\r\\n\\r\\n print(\\\"The Percent of Correct Predictions is {t}%\\\".format(t=round((t * 100 / len(answers)), 1)))\\r\\n print(\\\"The Percent of Incorrect Predictions is {f}%\\\\n\\\".format(f=round((f * 100 / len(answers)), 1)))\",\n \"def compute_accuracy(Y_test, Y_pred):\\n number_correct_prediction = 0\\n for i in range(len(Y_pred)): # They have the same length\\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\\n if id_test == id_pred:\\n number_correct_prediction += 1\\n\\n percentage_correct = number_correct_prediction / len(Y_pred)\\n\\n return percentage_correct\",\n \"def get_accuracy(output, labels):\\n \\n correct = 0\\n \\n for idx in range(len(output)):\\n if torch.argmax(output[idx]).item() == labels[idx].item():\\n correct += 1\\n \\n acc = correct / len(output)\\n return acc\",\n \"def accuracy(self, x, t):\\n\\n y = self.predict(x)\\n y_labels = np.argmax(y, axis=1)\\n t_labels = np.argmax(t, axis=1)\\n\\n num_all = x.shape[0]\\n num_hit = np.sum(y_labels == t_labels)\\n return num_hit / float(num_all)\",\n \"def compute_accuracy(labels=None, predictions=None):\\n labels = np.array(labels, dtype=np.int32)\\n if len(labels.shape) == 2:\\n labels = np.argmax(labels, -1)\\n return np.sum(np.equal(labels, predictions)) / np.size(labels)\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def true_negative_rate(y_true, y_pred):\\n n = np.sum(y_true == 0)\\n tn = np.sum((y_pred == y_true) & (y_true == 0))\\n return tn / n\",\n \"def naive_prediction(\\n y_test:np.array) -> float:\\n yhat = np.concatenate((np.zeros(1),y_test[:-1]))\\n \\n return np.sqrt(np.sum(np.square(yhat-y_test)))\",\n \"def accuracy(predictions, targets):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n correct = 0\\n for i in range(len(targets)):\\n if(predictions[i] == targets[i]):\\n correct += 1\\n accuracy = correct/len(targets)\\n #raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return accuracy\",\n \"def recall(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_neg = 0 #gold pos sys neg\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"1\\\" and predicted_labels[i] == \\\"0\\\"):\\n false_neg += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_neg))\",\n \"def num_correct_fun(preds, labels):\\n assert preds.size(0) == labels.size(\\n 0\\n ), \\\"Batch dim of predictions and labels must match\\\"\\n # Find number of correct predictions\\n num_correct = (preds == labels).float().sum()\\n return num_correct\",\n \"def evaluate(labels, predictions):\\n\\n truePositiveCounter = 0\\n trueNegativeCounter = 0\\n truePositiveCorrect = 0\\n trueNegativeCorrect = 0\\n \\n sensitivity = 0\\n specificity = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n truePositiveCounter += 1\\n if(labels[i] == predictions[i]):\\n truePositiveCorrect += 1\\n elif labels[i] == 0:\\n trueNegativeCounter += 1\\n if(labels[i] == predictions[i]):\\n trueNegativeCorrect += 1\\n\\n sensitivity = truePositiveCorrect / truePositiveCounter\\n specificity = trueNegativeCorrect / trueNegativeCounter\\n\\n return sensitivity, specificity\",\n \"def evaluate(predicted, actual):\\r\\n assert(len(predicted) == len(actual))\\r\\n total = len(actual)\\r\\n correct = len([x for x in range(total) if predicted[x] == actual[x]])\\r\\n return (float(correct) / float(total)) * 100.0\",\n \"def accuracy_with_gap(y_true, y_pred, gap):\\n true_predictions = 0\\n for i in range(len(y_pred)):\\n if abs(y_pred[i] - y_true[i]) <= gap:\\n true_predictions += 1\\n return true_predictions/len(y_true)\",\n \"def accuracy(pred, target):\\n N = pred.shape[0]\\n return (pred == target).sum() * 1.0 / N\",\n \"def accuracy_on_zero(y_true, y_pred):\\n \\n y_true_flipped = 1 - y_true\\n y_pred_flipped = 1- y_pred\\n \\n sum_true_negatives = K.sum(K.round(K.clip( y_true_flipped * y_pred_flipped, 0, 1)))\\n \\n sum_all_negatives = K.sum(K.round(K.clip(y_true_flipped, 0, 1)))\\n \\n acc_on_zero = sum_true_negatives / (sum_all_negatives + K.epsilon())\\n return acc_on_zero\",\n \"def compute_accuracy(self):\\n if not self.is_training:\\n logits = self.test_logits\\n labels = self.data.test_labels\\n else:\\n logits = self.train_logits\\n labels = self.data.labels\\n\\n predictions = tf.cast(tf.argmax(logits, 1), tf.int32)\\n correct = tf.equal(labels, predictions)\\n return tf.reduce_mean(tf.cast(correct, tf.float32))\",\n \"def one_zero_loss(self, test_set, predicted_values):\\r\\n\\r\\n incorrect=0\\r\\n for i in range(len(test_set)):\\r\\n if test_set[i].classification != predicted_values[i]:\\r\\n incorrect += 1\\r\\n self.performance += incorrect / len(test_set)\\r\\n self.num_performances += 1\\r\\n return incorrect / len(test_set)\",\n \"def accuracy(outputs, targets):\\n\\n batch_size = targets.size(0)\\n\\n _, pred = torch.max(outputs.data, 1)\\n correct = (pred == targets).sum().item()\\n\\n res = 100 * correct / batch_size\\n return res\",\n \"def binary_accuracy(preds, y):\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division \\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def label_accuracy_score(label_true, label_pred, n_class):\\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\\n check_vector_format(labels_true, labels_pred)\\n mask = (labels_true >= 0) & (labels_pred >= 0)\\n if np.sum(mask):\\n return np.mean(labels_true[mask] == labels_pred[mask])\\n else:\\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def kaggle_metric(predictions, exact_values):\\n norm = 70.*len(predictions)\\n \\n score = 0.\\n for p,e in zip(predictions,exact_values):\\n score += N.sum((heaviside(p)-heaviside(e))**2)\\n\\n return score/norm\",\n \"def get_precision(y_true, y_pred):\\n model_entities_filter = (y_pred != 3).astype(\\\"int\\\") # of the words our model say has a NER class\\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\\\"int\\\")\\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \\n return precision\",\n \"def calc_nmi_score(labels_true, labels_pred):\\n H_true = drv.entropy(labels_true, base=2)\\n H_pred = drv.entropy(labels_pred, base=2)\\n H_joint = drv.entropy_joint([labels_true, labels_pred], base=2)\\n mi = H_true + H_pred - H_joint\\n nmi = mi / max(H_true, H_pred)\\n return nmi\",\n \"def overall_accuracy(y_true, y_pred):\\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\\n intersection = list(pred_flat == true_flat).count(True)\\n sum_ = len(true_flat)\\n accuracy = round(intersection/sum_, 4)\\n return accuracy\",\n \"def accuracy_fn(y_true, y_pred):\\n correct = torch.eq(y_true, y_pred).sum().item()\\n acc = (correct / len(y_pred)) * 100\\n return acc\",\n \"def accuracy_score(y_true, y_predict):\\n assert y_true.shape[0] == y_predict.shape[0], \\\\\\n \\\"The size of y_true must be equal to y_predict\\\"\\n\\n return sum(y_true == y_predict) / len(y_true)\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def label_accuracy_score(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n # 一个batch里面可能有多个数据\\n # 通过迭代器将一个个数据进行计算\\n for lt, lp in zip(label_trues, label_preds):\\n # numpy.ndarray.flatten将numpy对象拉成1维\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n\\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\\n \\\"\\\"\\\"\\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\\n iu是召回率Recall，公式上面给出了\\n mean_iu就是对iu求了一个平均\\n freq是每一类被预测到的频率\\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\\n \\\"\\\"\\\"\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n # nanmean会自动忽略nan的元素求平均\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def flat_accuracy(logits, labels):\\n\\n pred_flat = np.argmax(logits, axis=1).flatten()\\n labels_flat = labels.flatten()\\n return np.sum(pred_flat == labels_flat) / len(labels_flat)\",\n \"def calculate_accuracy(actual_list, predicted_list):\\n valid_part_len = sum(i == j for i, j in zip(actual_list, predicted_list))\\n return (100.0 / len(actual_list)) * valid_part_len\",\n \"def _count_correct_prediction(\\n self, logits: Dict[str, torch.Tensor], labels: torch.Tensor\\n ) -> None:\\n if len(labels.size()) != 1: # For e.g., CutMix labels\\n return\\n for module_name, logit in logits.items():\\n _, predicted = torch.max(F.softmax(logit, dim=1).data, 1)\\n n_correct = int((predicted == labels).sum().cpu())\\n self.n_correct_epoch[module_name] += n_correct\",\n \"def accuracy(outputs, labels):\\n N, C, H, W = outputs.shape\\n# outputs = unnormalize(outputs, mean=[0.51371954, 0.40949144, 0.35572536], std= [0.2926419, 0.26180502, 0.25512055])\\n # check if we normalize label images #labels = unnormalize(labels, mean=[0.53459634,0.39673596,0.33788489], std= [0.29101071,0.26140346,0.25485687])\\n \\n nume = np.max(outputs, axis = (1, 2, 3), keepdims = True) #(N,)\\n deno = np.sum((outputs.reshape(-1,3,144,144) - labels.reshape(-1,3,144,144))**2, axis = (1, 2, 3), keepdims = True) / C\\n deno *= 255 * 255 / H / W # (N,) range from 0-255, pixel avg\\n \\n psnr = (nume * 255) ** 2 / deno # (N,)\\n psnr = np.log(psnr)\\n psnr = 10 * np.sum(psnr) \\n psnr /= math.log(10) * N\\n #print(outputs.shape)\\n #print(psnr)\\n \\n return psnr\",\n \"def evaluate(labels, predictions):\\n positive_count = 0\\n positive = 0\\n negative_count = 0\\n negative = 0\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n positive_count+=1\\n if predictions[i] == 1:\\n positive +=1\\n else:\\n negative_count+=1\\n if predictions[i] == 0:\\n negative +=1\\n\\n sensitivity = positive / positive_count\\n specificity = negative / negative_count\\n\\n return (sensitivity, specificity)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76227057","0.7379493","0.72297883","0.722671","0.71479374","0.71069294","0.7047552","0.70354223","0.7023279","0.7022213","0.70219743","0.6970781","0.6960516","0.69523424","0.69481045","0.6926855","0.692359","0.6909524","0.68767715","0.68717813","0.6866114","0.68628484","0.68298644","0.68265384","0.6786165","0.676691","0.6750034","0.6743244","0.6742624","0.67319876","0.6710249","0.6700855","0.6700789","0.66882855","0.66789347","0.66733885","0.66629314","0.66629314","0.6655236","0.66482645","0.66482645","0.6636642","0.6634511","0.6620667","0.6611046","0.6601085","0.6596442","0.65927905","0.6588474","0.6586464","0.65761214","0.657408","0.65720356","0.65715814","0.65633583","0.6559377","0.6517159","0.65078527","0.65054995","0.65016717","0.64909047","0.6490803","0.64792705","0.6464036","0.64469284","0.64424455","0.64311004","0.6423918","0.6421896","0.6414756","0.64082336","0.6402427","0.6400127","0.6399021","0.6393241","0.6390826","0.63732576","0.6371672","0.636136","0.6356335","0.6352724","0.63464063","0.63394827","0.6333317","0.6331715","0.6331289","0.6326003","0.6321506","0.6318059","0.6317328","0.63076586","0.6306985","0.6304645","0.62998676","0.62998676","0.62964314","0.62885344","0.6283462","0.626781","0.6261123","0.62609524"],"string":"[\n \"0.76227057\",\n \"0.7379493\",\n \"0.72297883\",\n \"0.722671\",\n \"0.71479374\",\n \"0.71069294\",\n \"0.7047552\",\n \"0.70354223\",\n \"0.7023279\",\n \"0.7022213\",\n \"0.70219743\",\n \"0.6970781\",\n \"0.6960516\",\n \"0.69523424\",\n \"0.69481045\",\n \"0.6926855\",\n \"0.692359\",\n \"0.6909524\",\n \"0.68767715\",\n \"0.68717813\",\n \"0.6866114\",\n \"0.68628484\",\n \"0.68298644\",\n \"0.68265384\",\n \"0.6786165\",\n \"0.676691\",\n \"0.6750034\",\n \"0.6743244\",\n \"0.6742624\",\n \"0.67319876\",\n \"0.6710249\",\n \"0.6700855\",\n \"0.6700789\",\n \"0.66882855\",\n \"0.66789347\",\n \"0.66733885\",\n \"0.66629314\",\n \"0.66629314\",\n \"0.6655236\",\n \"0.66482645\",\n \"0.66482645\",\n \"0.6636642\",\n \"0.6634511\",\n \"0.6620667\",\n \"0.6611046\",\n \"0.6601085\",\n \"0.6596442\",\n \"0.65927905\",\n \"0.6588474\",\n \"0.6586464\",\n \"0.65761214\",\n \"0.657408\",\n \"0.65720356\",\n \"0.65715814\",\n \"0.65633583\",\n \"0.6559377\",\n \"0.6517159\",\n \"0.65078527\",\n \"0.65054995\",\n \"0.65016717\",\n \"0.64909047\",\n \"0.6490803\",\n \"0.64792705\",\n \"0.6464036\",\n \"0.64469284\",\n \"0.64424455\",\n \"0.64311004\",\n \"0.6423918\",\n \"0.6421896\",\n \"0.6414756\",\n \"0.64082336\",\n \"0.6402427\",\n \"0.6400127\",\n \"0.6399021\",\n \"0.6393241\",\n \"0.6390826\",\n \"0.63732576\",\n \"0.6371672\",\n \"0.636136\",\n \"0.6356335\",\n \"0.6352724\",\n \"0.63464063\",\n \"0.63394827\",\n \"0.6333317\",\n \"0.6331715\",\n \"0.6331289\",\n \"0.6326003\",\n \"0.6321506\",\n \"0.6318059\",\n \"0.6317328\",\n \"0.63076586\",\n \"0.6306985\",\n \"0.6304645\",\n \"0.62998676\",\n \"0.62998676\",\n \"0.62964314\",\n \"0.62885344\",\n \"0.6283462\",\n \"0.626781\",\n \"0.6261123\",\n \"0.62609524\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85163,"cells":{"query":{"kind":"string","value":"Percentage of times that topk predictions matches labels on non0s."},"document":{"kind":"string","value":"def padded_accuracy_topk(logits, labels, k):\n with tf.compat.v1.variable_scope(\"padded_accuracy_topk\", values=[logits, labels]):\n logits, labels = _pad_tensors_to_same_length(logits, labels)\n weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)\n effective_k = tf.minimum(k, tf.shape(input=logits)[-1])\n _, outputs = tf.nn.top_k(logits, k=effective_k)\n outputs = tf.cast(outputs, dtype=tf.int32)\n padded_labels = tf.cast(labels, dtype=tf.int32)\n padded_labels = tf.expand_dims(padded_labels, axis=-1)\n padded_labels += tf.zeros_like(outputs) # Pad to same shape.\n same = tf.cast(tf.equal(outputs, padded_labels), dtype=tf.float32)\n same_topk = tf.reduce_sum(input_tensor=same, axis=-1)\n return same_topk, weights"},"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 topk_accuracies(preds, labels, ks):\n num_topks_correct = topks_correct(preds, labels, ks)\n return [(x / preds.size(0)) * 100.0 for x in num_topks_correct]","def topk_errors(preds, labels, ks):\n num_topks_correct = topks_correct(preds, labels, ks)\n return [(1.0 - x / preds.size(0)) * 100.0 for x in num_topks_correct]","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\n return [correct[:k].reshape(-1).float().sum(0) * 100. / batch_size for k in topk]","def top_k_accuracy(y_true : np.ndarray, probs: np.ndarray, k: int) -> float:\r\n \r\n # Top k sorted preds\r\n sorted_probs = probs.argsort()[:,-k:]\r\n\r\n # Does the truth intersect with any of the top k predictions?\r\n matches = np.max(sorted_probs == y_true.reshape(-1, 1), axis=1)\r\n return matches.mean()","def topk_accuracy(y, y_pred, k=2):\n pred = []\n for i in range(len(y)):\n if y[i] in y_pred[i][:k]:\n pred.append(1)\n else:\n pred.append(0)\n return sum(pred) / len(pred)","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, largest=True, sorted=True) \n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].contiguous().view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, indices = torch.topk(output, maxk, dim=1, largest=True, sorted=True)\n\n res = []\n for k in topk:\n count = 0.0\n for i, t in enumerate(target):\n if t in indices[i, :k]:\n count += 100.0 / batch_size\n res.append(count)\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].contiguous().view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def top_100_score(self,predictions,labels):\n\n # sort the array by predictions\n order = np.flipud(predictions.argsort())\n labels = labels[order]\n\n # take the top n\n num_positives = np.sum(np.asarray(labels,dtype=bool))\n\n # if no positive labels return nan\n if num_positives == 0:\n return float('nan')\n else:\n return np.sum(labels[0:num_positives]) / num_positives * 100","def label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0","def accuracy(output, target, top_k=(1,)):\n labels_count = output.shape[1]\n max_k = labels_count if max(top_k) > labels_count else max(top_k)\n batch_size = target.size(0)\n _, pred = output.topk(max_k, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n res = []\n for k in top_k:\n correct_k = correct[:k].reshape(-1).float().sum(0)\n res.append(correct_k / batch_size)\n return res","def accuracy(output, target, topk=(1,)):\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n\r\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.float().topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0).item()\n res.append(correct_k / batch_size)\n return res","def accuracy(output, target, topk=(1,)):\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def pk(y_true, y_pred, k):\n \n # if k is 0, return 0. we should never have this\n # as k is always >= 1\n if k == 0:\n return 0\n # we are interested only in top-k predictions\n y_pred = y_pred[:k]\n \n # convert predictions to set\n pred_set = set(y_pred)\n \n # convert actual values to set\n true_set = set(y_true)\n \n # find common values\n common_values = pred_set.intersection(true_set)\n \n # return length of common values over k\n return len(common_values) / len(y_pred[:k])","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n\n return res","def percent_accuracy(self, true_values, predicted_values):\n\n correct = 0\n size = len(true_values)\n for i in range(len(true_values)):\n true_labels = true_values[i]\n predicted_labels = predicted_values[i]\n predicted_index = np.argmax(predicted_labels)\n\n if true_labels[predicted_index] == 1:\n correct += 1","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n\tmaxk = max(topk)\n\tbatch_size = target.size(0)\n\n\t_, pred = output.topk(maxk, 1, True, True)\n\tpred = pred.t()\n\tcorrect = pred.eq(target.view(1, -1).expand_as(pred))\n\n\tres = []\n\tfor k in topk:\n\t\tcorrect_k = correct[:k].view(-1).float().sum(0)\n\t\tres.append(correct_k.mul_(100.0 / batch_size))\n\treturn res","def accuracy(output, target, topk=(1,)):\n\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n\n return res","def accuracy(y_pred, y_actual, topk=(1, )):\n maxk = max(topk)\n batch_size = y_actual.size(0)\n\n _, pred = y_pred.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(y_actual.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n\n return res","def accuracy(output, target, topk=(1, 5)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum() #sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res, pred","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].flatten().float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def __accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def knn(train_data, train_labels, test_data, test_labels, k):\n pred_labels = []\n for t in test_data:\n dist = calculate_distances(train_data, t)\n pred_class = majority_voting(dist, train_labels, k)\n pred_labels.append(pred_class)\n correct_pred_count = np.sum(pred_labels == test_labels)\n acc = correct_pred_count/len(test_labels)\n return acc","def accuracy_topk(output, target, topk=(5,10)):\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n maxk = max(topk)\n batch_size = target.size(0)\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n pred = pred.type_as(target)\n target = target.type_as(pred)\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def error_rate(predictions, labels):\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res_ = correct_k.mul_(100.0 / batch_size).cpu().numpy()[0]\n res.append(res_)\n return res","def accuracy(output, target, topk=(1,)):\r\n with torch.no_grad():\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n # pdb.set_trace()\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\r\n with torch.no_grad():\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\r\n with torch.no_grad():\r\n maxk = max(topk)\r\n batch_size = target.size(0)\r\n\r\n _, pred = output.topk(maxk, 1, True, True)\r\n pred = pred.t()\r\n correct = pred.eq(target.view(1, -1).expand_as(pred))\r\n\r\n res = []\r\n for k in topk:\r\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\r\n res.append(correct_k.mul_(100.0 / batch_size))\r\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res","def accuracy(output, target, topk=(1,)):\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res"],"string":"[\n \"def topk_accuracies(preds, labels, ks):\\n num_topks_correct = topks_correct(preds, labels, ks)\\n return [(x / preds.size(0)) * 100.0 for x in num_topks_correct]\",\n \"def topk_errors(preds, labels, ks):\\n num_topks_correct = topks_correct(preds, labels, ks)\\n return [(1.0 - x / preds.size(0)) * 100.0 for x in num_topks_correct]\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\\n return [correct[:k].reshape(-1).float().sum(0) * 100. / batch_size for k in topk]\",\n \"def top_k_accuracy(y_true : np.ndarray, probs: np.ndarray, k: int) -> float:\\r\\n \\r\\n # Top k sorted preds\\r\\n sorted_probs = probs.argsort()[:,-k:]\\r\\n\\r\\n # Does the truth intersect with any of the top k predictions?\\r\\n matches = np.max(sorted_probs == y_true.reshape(-1, 1), axis=1)\\r\\n return matches.mean()\",\n \"def topk_accuracy(y, y_pred, k=2):\\n pred = []\\n for i in range(len(y)):\\n if y[i] in y_pred[i][:k]:\\n pred.append(1)\\n else:\\n pred.append(0)\\n return sum(pred) / len(pred)\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, largest=True, sorted=True) \\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].contiguous().view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, indices = torch.topk(output, maxk, dim=1, largest=True, sorted=True)\\n\\n res = []\\n for k in topk:\\n count = 0.0\\n for i, t in enumerate(target):\\n if t in indices[i, :k]:\\n count += 100.0 / batch_size\\n res.append(count)\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].contiguous().view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def top_100_score(self,predictions,labels):\\n\\n # sort the array by predictions\\n order = np.flipud(predictions.argsort())\\n labels = labels[order]\\n\\n # take the top n\\n num_positives = np.sum(np.asarray(labels,dtype=bool))\\n\\n # if no positive labels return nan\\n if num_positives == 0:\\n return float('nan')\\n else:\\n return np.sum(labels[0:num_positives]) / num_positives * 100\",\n \"def label_accuracies(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (num_correct / preds.size(0)) * 100.0\",\n \"def accuracy(output, target, top_k=(1,)):\\n labels_count = output.shape[1]\\n max_k = labels_count if max(top_k) > labels_count else max(top_k)\\n batch_size = target.size(0)\\n _, pred = output.topk(max_k, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n res = []\\n for k in top_k:\\n correct_k = correct[:k].reshape(-1).float().sum(0)\\n res.append(correct_k / batch_size)\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.float().topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0).item()\\n res.append(correct_k / batch_size)\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def pk(y_true, y_pred, k):\\n \\n # if k is 0, return 0. we should never have this\\n # as k is always >= 1\\n if k == 0:\\n return 0\\n # we are interested only in top-k predictions\\n y_pred = y_pred[:k]\\n \\n # convert predictions to set\\n pred_set = set(y_pred)\\n \\n # convert actual values to set\\n true_set = set(y_true)\\n \\n # find common values\\n common_values = pred_set.intersection(true_set)\\n \\n # return length of common values over k\\n return len(common_values) / len(y_pred[:k])\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n\\n return res\",\n \"def percent_accuracy(self, true_values, predicted_values):\\n\\n correct = 0\\n size = len(true_values)\\n for i in range(len(true_values)):\\n true_labels = true_values[i]\\n predicted_labels = predicted_values[i]\\n predicted_index = np.argmax(predicted_labels)\\n\\n if true_labels[predicted_index] == 1:\\n correct += 1\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n\\tmaxk = max(topk)\\n\\tbatch_size = target.size(0)\\n\\n\\t_, pred = output.topk(maxk, 1, True, True)\\n\\tpred = pred.t()\\n\\tcorrect = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n\\tres = []\\n\\tfor k in topk:\\n\\t\\tcorrect_k = correct[:k].view(-1).float().sum(0)\\n\\t\\tres.append(correct_k.mul_(100.0 / batch_size))\\n\\treturn res\",\n \"def accuracy(output, target, topk=(1,)):\\n\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n\\n return res\",\n \"def accuracy(y_pred, y_actual, topk=(1, )):\\n maxk = max(topk)\\n batch_size = y_actual.size(0)\\n\\n _, pred = y_pred.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(y_actual.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n\\n return res\",\n \"def accuracy(output, target, topk=(1, 5)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum() #sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res, pred\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].flatten().float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def __accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def knn(train_data, train_labels, test_data, test_labels, k):\\n pred_labels = []\\n for t in test_data:\\n dist = calculate_distances(train_data, t)\\n pred_class = majority_voting(dist, train_labels, k)\\n pred_labels.append(pred_class)\\n correct_pred_count = np.sum(pred_labels == test_labels)\\n acc = correct_pred_count/len(test_labels)\\n return acc\",\n \"def accuracy_topk(output, target, topk=(5,10)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n maxk = max(topk)\\n batch_size = target.size(0)\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n pred = pred.type_as(target)\\n target = target.type_as(pred)\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res_ = correct_k.mul_(100.0 / batch_size).cpu().numpy()[0]\\n res.append(res_)\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n with torch.no_grad():\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n # pdb.set_trace()\\n res = []\\n for k in topk:\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n with torch.no_grad():\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\r\\n with torch.no_grad():\\r\\n maxk = max(topk)\\r\\n batch_size = target.size(0)\\r\\n\\r\\n _, pred = output.topk(maxk, 1, True, True)\\r\\n pred = pred.t()\\r\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\r\\n\\r\\n res = []\\r\\n for k in topk:\\r\\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\\r\\n res.append(correct_k.mul_(100.0 / batch_size))\\r\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.view(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\",\n \"def accuracy(output, target, topk=(1,)):\\n with torch.no_grad():\\n maxk = max(topk)\\n batch_size = target.size(0)\\n\\n _, pred = output.topk(maxk, 1, True, True)\\n pred = pred.t()\\n correct = pred.eq(target.reshape(1, -1).expand_as(pred))\\n\\n res = []\\n for k in topk:\\n correct_k = correct[:k].reshape(-1).float().sum(0, keepdim=True)\\n res.append(correct_k.mul_(100.0 / batch_size))\\n return res\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78908753","0.73390025","0.7233049","0.72291976","0.7195095","0.70900184","0.7036402","0.70240974","0.69874215","0.6977213","0.6972062","0.6952351","0.6952351","0.69479007","0.69431925","0.69333524","0.69322234","0.6922573","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6919798","0.6907756","0.68991464","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.6889072","0.68881285","0.6887188","0.6881227","0.6877361","0.6873605","0.6862461","0.68539613","0.6852976","0.6847525","0.6846797","0.6845351","0.68448174","0.68383014","0.68367106","0.68285894","0.68283844","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.68245274","0.682424","0.6821101","0.6821101","0.6821101","0.68176967","0.6817139","0.6817122","0.68158513","0.6811205","0.6811205","0.6810608","0.6810608","0.6810608","0.6810608","0.6810608","0.6803366","0.6803366"],"string":"[\n \"0.78908753\",\n \"0.73390025\",\n \"0.7233049\",\n \"0.72291976\",\n \"0.7195095\",\n \"0.70900184\",\n \"0.7036402\",\n \"0.70240974\",\n \"0.69874215\",\n \"0.6977213\",\n \"0.6972062\",\n \"0.6952351\",\n \"0.6952351\",\n \"0.69479007\",\n \"0.69431925\",\n \"0.69333524\",\n \"0.69322234\",\n \"0.6922573\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6919798\",\n \"0.6907756\",\n \"0.68991464\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.6889072\",\n \"0.68881285\",\n \"0.6887188\",\n \"0.6881227\",\n \"0.6877361\",\n \"0.6873605\",\n \"0.6862461\",\n \"0.68539613\",\n \"0.6852976\",\n \"0.6847525\",\n \"0.6846797\",\n \"0.6845351\",\n \"0.68448174\",\n \"0.68383014\",\n \"0.68367106\",\n \"0.68285894\",\n \"0.68283844\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.68245274\",\n \"0.682424\",\n \"0.6821101\",\n \"0.6821101\",\n \"0.6821101\",\n \"0.68176967\",\n \"0.6817139\",\n \"0.6817122\",\n \"0.68158513\",\n \"0.6811205\",\n \"0.6811205\",\n \"0.6810608\",\n \"0.6810608\",\n \"0.6810608\",\n \"0.6810608\",\n \"0.6810608\",\n \"0.6803366\",\n \"0.6803366\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85164,"cells":{"query":{"kind":"string","value":"Percentage of times that predictions matches labels everywhere (non0)."},"document":{"kind":"string","value":"def padded_sequence_accuracy(logits, labels):\n with tf.compat.v1.variable_scope(\"padded_sequence_accuracy\", values=[logits, labels]):\n logits, labels = _pad_tensors_to_same_length(logits, labels)\n weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)\n outputs = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)\n padded_labels = tf.cast(labels, dtype=tf.int32)\n not_correct = tf.cast(tf.not_equal(outputs, padded_labels), dtype=tf.float32) * weights\n axis = list(range(1, len(outputs.get_shape())))\n correct_seq = 1.0 - tf.minimum(1.0, tf.reduce_sum(input_tensor=not_correct, axis=axis))\n return correct_seq, tf.constant(1.0)"},"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 label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0","def accuracy(predictions, labels):\n predictions = list(predictions)\n labels = list(labels)\n count = 0\n for i in range(len(labels)):\n if labels[i] == predictions[i]:\n count += 1\n\n return count / len(labels)","def error_rate(predictions, labels):\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))","def percent_accuracy(self, true_values, predicted_values):\n\n correct = 0\n size = len(true_values)\n for i in range(len(true_values)):\n true_labels = true_values[i]\n predicted_labels = predicted_values[i]\n predicted_index = np.argmax(predicted_labels)\n\n if true_labels[predicted_index] == 1:\n correct += 1","def accuracy(labels, predictions):\n if len(labels) != len(predictions):\n return -1\n\n correct = 0\n total = 0\n\n for i,v in enumerate(predictions):\n if labels[i] == str(v):\n correct += 1\n total += 1\n\n return (float(correct) / float(total)) * 100.0","def accuracy(predictions, labels):\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n numpy.sum(numpy.argmax(predictions, 1) == labels) /\n predictions.shape[0])","def accuracy(self, probabilities, labels):\n # TODO: calculate the batch accuracy\n count = 0\n for x in range(len(probabilities)):\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\n count += 1\n return count/len(probabilities)","def label_errors(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (1.0 - num_correct / preds.size(0)) * 100.0","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\n predictions.shape[0])","def error_rate(predictions, labels):\n return 100.0 - (\n 100.0 *\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\n predictions.shape[0])","def accuracy(targets: List[List[float]], predict: List[List[float]]):\r\n correct = 0\r\n for i in range(len(targets)):\r\n if predict[i] == targets[i]:\r\n correct += 1\r\n return correct / len(targets) * 100","def accuracy(labels, preds):\n\tassert labels.shape[0]==preds.shape[0]\n\treturn np.sum(preds==labels)/float(labels.shape[0])","def accuracy(self, X_train, y_train):\n y_train_pred = self.predict(X_train)\n diffs = y_train_pred - y_train\n count = 0.\n for i in range(y_train.shape[0]):\n if diffs[i] != 0:\n count+=1\n return 100 - count*100/y_train.shape[0]","def accuracy(pred, labels):\n pred = torch.sigmoid(pred)\n predicted = (pred > 0.5).int()\n correct = (predicted == labels).sum().item()\n return correct / labels.shape[0]","def accuracy(predictions, targets):\n correct_count = 0\n for prediction, target in zip(predictions, targets):\n if prediction == target:\n correct_count += 1\n return correct_count / len(predictions)","def accuracy(preds, labels):\n correct = preds == labels\n return correct.sum().float() / correct.shape[0]","def precision(y, ypred):\n return len(set(y).intersection(set(ypred))) / len(ypred)","def accuracy(outputs, labels):\n predicted = outputs.argmax(dim=1)\n correct = (predicted == labels).sum().item()\n return correct / labels.size(0)","def get_percentage_false_class(arr_of_results):\n\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\n count_correct_prediction = 0\n\n for i in range(len(arr_of_results[0])):\n use = True\n for result in arr_of_results[:,i]:\n if result[\"image_target\"] != result[\"prediction_image\"] or result[\"std_noise\"] == 0:\n use = False\n if use:\n count_correct_prediction += 1\n i2 = 0\n for result in arr_of_results[:,i]:\n if result[\"success\"]:\n count_success[i2] += 1\n i2 += 1\n\n\n errors = proportion_confint(count_success, count_correct_prediction)\n count_success = count_success/count_correct_prediction\n errors = np.array(errors)\n\n errors[0] = np.abs(count_success - errors[0])\n errors[1] = np.abs(count_success - errors[1])\n\n return count_success, errors","def realistic_error_rate(predictions, labels, predicted_hardness):\n # # print (predicted_hardness)\n # predicted_hardness = predicted_hardness / np.sum(predicted_hardness)\n # # print (np.argmax(predictions, 1) == labels)\n # # print (np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\n # return 100.0 - 100 * np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\n # # return 100.0 - (\n # # 100.0 *\n # # np.sum(np.argmax(predictions, 1) == labels) /\n # # predictions.shape[0])\n print (np.sum(predicted_hardness))\n return 100.0 - 100 * (np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness))) / np.sum(predicted_hardness))","def precision(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_pos = 0 #gold neg sys pos\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"0\" and predicted_labels[i] == \"1\"):\n false_pos += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_pos))","def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\n assert len(predictions) == len(labels), \"Predictions and labels must have the same length.\"\n assert len(labels.shape) == 1, \"Labels must be a column vector.\"\n\n return ( # type: ignore\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\n )","def precision_score(y_true, y_pred):\n return ((y_true == 1) * (y_pred == 1)).sum() / (y_pred == 1).sum()","def check_accuracy (data, labels, weights):\n\tcount = 0\n\tgs = []\n\trs = []\n\tfor x in range(0,len(data)):\n\t\tresults = dot(data[x], weights)\n\t\tguess = unit_step(results)\n\t\tgs.append(guess) # append prediction\n\t\trs.append(labels[x]) # append result\n\t\tif guess - labels[x] == 0:\n\t\t\tcount += 1\n\n\tpercentage = ((float(count) / len(data)) * 100)\n\n\treturn percentage","def accuracy(outputs, labels):\r\n outputs = np.argmax(outputs, axis=1)\r\n return np.sum(outputs == labels) / float(labels.size)","def sentence_accuracy(references, predictions):\n count = 0.0\n match = 0.0\n for label, pred in zip(references, predictions):\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def masked_accuracy(preds, labels, mask):\n preds = preds[mask]\n labels = labels[mask]\n num_correct_pred = np.sum(np.argmax(preds, 1) == np.argmax(labels, 1))\n\n return num_correct_pred / np.sum(mask)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels)/float(labels.size)","def percent_accuracy(self, test_set, predicted_values):\r\n\r\n correct = 0\r\n for i in range(len(test_set)):\r\n if test_set[i].classification == predicted_values[i]:\r\n correct += 1\r\n return correct / len(test_set)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs == labels) / float(labels.size)","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def accuracy_score(truth, predicted):\n return len(np.where(truth==predicted)[0]) / len(truth)","def accuracy(self, logits, labels):\r\n preds = tf.map_fn(tf.math.round, logits)\r\n diff = tf.math.abs(preds - labels)\r\n return 1 - tf.reduce_mean(diff, axis=0)","def calculate_accuracy(mod_pred, y):\n count = 0\n for i, y_true in enumerate(y):\n if y_true == mod_pred[i]:\n count += 1\n\n return count/len(y)","def compare(predictions, truth):\n comp = predictions - truth\n return 1 - (np.count_nonzero(comp) / len(predictions))","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)","def accuracy(outputs, labels):\n outputs = np.argmax(outputs, axis=1)\n return np.sum(outputs==labels)/float(labels.size)","def score(self, predictions):\n return 0.","def accuracy(labels, predictions, n_classes):\n\t\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\n\t\treturn tf.reduce_mean(tf.cast(equality, tf.float32))","def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\n # [batch_size]\n predictions = probabilities.argmax(axis=1)\n # [batch_size]\n labels = labels.argmax(axis=1)\n return (predictions == labels).astype(int).mean()","def report_prediction_accuracy(y, tx, w_best, verbose=True):\n predictions = tx.dot(w_best)\n predictions[predictions >= 0] = 1\n predictions[predictions < 0] = -1\n correct_percentage = np.sum(predictions == y) / float(len(predictions))\n if verbose:\n print('Percentage of correct predictions is: ', correct_percentage * 100, '%')\n return correct_percentage","def accuracy(predictions, targets):\n\n compare = predictions == targets\n # compare = (predictions.argmax(dim=1)) == (targets)\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\n # summed = compare.sum().item()\n summed = compare.sum()\n # print(summed, compare.size())\n # print(compare.size()[0])\n return summed/compare.size","def get_percentage_false_class_for_resultset(results):\n count_success = 0\n count_correct_prediction = 0\n for result in results:\n if result[\"image_target\"] == result[\"prediction_image\"] and result[\"std_noise\"] != 0:\n count_correct_prediction += 1\n if result[\"success\"] == True:\n count_success += 1\n\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\n\n return np.array([count_success/count_correct_prediction, error])","def accuracy_score(Y_true, Y_predict):\n \n true = 0\n\n for i in range(len(Y_predict)):\n if Y_true[i] == Y_predict[i]:\n true+=1\n acc = true/float(len(Y_true))* 100.0\n return acc","def calc_accuracy(true, predicted):\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))","def compute_accuracy(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor):\n pad_pred = pad_pred.argmax(2)\n mask = pad_targets != self.ignore_label\n numerator = torch.sum(\n pad_pred.masked_select(mask) == pad_targets.masked_select(mask)\n )\n denominator = torch.sum(mask)\n return float(numerator) / float(denominator)","def accuracy(actual, predicted):\n return np.sum(predicted == actual) / actual.shape[0]","def find_prediction_success_rate(decision_tree, test_examples, attributes):\n totalCorrect = 0\n for example in test_examples:\n actualResult = example[14]\n prediction = decision_tree_prediction(example, decision_tree, attributes)\n if prediction == actualResult:\n totalCorrect = totalCorrect + 1\n return totalCorrect / len(test_examples)","def evaluate(labels, predictions):\n\n true_positives = 0\n label_positives = 0\n\n true_negatives = 0\n label_negatives = 0\n\n for i in range(len(predictions)):\n if labels[i] == predictions[i] == 1:\n true_positives += 1\n if labels[i] == 1:\n label_positives += 1\n\n if labels[i] == predictions[i] == 0:\n true_negatives += 1\n if labels[i] == 0:\n label_negatives += 1\n\n return true_positives / label_positives, true_negatives / label_negatives\n\n # raise NotImplementedError","def accuracy_with_gap(y_true, y_pred, gap):\n true_predictions = 0\n for i in range(len(y_pred)):\n if abs(y_pred[i] - y_true[i]) <= gap:\n true_predictions += 1\n return true_predictions/len(y_true)","def calc_ac_score(labels_true, labels_pred):\n nclass = len(np.unique(labels_true))\n labels_size = len(labels_true)\n mat = labels_size * np.ones((nclass, nclass))\n \n idx = 0\n \n for i in range(labels_size):\n mat[labels_pred[i], labels_true[i]] -= 1.0\n \n munkres = Munkres()\n mapping = munkres.compute(mat)\n \n ac = 0.0\n\n for i in range(labels_size):\n val = mapping[labels_pred[i]][1]\n if val == labels_true[i]:\n ac += 1.0\n\n ac = ac / labels_size \n \n return ac","def check_correctness_statistics(classifier_out, mode, image_type):\n labels = image_type.image_data[mode].labels\n num_correct = 0\n total = len(classifier_out)\n for index, label in classifier_out:\n if labels[index] == label:\n num_correct += 1\n return (num_correct / total) * 100","def compute_accuracy(labels=None, predictions=None):\n labels = np.array(labels, dtype=np.int32)\n if len(labels.shape) == 2:\n labels = np.argmax(labels, -1)\n return np.sum(np.equal(labels, predictions)) / np.size(labels)","def accuracy(outputs, labels):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n labels = labels.ravel()\n\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\n mask = (labels >= 0)\n\n # np.argmax gives us the class predicted for each token by the model\n outputs = np.argmax(outputs, axis=1)\n\n # compare outputs with labels and divide by number of tokens (excluding PADding tokens)\n return np.sum(outputs == labels)/float(np.sum(mask))","def get_accuracy(self, gold, predicted):\n # Exercise 3: calculate accuracy\n i = 0\n j = 0\n for labels in gold:\n if labels == predicted[i]:\n j +=1\n i +=1\n return j / i * 100","def accuracy(predicted, ground_truth):\n predicted_labels_decoded = np.argmax(predicted, axis=1)\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\n return accuracy * 100","def accuracy(pred, target):\n N = pred.shape[0]\n return (pred == target).sum() * 1.0 / N","def kaggle_metric(predictions, exact_values):\n norm = 70.*len(predictions)\n \n score = 0.\n for p,e in zip(predictions,exact_values):\n score += N.sum((heaviside(p)-heaviside(e))**2)\n\n return score/norm","def accuracy(predictions, test_labels):\n return f1_score(test_labels, predictions, average='micro') * 100","def model_accuracy(predict, y):\n true_predict = (predict.argmax(1) == y.argmax(1)).float()\n acc = true_predict.sum() / len(true_predict)\n return acc","def calculateResults(predictions, answers):\r\n t = 0\r\n f = 0\r\n for i in range(len(answers)):\r\n if predictions[i] == answers[i]:\r\n t += 1\r\n else:\r\n f += 1\r\n\r\n print(\"The Percent of Correct Predictions is {t}%\".format(t=round((t * 100 / len(answers)), 1)))\r\n print(\"The Percent of Incorrect Predictions is {f}%\\n\".format(f=round((f * 100 / len(answers)), 1)))","def evaluate(labels, predictions):\n actual_positive = 0\n actual_negative = 0\n predicted_positive = 0\n predicted_negative = 0\n for i, j in zip(labels, predictions):\n if i == 1:\n actual_positive += i\n predicted_positive += j\n else:\n actual_negative += 1\n if j == 0:\n predicted_negative += 1\n return predicted_positive/actual_positive, predicted_negative/actual_negative","def accuracy(predictions, targets):\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n correct = 0\n for i in range(len(targets)):\n if(predictions[i] == targets[i]):\n correct += 1\n accuracy = correct/len(targets)\n #raise NotImplementedError\n ########################\n # END OF YOUR CODE #\n #######################\n\n return accuracy","def evaluate(self, dataset):\n success = 0\n for sample, labelVector, label in dataset.tests:\n if self.guessLabel(sample) == label:\n success += 1\n return success / len(dataset.tests)","def accuracy(self, x, t):\n\n y = self.predict(x)\n y_labels = np.argmax(y, axis=1)\n t_labels = np.argmax(t, axis=1)\n\n num_all = x.shape[0]\n num_hit = np.sum(y_labels == t_labels)\n return num_hit / float(num_all)","def num_correct_fun(preds, labels):\n assert preds.size(0) == labels.size(\n 0\n ), \"Batch dim of predictions and labels must match\"\n # Find number of correct predictions\n num_correct = (preds == labels).float().sum()\n return num_correct","def naive_prediction(\n y_test:np.array) -> float:\n yhat = np.concatenate((np.zeros(1),y_test[:-1]))\n \n return np.sqrt(np.sum(np.square(yhat-y_test)))","def get_precision(y_true, y_pred):\n model_entities_filter = (y_pred != 3).astype(\"int\") # of the words our model say has a NER class\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\"int\")\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \n return precision","def compute_accuracy(Y_test, Y_pred):\n number_correct_prediction = 0\n for i in range(len(Y_pred)): # They have the same length\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\n if id_test == id_pred:\n number_correct_prediction += 1\n\n percentage_correct = number_correct_prediction / len(Y_pred)\n\n return percentage_correct","def overall_accuracy(y_true, y_pred):\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\n intersection = list(pred_flat == true_flat).count(True)\n sum_ = len(true_flat)\n accuracy = round(intersection/sum_, 4)\n return accuracy","def accuracies(actual_labels, predicted_labels):\n acc = 0\n letter_acc = 0\n letter_cnt = 0\n cnt = 0\n for i in range(len(actual_labels)):\n predicted_output = predicted_labels[i]\n actual_output = actual_labels[i]\n cnt += 1\n for j in range(min(len(predicted_output), len(actual_output))):\n if predicted_output[j] == actual_output[j]:\n letter_acc += 1\n letter_cnt += max(len(predicted_output), len(actual_output))\n if actual_output == predicted_output:\n acc += 1\n final_accuracy = np.round((acc / len(actual_labels)) * 100, 2)\n final_letter_accuracy = np.round((letter_acc / letter_cnt) * 100, 2)\n return final_accuracy, final_letter_accuracy","def mape(true, predictions):\n true = np.array(true)\n predictions = np.array(predictions) \n return np.mean(np.abs((true - predictions)) / true) * 100","def recall(y, ypred):\n return len(set(y).intersection(set(ypred))) / len(y)","def test_accuracy(y, tx, w):\n labels = predict_regression_labels(w, tx)\n \n return (labels==y).sum()/len(y)","def fraction_mislabeled_nodes(labels, labels_pred):\n G1 = partition_indicator(labels)\n G2 = partition_indicator(labels_pred)\n\n # cost is minimized, overlap maximized\n cost_matrix = -G1.T.dot(G2)\n row_ind, col_ind = linear_sum_assignment(cost_matrix.A)\n cost = -cost_matrix[row_ind, col_ind].sum()\n\n return 1 - (cost / len(labels))","def label_accuracy_score(label_true, label_pred, n_class):\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def flat_accuracy(logits, labels):\n\n pred_flat = np.argmax(logits, axis=1).flatten()\n labels_flat = labels.flatten()\n return np.sum(pred_flat == labels_flat) / len(labels_flat)","def _accuracy_without_reject(actual, preds):\r\n\r\n total = len(actual)\r\n acc_list = []\r\n for i in range(preds.shape[1]): # for loop on the n predicted result of samples\r\n misclassified = sum(\r\n 1 for act, pred in zip(actual, preds[:, i]) if act != pred) # Number of misclassified samples\r\n acc_list.append((total - misclassified) / total)\r\n return np.cumsum(acc_list)","def calculate_accuracy(actual_list, predicted_list):\n valid_part_len = sum(i == j for i, j in zip(actual_list, predicted_list))\n return (100.0 / len(actual_list)) * valid_part_len","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def evaluate(labels, predictions):\n\n truePositiveCounter = 0\n trueNegativeCounter = 0\n truePositiveCorrect = 0\n trueNegativeCorrect = 0\n \n sensitivity = 0\n specificity = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n truePositiveCounter += 1\n if(labels[i] == predictions[i]):\n truePositiveCorrect += 1\n elif labels[i] == 0:\n trueNegativeCounter += 1\n if(labels[i] == predictions[i]):\n trueNegativeCorrect += 1\n\n sensitivity = truePositiveCorrect / truePositiveCounter\n specificity = trueNegativeCorrect / trueNegativeCounter\n\n return sensitivity, specificity","def precision(ground_truth, prediction):\n ground_truth = remove_duplicates(ground_truth)\n prediction = remove_duplicates(prediction)\n precision_score = count_a_in_b_unique(prediction, ground_truth) / float(len(prediction))\n assert 0 <= precision_score <= 1\n return precision_score","def recall_for_label(gt, pred, label):\n mask = gt == label\n masked_pred = pred[mask]\n n = float(masked_pred.numel())\n tp = torch.sum(masked_pred == 1)\n return tp / n","def get_accuracy(output, labels):\n \n correct = 0\n \n for idx in range(len(output)):\n if torch.argmax(output[idx]).item() == labels[idx].item():\n correct += 1\n \n acc = correct / len(output)\n return acc","def evaluate(predicted, actual):\r\n assert(len(predicted) == len(actual))\r\n total = len(actual)\r\n correct = len([x for x in range(total) if predicted[x] == actual[x]])\r\n return (float(correct) / float(total)) * 100.0","def binary_accuracy(preds, y):\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division \n acc = correct.sum() / len(correct)\n return acc","def get_accuracy(actual, predicted):\n predicted_correct = 0\n # for each index in the actual result\n for i in range(len(actual)):\n # if actual is the same as predicted\n if actual[i] == predicted[i]:\n predicted_correct+=1\n return predicted_correct/len(actual)","def recall(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_neg = 0 #gold pos sys neg\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"1\" and predicted_labels[i] == \"0\"):\n false_neg += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_neg))","def label_accuracy_score(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n # 一个batch里面可能有多个数据\n # 通过迭代器将一个个数据进行计算\n for lt, lp in zip(label_trues, label_preds):\n # numpy.ndarray.flatten将numpy对象拉成1维\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\n \"\"\"\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\n iu是召回率Recall，公式上面给出了\n mean_iu就是对iu求了一个平均\n freq是每一类被预测到的频率\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\n \"\"\"\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n # nanmean会自动忽略nan的元素求平均\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def binary_accuracy(preds, y):\n\n #round predictions to the closest integer\n rounded_preds = torch.round(torch.sigmoid(preds))\n correct = (rounded_preds == y).float() #convert into float for division\n acc = correct.sum() / len(correct)\n return acc","def overlap_score(labels, labels_pred):\n raw_overlap = 1-fraction_mislabeled_nodes(labels, labels_pred)\n partition_true = np.array(labels).astype(int)\n partition_pred = np.array(labels_pred).astype(int)\n num_nodes = partition_pred.size\n num_groups = partition_true.max() + 1\n\n chance_level = 0.\n for i in range(num_groups):\n temp = np.sum(i == partition_true) / num_nodes\n if temp > chance_level:\n chance_level = temp\n\n score = (raw_overlap - chance_level) / (1 - chance_level)\n if score <= 0:\n score = 0\n\n return score","def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\n check_vector_format(labels_true, labels_pred)\n mask = (labels_true >= 0) & (labels_pred >= 0)\n if np.sum(mask):\n return np.mean(labels_true[mask] == labels_pred[mask])\n else:\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')","def accuracy_score(y_true, y_predict):\n assert y_true.shape[0] == y_predict.shape[0], \\\n \"The size of y_true must be equal to y_predict\"\n\n return sum(y_true == y_predict) / len(y_true)","def per_token_accuracy(gold_seq, pred_seq):\n num_correct = 0\n for i, gold_token in enumerate(gold_seq):\n if i < len(pred_seq) and pred_seq[i] == gold_token:\n num_correct += 1\n\n return float(num_correct) / len(gold_seq)","def accuracy(gt, pred):\n \n return np.mean(gt == pred)","def one_prediction(predictions, step_nb, threshold):\n number_sequences = step_nb//50\n total_prediction = 0\n for i in range(number_sequences):\n total_prediction += 1/predictions[i]\n return(total_prediction/step_nb)"],"string":"[\n \"def label_accuracies(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (num_correct / preds.size(0)) * 100.0\",\n \"def accuracy(predictions, labels):\\n predictions = list(predictions)\\n labels = list(labels)\\n count = 0\\n for i in range(len(labels)):\\n if labels[i] == predictions[i]:\\n count += 1\\n\\n return count / len(labels)\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (100*(np.sum(predictions == labels)/float(predictions.shape[0]*predictions.shape[1])))\",\n \"def percent_accuracy(self, true_values, predicted_values):\\n\\n correct = 0\\n size = len(true_values)\\n for i in range(len(true_values)):\\n true_labels = true_values[i]\\n predicted_labels = predicted_values[i]\\n predicted_index = np.argmax(predicted_labels)\\n\\n if true_labels[predicted_index] == 1:\\n correct += 1\",\n \"def accuracy(labels, predictions):\\n if len(labels) != len(predictions):\\n return -1\\n\\n correct = 0\\n total = 0\\n\\n for i,v in enumerate(predictions):\\n if labels[i] == str(v):\\n correct += 1\\n total += 1\\n\\n return (float(correct) / float(total)) * 100.0\",\n \"def accuracy(predictions, labels):\\n return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) / predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n numpy.sum(numpy.argmax(predictions, 1) == labels) /\\n predictions.shape[0])\",\n \"def accuracy(self, probabilities, labels):\\n # TODO: calculate the batch accuracy\\n count = 0\\n for x in range(len(probabilities)):\\n if np.argmax(labels[x]) == np.argmax(probabilities[x]):\\n count += 1\\n return count/len(probabilities)\",\n \"def label_errors(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (1.0 - num_correct / preds.size(0)) * 100.0\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\\n predictions.shape[0])\",\n \"def error_rate(predictions, labels):\\n return 100.0 - (\\n 100.0 *\\n np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1)) /\\n predictions.shape[0])\",\n \"def accuracy(targets: List[List[float]], predict: List[List[float]]):\\r\\n correct = 0\\r\\n for i in range(len(targets)):\\r\\n if predict[i] == targets[i]:\\r\\n correct += 1\\r\\n return correct / len(targets) * 100\",\n \"def accuracy(labels, preds):\\n\\tassert labels.shape[0]==preds.shape[0]\\n\\treturn np.sum(preds==labels)/float(labels.shape[0])\",\n \"def accuracy(self, X_train, y_train):\\n y_train_pred = self.predict(X_train)\\n diffs = y_train_pred - y_train\\n count = 0.\\n for i in range(y_train.shape[0]):\\n if diffs[i] != 0:\\n count+=1\\n return 100 - count*100/y_train.shape[0]\",\n \"def accuracy(pred, labels):\\n pred = torch.sigmoid(pred)\\n predicted = (pred > 0.5).int()\\n correct = (predicted == labels).sum().item()\\n return correct / labels.shape[0]\",\n \"def accuracy(predictions, targets):\\n correct_count = 0\\n for prediction, target in zip(predictions, targets):\\n if prediction == target:\\n correct_count += 1\\n return correct_count / len(predictions)\",\n \"def accuracy(preds, labels):\\n correct = preds == labels\\n return correct.sum().float() / correct.shape[0]\",\n \"def precision(y, ypred):\\n return len(set(y).intersection(set(ypred))) / len(ypred)\",\n \"def accuracy(outputs, labels):\\n predicted = outputs.argmax(dim=1)\\n correct = (predicted == labels).sum().item()\\n return correct / labels.size(0)\",\n \"def get_percentage_false_class(arr_of_results):\\n\\n count_success = np.zeros_like(arr_of_results[:,0], dtype=float)\\n count_correct_prediction = 0\\n\\n for i in range(len(arr_of_results[0])):\\n use = True\\n for result in arr_of_results[:,i]:\\n if result[\\\"image_target\\\"] != result[\\\"prediction_image\\\"] or result[\\\"std_noise\\\"] == 0:\\n use = False\\n if use:\\n count_correct_prediction += 1\\n i2 = 0\\n for result in arr_of_results[:,i]:\\n if result[\\\"success\\\"]:\\n count_success[i2] += 1\\n i2 += 1\\n\\n\\n errors = proportion_confint(count_success, count_correct_prediction)\\n count_success = count_success/count_correct_prediction\\n errors = np.array(errors)\\n\\n errors[0] = np.abs(count_success - errors[0])\\n errors[1] = np.abs(count_success - errors[1])\\n\\n return count_success, errors\",\n \"def realistic_error_rate(predictions, labels, predicted_hardness):\\n # # print (predicted_hardness)\\n # predicted_hardness = predicted_hardness / np.sum(predicted_hardness)\\n # # print (np.argmax(predictions, 1) == labels)\\n # # print (np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\\n # return 100.0 - 100 * np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness)))\\n # # return 100.0 - (\\n # # 100.0 *\\n # # np.sum(np.argmax(predictions, 1) == labels) /\\n # # predictions.shape[0])\\n print (np.sum(predicted_hardness))\\n return 100.0 - 100 * (np.sum(np.multiply(np.argmax(predictions, 1) == labels, np.squeeze(predicted_hardness))) / np.sum(predicted_hardness))\",\n \"def precision(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_pos = 0 #gold neg sys pos\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"0\\\" and predicted_labels[i] == \\\"1\\\"):\\n false_pos += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_pos))\",\n \"def accuracy_rate(predictions: torch.Tensor, labels: torch.Tensor) -> float:\\n assert len(predictions) == len(labels), \\\"Predictions and labels must have the same length.\\\"\\n assert len(labels.shape) == 1, \\\"Labels must be a column vector.\\\"\\n\\n return ( # type: ignore\\n float((predictions.argmax(1) == labels.to(torch.long)).sum()) / predictions.shape[0]\\n )\",\n \"def precision_score(y_true, y_pred):\\n return ((y_true == 1) * (y_pred == 1)).sum() / (y_pred == 1).sum()\",\n \"def check_accuracy (data, labels, weights):\\n\\tcount = 0\\n\\tgs = []\\n\\trs = []\\n\\tfor x in range(0,len(data)):\\n\\t\\tresults = dot(data[x], weights)\\n\\t\\tguess = unit_step(results)\\n\\t\\tgs.append(guess) # append prediction\\n\\t\\trs.append(labels[x]) # append result\\n\\t\\tif guess - labels[x] == 0:\\n\\t\\t\\tcount += 1\\n\\n\\tpercentage = ((float(count) / len(data)) * 100)\\n\\n\\treturn percentage\",\n \"def accuracy(outputs, labels):\\r\\n outputs = np.argmax(outputs, axis=1)\\r\\n return np.sum(outputs == labels) / float(labels.size)\",\n \"def sentence_accuracy(references, predictions):\\n count = 0.0\\n match = 0.0\\n for label, pred in zip(references, predictions):\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def masked_accuracy(preds, labels, mask):\\n preds = preds[mask]\\n labels = labels[mask]\\n num_correct_pred = np.sum(np.argmax(preds, 1) == np.argmax(labels, 1))\\n\\n return num_correct_pred / np.sum(mask)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs == labels)/float(labels.size)\",\n \"def percent_accuracy(self, test_set, predicted_values):\\r\\n\\r\\n correct = 0\\r\\n for i in range(len(test_set)):\\r\\n if test_set[i].classification == predicted_values[i]:\\r\\n correct += 1\\r\\n return correct / len(test_set)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs == labels) / float(labels.size)\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def accuracy_score(truth, predicted):\\n return len(np.where(truth==predicted)[0]) / len(truth)\",\n \"def accuracy(self, logits, labels):\\r\\n preds = tf.map_fn(tf.math.round, logits)\\r\\n diff = tf.math.abs(preds - labels)\\r\\n return 1 - tf.reduce_mean(diff, axis=0)\",\n \"def calculate_accuracy(mod_pred, y):\\n count = 0\\n for i, y_true in enumerate(y):\\n if y_true == mod_pred[i]:\\n count += 1\\n\\n return count/len(y)\",\n \"def compare(predictions, truth):\\n comp = predictions - truth\\n return 1 - (np.count_nonzero(comp) / len(predictions))\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\",\n \"def accuracy(outputs, labels):\\n outputs = np.argmax(outputs, axis=1)\\n return np.sum(outputs==labels)/float(labels.size)\",\n \"def score(self, predictions):\\n return 0.\",\n \"def accuracy(labels, predictions, n_classes):\\n\\t\\tequality = tf.equal(x = predictions, y = labels) # match the type of labels\\n\\t\\treturn tf.reduce_mean(tf.cast(equality, tf.float32))\",\n \"def accuracy(probabilities: np.ndarray, labels: np.ndarray) -> float:\\n # [batch_size]\\n predictions = probabilities.argmax(axis=1)\\n # [batch_size]\\n labels = labels.argmax(axis=1)\\n return (predictions == labels).astype(int).mean()\",\n \"def report_prediction_accuracy(y, tx, w_best, verbose=True):\\n predictions = tx.dot(w_best)\\n predictions[predictions >= 0] = 1\\n predictions[predictions < 0] = -1\\n correct_percentage = np.sum(predictions == y) / float(len(predictions))\\n if verbose:\\n print('Percentage of correct predictions is: ', correct_percentage * 100, '%')\\n return correct_percentage\",\n \"def accuracy(predictions, targets):\\n\\n compare = predictions == targets\\n # compare = (predictions.argmax(dim=1)) == (targets)\\n # compare = (predictions.argmax(dim=1)) == (targets.argmax(dim=1))\\n # summed = compare.sum().item()\\n summed = compare.sum()\\n # print(summed, compare.size())\\n # print(compare.size()[0])\\n return summed/compare.size\",\n \"def get_percentage_false_class_for_resultset(results):\\n count_success = 0\\n count_correct_prediction = 0\\n for result in results:\\n if result[\\\"image_target\\\"] == result[\\\"prediction_image\\\"] and result[\\\"std_noise\\\"] != 0:\\n count_correct_prediction += 1\\n if result[\\\"success\\\"] == True:\\n count_success += 1\\n\\n error = stats.proportion.proportion_confint(count_success, count_correct_prediction, 0.05)\\n\\n return np.array([count_success/count_correct_prediction, error])\",\n \"def accuracy_score(Y_true, Y_predict):\\n \\n true = 0\\n\\n for i in range(len(Y_predict)):\\n if Y_true[i] == Y_predict[i]:\\n true+=1\\n acc = true/float(len(Y_true))* 100.0\\n return acc\",\n \"def calc_accuracy(true, predicted):\\n return sum([t==p for t,p in zip(true, predicted)]) / float(len(true))\",\n \"def compute_accuracy(self,pad_pred:torch.Tensor, pad_targets:torch.Tensor):\\n pad_pred = pad_pred.argmax(2)\\n mask = pad_targets != self.ignore_label\\n numerator = torch.sum(\\n pad_pred.masked_select(mask) == pad_targets.masked_select(mask)\\n )\\n denominator = torch.sum(mask)\\n return float(numerator) / float(denominator)\",\n \"def accuracy(actual, predicted):\\n return np.sum(predicted == actual) / actual.shape[0]\",\n \"def find_prediction_success_rate(decision_tree, test_examples, attributes):\\n totalCorrect = 0\\n for example in test_examples:\\n actualResult = example[14]\\n prediction = decision_tree_prediction(example, decision_tree, attributes)\\n if prediction == actualResult:\\n totalCorrect = totalCorrect + 1\\n return totalCorrect / len(test_examples)\",\n \"def evaluate(labels, predictions):\\n\\n true_positives = 0\\n label_positives = 0\\n\\n true_negatives = 0\\n label_negatives = 0\\n\\n for i in range(len(predictions)):\\n if labels[i] == predictions[i] == 1:\\n true_positives += 1\\n if labels[i] == 1:\\n label_positives += 1\\n\\n if labels[i] == predictions[i] == 0:\\n true_negatives += 1\\n if labels[i] == 0:\\n label_negatives += 1\\n\\n return true_positives / label_positives, true_negatives / label_negatives\\n\\n # raise NotImplementedError\",\n \"def accuracy_with_gap(y_true, y_pred, gap):\\n true_predictions = 0\\n for i in range(len(y_pred)):\\n if abs(y_pred[i] - y_true[i]) <= gap:\\n true_predictions += 1\\n return true_predictions/len(y_true)\",\n \"def calc_ac_score(labels_true, labels_pred):\\n nclass = len(np.unique(labels_true))\\n labels_size = len(labels_true)\\n mat = labels_size * np.ones((nclass, nclass))\\n \\n idx = 0\\n \\n for i in range(labels_size):\\n mat[labels_pred[i], labels_true[i]] -= 1.0\\n \\n munkres = Munkres()\\n mapping = munkres.compute(mat)\\n \\n ac = 0.0\\n\\n for i in range(labels_size):\\n val = mapping[labels_pred[i]][1]\\n if val == labels_true[i]:\\n ac += 1.0\\n\\n ac = ac / labels_size \\n \\n return ac\",\n \"def check_correctness_statistics(classifier_out, mode, image_type):\\n labels = image_type.image_data[mode].labels\\n num_correct = 0\\n total = len(classifier_out)\\n for index, label in classifier_out:\\n if labels[index] == label:\\n num_correct += 1\\n return (num_correct / total) * 100\",\n \"def compute_accuracy(labels=None, predictions=None):\\n labels = np.array(labels, dtype=np.int32)\\n if len(labels.shape) == 2:\\n labels = np.argmax(labels, -1)\\n return np.sum(np.equal(labels, predictions)) / np.size(labels)\",\n \"def accuracy(outputs, labels):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n labels = labels.ravel()\\n\\n # since PADding tokens have label -1, we can generate a mask to exclude the loss from those terms\\n mask = (labels >= 0)\\n\\n # np.argmax gives us the class predicted for each token by the model\\n outputs = np.argmax(outputs, axis=1)\\n\\n # compare outputs with labels and divide by number of tokens (excluding PADding tokens)\\n return np.sum(outputs == labels)/float(np.sum(mask))\",\n \"def get_accuracy(self, gold, predicted):\\n # Exercise 3: calculate accuracy\\n i = 0\\n j = 0\\n for labels in gold:\\n if labels == predicted[i]:\\n j +=1\\n i +=1\\n return j / i * 100\",\n \"def accuracy(predicted, ground_truth):\\n predicted_labels_decoded = np.argmax(predicted, axis=1)\\n ground_truth_labels_decoded = np.argmax(ground_truth, axis=1)\\n correct_rate = [1 if pred == truth else 0 for (pred, truth) in\\n zip(predicted_labels_decoded, ground_truth_labels_decoded)]\\n accuracy = sum(correct_rate) / ground_truth_labels_decoded.size\\n return accuracy * 100\",\n \"def accuracy(pred, target):\\n N = pred.shape[0]\\n return (pred == target).sum() * 1.0 / N\",\n \"def kaggle_metric(predictions, exact_values):\\n norm = 70.*len(predictions)\\n \\n score = 0.\\n for p,e in zip(predictions,exact_values):\\n score += N.sum((heaviside(p)-heaviside(e))**2)\\n\\n return score/norm\",\n \"def accuracy(predictions, test_labels):\\n return f1_score(test_labels, predictions, average='micro') * 100\",\n \"def model_accuracy(predict, y):\\n true_predict = (predict.argmax(1) == y.argmax(1)).float()\\n acc = true_predict.sum() / len(true_predict)\\n return acc\",\n \"def calculateResults(predictions, answers):\\r\\n t = 0\\r\\n f = 0\\r\\n for i in range(len(answers)):\\r\\n if predictions[i] == answers[i]:\\r\\n t += 1\\r\\n else:\\r\\n f += 1\\r\\n\\r\\n print(\\\"The Percent of Correct Predictions is {t}%\\\".format(t=round((t * 100 / len(answers)), 1)))\\r\\n print(\\\"The Percent of Incorrect Predictions is {f}%\\\\n\\\".format(f=round((f * 100 / len(answers)), 1)))\",\n \"def evaluate(labels, predictions):\\n actual_positive = 0\\n actual_negative = 0\\n predicted_positive = 0\\n predicted_negative = 0\\n for i, j in zip(labels, predictions):\\n if i == 1:\\n actual_positive += i\\n predicted_positive += j\\n else:\\n actual_negative += 1\\n if j == 0:\\n predicted_negative += 1\\n return predicted_positive/actual_positive, predicted_negative/actual_negative\",\n \"def accuracy(predictions, targets):\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n correct = 0\\n for i in range(len(targets)):\\n if(predictions[i] == targets[i]):\\n correct += 1\\n accuracy = correct/len(targets)\\n #raise NotImplementedError\\n ########################\\n # END OF YOUR CODE #\\n #######################\\n\\n return accuracy\",\n \"def evaluate(self, dataset):\\n success = 0\\n for sample, labelVector, label in dataset.tests:\\n if self.guessLabel(sample) == label:\\n success += 1\\n return success / len(dataset.tests)\",\n \"def accuracy(self, x, t):\\n\\n y = self.predict(x)\\n y_labels = np.argmax(y, axis=1)\\n t_labels = np.argmax(t, axis=1)\\n\\n num_all = x.shape[0]\\n num_hit = np.sum(y_labels == t_labels)\\n return num_hit / float(num_all)\",\n \"def num_correct_fun(preds, labels):\\n assert preds.size(0) == labels.size(\\n 0\\n ), \\\"Batch dim of predictions and labels must match\\\"\\n # Find number of correct predictions\\n num_correct = (preds == labels).float().sum()\\n return num_correct\",\n \"def naive_prediction(\\n y_test:np.array) -> float:\\n yhat = np.concatenate((np.zeros(1),y_test[:-1]))\\n \\n return np.sqrt(np.sum(np.square(yhat-y_test)))\",\n \"def get_precision(y_true, y_pred):\\n model_entities_filter = (y_pred != 3).astype(\\\"int\\\") # of the words our model say has a NER class\\n precision_correct_entities = (y_pred[np.where(model_entities_filter)] == y_true[np.where(model_entities_filter)]).astype(\\\"int\\\")\\n precision = np.sum(precision_correct_entities)/np.sum(model_entities_filter) \\n return precision\",\n \"def compute_accuracy(Y_test, Y_pred):\\n number_correct_prediction = 0\\n for i in range(len(Y_pred)): # They have the same length\\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\\n if id_test == id_pred:\\n number_correct_prediction += 1\\n\\n percentage_correct = number_correct_prediction / len(Y_pred)\\n\\n return percentage_correct\",\n \"def overall_accuracy(y_true, y_pred):\\n pred_flat, true_flat = y_pred.flatten(), y_true.flatten()\\n intersection = list(pred_flat == true_flat).count(True)\\n sum_ = len(true_flat)\\n accuracy = round(intersection/sum_, 4)\\n return accuracy\",\n \"def accuracies(actual_labels, predicted_labels):\\n acc = 0\\n letter_acc = 0\\n letter_cnt = 0\\n cnt = 0\\n for i in range(len(actual_labels)):\\n predicted_output = predicted_labels[i]\\n actual_output = actual_labels[i]\\n cnt += 1\\n for j in range(min(len(predicted_output), len(actual_output))):\\n if predicted_output[j] == actual_output[j]:\\n letter_acc += 1\\n letter_cnt += max(len(predicted_output), len(actual_output))\\n if actual_output == predicted_output:\\n acc += 1\\n final_accuracy = np.round((acc / len(actual_labels)) * 100, 2)\\n final_letter_accuracy = np.round((letter_acc / letter_cnt) * 100, 2)\\n return final_accuracy, final_letter_accuracy\",\n \"def mape(true, predictions):\\n true = np.array(true)\\n predictions = np.array(predictions) \\n return np.mean(np.abs((true - predictions)) / true) * 100\",\n \"def recall(y, ypred):\\n return len(set(y).intersection(set(ypred))) / len(y)\",\n \"def test_accuracy(y, tx, w):\\n labels = predict_regression_labels(w, tx)\\n \\n return (labels==y).sum()/len(y)\",\n \"def fraction_mislabeled_nodes(labels, labels_pred):\\n G1 = partition_indicator(labels)\\n G2 = partition_indicator(labels_pred)\\n\\n # cost is minimized, overlap maximized\\n cost_matrix = -G1.T.dot(G2)\\n row_ind, col_ind = linear_sum_assignment(cost_matrix.A)\\n cost = -cost_matrix[row_ind, col_ind].sum()\\n\\n return 1 - (cost / len(labels))\",\n \"def label_accuracy_score(label_true, label_pred, n_class):\\n hist = _fast_hist(label_true.flatten(), label_pred.flatten(), n_class)\\n acc = np.diag(hist).sum() / hist.sum().astype(np.float64)\\n acc_cls = np.diag(hist) / hist.sum(axis=1).astype(np.float64)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist)).astype(np.float64)\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum().astype(np.float64)\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def flat_accuracy(logits, labels):\\n\\n pred_flat = np.argmax(logits, axis=1).flatten()\\n labels_flat = labels.flatten()\\n return np.sum(pred_flat == labels_flat) / len(labels_flat)\",\n \"def _accuracy_without_reject(actual, preds):\\r\\n\\r\\n total = len(actual)\\r\\n acc_list = []\\r\\n for i in range(preds.shape[1]): # for loop on the n predicted result of samples\\r\\n misclassified = sum(\\r\\n 1 for act, pred in zip(actual, preds[:, i]) if act != pred) # Number of misclassified samples\\r\\n acc_list.append((total - misclassified) / total)\\r\\n return np.cumsum(acc_list)\",\n \"def calculate_accuracy(actual_list, predicted_list):\\n valid_part_len = sum(i == j for i, j in zip(actual_list, predicted_list))\\n return (100.0 / len(actual_list)) * valid_part_len\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def evaluate(labels, predictions):\\n\\n truePositiveCounter = 0\\n trueNegativeCounter = 0\\n truePositiveCorrect = 0\\n trueNegativeCorrect = 0\\n \\n sensitivity = 0\\n specificity = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n truePositiveCounter += 1\\n if(labels[i] == predictions[i]):\\n truePositiveCorrect += 1\\n elif labels[i] == 0:\\n trueNegativeCounter += 1\\n if(labels[i] == predictions[i]):\\n trueNegativeCorrect += 1\\n\\n sensitivity = truePositiveCorrect / truePositiveCounter\\n specificity = trueNegativeCorrect / trueNegativeCounter\\n\\n return sensitivity, specificity\",\n \"def precision(ground_truth, prediction):\\n ground_truth = remove_duplicates(ground_truth)\\n prediction = remove_duplicates(prediction)\\n precision_score = count_a_in_b_unique(prediction, ground_truth) / float(len(prediction))\\n assert 0 <= precision_score <= 1\\n return precision_score\",\n \"def recall_for_label(gt, pred, label):\\n mask = gt == label\\n masked_pred = pred[mask]\\n n = float(masked_pred.numel())\\n tp = torch.sum(masked_pred == 1)\\n return tp / n\",\n \"def get_accuracy(output, labels):\\n \\n correct = 0\\n \\n for idx in range(len(output)):\\n if torch.argmax(output[idx]).item() == labels[idx].item():\\n correct += 1\\n \\n acc = correct / len(output)\\n return acc\",\n \"def evaluate(predicted, actual):\\r\\n assert(len(predicted) == len(actual))\\r\\n total = len(actual)\\r\\n correct = len([x for x in range(total) if predicted[x] == actual[x]])\\r\\n return (float(correct) / float(total)) * 100.0\",\n \"def binary_accuracy(preds, y):\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division \\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def get_accuracy(actual, predicted):\\n predicted_correct = 0\\n # for each index in the actual result\\n for i in range(len(actual)):\\n # if actual is the same as predicted\\n if actual[i] == predicted[i]:\\n predicted_correct+=1\\n return predicted_correct/len(actual)\",\n \"def recall(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_neg = 0 #gold pos sys neg\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"1\\\" and predicted_labels[i] == \\\"0\\\"):\\n false_neg += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_neg))\",\n \"def label_accuracy_score(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n # 一个batch里面可能有多个数据\\n # 通过迭代器将一个个数据进行计算\\n for lt, lp in zip(label_trues, label_preds):\\n # numpy.ndarray.flatten将numpy对象拉成1维\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n\\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\\n \\\"\\\"\\\"\\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\\n iu是召回率Recall，公式上面给出了\\n mean_iu就是对iu求了一个平均\\n freq是每一类被预测到的频率\\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\\n \\\"\\\"\\\"\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n # nanmean会自动忽略nan的元素求平均\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def binary_accuracy(preds, y):\\n\\n #round predictions to the closest integer\\n rounded_preds = torch.round(torch.sigmoid(preds))\\n correct = (rounded_preds == y).float() #convert into float for division\\n acc = correct.sum() / len(correct)\\n return acc\",\n \"def overlap_score(labels, labels_pred):\\n raw_overlap = 1-fraction_mislabeled_nodes(labels, labels_pred)\\n partition_true = np.array(labels).astype(int)\\n partition_pred = np.array(labels_pred).astype(int)\\n num_nodes = partition_pred.size\\n num_groups = partition_true.max() + 1\\n\\n chance_level = 0.\\n for i in range(num_groups):\\n temp = np.sum(i == partition_true) / num_nodes\\n if temp > chance_level:\\n chance_level = temp\\n\\n score = (raw_overlap - chance_level) / (1 - chance_level)\\n if score <= 0:\\n score = 0\\n\\n return score\",\n \"def get_accuracy_score(labels_true: np.ndarray, labels_pred: np.ndarray) -> float:\\n check_vector_format(labels_true, labels_pred)\\n mask = (labels_true >= 0) & (labels_pred >= 0)\\n if np.sum(mask):\\n return np.mean(labels_true[mask] == labels_pred[mask])\\n else:\\n raise ValueError('No sample with both true non-negative label and predicted non-negative label.')\",\n \"def accuracy_score(y_true, y_predict):\\n assert y_true.shape[0] == y_predict.shape[0], \\\\\\n \\\"The size of y_true must be equal to y_predict\\\"\\n\\n return sum(y_true == y_predict) / len(y_true)\",\n \"def per_token_accuracy(gold_seq, pred_seq):\\n num_correct = 0\\n for i, gold_token in enumerate(gold_seq):\\n if i < len(pred_seq) and pred_seq[i] == gold_token:\\n num_correct += 1\\n\\n return float(num_correct) / len(gold_seq)\",\n \"def accuracy(gt, pred):\\n \\n return np.mean(gt == pred)\",\n \"def one_prediction(predictions, step_nb, threshold):\\n number_sequences = step_nb//50\\n total_prediction = 0\\n for i in range(number_sequences):\\n total_prediction += 1/predictions[i]\\n return(total_prediction/step_nb)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7791173","0.7454314","0.73788065","0.7339361","0.73184043","0.72473156","0.7175092","0.7150846","0.71485466","0.71371794","0.70903116","0.7048925","0.7027989","0.6983812","0.6973967","0.6961783","0.6957565","0.6949172","0.6945957","0.6927787","0.6919117","0.6873311","0.6872349","0.6863672","0.6863237","0.6856637","0.6804112","0.67938936","0.6788617","0.677431","0.6756391","0.6755616","0.6746687","0.67369294","0.67369294","0.6728687","0.67228305","0.6721833","0.67195386","0.67195386","0.67190546","0.6712478","0.6690994","0.6676517","0.6671687","0.66634446","0.66544783","0.66481936","0.6640553","0.6639447","0.6637809","0.6625106","0.66245276","0.6618292","0.6612891","0.6610344","0.6600015","0.6590215","0.6587139","0.6578878","0.6575007","0.65748125","0.6564847","0.6560477","0.6558791","0.655027","0.6538853","0.6529629","0.65079266","0.6482034","0.64747304","0.6474129","0.6463918","0.6462365","0.6460747","0.6460311","0.64566475","0.64563465","0.64536166","0.6453479","0.6450971","0.64473665","0.6430167","0.6425034","0.6416169","0.64024645","0.6401553","0.63816696","0.63809246","0.63700324","0.63589036","0.6356148","0.63525647","0.63521814","0.63507843","0.6347365","0.6344303","0.63424605","0.6340775","0.6339277","0.63194716"],"string":"[\n \"0.7791173\",\n \"0.7454314\",\n \"0.73788065\",\n \"0.7339361\",\n \"0.73184043\",\n \"0.72473156\",\n \"0.7175092\",\n \"0.7150846\",\n \"0.71485466\",\n \"0.71371794\",\n \"0.70903116\",\n \"0.7048925\",\n \"0.7027989\",\n \"0.6983812\",\n \"0.6973967\",\n \"0.6961783\",\n \"0.6957565\",\n \"0.6949172\",\n \"0.6945957\",\n \"0.6927787\",\n \"0.6919117\",\n \"0.6873311\",\n \"0.6872349\",\n \"0.6863672\",\n \"0.6863237\",\n \"0.6856637\",\n \"0.6804112\",\n \"0.67938936\",\n \"0.6788617\",\n \"0.677431\",\n \"0.6756391\",\n \"0.6755616\",\n \"0.6746687\",\n \"0.67369294\",\n \"0.67369294\",\n \"0.6728687\",\n \"0.67228305\",\n \"0.6721833\",\n \"0.67195386\",\n \"0.67195386\",\n \"0.67190546\",\n \"0.6712478\",\n \"0.6690994\",\n \"0.6676517\",\n \"0.6671687\",\n \"0.66634446\",\n \"0.66544783\",\n \"0.66481936\",\n \"0.6640553\",\n \"0.6639447\",\n \"0.6637809\",\n \"0.6625106\",\n \"0.66245276\",\n \"0.6618292\",\n \"0.6612891\",\n \"0.6610344\",\n \"0.6600015\",\n \"0.6590215\",\n \"0.6587139\",\n \"0.6578878\",\n \"0.6575007\",\n \"0.65748125\",\n \"0.6564847\",\n \"0.6560477\",\n \"0.6558791\",\n \"0.655027\",\n \"0.6538853\",\n \"0.6529629\",\n \"0.65079266\",\n \"0.6482034\",\n \"0.64747304\",\n \"0.6474129\",\n \"0.6463918\",\n \"0.6462365\",\n \"0.6460747\",\n \"0.6460311\",\n \"0.64566475\",\n \"0.64563465\",\n \"0.64536166\",\n \"0.6453479\",\n \"0.6450971\",\n \"0.64473665\",\n \"0.6430167\",\n \"0.6425034\",\n \"0.6416169\",\n \"0.64024645\",\n \"0.6401553\",\n \"0.63816696\",\n \"0.63809246\",\n \"0.63700324\",\n \"0.63589036\",\n \"0.6356148\",\n \"0.63525647\",\n \"0.63521814\",\n \"0.63507843\",\n \"0.6347365\",\n \"0.6344303\",\n \"0.63424605\",\n \"0.6340775\",\n \"0.6339277\",\n \"0.63194716\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85165,"cells":{"query":{"kind":"string","value":"Average logperplexity excluding padding 0s. No smoothing."},"document":{"kind":"string","value":"def padded_neg_log_perplexity(logits, labels, vocab_size):\n num, den = padded_cross_entropy_loss(logits, labels, 0, vocab_size)\n return -num, den"},"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 calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def mean_logprob(context, pos_lm):\n logprobs = []\n for tag in pos_lm.vocab:\n logprob = pos_lm.logscore(tag,context)\n if logprob != -float('inf'):\n logprobs.append(logprob)\n return np.mean(logprobs)","def logloss(self,tple):\n feats = self.dataset.input_features\n res = 0\n cc = self.class_counts\n fc = self.feature_counts\n for c in range(self.num_classes):\n res += prod(fc[i][feat(tple)][c]\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\n if res>0:\n return -math.log2(res/len(self.dataset.train))\n else:\n return float(\"inf\") #infinity","def log_loss(self):\n probabilities = self.probability_array().copy()\n # need to flip the probabilities for p < 0.5 with this binary case.\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\n probabilities[np.equal(0, self.y)] *= -1\n probabilities[np.equal(0, self.y)] += 1\n # when multiclass: np.amax(probabilities, 1)\n return np.log(probabilities).sum()","def _perplexity(self, X, log_w):\n return np.exp(-log_w/X.sum())","def log1p(x):\n return 0.0","def log_prob(self):","def log_mae(labels, predictions):\n\n result = abs(labels - predictions)\n result = reduce_mean(result)\n result = log(result)\n\n return result","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def _log_linear_interpolation(predictions):\n log_probs = utils.average_arrays([mx.nd.log(p) for p in predictions])\n return -mx.nd.log(mx.nd.softmax(log_probs))","def loglike(self, params, *args, **kwargs):\n return np.sum(self.loglikeobs(params, *args, **kwargs))","def compute_log_loss(predicted, actual, eps=1e-14):\n predicted = np.clip(predicted, eps, 1 - eps)\n loss = -1 * np.mean(actual * np.log(predicted)\n + (1 - actual)\n * np.log(1 - predicted))\n\n return loss","def logloss(y, p):\n\n p[p < EPS] = EPS\n p[p > 1 - EPS] = 1 - EPS\n return log_loss(y, p)","def logprob(predictions, labels):\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions)))","def logprob(predictions, labels):\n # prevent negative probability\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]","def log_p(self,z): \n return np.array([self.log_p_blanket(i) for i in z])","def log_probability(self, samples):\n pass","def log_mean_exp(x, dim):\n return log_sum_exp(x, dim) - np.log(x.size(dim))","def penalized_logp(mol):\n # normalization constants, statistics from 250k_rndm_zinc_drugs_clean.smi\n mol = to_mol(mol)\n logP_mean = 2.4570953396190123\n logP_std = 1.434324401111988\n SA_mean = -3.0525811293166134\n SA_std = 0.8335207024513095\n cycle_mean = -0.0485696876403053\n cycle_std = 0.2860212110245455\n\n log_p = logp(mol)\n SA = -sa_score(mol)\n\n # cycle score\n cycle_list = nx.cycle_basis(nx.Graph(\n Chem.rdmolops.GetAdjacencyMatrix(mol)))\n if len(cycle_list) == 0:\n cycle_length = 0\n else:\n cycle_length = max([len(j) for j in cycle_list])\n if cycle_length <= 6:\n cycle_length = 0\n else:\n cycle_length = cycle_length - 6\n cycle_score = -cycle_length\n\n normalized_log_p = (log_p - logP_mean) / logP_std\n normalized_SA = (SA - SA_mean) / SA_std\n normalized_cycle = (cycle_score - cycle_mean) / cycle_std\n\n return normalized_log_p + normalized_SA + normalized_cycle","def multiclass_log_loss(y_true, y_pred, eps=1e-15):\n clip = np.clip(y_pred, eps, 1 - eps)\n actual = np.zeros(y_pred.shape)\n rows = actual.shape[0]\n print rows\n print np.arange(rows)\n print (y_true.astype(int))\n actual[np.arange(rows), y_true.astype(int)] = 1\n print actual\n vsota = np.sum(actual * np.log(clip))\n print vsota\n return -1.0 / rows * vsota","def mean(state, keepdims=True, is_log=False):\n return mean_raw(state.particles, state.log_weights, keepdims, is_log)","def logP(self):\n raise NotImplementedError","def log_filter(img, noData):\n img1 = np.float64(img.copy())\n img1 = sf.laplace( img1, mode='constant')\n if np.sum(img<=noData) > 0 : #zero the filtered image at data-nodata boundaries\n mask = np.float64(img.copy())\n mask[:] = 1.\n mask[img<=noData] = 0.0\n mask=sf.laplace(mask, mode='constant')\n img1[mask != 0.] = 0. # set the borders to zero\n img1 = sf.gaussian_filter(img1, (1.4, 1.4), mode='constant')\n return img1","def log_loss(actual, predicted):\n\n predicted, actual = np.array(predicted), np.array(actual)\n\n small_value = 1e-15\n predicted[predicted < small_value] = small_value\n predicted[predicted > 1 - small_value] = 1. - small_value\n return (-1. / len(actual)) * np.sum(\n actual * np.log(predicted) + (1. - actual) * np.log(1. - predicted))","def _update_logprobs(self):\n #self._logp_src = self._log_lim(self.p_source)\n self._logp_I0 = self._log_lim(self.p_source)\n self._logp_R0 = self._log_lim(self.p_source/(self.p_rec_div))\n self._logp_S_fin = self._log_lim(self.p_S_fin)\n self._logp_inf_fin = self._log_lim(self.p_infect_fin)","def analyse_loglike(test_data, mods):\r\n l1 = list(map(lambda x: x + ' NB', mods.names))\r\n l1.extend(list(map(lambda x: x + ' ZI', mods.names)))\r\n l1.extend(list(map(lambda x: x + ' P', mods.names)))\r\n loglikeNB = np.array(mods.compute_log_likelihood(test_data, 'NB'))\r\n loglikeZI = np.array(mods.compute_log_likelihood(test_data, 'ZI'))\r\n loglikeP = np.array(mods.compute_log_likelihood(test_data, 'P'))\r\n # loglikeG = np.array(mods.compute_log_likelihood_gaussian(test_data))\r\n # loglikegeo = np.array(mods.compute_log_likelihood_geom(test_data))\r\n LL = np.zeros((loglikeNB.shape[0] * 3, loglikeNB.shape[1]))\r\n LL[:loglikeNB.shape[0], :] = loglikeNB\r\n LL[loglikeNB.shape[0]:2 * loglikeNB.shape[0], :] = loglikeZI\r\n LL[2 * loglikeNB.shape[0]:3 * loglikeNB.shape[0], :] = loglikeP\r\n # LL[3 * loglikeNB.shape[0]:4 * loglikeNB.shape[0], :] = loglikeG\r\n # LL[4 * llzi.shape[0]:, :] = np.array(mods.loglikegeo)\r\n print('mean per model', list(zip(np.ma.masked_invalid(LL).sum(axis=1), map(lambda x: x.mod.name, mods.models))))\r\n print('mean per distrib')\r\n print(np.ma.masked_invalid(LL[:loglikeNB.shape[0], :]).mean())\r\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0]:loglikeNB.shape[0] * 2, :]).mean())\r\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0] * 2:loglikeNB.shape[0] * 3, :]).mean())\r\n # print(np.nanmean(LL[1-np.isinf(LL)], axis=1))\r\n # print(np.nanmean(LL[LL != np.inf],axis=1))\r\n LL[np.isnan(LL)] = 0\r\n LL[np.isinf(LL)] = 0\r\n LL[LL == 0] = -np.inf\r\n r = np.argmax(LL, axis=0)\r\n # LL /= mx\r\n print('mean_best', np.mean(np.ma.masked_invalid(LL[r, range(LL.shape[1])])))\r\n mx = np.max(LL, axis=0)\r\n LL = LL / mx\r\n means = test_data.get_miniOD(None)[test_data.get_stations_col(None)].mean(axis=0).to_numpy()\r\n # for i in np.unique(r):\r\n # print(means[r == i].max())\r\n print('mean NB', means[r < loglikeNB.shape[0]].mean())\r\n print('mean ZI', means[(r < 2 * loglikeNB.shape[0]) * (r > loglikeNB.shape[0])].mean())\r\n print('mean poisson', means[(r < 3 * loglikeNB.shape[0]) * (r > 2 * loglikeNB.shape[0])].mean())\r\n # print('mean ga', means[(r < 4 * llzi.shape[0]) * (r > 3 * llzi.shape[0])].mean())\r\n # print('mean Gaussian', means[r > 3 * loglikeNB.shape[0]].mean())\r\n print('model name, mean trips per model, LL/maxLL, N inf')\r\n for i in range(LL.shape[0]):\r\n print(l1[i], means[r == i].mean(), np.mean(np.ma.masked_invalid(LL[i, :])), np.sum(np.isinf(LL[i, :])))\r\n print(np.ma.corrcoef(np.ma.masked_invalid(LL[i, :]), means[:LL.shape[1]])[1, 0])\r\n plt.hist(r, bins=np.arange(-0.5, 3 * len(mods.names) + 1, 1))\r\n\r\n # l1.extend(list(map(lambda x: x + ' geo', mods.names)))\r\n # l1.extend(list(map(lambda x: x + ' G', mods.names)))\r\n plt.xticks(range(len(l1)), l1, rotation='vertical')\r\n plt.show()\r\n\r\n for m in mods.loglike:\r\n print(m)\r\n print(m[np.logical_not(np.isinf(m))].mean())","def logistic_loss(z):\n idx_pos = np.where(z >= 0.)\n idx_neg = np.where(z < 0.)\n res = np.empty(z.shape)\n res[idx_pos] = np.log(1. + np.exp(-z[idx_pos]))\n z_neg = z[idx_neg]\n res[idx_neg] = -z_neg + np.log(1. + np.exp(z_neg))\n return res","def nll_logprobs(self, input, target_idx):\n raise NotImplementedError()","def log_ess(log_weight):\n dim = 1 if log_weight.ndimension() == 2 else 0\n\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\n torch.logsumexp(2 * log_weight, dim=dim)","def log_inplace(a):","def entropy_(P):\n res = 0.0\n\n mask = P != 0.0 # avoid 0 in log\n f = lambda x: x*np.log2(x)\n # map-reduce strategy (likely to be more optimized than loops)\n temp = list(map(f, P[mask]))\n res = -np.sum(temp, dtype=float)\n return res","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n return np.log(proba)","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def log_transform(x, epsilon = 1e-4):\n if x.min() < 0: epsilon += np.abs(x.min())\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)","def loglike(store):\n nobs = store['yvec'].shape[0]\n calcweighted(store)\n store['regsampler'].update_yvec(store['yvectil'])\n store['regsampler'].update_xmat(store['xmattil'])\n return store['regsampler'].loglike(store['sigma'], store['beta'])","def log_probs(self):\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)","def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self._LL(self.endog, rate=lambda_)\n\n return -np.log(ll_output)","def log_prob(self, samples):\n return -0.5 * sum_except_batch(\n np.log(2 * np.pi) + self.logstd + \\\n tf.exp(-2 * self.logstd) * tf.square(samples - self.mean))","def compute_log_prob(self,params: ndarray) -> float:\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)","def lognormalize(x, temp = 1):\n if type(x) is list: x = np.array(x)\n\n x = x - np.max(x)\n # anneal\n xp = np.power(np.exp(x), temp)\n return xp / xp.sum()","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def log_prob(target_distribution, x0, xs, accepteds):\n return np.mean([target_distribution.log_probability(x) for x in xs])","def exp_mean_dense(x):\n # convert out of compressed sparse matrix\n return np.log((np.sum(np.exp(x)-1)/x.shape[1]) + 1)","def log_prob_from_logits(x):\n axis = len(x.shape) - 1\n m = x.max(dim=axis, keepdim=True)[0]\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))","def bernoulli_logpmf(X, p):\n return -T.nnet.binary_crossentropy(p, X).sum(axis=-1)","def gmmloglik(log_emlik, weights):\n gmm_loglik = np.mean(log_emlik)\n\n\n return gmm_loglik","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def compute_loglike(self, tools: ModelingTools) -> float:\n return -1.5","def logsum_safe(prob_ll, atl):\n logpdf = prob_ll + K.log(atl + K.epsilon())\n alpha = tf.reduce_max(logpdf, -1, keepdims=True)\n return alpha + tf.log(tf.reduce_sum(K.exp(logpdf-alpha), -1, keepdims=True) + K.epsilon())","def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\n word_list = sentence.split()\n log_prob = 0\n for i in range(len(word_list)-1):\n print(word_list[i], word_list[i+1])\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\n uni_count = LM['uni'][word_list[i]]\n if uni_count == 0 and smoothing:\n return float('-inf')\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\n return log_prob","def NLL(sample, params):\n mu = params[:,:,0]\n logsigma = params[:,:,1]\n \n c = normalization.to(mu.device)\n inv_sigma = torch.exp(-logsigma)\n tmp = (sample - mu) * inv_sigma\n return torch.mean(0.5 * (tmp * tmp + 2 * logsigma + c))","def weighted_log_loss(yt, yp) -> Any:\n from keras import backend as K\n\n pos_loss = -(0 + yt) * K.log(0 + yp + K.epsilon())\n neg_loss = -(1 - yt) * K.log(1 - yp + K.epsilon())\n\n return LOSS_BIAS * K.mean(neg_loss) + (1. - LOSS_BIAS) * K.mean(pos_loss)","def geo_mean(array):\n logsum = sum([np.log(each) for each in array])/len(array)\n return np.exp(logsum)","def prior_log_loss(frac_pos, task=BINARY_CLASSIFICATION):\n eps = 1e-15\n frac_pos_ = sp.maximum(eps, frac_pos)\n if task != MULTICLASS_CLASSIFICATION: # binary case\n frac_neg = 1 - frac_pos\n frac_neg_ = sp.maximum(eps, frac_neg)\n pos_class_log_loss_ = -frac_pos * np.log(frac_pos_)\n neg_class_log_loss_ = -frac_neg * np.log(frac_neg_)\n base_log_loss = pos_class_log_loss_ + neg_class_log_loss_\n # base_log_loss = mvmean(base_log_loss)\n # print('binary {}'.format(base_log_loss))\n # In the multilabel case, the right thing i to AVERAGE not sum\n # We return all the scores so we can normalize correctly later on\n else: # multiclass case\n fp = frac_pos_ / sum(\n frac_pos_\n ) # Need to renormalize the lines in multiclass case\n # Only ONE label is 1 in the multiclass case active for each line\n pos_class_log_loss_ = -frac_pos * np.log(fp)\n base_log_loss = np.sum(pos_class_log_loss_)\n return base_log_loss","def score_samples(self, x):\n n, dim = x.shape\n logp = np.log(self.mix_weight)\n logt = np.log(self.cond_proba.T + np.finfo(np.float64).eps)\n lijk = np.zeros((n, dim, self.ncomponents))\n\n x = canonize_labels(x)\n\n for i in range(dim):\n ndx = ~np.isnan(x[:, i])\n lijk[ndx, i] = logt[:, x[ndx, i], i].T\n logpz = logp + np.squeeze(np.sum(lijk, 1))\n\n logpz, ll = normalize_logspace(logpz)\n pz = np.exp(logpz)\n return pz, ll","def log_p(self,z):\n return log_p_posterior(z, self.neg_posterior)","def logp(self, x):\n pass","def log_p(self,z):\n return mb_log_p_posterior(z, self.neg_posterior, self.mini_batch)","def calc_probs(log_p):\n\n N = log_p.shape[0]\n\n log_Z_per_N = np.zeros(shape=(N, 1))\n\n for i in range(N):\n\n log_Z_per_N[i] = log_norm(log_p[i])\n\n log_p_new = log_p - log_Z_per_N\n\n p = np.exp(log_p_new)\n\n # log_Z = log_norm(log_p)\n\n # p = np.exp(log_p - log_Z)\n\n return p","def logloss_mc(y_true, y_prob, epsilon=1e-15):\n # normalize\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\n y_prob = np.maximum(epsilon, y_prob)\n y_prob = np.minimum(1 - epsilon, y_prob)\n # get probabilities\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\n ll = - np.mean(np.log(y))\n return ll","def smooth_loss(logits, labels, num_classes, eps):\n smoothed_one_hot = one_hot(labels.reshape(-1), num_classes)\n smoothed_one_hot = smoothed_one_hot * (1 - eps) + (1 - smoothed_one_hot) * eps / (num_classes - 1)\n log_prb = F.log_softmax(logits.reshape(-1, num_classes), dim=1)\n loss = -(smoothed_one_hot * log_prb).sum(dim=1)\n # print(\"loss:\", loss)\n loss = loss.mean()\n return loss","def compute_mean_logits(list_of_examples, label_vocab):\n mean_logits_list = []\n\n for possible_label in label_vocab.itos:\n logits_for_this_label = [example.logit for example in list_of_examples if example.predicted_label ==\n possible_label]\n\n mean_logits_list.append(np.mean(logits_for_this_label, axis=0))\n\n return mean_logits_list","def log_nse(self, epsilon=0.0) -> float:\n s, o = self.predicted + epsilon, self.true + epsilon # todo, check why s is here\n return float(1 - sum((np.log(o) - np.log(o)) ** 2) / sum((np.log(o) - np.mean(np.log(o))) ** 2))","def log2_inplace(a):","def log_normalize(a, axis=None):\n if axis is not None and a.shape[axis] == 1:\n # Handle single-state GMMHMM in the degenerate case normalizing a\n # single -inf to zero.\n a[:] = 0\n else:\n with np.errstate(under=\"ignore\"):\n a_lse = logsumexp(a, axis, keepdims=True)\n a -= a_lse","def compute_loss(a3, Y):\n\n m = Y.shape[1]\n # 对数似然函数 / 交叉熵损失函数\n logprobs = np.multiply(-np.log(a3), Y) + np.multiply(-np.log(1 - a3), 1 - Y)\n # 求均值\n loss = 1. / m * np.nansum(logprobs) # 将np.nan当作0来计算\n\n return loss","def log_prior_grad(self, inputs):","def get_log(p):\n if p==0:\n return 0.\n return p*np.log2(p)","def logpeak(x, p=default()):\n model = p[0] - p[1]*(x**2)\n return model","def generalized_mean(x, p, N):\n if p != 0:\n D = 1/(N)\n out = (D*sum(x**p))**(1/p)\n else:\n D = 1/(N)\n out = np.exp(D*sum(np.log(x)))\n return out","def forward(self, x):\n out = self.net(x)\n out = self.avg(out)\n out = out.view(out.size(0), -1)\n out = self.fc1(out)\n\n return func.log_softmax(out, dim=-1)","def log(self) -> np.ndarray:\n S = 0.5*(self.A-self.A.T) # Skew-symmetric matrix\n y = np.array([S[2, 1], -S[2, 0], S[1, 0]]) # Axis\n if np.allclose(np.zeros(3), y):\n return np.zeros(3)\n y2 = np.linalg.norm(y)\n return np.arcsin(y2)*y/y2","def msle(self, weights=None) -> float:\n return float(np.average((np.log1p(self.true) - np.log1p(self.predicted)) ** 2, axis=0, weights=weights))","def score_samples(self, x):\n n = x.shape[0]\n logp = np.log(self.mix_weight)\n logpz = np.zeros((n, self.ncomponents))\n\n for i in range(self.ncomponents):\n logpz[:, i] = logp[i] + multivariate_normal.logpdf(x, self.cond_proba.mean[i], self.cond_proba.cov[i])\n\n logpz, ll = normalize_logspace(logpz)\n pz = np.exp(logpz)\n return pz, ll","def theil(x, weights):\n assert numpy.all(x >= 0), \"negative numbers can't be used in Theil\"\n x_mean = numpy.average(x, weights=weights) + 1e-100\n normed = x / x_mean\n normed[normed < 1e-10] = 1e-10\n return numpy.average(normed * numpy.log(normed), weights=weights)","def neglogli(preds, actual):\n preds = np.reshape(preds, (-1,))\n nll = np.sum((preds - actual*np.log(preds + 1e-07) + np.log(sp.special.factorial(actual))))\n return nll","def logsumexp(p):\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20","def avg_transition_prob(line, log_prob_mat):\n res = [1.0, 0]\n bigrams = filter_chars(accepted_chars, ngrams(2, rev_counter(log_prob_mat, res))) \n for c in line: bigrams.send(c)\n # The exponentiation translates from log probs to probs.\n return math.exp(res[0] / (res[1] or 1))","def naivebayes(x,y,xtest,naivebayesPXY):\n pos, neg = naivebayesPY(x, y)\n posprob, negprob = naivebayesPXY(x, y)\n numerator = np.dot(xtest, np.log(posprob)) + np.log(pos)\n denominator = np.dot(xtest, np.log(negprob)) + np.log(neg)\n logratio = numerator - denominator\n return logratio","def agammln(xx):\r\n coeff = [76.18009173, -86.50532033, 24.01409822, -1.231739516,\r\n 0.120858003e-2, -0.536382e-5]\r\n x = xx - 1.0\r\n tmp = x + 5.5\r\n tmp = tmp - (x+0.5)*N.log(tmp)\r\n ser = 1.0\r\n for j in range(len(coeff)):\r\n x = x + 1\r\n ser = ser + coeff[j]/x\r\n return -tmp + N.log(2.50662827465*ser)","def compute_logistic_loss(y, tx, w):\n pred = tx.dot(w)\n y = np.asarray(y)\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\n\n return np.mean((1 - y) * pred - logsig)","def multiclass_log_loss(y_true, y_pred, eps=1e-15):\n predictions = np.clip(y_pred, eps, 1 - eps)\n\n # normalize row sums to 1\n predictions /= predictions.sum(axis=1)[:, np.newaxis]\n\n actual = np.zeros(y_pred.shape)\n rows = actual.shape[0]\n actual[np.arange(rows), y_true.astype(int)] = 1\n vsota = np.sum(actual * np.log(predictions))\n return -1.0 / rows * vsota","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in range(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def _get_acc(logits: torch.Tensor, target: torch.Tensor) -> torch.Tensor:\n predictions = logits > 0\n target_bool = target > 0.5\n return (predictions == target_bool).float().mean()","def score(self, beam, logprobs):\n l_term = (((5 + len(beam.next_ys)) ** self.alpha) /\n ((5 + 1) ** self.alpha))\n return (logprobs / l_term)","def log_prob_from_logits(x):\n axis = len(x.get_shape()) - 1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))","def log_prob_from_logits(x):\n axis = len(x.get_shape())-1\n m = tf.reduce_max(x, axis, keep_dims=True)\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))","def log10_inplace(a):","def log_noise_model(self, x, y, pflip):\n \n return np.log(pflip)*np.sum(x != y) + np.log(1.0-pflip)*np.sum(x == y)","def mean( x=10.**np.arange(2), log=False, **kwargs ):\n if log:\n return 10.**np.mean( np.log10( x ), **kwargs )\n else:\n return np.mean( x, **kwargs )","def exp_mean_sparse(x):\n # convert out of compressed sparse matrix\n return np.log((np.sum(x.expm1())/x.shape[1]) + 1)","def predict_log_proba(self, X):\n proba = self.predict_proba(X)\n\n if self.n_outputs_ == 1:\n return np.log(proba)\n\n else:\n for k in xrange(self.n_outputs_):\n proba[k] = np.log(proba[k])\n\n return proba","def log_m_probs(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n return self._prob_inverse_transform(m)","def streaming_log_perplexity():\n\n def perplexity_metric(losses, target_len):\n \"\"\"Calculates the mean log perplexity based on losses and target_len\"\"\"\n loss_mask = tf.sequence_mask(\n lengths=tf.to_int32(target_len - 1),\n maxlen=tf.to_int32(tf.shape(losses)[1]))\n return metrics.streaming_mean(losses, loss_mask)\n\n return metric_spec.MetricSpec(\n metric_fn=perplexity_metric,\n label_key=\"target_len\",\n prediction_key=\"losses\")","def normalize_log_likelihoods(X):\n h, w = np.shape(X)\n return X - np.tile(logsumexp(X, axis=0), (h, 1))\n # return X - np.matlib.repmat(logsumexp(X, axis=0), h, 1)","def gmmloglik(log_emlik, weights):\n N,_ = log_emlik.shape;\n ll = 0;\n for i in range(N):\n ll += logsumexp(log_emlik[i, :] + np.log(weights));\n return ll","def nloglikeobs(self, params):\n #print len(params),\n beta = params[:-2]\n df = params[-2]\n scale = params[-1]\n loc = np.dot(self.exog, beta)\n endog = self.endog\n x = (endog - loc)/scale\n #next part is stats.t._logpdf\n lPx = sps_gamln((df+1)/2) - sps_gamln(df/2.)\n lPx -= 0.5*np_log(df*np_pi) + (df+1)/2.*np_log(1+(x**2)/df)\n lPx -= np_log(scale) # correction for scale\n return -lPx","def score_samples(self, x):\n n = x.shape[0]\n logp = np.log(self.mix_weight)\n logpz = np.zeros((n, self.ncomponents))\n\n for i in range(self.ncomponents):\n logpz[:, i] = logp[i] + multivariate_student.logpdf(x, self.cond_proba.mean[i], self.cond_proba.cov[i],\n self.cond_proba.df)\n\n logpz, ll = normalize_logspace(logpz)\n pz = np.exp(logpz)\n return pz, ll","def log1p(x):\n return Log1p().apply((x,))[0]"],"string":"[\n \"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def mean_logprob(context, pos_lm):\\n logprobs = []\\n for tag in pos_lm.vocab:\\n logprob = pos_lm.logscore(tag,context)\\n if logprob != -float('inf'):\\n logprobs.append(logprob)\\n return np.mean(logprobs)\",\n \"def logloss(self,tple):\\n feats = self.dataset.input_features\\n res = 0\\n cc = self.class_counts\\n fc = self.feature_counts\\n for c in range(self.num_classes):\\n res += prod(fc[i][feat(tple)][c]\\n for (i,feat) in enumerate(feats))/(cc[c]**(len(feats)-1))\\n if res>0:\\n return -math.log2(res/len(self.dataset.train))\\n else:\\n return float(\\\"inf\\\") #infinity\",\n \"def log_loss(self):\\n probabilities = self.probability_array().copy()\\n # need to flip the probabilities for p < 0.5 with this binary case.\\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\\n probabilities[np.equal(0, self.y)] *= -1\\n probabilities[np.equal(0, self.y)] += 1\\n # when multiclass: np.amax(probabilities, 1)\\n return np.log(probabilities).sum()\",\n \"def _perplexity(self, X, log_w):\\n return np.exp(-log_w/X.sum())\",\n \"def log1p(x):\\n return 0.0\",\n \"def log_prob(self):\",\n \"def log_mae(labels, predictions):\\n\\n result = abs(labels - predictions)\\n result = reduce_mean(result)\\n result = log(result)\\n\\n return result\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def _log_linear_interpolation(predictions):\\n log_probs = utils.average_arrays([mx.nd.log(p) for p in predictions])\\n return -mx.nd.log(mx.nd.softmax(log_probs))\",\n \"def loglike(self, params, *args, **kwargs):\\n return np.sum(self.loglikeobs(params, *args, **kwargs))\",\n \"def compute_log_loss(predicted, actual, eps=1e-14):\\n predicted = np.clip(predicted, eps, 1 - eps)\\n loss = -1 * np.mean(actual * np.log(predicted)\\n + (1 - actual)\\n * np.log(1 - predicted))\\n\\n return loss\",\n \"def logloss(y, p):\\n\\n p[p < EPS] = EPS\\n p[p > 1 - EPS] = 1 - EPS\\n return log_loss(y, p)\",\n \"def logprob(predictions, labels):\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions)))\",\n \"def logprob(predictions, labels):\\n # prevent negative probability\\n predictions[predictions < 1e-10] = 1e-10\\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\",\n \"def log_p(self,z): \\n return np.array([self.log_p_blanket(i) for i in z])\",\n \"def log_probability(self, samples):\\n pass\",\n \"def log_mean_exp(x, dim):\\n return log_sum_exp(x, dim) - np.log(x.size(dim))\",\n \"def penalized_logp(mol):\\n # normalization constants, statistics from 250k_rndm_zinc_drugs_clean.smi\\n mol = to_mol(mol)\\n logP_mean = 2.4570953396190123\\n logP_std = 1.434324401111988\\n SA_mean = -3.0525811293166134\\n SA_std = 0.8335207024513095\\n cycle_mean = -0.0485696876403053\\n cycle_std = 0.2860212110245455\\n\\n log_p = logp(mol)\\n SA = -sa_score(mol)\\n\\n # cycle score\\n cycle_list = nx.cycle_basis(nx.Graph(\\n Chem.rdmolops.GetAdjacencyMatrix(mol)))\\n if len(cycle_list) == 0:\\n cycle_length = 0\\n else:\\n cycle_length = max([len(j) for j in cycle_list])\\n if cycle_length <= 6:\\n cycle_length = 0\\n else:\\n cycle_length = cycle_length - 6\\n cycle_score = -cycle_length\\n\\n normalized_log_p = (log_p - logP_mean) / logP_std\\n normalized_SA = (SA - SA_mean) / SA_std\\n normalized_cycle = (cycle_score - cycle_mean) / cycle_std\\n\\n return normalized_log_p + normalized_SA + normalized_cycle\",\n \"def multiclass_log_loss(y_true, y_pred, eps=1e-15):\\n clip = np.clip(y_pred, eps, 1 - eps)\\n actual = np.zeros(y_pred.shape)\\n rows = actual.shape[0]\\n print rows\\n print np.arange(rows)\\n print (y_true.astype(int))\\n actual[np.arange(rows), y_true.astype(int)] = 1\\n print actual\\n vsota = np.sum(actual * np.log(clip))\\n print vsota\\n return -1.0 / rows * vsota\",\n \"def mean(state, keepdims=True, is_log=False):\\n return mean_raw(state.particles, state.log_weights, keepdims, is_log)\",\n \"def logP(self):\\n raise NotImplementedError\",\n \"def log_filter(img, noData):\\n img1 = np.float64(img.copy())\\n img1 = sf.laplace( img1, mode='constant')\\n if np.sum(img<=noData) > 0 : #zero the filtered image at data-nodata boundaries\\n mask = np.float64(img.copy())\\n mask[:] = 1.\\n mask[img<=noData] = 0.0\\n mask=sf.laplace(mask, mode='constant')\\n img1[mask != 0.] = 0. # set the borders to zero\\n img1 = sf.gaussian_filter(img1, (1.4, 1.4), mode='constant')\\n return img1\",\n \"def log_loss(actual, predicted):\\n\\n predicted, actual = np.array(predicted), np.array(actual)\\n\\n small_value = 1e-15\\n predicted[predicted < small_value] = small_value\\n predicted[predicted > 1 - small_value] = 1. - small_value\\n return (-1. / len(actual)) * np.sum(\\n actual * np.log(predicted) + (1. - actual) * np.log(1. - predicted))\",\n \"def _update_logprobs(self):\\n #self._logp_src = self._log_lim(self.p_source)\\n self._logp_I0 = self._log_lim(self.p_source)\\n self._logp_R0 = self._log_lim(self.p_source/(self.p_rec_div))\\n self._logp_S_fin = self._log_lim(self.p_S_fin)\\n self._logp_inf_fin = self._log_lim(self.p_infect_fin)\",\n \"def analyse_loglike(test_data, mods):\\r\\n l1 = list(map(lambda x: x + ' NB', mods.names))\\r\\n l1.extend(list(map(lambda x: x + ' ZI', mods.names)))\\r\\n l1.extend(list(map(lambda x: x + ' P', mods.names)))\\r\\n loglikeNB = np.array(mods.compute_log_likelihood(test_data, 'NB'))\\r\\n loglikeZI = np.array(mods.compute_log_likelihood(test_data, 'ZI'))\\r\\n loglikeP = np.array(mods.compute_log_likelihood(test_data, 'P'))\\r\\n # loglikeG = np.array(mods.compute_log_likelihood_gaussian(test_data))\\r\\n # loglikegeo = np.array(mods.compute_log_likelihood_geom(test_data))\\r\\n LL = np.zeros((loglikeNB.shape[0] * 3, loglikeNB.shape[1]))\\r\\n LL[:loglikeNB.shape[0], :] = loglikeNB\\r\\n LL[loglikeNB.shape[0]:2 * loglikeNB.shape[0], :] = loglikeZI\\r\\n LL[2 * loglikeNB.shape[0]:3 * loglikeNB.shape[0], :] = loglikeP\\r\\n # LL[3 * loglikeNB.shape[0]:4 * loglikeNB.shape[0], :] = loglikeG\\r\\n # LL[4 * llzi.shape[0]:, :] = np.array(mods.loglikegeo)\\r\\n print('mean per model', list(zip(np.ma.masked_invalid(LL).sum(axis=1), map(lambda x: x.mod.name, mods.models))))\\r\\n print('mean per distrib')\\r\\n print(np.ma.masked_invalid(LL[:loglikeNB.shape[0], :]).mean())\\r\\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0]:loglikeNB.shape[0] * 2, :]).mean())\\r\\n print(np.ma.masked_invalid(LL[loglikeNB.shape[0] * 2:loglikeNB.shape[0] * 3, :]).mean())\\r\\n # print(np.nanmean(LL[1-np.isinf(LL)], axis=1))\\r\\n # print(np.nanmean(LL[LL != np.inf],axis=1))\\r\\n LL[np.isnan(LL)] = 0\\r\\n LL[np.isinf(LL)] = 0\\r\\n LL[LL == 0] = -np.inf\\r\\n r = np.argmax(LL, axis=0)\\r\\n # LL /= mx\\r\\n print('mean_best', np.mean(np.ma.masked_invalid(LL[r, range(LL.shape[1])])))\\r\\n mx = np.max(LL, axis=0)\\r\\n LL = LL / mx\\r\\n means = test_data.get_miniOD(None)[test_data.get_stations_col(None)].mean(axis=0).to_numpy()\\r\\n # for i in np.unique(r):\\r\\n # print(means[r == i].max())\\r\\n print('mean NB', means[r < loglikeNB.shape[0]].mean())\\r\\n print('mean ZI', means[(r < 2 * loglikeNB.shape[0]) * (r > loglikeNB.shape[0])].mean())\\r\\n print('mean poisson', means[(r < 3 * loglikeNB.shape[0]) * (r > 2 * loglikeNB.shape[0])].mean())\\r\\n # print('mean ga', means[(r < 4 * llzi.shape[0]) * (r > 3 * llzi.shape[0])].mean())\\r\\n # print('mean Gaussian', means[r > 3 * loglikeNB.shape[0]].mean())\\r\\n print('model name, mean trips per model, LL/maxLL, N inf')\\r\\n for i in range(LL.shape[0]):\\r\\n print(l1[i], means[r == i].mean(), np.mean(np.ma.masked_invalid(LL[i, :])), np.sum(np.isinf(LL[i, :])))\\r\\n print(np.ma.corrcoef(np.ma.masked_invalid(LL[i, :]), means[:LL.shape[1]])[1, 0])\\r\\n plt.hist(r, bins=np.arange(-0.5, 3 * len(mods.names) + 1, 1))\\r\\n\\r\\n # l1.extend(list(map(lambda x: x + ' geo', mods.names)))\\r\\n # l1.extend(list(map(lambda x: x + ' G', mods.names)))\\r\\n plt.xticks(range(len(l1)), l1, rotation='vertical')\\r\\n plt.show()\\r\\n\\r\\n for m in mods.loglike:\\r\\n print(m)\\r\\n print(m[np.logical_not(np.isinf(m))].mean())\",\n \"def logistic_loss(z):\\n idx_pos = np.where(z >= 0.)\\n idx_neg = np.where(z < 0.)\\n res = np.empty(z.shape)\\n res[idx_pos] = np.log(1. + np.exp(-z[idx_pos]))\\n z_neg = z[idx_neg]\\n res[idx_neg] = -z_neg + np.log(1. + np.exp(z_neg))\\n return res\",\n \"def nll_logprobs(self, input, target_idx):\\n raise NotImplementedError()\",\n \"def log_ess(log_weight):\\n dim = 1 if log_weight.ndimension() == 2 else 0\\n\\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\\\\n torch.logsumexp(2 * log_weight, dim=dim)\",\n \"def log_inplace(a):\",\n \"def entropy_(P):\\n res = 0.0\\n\\n mask = P != 0.0 # avoid 0 in log\\n f = lambda x: x*np.log2(x)\\n # map-reduce strategy (likely to be more optimized than loops)\\n temp = list(map(f, P[mask]))\\n res = -np.sum(temp, dtype=float)\\n return res\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n return np.log(proba)\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def log_transform(x, epsilon = 1e-4):\\n if x.min() < 0: epsilon += np.abs(x.min())\\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)\",\n \"def loglike(store):\\n nobs = store['yvec'].shape[0]\\n calcweighted(store)\\n store['regsampler'].update_yvec(store['yvectil'])\\n store['regsampler'].update_xmat(store['xmattil'])\\n return store['regsampler'].loglike(store['sigma'], store['beta'])\",\n \"def log_probs(self):\\n return np.array([m['log_probs'] for m in self.model_outs], dtype=np.float32)\",\n \"def nloglikeobs(self, params):\\n lambda_ = params[0]\\n\\n ll_output = self._LL(self.endog, rate=lambda_)\\n\\n return -np.log(ll_output)\",\n \"def log_prob(self, samples):\\n return -0.5 * sum_except_batch(\\n np.log(2 * np.pi) + self.logstd + \\\\\\n tf.exp(-2 * self.logstd) * tf.square(samples - self.mean))\",\n \"def compute_log_prob(self,params: ndarray) -> float:\\n return self.compute_log_prior(params) + self.compute_log_likelihood(params)\",\n \"def lognormalize(x, temp = 1):\\n if type(x) is list: x = np.array(x)\\n\\n x = x - np.max(x)\\n # anneal\\n xp = np.power(np.exp(x), temp)\\n return xp / xp.sum()\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def log_prob(target_distribution, x0, xs, accepteds):\\n return np.mean([target_distribution.log_probability(x) for x in xs])\",\n \"def exp_mean_dense(x):\\n # convert out of compressed sparse matrix\\n return np.log((np.sum(np.exp(x)-1)/x.shape[1]) + 1)\",\n \"def log_prob_from_logits(x):\\n axis = len(x.shape) - 1\\n m = x.max(dim=axis, keepdim=True)[0]\\n return x - m - torch.log(torch.exp(x - m).sum(dim=axis, keepdim=True))\",\n \"def bernoulli_logpmf(X, p):\\n return -T.nnet.binary_crossentropy(p, X).sum(axis=-1)\",\n \"def gmmloglik(log_emlik, weights):\\n gmm_loglik = np.mean(log_emlik)\\n\\n\\n return gmm_loglik\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def compute_loglike(self, tools: ModelingTools) -> float:\\n return -1.5\",\n \"def logsum_safe(prob_ll, atl):\\n logpdf = prob_ll + K.log(atl + K.epsilon())\\n alpha = tf.reduce_max(logpdf, -1, keepdims=True)\\n return alpha + tf.log(tf.reduce_sum(K.exp(logpdf-alpha), -1, keepdims=True) + K.epsilon())\",\n \"def log_prob(sentence, LM, smoothing=False, delta=0, vocabSize=0):\\n word_list = sentence.split()\\n log_prob = 0\\n for i in range(len(word_list)-1):\\n print(word_list[i], word_list[i+1])\\n bi_count = LM['bi'][word_list[i]][word_list[i+1]]\\n uni_count = LM['uni'][word_list[i]]\\n if uni_count == 0 and smoothing:\\n return float('-inf')\\n log_prob += log(((bi_count + delta)/(uni_count + delta * vocabSize)))\\n return log_prob\",\n \"def NLL(sample, params):\\n mu = params[:,:,0]\\n logsigma = params[:,:,1]\\n \\n c = normalization.to(mu.device)\\n inv_sigma = torch.exp(-logsigma)\\n tmp = (sample - mu) * inv_sigma\\n return torch.mean(0.5 * (tmp * tmp + 2 * logsigma + c))\",\n \"def weighted_log_loss(yt, yp) -> Any:\\n from keras import backend as K\\n\\n pos_loss = -(0 + yt) * K.log(0 + yp + K.epsilon())\\n neg_loss = -(1 - yt) * K.log(1 - yp + K.epsilon())\\n\\n return LOSS_BIAS * K.mean(neg_loss) + (1. - LOSS_BIAS) * K.mean(pos_loss)\",\n \"def geo_mean(array):\\n logsum = sum([np.log(each) for each in array])/len(array)\\n return np.exp(logsum)\",\n \"def prior_log_loss(frac_pos, task=BINARY_CLASSIFICATION):\\n eps = 1e-15\\n frac_pos_ = sp.maximum(eps, frac_pos)\\n if task != MULTICLASS_CLASSIFICATION: # binary case\\n frac_neg = 1 - frac_pos\\n frac_neg_ = sp.maximum(eps, frac_neg)\\n pos_class_log_loss_ = -frac_pos * np.log(frac_pos_)\\n neg_class_log_loss_ = -frac_neg * np.log(frac_neg_)\\n base_log_loss = pos_class_log_loss_ + neg_class_log_loss_\\n # base_log_loss = mvmean(base_log_loss)\\n # print('binary {}'.format(base_log_loss))\\n # In the multilabel case, the right thing i to AVERAGE not sum\\n # We return all the scores so we can normalize correctly later on\\n else: # multiclass case\\n fp = frac_pos_ / sum(\\n frac_pos_\\n ) # Need to renormalize the lines in multiclass case\\n # Only ONE label is 1 in the multiclass case active for each line\\n pos_class_log_loss_ = -frac_pos * np.log(fp)\\n base_log_loss = np.sum(pos_class_log_loss_)\\n return base_log_loss\",\n \"def score_samples(self, x):\\n n, dim = x.shape\\n logp = np.log(self.mix_weight)\\n logt = np.log(self.cond_proba.T + np.finfo(np.float64).eps)\\n lijk = np.zeros((n, dim, self.ncomponents))\\n\\n x = canonize_labels(x)\\n\\n for i in range(dim):\\n ndx = ~np.isnan(x[:, i])\\n lijk[ndx, i] = logt[:, x[ndx, i], i].T\\n logpz = logp + np.squeeze(np.sum(lijk, 1))\\n\\n logpz, ll = normalize_logspace(logpz)\\n pz = np.exp(logpz)\\n return pz, ll\",\n \"def log_p(self,z):\\n return log_p_posterior(z, self.neg_posterior)\",\n \"def logp(self, x):\\n pass\",\n \"def log_p(self,z):\\n return mb_log_p_posterior(z, self.neg_posterior, self.mini_batch)\",\n \"def calc_probs(log_p):\\n\\n N = log_p.shape[0]\\n\\n log_Z_per_N = np.zeros(shape=(N, 1))\\n\\n for i in range(N):\\n\\n log_Z_per_N[i] = log_norm(log_p[i])\\n\\n log_p_new = log_p - log_Z_per_N\\n\\n p = np.exp(log_p_new)\\n\\n # log_Z = log_norm(log_p)\\n\\n # p = np.exp(log_p - log_Z)\\n\\n return p\",\n \"def logloss_mc(y_true, y_prob, epsilon=1e-15):\\n # normalize\\n y_prob = y_prob / y_prob.sum(axis=1).reshape(-1, 1)\\n y_prob = np.maximum(epsilon, y_prob)\\n y_prob = np.minimum(1 - epsilon, y_prob)\\n # get probabilities\\n y = [y_prob[i, j] for (i, j) in enumerate(y_true)]\\n ll = - np.mean(np.log(y))\\n return ll\",\n \"def smooth_loss(logits, labels, num_classes, eps):\\n smoothed_one_hot = one_hot(labels.reshape(-1), num_classes)\\n smoothed_one_hot = smoothed_one_hot * (1 - eps) + (1 - smoothed_one_hot) * eps / (num_classes - 1)\\n log_prb = F.log_softmax(logits.reshape(-1, num_classes), dim=1)\\n loss = -(smoothed_one_hot * log_prb).sum(dim=1)\\n # print(\\\"loss:\\\", loss)\\n loss = loss.mean()\\n return loss\",\n \"def compute_mean_logits(list_of_examples, label_vocab):\\n mean_logits_list = []\\n\\n for possible_label in label_vocab.itos:\\n logits_for_this_label = [example.logit for example in list_of_examples if example.predicted_label ==\\n possible_label]\\n\\n mean_logits_list.append(np.mean(logits_for_this_label, axis=0))\\n\\n return mean_logits_list\",\n \"def log_nse(self, epsilon=0.0) -> float:\\n s, o = self.predicted + epsilon, self.true + epsilon # todo, check why s is here\\n return float(1 - sum((np.log(o) - np.log(o)) ** 2) / sum((np.log(o) - np.mean(np.log(o))) ** 2))\",\n \"def log2_inplace(a):\",\n \"def log_normalize(a, axis=None):\\n if axis is not None and a.shape[axis] == 1:\\n # Handle single-state GMMHMM in the degenerate case normalizing a\\n # single -inf to zero.\\n a[:] = 0\\n else:\\n with np.errstate(under=\\\"ignore\\\"):\\n a_lse = logsumexp(a, axis, keepdims=True)\\n a -= a_lse\",\n \"def compute_loss(a3, Y):\\n\\n m = Y.shape[1]\\n # 对数似然函数 / 交叉熵损失函数\\n logprobs = np.multiply(-np.log(a3), Y) + np.multiply(-np.log(1 - a3), 1 - Y)\\n # 求均值\\n loss = 1. / m * np.nansum(logprobs) # 将np.nan当作0来计算\\n\\n return loss\",\n \"def log_prior_grad(self, inputs):\",\n \"def get_log(p):\\n if p==0:\\n return 0.\\n return p*np.log2(p)\",\n \"def logpeak(x, p=default()):\\n model = p[0] - p[1]*(x**2)\\n return model\",\n \"def generalized_mean(x, p, N):\\n if p != 0:\\n D = 1/(N)\\n out = (D*sum(x**p))**(1/p)\\n else:\\n D = 1/(N)\\n out = np.exp(D*sum(np.log(x)))\\n return out\",\n \"def forward(self, x):\\n out = self.net(x)\\n out = self.avg(out)\\n out = out.view(out.size(0), -1)\\n out = self.fc1(out)\\n\\n return func.log_softmax(out, dim=-1)\",\n \"def log(self) -> np.ndarray:\\n S = 0.5*(self.A-self.A.T) # Skew-symmetric matrix\\n y = np.array([S[2, 1], -S[2, 0], S[1, 0]]) # Axis\\n if np.allclose(np.zeros(3), y):\\n return np.zeros(3)\\n y2 = np.linalg.norm(y)\\n return np.arcsin(y2)*y/y2\",\n \"def msle(self, weights=None) -> float:\\n return float(np.average((np.log1p(self.true) - np.log1p(self.predicted)) ** 2, axis=0, weights=weights))\",\n \"def score_samples(self, x):\\n n = x.shape[0]\\n logp = np.log(self.mix_weight)\\n logpz = np.zeros((n, self.ncomponents))\\n\\n for i in range(self.ncomponents):\\n logpz[:, i] = logp[i] + multivariate_normal.logpdf(x, self.cond_proba.mean[i], self.cond_proba.cov[i])\\n\\n logpz, ll = normalize_logspace(logpz)\\n pz = np.exp(logpz)\\n return pz, ll\",\n \"def theil(x, weights):\\n assert numpy.all(x >= 0), \\\"negative numbers can't be used in Theil\\\"\\n x_mean = numpy.average(x, weights=weights) + 1e-100\\n normed = x / x_mean\\n normed[normed < 1e-10] = 1e-10\\n return numpy.average(normed * numpy.log(normed), weights=weights)\",\n \"def neglogli(preds, actual):\\n preds = np.reshape(preds, (-1,))\\n nll = np.sum((preds - actual*np.log(preds + 1e-07) + np.log(sp.special.factorial(actual))))\\n return nll\",\n \"def logsumexp(p):\\n return scipy.misc.logsumexp(p) if (len(p) > 0) else -1e20\",\n \"def avg_transition_prob(line, log_prob_mat):\\n res = [1.0, 0]\\n bigrams = filter_chars(accepted_chars, ngrams(2, rev_counter(log_prob_mat, res))) \\n for c in line: bigrams.send(c)\\n # The exponentiation translates from log probs to probs.\\n return math.exp(res[0] / (res[1] or 1))\",\n \"def naivebayes(x,y,xtest,naivebayesPXY):\\n pos, neg = naivebayesPY(x, y)\\n posprob, negprob = naivebayesPXY(x, y)\\n numerator = np.dot(xtest, np.log(posprob)) + np.log(pos)\\n denominator = np.dot(xtest, np.log(negprob)) + np.log(neg)\\n logratio = numerator - denominator\\n return logratio\",\n \"def agammln(xx):\\r\\n coeff = [76.18009173, -86.50532033, 24.01409822, -1.231739516,\\r\\n 0.120858003e-2, -0.536382e-5]\\r\\n x = xx - 1.0\\r\\n tmp = x + 5.5\\r\\n tmp = tmp - (x+0.5)*N.log(tmp)\\r\\n ser = 1.0\\r\\n for j in range(len(coeff)):\\r\\n x = x + 1\\r\\n ser = ser + coeff[j]/x\\r\\n return -tmp + N.log(2.50662827465*ser)\",\n \"def compute_logistic_loss(y, tx, w):\\n pred = tx.dot(w)\\n y = np.asarray(y)\\n logsig = -np.logaddexp(0, -pred) # == np.log(sigmoid(pred))\\n\\n return np.mean((1 - y) * pred - logsig)\",\n \"def multiclass_log_loss(y_true, y_pred, eps=1e-15):\\n predictions = np.clip(y_pred, eps, 1 - eps)\\n\\n # normalize row sums to 1\\n predictions /= predictions.sum(axis=1)[:, np.newaxis]\\n\\n actual = np.zeros(y_pred.shape)\\n rows = actual.shape[0]\\n actual[np.arange(rows), y_true.astype(int)] = 1\\n vsota = np.sum(actual * np.log(predictions))\\n return -1.0 / rows * vsota\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in range(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def _get_acc(logits: torch.Tensor, target: torch.Tensor) -> torch.Tensor:\\n predictions = logits > 0\\n target_bool = target > 0.5\\n return (predictions == target_bool).float().mean()\",\n \"def score(self, beam, logprobs):\\n l_term = (((5 + len(beam.next_ys)) ** self.alpha) /\\n ((5 + 1) ** self.alpha))\\n return (logprobs / l_term)\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape()) - 1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x - m), axis, keep_dims=True))\",\n \"def log_prob_from_logits(x):\\n axis = len(x.get_shape())-1\\n m = tf.reduce_max(x, axis, keep_dims=True)\\n return x - m - tf.log(tf.reduce_sum(tf.exp(x-m), axis, keep_dims=True))\",\n \"def log10_inplace(a):\",\n \"def log_noise_model(self, x, y, pflip):\\n \\n return np.log(pflip)*np.sum(x != y) + np.log(1.0-pflip)*np.sum(x == y)\",\n \"def mean( x=10.**np.arange(2), log=False, **kwargs ):\\n if log:\\n return 10.**np.mean( np.log10( x ), **kwargs )\\n else:\\n return np.mean( x, **kwargs )\",\n \"def exp_mean_sparse(x):\\n # convert out of compressed sparse matrix\\n return np.log((np.sum(x.expm1())/x.shape[1]) + 1)\",\n \"def predict_log_proba(self, X):\\n proba = self.predict_proba(X)\\n\\n if self.n_outputs_ == 1:\\n return np.log(proba)\\n\\n else:\\n for k in xrange(self.n_outputs_):\\n proba[k] = np.log(proba[k])\\n\\n return proba\",\n \"def log_m_probs(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n return self._prob_inverse_transform(m)\",\n \"def streaming_log_perplexity():\\n\\n def perplexity_metric(losses, target_len):\\n \\\"\\\"\\\"Calculates the mean log perplexity based on losses and target_len\\\"\\\"\\\"\\n loss_mask = tf.sequence_mask(\\n lengths=tf.to_int32(target_len - 1),\\n maxlen=tf.to_int32(tf.shape(losses)[1]))\\n return metrics.streaming_mean(losses, loss_mask)\\n\\n return metric_spec.MetricSpec(\\n metric_fn=perplexity_metric,\\n label_key=\\\"target_len\\\",\\n prediction_key=\\\"losses\\\")\",\n \"def normalize_log_likelihoods(X):\\n h, w = np.shape(X)\\n return X - np.tile(logsumexp(X, axis=0), (h, 1))\\n # return X - np.matlib.repmat(logsumexp(X, axis=0), h, 1)\",\n \"def gmmloglik(log_emlik, weights):\\n N,_ = log_emlik.shape;\\n ll = 0;\\n for i in range(N):\\n ll += logsumexp(log_emlik[i, :] + np.log(weights));\\n return ll\",\n \"def nloglikeobs(self, params):\\n #print len(params),\\n beta = params[:-2]\\n df = params[-2]\\n scale = params[-1]\\n loc = np.dot(self.exog, beta)\\n endog = self.endog\\n x = (endog - loc)/scale\\n #next part is stats.t._logpdf\\n lPx = sps_gamln((df+1)/2) - sps_gamln(df/2.)\\n lPx -= 0.5*np_log(df*np_pi) + (df+1)/2.*np_log(1+(x**2)/df)\\n lPx -= np_log(scale) # correction for scale\\n return -lPx\",\n \"def score_samples(self, x):\\n n = x.shape[0]\\n logp = np.log(self.mix_weight)\\n logpz = np.zeros((n, self.ncomponents))\\n\\n for i in range(self.ncomponents):\\n logpz[:, i] = logp[i] + multivariate_student.logpdf(x, self.cond_proba.mean[i], self.cond_proba.cov[i],\\n self.cond_proba.df)\\n\\n logpz, ll = normalize_logspace(logpz)\\n pz = np.exp(logpz)\\n return pz, ll\",\n \"def log1p(x):\\n return Log1p().apply((x,))[0]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66184866","0.6430783","0.64092505","0.6403149","0.63637125","0.6289191","0.62084115","0.61952806","0.6139312","0.6139312","0.6114071","0.60729593","0.6072521","0.60281146","0.6023515","0.60105234","0.59943175","0.5982887","0.59648985","0.59572244","0.5932306","0.5930485","0.592026","0.5902931","0.58889234","0.5886228","0.58783466","0.5867387","0.58623886","0.5859228","0.58572215","0.5855353","0.58199495","0.58154047","0.5805192","0.5801992","0.57956916","0.57928765","0.5790824","0.57906336","0.578168","0.5768322","0.57568324","0.5753954","0.5749796","0.57392395","0.5736648","0.5732404","0.5724711","0.5723316","0.5719224","0.5711681","0.5711539","0.570469","0.5703902","0.5695499","0.5693244","0.5692996","0.5685937","0.5681507","0.5678791","0.56745887","0.5672525","0.5670904","0.56621754","0.56610227","0.56579715","0.56512755","0.5649021","0.5647596","0.56465906","0.56450844","0.5639546","0.5632086","0.5631534","0.56205136","0.5618545","0.56174386","0.5617267","0.5616615","0.5614738","0.56140333","0.5609312","0.5607995","0.56058896","0.56052774","0.56031275","0.55945337","0.5594191","0.55938804","0.55902934","0.5586762","0.55855554","0.5584686","0.5584152","0.55834025","0.5579024","0.55749863","0.5573464","0.556326"],"string":"[\n \"0.66184866\",\n \"0.6430783\",\n \"0.64092505\",\n \"0.6403149\",\n \"0.63637125\",\n \"0.6289191\",\n \"0.62084115\",\n \"0.61952806\",\n \"0.6139312\",\n \"0.6139312\",\n \"0.6114071\",\n \"0.60729593\",\n \"0.6072521\",\n \"0.60281146\",\n \"0.6023515\",\n \"0.60105234\",\n \"0.59943175\",\n \"0.5982887\",\n \"0.59648985\",\n \"0.59572244\",\n \"0.5932306\",\n \"0.5930485\",\n \"0.592026\",\n \"0.5902931\",\n \"0.58889234\",\n \"0.5886228\",\n \"0.58783466\",\n \"0.5867387\",\n \"0.58623886\",\n \"0.5859228\",\n \"0.58572215\",\n \"0.5855353\",\n \"0.58199495\",\n \"0.58154047\",\n \"0.5805192\",\n \"0.5801992\",\n \"0.57956916\",\n \"0.57928765\",\n \"0.5790824\",\n \"0.57906336\",\n \"0.578168\",\n \"0.5768322\",\n \"0.57568324\",\n \"0.5753954\",\n \"0.5749796\",\n \"0.57392395\",\n \"0.5736648\",\n \"0.5732404\",\n \"0.5724711\",\n \"0.5723316\",\n \"0.5719224\",\n \"0.5711681\",\n \"0.5711539\",\n \"0.570469\",\n \"0.5703902\",\n \"0.5695499\",\n \"0.5693244\",\n \"0.5692996\",\n \"0.5685937\",\n \"0.5681507\",\n \"0.5678791\",\n \"0.56745887\",\n \"0.5672525\",\n \"0.5670904\",\n \"0.56621754\",\n \"0.56610227\",\n \"0.56579715\",\n \"0.56512755\",\n \"0.5649021\",\n \"0.5647596\",\n \"0.56465906\",\n \"0.56450844\",\n \"0.5639546\",\n \"0.5632086\",\n \"0.5631534\",\n \"0.56205136\",\n \"0.5618545\",\n \"0.56174386\",\n \"0.5617267\",\n \"0.5616615\",\n \"0.5614738\",\n \"0.56140333\",\n \"0.5609312\",\n \"0.5607995\",\n \"0.56058896\",\n \"0.56052774\",\n \"0.56031275\",\n \"0.55945337\",\n \"0.5594191\",\n \"0.55938804\",\n \"0.55902934\",\n \"0.5586762\",\n \"0.55855554\",\n \"0.5584686\",\n \"0.5584152\",\n \"0.55834025\",\n \"0.5579024\",\n \"0.55749863\",\n \"0.5573464\",\n \"0.556326\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5679914"},"document_rank":{"kind":"string","value":"60"}}},{"rowIdx":85166,"cells":{"query":{"kind":"string","value":"Approximate BLEU score computation between labels and predictions. An approximate BLEU scoring method since we do not glue word pieces or decode the ids and tokenize the output. By default, we use ngram order of 4 and use brevity penalty. Also, this does not have beam search."},"document":{"kind":"string","value":"def bleu_score(logits, labels):\n predictions = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)\n # TODO: Look into removing use of py_func\n bleu = tf.compat.v1.py_func(compute_bleu, (labels, predictions), tf.float32)\n return bleu, tf.constant(1.0)"},"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 score(self, target_text, prediction_text):\n bleu_score = sacrebleu.corpus_bleu([prediction_text], [[target_text]],\n smooth_method=\"exp\",\n smooth_value=0.0,\n force=False,\n lowercase=False,\n tokenize=\"intl\",\n use_effective_order=False)\n return {\"bleu\": BleuScore(bleu_score.score)}","def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n if smooth:\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\n bleu = brevity_penalty * geometric_mean\n return bleu","def _bleu_score_update(\n preds: Sequence[str],\n target: Sequence[Sequence[str]],\n numerator: Tensor,\n denominator: Tensor,\n preds_len: Tensor,\n target_len: Tensor,\n n_gram: int = 4,\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\n) -> Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\n\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n\n ngram_counter_clip = preds_counter & target_counter\n\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n\n return preds_len, target_len","def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n ngram_counter_clip = preds_counter & target_counter\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n return preds_len, target_len","def bleu_score(\n preds: Union[str, Sequence[str]],\n target: Sequence[Union[str, Sequence[str]]],\n n_gram: int = 4,\n smooth: bool = False,\n weights: Optional[Sequence[float]] = None,\n) -> Tensor:\n preds_ = [preds] if isinstance(preds, str) else preds\n target_ = [[tgt] if isinstance(tgt, str) else tgt for tgt in target]\n\n if len(preds_) != len(target_):\n raise ValueError(f\"Corpus has different size {len(preds_)} != {len(target_)}\")\n\n if weights is not None and len(weights) != n_gram:\n raise ValueError(f\"List of weights has different weights than `n_gram`: {len(weights)} != {n_gram}\")\n if weights is None:\n weights = [1.0 / n_gram] * n_gram\n\n numerator = torch.zeros(n_gram)\n denominator = torch.zeros(n_gram)\n preds_len = tensor(0.0)\n target_len = tensor(0.0)\n\n preds_len, target_len = _bleu_score_update(\n preds_, target_, numerator, denominator, preds_len, target_len, n_gram, _tokenize_fn\n )\n\n return _bleu_score_compute(preds_len, target_len, numerator, denominator, n_gram, weights, smooth)","def _bleu_score_compute(\n preds_len: Tensor,\n target_len: Tensor,\n numerator: Tensor,\n denominator: Tensor,\n n_gram: int,\n weights: Sequence[float],\n smooth: bool,\n) -> Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n\n if smooth:\n precision_scores = torch.div(\n torch.add(numerator, torch.ones(n_gram, device=device)),\n torch.add(denominator, torch.ones(n_gram, device=device)),\n )\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\n return brevity_penalty * geometric_mean","def calculate_bleu(output_lns, refs_lns):\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)","def bleu_score(references, generated, n_gram=4, smooth=False):\r\n formatted_ref = [[ref] for ref in references]\r\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\r\n return bleu_s * 100","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\n best_f_score = tensor(0.0)\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n for target in targets:\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\n if f_score > best_f_score:\n best_f_score = f_score\n best_matching_char_n_grams = matching_char_n_grams\n best_matching_word_n_grams = matching_word_n_grams\n best_target_char_n_grams = target_char_n_grams\n best_target_word_n_grams = target_word_n_grams\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams","def recognize_ngram(models: dict, test_set: SinglesData,probs,BIC_guesses):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n probabilities = []\n guesses = []\n\n model = arpa.loadf(\"devel-lm-M3.sri.lm\")\n lm = model[0] # ARPA files may contain several models.\n # TODO implement the recognizer\n # return probabilities, guesses\n test_sequences = list(test_set.get_all_Xlengths().values())\n word_keys = list(test_set.get_all_Xlengths().keys())\n i = -1 \n for sentence in test_set.sentences_index.values():\n f = {}\n maxs = float(\"-inf\")\n prob = []\n words = []\n\n sentenceLength = 0\n for word_index in sentence:\n i+=1\n word = test_set.wordlist[word_index]\n sentenceLength+=1\n try:\n f[word] = probs[word][i]\n except:\n f[word] = float(\"-inf\")\n prob.append(f[word]) ## These are Just the probabilities unchanged from the BIC recognizer.\n \n # Find Six most probable words and generate the possible permutations \n sixwords = sorted(f,key=f.get,reverse=True)[:6]\n for k in permutations(sixwords, r=sentenceLength):\n l = 0\n for j in range(len(k)):\n l += f[k[j]]\n try:\n sentenceLP = l + 13*lm.log_s(\" \".join(k)) ## According to one student in the forum 13 is the best hyperparameter\n if sentenceLP > maxs: ## https://discussions.udacity.com/t/slm-data-for-this-asl-dataset/230822/8?u=spiros\n sentence = \" \".join(k)\n maxs = sentenceLP\n words = list(k)\n except:\n pass\n\n if(words == []):\n words = BIC_guesses[len(guesses):len(guesses)+sentenceLength] ## Fall back to BIC guesses\n probabilities.append(prob) \n guesses += words\n return (probabilities,guesses)","def _score_ngrams(target_ngrams, prediction_ngrams):\n\n intersection_ngrams_count = 0\n for ngram in six.iterkeys(target_ngrams):\n intersection_ngrams_count += min(target_ngrams[ngram],\n prediction_ngrams[ngram])\n target_ngrams_count = sum(target_ngrams.values())\n prediction_ngrams_count = sum(prediction_ngrams.values())\n\n precision = intersection_ngrams_count / max(prediction_ngrams_count, 1)\n recall = intersection_ngrams_count / max(target_ngrams_count, 1)\n fmeasure = scoring.fmeasure(precision, recall)\n\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)","def evaluate_bleu_score(cls, predictions, targets, ticks=False, corpus=True):\n if ticks:\n ref_sentences = cls._ticks_to_sentences(targets)\n cand_sentences = cls._ticks_to_sentences(predictions)\n else:\n ref_sentences = [[str(x) for x in seq] for seq in predictions]\n cand_sentences = [[str(x) for x in seq] for seq in targets]\n\n if corpus: bleu_score = corpus_bleu([[l] for l in ref_sentences], cand_sentences)\n else:\n bleu_score = 0.0\n num_sentences = 0\n\n for i in tqdm(range(len(ref_sentences))):\n sentence_bleu_score = sentence_bleu(ref_sentences[i], cand_sentences[i])\n print(sentence_bleu_score)\n bleu_score += sentence_bleu_score\n num_sentences += 1\n\n bleu_score /= num_sentences\n\n return bleu_score","def computeErrorRate(test_set, words_likely_tags):\n # initiate vars\n known_words = {} # those two dictionaries are optional, just for debuging\n unknown_words = {} # those two dictionaries are optional, just for debuging\n correct_predictions = 0\n total_predictions = 0\n correct_unknown_predictions = 0\n total_unknown_predictions = 0\n\n for i in range(len(test_set)): # iterate sentences\n test_sent = test_set[i]\n for j in range(len(test_sent)): # iterate words in sent\n w = test_sent[j][WORD]\n t = test_sent[j][TAG]\n\n # known words\n if w in words_likely_tags:\n if w in known_words:\n known_words[w][COUNTER_SHOWS] += 1\n if t == words_likely_tags[w]: # same tag\n known_words[w][COUNTER_EQUAL] += 1\n correct_predictions += 1\n else:\n if t == words_likely_tags[w]: # same tag\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_predictions += 1\n else:\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_predictions += 1\n # unknown words\n else: # w not in words_likely_tags, treat w as unknown_word\n if w in unknown_words:\n unknown_words[w][COUNTER_SHOWS] += 1\n if t == UNKNOWN_TAG:\n # same tag as our model predicts for unknown words\n unknown_words[w][COUNTER_EQUAL] += 1\n correct_unknown_predictions += 1\n else:\n if t == UNKNOWN_TAG: # same tag\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_unknown_predictions += 1\n else:\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_unknown_predictions += 1\n\n # print('correct_predictions......... = ', correct_predictions)\n # print('total_predictions........... = ', total_predictions)\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\n # print('total_unknown_predictions... = ', total_unknown_predictions)\n err_rate_known = 1 - correct_predictions/total_predictions\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\n # total_err = err_rate_known + err_rate_unknown\n tot_pred = total_predictions + total_unknown_predictions\n corr_pred = correct_predictions + correct_unknown_predictions\n total_err = 1 - corr_pred/tot_pred\n\n return err_rate_known, err_rate_unknown, total_err","def compute_bleu(reference_corpus, translation_corpus, max_order=4,\n use_bp=True):\n reference_length = 0\n translation_length = 0\n bp = 1.0\n geo_mean = 0\n\n matches_by_order = [0] * max_order\n possible_matches_by_order = [0] * max_order\n precisions = []\n\n for (references, translations) in zip(reference_corpus, translation_corpus):\n reference_length += len(references)\n translation_length += len(translations)\n ref_ngram_counts = _get_ngrams_with_counter(references, max_order)\n translation_ngram_counts = _get_ngrams_with_counter(translations, max_order)\n\n overlap = dict((ngram,\n min(count, translation_ngram_counts[ngram]))\n for ngram, count in ref_ngram_counts.items())\n\n for ngram in overlap:\n matches_by_order[len(ngram) - 1] += overlap[ngram]\n for ngram in translation_ngram_counts:\n possible_matches_by_order[len(ngram) - 1] += translation_ngram_counts[\n ngram]\n\n precisions = [0] * max_order\n smooth = 1.0\n\n for i in xrange(0, max_order):\n if possible_matches_by_order[i] > 0:\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[i]\n if matches_by_order[i] > 0:\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[\n i]\n else:\n smooth *= 2\n precisions[i] = 1.0 / (smooth * possible_matches_by_order[i])\n else:\n precisions[i] = 0.0\n\n if max(precisions) > 0:\n p_log_sum = sum(math.log(p) for p in precisions if p)\n geo_mean = math.exp(p_log_sum / max_order)\n\n if use_bp:\n ratio = translation_length / reference_length\n bp = math.exp(1 - 1. / ratio) if ratio < 1.0 else 1.0\n bleu = geo_mean * bp\n return np.float32(bleu)","def compute_bleu(correct: List[int],\n total: List[int],\n sys_len: int,\n ref_len: int,\n smooth_method = 'none',\n smooth_value = None,\n use_effective_order = False) -> BLEU:\n if smooth_method in SMOOTH_VALUE_DEFAULT and smooth_value is None:\n smooth_value = SMOOTH_VALUE_DEFAULT[smooth_method]\n\n precisions = [0 for x in range(NGRAM_ORDER)]\n\n smooth_mteval = 1.\n effective_order = NGRAM_ORDER\n for n in range(1, NGRAM_ORDER + 1):\n if smooth_method == 'add-k' and n > 1:\n correct[n-1] += smooth_value\n total[n-1] += smooth_value\n if total[n-1] == 0:\n break\n\n if use_effective_order:\n effective_order = n\n\n if correct[n-1] == 0:\n if smooth_method == 'exp':\n smooth_mteval *= 2\n precisions[n-1] = 100. / (smooth_mteval * total[n-1])\n elif smooth_method == 'floor':\n precisions[n-1] = 100. * smooth_value / total[n-1]\n else:\n precisions[n-1] = 100. * correct[n-1] / total[n-1]\n\n # If the system guesses no i-grams, 1 <= i <= NGRAM_ORDER, the BLEU score is 0 (technically undefined).\n # This is a problem for sentence-level BLEU or a corpus of short sentences, where systems will get no credit\n # if sentence lengths fall under the NGRAM_ORDER threshold. This fix scales NGRAM_ORDER to the observed\n # maximum order. It is only available through the API and off by default\n\n brevity_penalty = 1.0\n if sys_len < ref_len:\n brevity_penalty = math.exp(1 - ref_len / sys_len) if sys_len > 0 else 0.0\n\n score = brevity_penalty * math.exp(sum(map(my_log, precisions[:effective_order])) / effective_order)\n\n return BLEU(score, correct, total, precisions, brevity_penalty, sys_len, ref_len)","def eval_metrics_for_seqtags(self, predicted_answers):\n total_correct_in_all = 0\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids, include padding ids.\n correct_label_indices = sample['correct_seq_labels']\n # use extend to add all the labels in the seq, include the head padding and tail padding\n label_true.extend(correct_label_indices)\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n label_pred.extend(sample['pred_seq_tags'])\n\n if total_correct_in_all != 0:\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\n title='Confusion matrix when seq labeling, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\n title='Normalized confusion matrix when seq labeling')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def prediction_processing(predictions, labels, threshold, step_nb):\n new_labels = []\n new_predictions = []\n number_sequences = step_nb//50\n\n for k in range(len(labels)//number_sequences):\n total_prediction = 0\n isLabelTrue = labels[number_sequences*k]\n for i in range(number_sequences):\n total_prediction += (1/predictions[number_sequences*k+i])\n if not(isLabelTrue == (labels[number_sequences*k+i])):\n logger.error('Problem.')\n if total_prediction > threshold:\n total_prediction = False\n else:\n total_prediction = True\n new_labels.append(isLabelTrue)\n new_predictions.append(total_prediction)\n\n recall_1 = recall_score(new_labels, new_predictions)\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\n precision_1 = precision_score(new_labels, new_predictions)\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)","def predict(self, test_vectors):\n # Calculate the best matching label for each node\n if not self.ready_for_prediction:\n # totals = sum((node.labels for node in self.codebook), Counter())\n for node in self.codebook:\n # Remove unlabeled hits\n try:\n node.labels.pop(None)\n except KeyError:\n pass\n # # Take into account small clusters. A frequency approach\n # freq_counter = Counter({label: count / totals[label]\n # for label, count in node.labels.items()})\n # if len(freq_counter) > 0:\n # node.label = freq_counter.most_common(1)[0][0]\n # else:\n # node.label = ''\n # Or ignore small clusters and just aim for accuracy\n if len(node.labels) > 0:\n node.label = node.labels.most_common(1)[0][0]\n else:\n node.label = ''\n self.ready_for_prediction = True\n\n # Return the label of the best matching unit for the given test_vectors\n if isinstance(test_vectors, collections.Iterable):\n return [self.bmu(test_vector).label for test_vector in test_vectors]\n else:\n return self.bmu(test_vectors).label","def score_sequence(seq, ngramlogprobs):\n return","def predictability(self):\n temp = self.probs\n for n in range(10):\n temp = temp.dot(temp)\n final = temp[0,:]\n #Let's assume that all words have unique initial letters\n probs = map(len, self.words)\n probs = array(probs)\n probs = (probs + self.probs.max(1)-1)/probs\n return sum(final*probs)","def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12","def compute_blue_ngram(x1_list,x2_list):\r\n count_dict={}\r\n count_dict_clip={}\r\n #1. count for each token at predict sentence side.\r\n for token in x1_list:\r\n if token not in count_dict:\r\n count_dict[token]=1\r\n else:\r\n count_dict[token]=count_dict[token]+1\r\n count=np.sum([value for key,value in count_dict.items()])\r\n\r\n #2.count for tokens existing in predict sentence for target sentence side.\r\n for token in x2_list:\r\n if token in count_dict:\r\n if token not in count_dict_clip:\r\n count_dict_clip[token]=1\r\n else:\r\n count_dict_clip[token]=count_dict_clip[token]+1\r\n\r\n #3. clip value to ceiling value for that token\r\n count_dict_clip={key:(value if value<=count_dict[key] else count_dict[key]) for key,value in count_dict_clip.items()}\r\n count_clip=np.sum([value for key,value in count_dict_clip.items()])\r\n result=float(count_clip)/(float(count)+0.00000001)\r\n return result","def classify(texts: List[str], params: Any) -> List[str]:\n\n alpha = 1\n token_probs_pos = params[\"token_probs_pos\"]\n token_probs_neg = params[\"token_probs_neg\"]\n all_words = params[\"all_words\"]\n M = len(all_words)\n cnt_pos_docs = params[\"cnt_pos_docs\"]\n cnt_neg_docs = params[\"cnt_neg_docs\"]\n\n sum_len_neg = params[\"sum_len_neg\"]\n sum_len_pos = params[\"sum_len_pos\"]\n pos_dict = params[\"pos_dict\"]\n neg_dict = params[\"neg_dict\"]\n\n\n test_texts = preprocessing(texts)\n test_tokenized_texts = text_to_tokens(test_texts)\n \n res = []\n log_pos_probablity = 0\n log_neg_probablity = 0\n i = 0\n for text in test_tokenized_texts:\n if (i % 5000 == 0):\n print(\"Classified\", i, \"texts\")\n i += 1\n log_pos_probablity = log(cnt_pos_docs)\n log_neg_probablity = log(cnt_neg_docs)\n for token in text:\n if (token_probs_pos[token] == 0):\n token_probs_pos[token] = alpha / (alpha * M + sum_len_pos)\n else:\n log_pos_probablity += log(token_probs_pos[token])\n if (token_probs_neg[token] == 0):\n token_probs_neg[token] = alpha / (alpha * M + sum_len_neg)\n else:\n log_neg_probablity += log(token_probs_neg[token])\n if (log_neg_probablity > log_pos_probablity):\n res.append(\"neg\")\n #for token in text:\n # all_words.add(token)\n # M = len(all_words)\n # neg_dict[token] += text[token]\n # sum_len_neg += text[token]\n # token_probs_neg[token] = (alpha + neg_dict[token]) / (alpha * M + sum_len_neg)\n\n else:\n res.append(\"pos\")\n #for token in text:\n # all_words.add(token)\n # M = len(all_words)\n # pos_dict[token] += text[token]\n # sum_len_pos += text[token]\n # token_probs_pos[token] = (alpha + pos_dict[token]) / (alpha * M + sum_len_pos)\n\n\n \n print('Predicted labels counts:')\n print(count_labels(res))\n return res","def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\n \"missing keys: {}\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\n scores = {}\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\n for i, bleu_score in enumerate(bleu_scores):\n scores['Bleu-%d' % (i + 1)] = bleu_score\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\n scores['Rouge-L'] = rouge_score\n return scores","def eval_metrics_for_multiclass(self, predicted_answers):\n total_correct_in_all = 0\n total_pred_in_all = len(predicted_answers)\n # initial a dict for total correct in topK counting.\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\n max_topK = max(self.topK_list)\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids\n correct_label_indices = sample['correct_labels']\n # current case, we only have a majority lable for the correct label\n label_true.append(correct_label_indices[0])\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\n top1_pred = sorted_probs_max_topK[0]\n label_pred.append(top1_pred['label_index'])\n\n # for all topK predictions\n for i in range(len(sorted_probs_max_topK)):\n pred = sorted_probs_max_topK[i]\n for topK in self.topK_list:\n if i >= topK:\n continue\n else:\n total_pred_in_topK[topK] += 1\n if pred['label_index'] in correct_label_indices:\n total_correct_in_topK[topK] += 1\n\n if total_correct_in_all != 0:\n # recall@K\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\n # assign recall@K into metrics\n for k, v in recall_at_K.items():\n # Jie\n # 1 means the greater the better.\n # -1 means the smaller the better.\n metrics['R@{}'.format(k)] = (1, v)\n\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\n # here return all the p,r,f for each label, then we compute the micro average later.\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\n title='Confusion matrix, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\n title='Normalized confusion matrix')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def evaluate_ngrams(eval_dataset, trigram_counts, bigram_counts, unigram_counts, train_token_count, lambda1, lambda2):\n perplexity = 0\n\n ### YOUR CODE HERE\n def calc_prob(sentense, i, word, trigram_counts, bigram_counts, unigram_counts, train_token_count, model):\n prob = 0.0\n prev_word = sentense[i - 1]\n prev_to_prev_word = sentense[i - 2]\n\n if model == \"unigram\":\n if word in unigram_counts:\n prob = (unigram_counts[word] + 0.0) / train_token_count\n else:\n prob = (unigram_counts[word_to_num['UUUNKKK']] + 0.0) / \\\n train_token_count\n\n if model == \"bigram\":\n if (prev_word, word) in bigram_counts:\n prob = (bigram_counts[(prev_word, word)] + 0.0) / \\\n unigram_counts[prev_word]\n # print(num_to_word[prev_word] ,num_to_word[word])\n # print(bigram_counts[(prev_word, word)])\n # print(unigram_counts[prev_word])\n # print(\"---------------------------\")\n else:\n prob = 0.0\n\n if model == \"trigram\":\n if (prev_to_prev_word, prev_word, word) in trigram_counts:\n prob = (trigram_counts[(prev_to_prev_word, prev_word, word)] + 0.0) \\\n / bigram_counts[(prev_to_prev_word, prev_word)]\n # / bigram_counts[(prev_word, word)] #this according to lecture notes slide 27\n else:\n prob = 0.0\n\n return prob\n\n l = 0\n num_of_words = 0\n\n ##########3\n better_than_chance = 0\n ###########\n\n for sentense in eval_dataset:\n for i, word in enumerate(sentense[2:]):\n num_of_words += 1\n prob = lambda1 * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts, unigram_counts,\n train_token_count, \"trigram\") + \\\n lambda2 * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts, unigram_counts,\n train_token_count, \"bigram\") + \\\n (1 - lambda1 - lambda2) * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts,\n unigram_counts, train_token_count, \"unigram\")\n ######################################\n if prob > (1.0 / vocabsize):\n better_than_chance += 1\n #########################\n l += np.log2(prob)\n l /= num_of_words\n perplexity = 2 ** -l\n\n print(\"better_than_chance:\", (better_than_chance + 0.0) / num_of_words)\n\n ### END YOUR CODE\n return perplexity","def compute_score(predictions, references, vocab=None, beam_size=4):\n assert np.rank(predictions) == 3\n assert predictions.shape[0] == references.shape[0]\n batch_size = predictions.shape[0]\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\n hypotheses_list = []\n references_list = []\n\n for index in range(batch_size):\n # All predictions in beam search are used for validation scores.\n for b_index in range(beam_size):\n h = predictions[index][b_index]\n try:\n eos_index = h.index(input_utils.EOS)\n except ValueError:\n eos_index = len(h)\n hypotheses_list.append(h[:eos_index])\n\n ref = references[index][0].decode().split('|')\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\n references_list.append(ref_list)\n\n all_scores = collections.defaultdict(list)\n for hypothesis, references in zip(hypotheses_list, references_list):\n if vocab is not None and len(vocab):\n # Skip PADDING, UNK, EOS, START (0-3).\n hypothesis = [\n vocab[word_id].numpy().decode()\n for word_id in hypothesis\n if word_id > 3\n ]\n\n h_str = ' '.join(str(e) for e in hypothesis)\n r_str = [' '.join(str(e) for e in ref) for ref in references]\n\n print('hypothesis: ', str(h_str))\n print('references: ', str(r_str))\n print('\\n')\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\n for key, score in scores.items():\n all_scores[key].append(score)\n score_names = [\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\n ]\n\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]","def PredictReviewScore(self, sentences, label=0):\n AdjR = 0.0\n # if text.startswith(\"For more photos and reviews do check out fourleggedfoodies\"):\n # x = 1\n adjAll = []\n for sentence in sentences:\n adjectives, dependencies = self.ExtractSentDetails(sentence)\n adjAll.extend(adjectives)\n allAdjectives = adjectives | Angel.GlobalAdjList\n AdjS = 0.0\n words = wordpunct_tokenize(sentence[\"Text\"])\n if len(words) <= 3:\n allAdjectives |= set([x.lower() for x in words])\n for i in range(len(words)):\n word = words[i].lower()\n if word in {\"but\", \"if\"}:\n AdjS = 0.0\n elif word in allAdjectives and word in self.lexicon:\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\n AdjR += AdjS\n AdjR *= self.PredictBase(adjAll)\n finalScore = AdjR\n if self.DumpRequested(finalScore, label):\n self.DumpDetails(sentences, label)\n return finalScore","def compute_confuse_matrix(y_targetlabel_list_single, y_logit_array_single, label_dict, name='default'):\n #1.get target label and predict label\n # y_target_labels=get_target_label_short(y_targetlabel_list_single) #e.g. y_targetlabel_list[0]=[2,12,88]\n y_target_labels = y_targetlabel_list_single\n\n # y_predict_labels=[i for i in range(len(y_logit_array_single)) if y_logit_array_single[i]>=0.50] #TODO 0.5PW e.g.[2,12,13,10]\n # y_predict_labels= y_logit_array_single.index(min(y_logit_array_single))\n\n flag = max(y_logit_array_single)\n y_predict_labels = []\n for i in range(len(y_logit_array_single)):\n if abs(y_logit_array_single[i] - flag) < 0.1:\n y_predict_labels.append(i)\n\n a = list(set(y_target_labels))\n b = list(set(y_predict_labels))\n acc = operator.eq(a,b)\n\n #if len(y_predict_labels)<1: y_predict_labels=[np.argmax(y_logit_array_single)] #TODO ADD 2018.05.29\n if random.choice([x for x in range(random_number)]) ==1:\n print(name+\".y_target_labels:\",y_target_labels,\";y_predict_labels:\",y_predict_labels) #debug purpose\n\n #2.count number of TP,FP,FN for each class\n y_labels_unique=[]\n y_labels_unique.extend(y_target_labels)\n y_labels_unique.extend(y_predict_labels)\n y_labels_unique=list(set(y_labels_unique))\n for i,label in enumerate(y_labels_unique): #e.g. label=2\n TP, FP, FN = label_dict[label]\n if label in y_predict_labels and label in y_target_labels:#predict=1,truth=1 (TP)\n TP=TP+1\n elif label in y_predict_labels and label not in y_target_labels:#predict=1,truth=0(FP)\n FP=FP+1\n elif label not in y_predict_labels and label in y_target_labels:#predict=0,truth=1(FN)\n FN=FN+1\n label_dict[label] = (TP, FP, FN)\n return label_dict, acc","def performClassification(ngram, df, mode = None, split = 0.9):\r\n \r\n if type(mode) == str:\r\n X = df[mode.capitalize()]\r\n else:\r\n X = df.Features\r\n \r\n y = df.Label\r\n\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1, train_size = split)\r\n \r\n vect = CountVectorizer(analyzer='word', ngram_range=(ngram,ngram))\r\n \r\n X_train_dtm = vect.fit_transform(X_train)\r\n X_test_dtm = vect.transform(X_test)\r\n \r\n nb = MultinomialNB()\r\n svm = LinearSVC(random_state = 1)\r\n\r\n nb.fit(X_train_dtm, y_train)\r\n svm.fit(X_train_dtm, y_train)\r\n\r\n nb_pred_class = nb.predict(X_test_dtm)\r\n svm_pred_class = svm.predict(X_test_dtm)\r\n\r\n nb_accuracy = metrics.accuracy_score(y_test, nb_pred_class)\r\n nb_precision = metrics.precision_score(y_test, nb_pred_class, pos_label='negative')\r\n nb_recall = metrics.recall_score(y_test, nb_pred_class, pos_label='negative')\r\n nb_f1 = metrics.f1_score(y_test, nb_pred_class, pos_label='negative')\r\n\r\n svm_accuracy = metrics.accuracy_score(y_test, svm_pred_class)\r\n svm_precision = metrics.precision_score(y_test, svm_pred_class, pos_label='negative')\r\n svm_recall = metrics.recall_score(y_test, svm_pred_class, pos_label='negative')\r\n svm_f1 = metrics.f1_score(y_test, svm_pred_class, pos_label='negative')\r\n\r\n print('=====Naive Bayes===== \\t =====Linear SVC=====' )\r\n print('Accuracy score \\t\\t Accuracy score')\r\n print(round((nb_accuracy * 100), 1), '\\t\\t\\t', round((svm_accuracy * 100), 1), '\\n')\r\n print('Precision \\t\\t Precision')\r\n print(round((nb_precision * 100), 1), '\\t\\t\\t', round((svm_precision * 100), 1), '\\n')\r\n print('Recall \\t\\t\\t Recall')\r\n print(round((nb_recall * 100), 1), '\\t\\t\\t', round((svm_recall * 100), 1), '\\n')\r\n print('F1-score \\t\\t F1-score')\r\n print(round((nb_f1 * 100), 1), '\\t\\t\\t', round((svm_f1 * 100), 1))","def predict(self, X):\n words = X.split()\n chance = []\n for cur_label in self.model[\"labels\"]:\n probability = self.model[\"labels\"][cur_label][\"probability\"]\n total_grade = math.log(probability, math.e)\n for word in words:\n word_dict = self.model[\"words\"].get(word, None)\n if word_dict:\n total_grade += math.log(word_dict[cur_label], math.e)\n chance.append((total_grade, cur_label))\n _, prediction = max(chance)\n return prediction","def sentence_accuracy(references, predictions):\n count = 0.0\n match = 0.0\n for label, pred in zip(references, predictions):\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def _word_accuracy(label_file, pred_file,subword_option=None):\n\n with open(label_file, \"r\", encoding='utf-8') as label_fh:\n with open(pred_file, \"r\", encoding='utf-8') as pred_fh:\n total_acc, total_count = 0., 0.\n for sentence in label_fh:\n sentence = \" \".join(_clean(sentence, subword_option))\n labels = sentence.strip().split(\" \")\n preds = \" \".join(_clean(pred_fh.readline(), subword_option))\n preds = preds.strip().split(\" \")\n match = 0.0\n for pos in range(min(len(labels), len(preds))):\n label = labels[pos]\n pred = preds[pos]\n if label == pred:\n match += 1\n total_acc += 100 * match / max(len(labels), len(preds))\n total_count += 1\n return total_acc / total_count","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def _self_bleu(completions: List[Sequence], **unused_kwargs) -> float:\n completion_sequences: List[str] = [completion.text.strip() for completion in completions if completion.text.strip()]\n\n if len(completion_sequences) <= 1:\n return 0\n\n scores = []\n for i in range(len(completion_sequences)):\n hypothesis = completion_sequences[i]\n references = completion_sequences[:i] + completion_sequences[i + 1 :]\n\n # Enable `effective_order` for sentence-level BLEU.\n score = BLEU(effective_order=True).sentence_score(hypothesis=hypothesis, references=references)\n scores.append(score.score)\n return sum(scores) / len(scores)","def _accuracy(label_file, pred_file,subword_option=None):\n\n with open(label_file, \"r\", encoding='utf-8') as label_fh:\n with open(pred_file, \"r\", encoding='utf-8') as pred_fh:\n count = 0.0\n match = 0.0\n for label in label_fh:\n label = label.strip()\n label = \" \".join(_clean(label,subword_option))\n pred = pred_fh.readline().strip()\n pred = \" \".join(_clean(pred,subword_option))\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def word_accuracy(references, predictions):\n total_acc, total_count = 0., 0.\n for labels, preds in zip(references, predictions):\n match = 0.0\n for pos in range(min(len(labels), len(preds))):\n label = labels[pos]\n pred = preds[pos]\n if label == pred:\n match += 1\n total_acc += 100 * match / max(len(labels), len(preds))\n total_count += 1\n return total_acc / total_count","def predictRating(self, writtenReview):\n totalScores = [0] * 6\n sentence = writtenReview.split()\n \n for word in sentence:\n if word in self.dictionary:\n wordScores = self.dictionary[word].getTFIDF()\n for i in range(1, len(totalScores)):\n totalScores[i] += wordScores[i]\n\n maxIndex = totalScores.index(max(totalScores))\n if maxIndex == 0:\n return 5\n return maxIndex","def okapi_best_match(tf_q, idf_q, doc_len, avgdl, k=0.2, b=0.75):\r\n score = (tf_q * idf_q * (k + 1)) / (tf_q + k * (1 - b + b * doc_len / avgdl))\r\n return score","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\r\n # TODO: Write your code here\r\n # return predicted labels of development set\r\n retval = []\r\n smoothing_parameter = 0.0055\r\n # Generate a unigram BOW for both positive and negative reviews, choose the top 2500 words\r\n pos_bow, neg_bow = generate_unigram_BOW(train_set, train_labels)\r\n sorted_pos = sorted(pos_bow.items(), key=lambda x: x[1], reverse = True)\r\n sorted_neg = sorted(neg_bow.items(), key=lambda x: x[1], reverse = True)\r\n pos_words = sorted_pos[:].copy()\r\n neg_words = sorted_neg[:].copy()\r\n\r\n pos_bi_bow, neg_bi_bow = generate_bigram_BOW(train_set, train_labels)\r\n sorted_bi_pos = sorted(pos_bi_bow.items(), key=lambda x: x[1], reverse = True)\r\n sorted_bi_neg = sorted(neg_bi_bow.items(), key=lambda x: x[1], reverse = True)\r\n bi_pos_words = sorted_bi_pos[:].copy()\r\n bi_neg_words = sorted_bi_neg[:].copy()\r\n\r\n # Calculate the log probabilities each word given type\r\n pos_count = sum(pair[1] for pair in pos_words)\r\n neg_count = sum(pair[1] for pair in neg_words)\r\n bi_pos_count = sum(pair[1] for pair in bi_pos_words)\r\n bi_neg_count = sum(pair[1] for pair in bi_neg_words)\r\n\r\n log_probability_pos = {} #(word)->P(word|positive)\r\n log_probability_neg = {} #(word)->P(word|negative)\r\n log_prob_bi_pos = {}\r\n log_prob_bi_neg = {}\r\n\r\n for pair in pos_words:\r\n pos_prob = np.log((pair[1]+smoothing_parameter)/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\r\n log_probability_pos[pair[0]] = pos_prob\r\n\r\n for pair in neg_words:\r\n neg_prob = np.log((pair[1]+smoothing_parameter)/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\r\n log_probability_neg[pair[0]] = neg_prob\r\n\r\n for pair in bi_pos_words:\r\n bi_pos_prob = np.log((pair[1]+smoothing_parameter)/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\r\n log_prob_bi_pos[pair[0]] = bi_pos_prob\r\n\r\n for pair in bi_neg_words:\r\n bi_neg_prob = np.log((pair[1]+smoothing_parameter)/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\r\n log_prob_bi_neg[pair[0]] = bi_neg_prob\r\n # Finished training\r\n\r\n # For each of the new reviews from development data\r\n for review in dev_set:\r\n uni_pos = np.log(pos_prior)\r\n uni_neg = np.log(1 - pos_prior)\r\n for word in review:\r\n if word in log_probability_pos:\r\n uni_pos += log_probability_pos[word]\r\n elif word not in log_probability_pos:\r\n uni_pos += np.log(smoothing_parameter/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\r\n\r\n if word in log_probability_neg:\r\n uni_neg += log_probability_neg[word]\r\n elif word not in log_probability_neg:\r\n uni_neg += np.log(smoothing_parameter/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\r\n\r\n bi_pos = np.log(pos_prior)\r\n bi_neg = np.log(1 - pos_prior)\r\n for i in range(len(review)-1):\r\n currTuple = (review[i], review[i+1])\r\n if currTuple in log_prob_bi_pos:\r\n bi_pos += log_prob_bi_pos[currTuple]\r\n elif currTuple not in log_prob_bi_pos:\r\n bi_pos += np.log(smoothing_parameter/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\r\n\r\n if currTuple in log_prob_bi_neg:\r\n bi_neg += log_prob_bi_neg[currTuple]\r\n elif currTuple not in log_prob_bi_neg:\r\n bi_neg += np.log(smoothing_parameter/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\r\n\r\n MAP_pos = (1-0.4)*uni_pos + 0.4*bi_pos\r\n MAP_neg = (1-0.4)*uni_neg + 0.4*bi_neg\r\n\r\n if MAP_pos >= MAP_neg:\r\n retval.append(1)\r\n else:\r\n retval.append(0)\r\n\r\n return retval","def evaluate(self, prediction_fn, save_dir=None, save_name=\"translation_eval.txt\", batched=None):\n if batched:\n src_sents = [src for (src, tgt) in self.task_data]\n chunked_sents = list(chunks(src_sents, batched))\n predictions = [prediction_fn(sents) for sents in tqdm.tqdm(chunked_sents, desc=\"predicting\", total=len(chunked_sents))]\n predictions = [val for sublist in predictions for val in sublist] # flattening\n else:\n predictions = [prediction_fn(src) for (src, tgt) in tqdm.tqdm(self.task_data, desc=\"predicting\")]\n \n # BLEU calculation\n BLEU_scores = []\n for (src, tgt), pred in tqdm.tqdm(list(zip(self.task_data, predictions)), desc=\"calculating bleu\"):\n BLEU_score = nltk_bleu(self.tgt_splitter(tgt), self.tgt_splitter(pred))\n BLEU_scores.append(BLEU_score)\n total_BLEU = np.average(BLEU_scores)\n \n # Write to file\n if save_dir != None:\n save_path = os.path.join(save_dir, save_name)\n print(f\"saving translation eval to file: {save_path}\")\n with open(save_path, \"w\", encoding=\"utf-8\") as out_fp:\n for (src, tgt), pred, BLEU in zip(self.task_data, predictions, BLEU_scores):\n\n out_fp.write(\"SRC :\" + src + \"\\n\")\n out_fp.write(\"TGT :\" + tgt + \"\\n\")\n out_fp.write(\"PRED :\" + pred + \"\\n\")\n out_fp.write(\"BLEU :\" + str(BLEU) + \"\\n\")\n out_fp.write(\"\\n\")\n\n out_fp.write(\"\\n\\n| EVALUATION | BLEU: {:5.2f} |\\n\".format(total_BLEU))\n print(\"| EVALUATION | BLEU: {:5.3f} |\".format(total_BLEU))\n \n return {\"BLEU\":total_BLEU}","def _detection_scores(inputs, gt_boxes, gt_labels, model):\n model = check_model('model', model, BlackModel)\n boxes_and_confi, pred_labels = model.predict(*inputs)\n det_scores = []\n correct_labels_num = []\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\n iou_thres = 0.5\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\n gt_box_num = gt_box.shape[0]\n score = 0\n box_num = boxes.shape[0]\n correct_label_flag = np.zeros(gt_label.shape)\n for i in range(box_num):\n pred_box = boxes[i]\n max_iou_confi = 0\n for j in range(gt_box_num):\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\n correct_label_flag[j] = 1\n score += max_iou_confi\n det_scores.append(score)\n correct_labels_num.append(np.sum(correct_label_flag))\n return np.array(det_scores), np.array(correct_labels_num)","def _bleu(ref_file, trans_file,max_order=4, subword_option=None):\n smooth = False\n\n ref_files = [ref_file]\n reference_text = []\n for reference_filename in ref_files:\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(reference_filename, \"rb\")) as fh:\n reference_text.append(fh.readlines())\n\n per_segment_references = []\n for references in zip(*reference_text):\n reference_list = []\n for reference in references:\n reference = _clean(reference, subword_option)\n reference_list.append(reference.split(\" \"))\n per_segment_references.append(reference_list)\n\n print(per_segment_references[0:15])\n\n translations = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(trans_file, \"rb\")) as fh:\n for line in fh:\n line = _clean(line, subword_option=subword_option)\n translations.append(line.split(\" \"))\n print(translations[0:15])\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\n per_segment_references, translations, max_order, smooth)\n return 100 * bleu_score","def label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0","def PredictMatch(yourName, tgtName, teamModels, db):\n\n teamTgtPipe, teamYourPipe = QueryTeamData(tgtName, yourName, db)\n featureCoefTgt, probTgt = PredictOp(teamTgtPipe, teamYourPipe, tgtName, teamModels)\n featureCoefYour, probYour = PredictOp(teamYourPipe, teamTgtPipe, yourName, teamModels)\n odds = round(probYour / (probYour + probTgt), 2)\n\n # In featureCoefYour, you want INCREASE those with POSTIVE COEF, DECREASE those with NEGATIVE COEF\n # In featureCoefTgt, you want to do the opposite\n\n # reverse both the sign of the coef, and '_op' in features so as to be the same with featureCoefYour\n featureCoefTgt['coef'] = - featureCoefTgt['coef']\n featureCoefTgt.features = [ii[:-3] if \"_op\" in ii else ii + '_op' for ii in featureCoefTgt.features]\n\n # Combine only the most important 10 features\n # featureBoth = featureCoefTgt[11:].append(featureCoefYour[11:])\n\n # Combine only all the most important features\n featureBoth = featureCoefTgt.append(featureCoefYour)\n\n # get action recommendations\n # Somehow the pandas here uses a deprecated para cols, instaed of the new one subset\n #featureBoth.drop_duplicates(subset = 'features', take_last = True, inplace = True)\n featureBoth.drop_duplicates(cols = 'features', take_last = True, inplace = True)\n actions, featureImprove = GetActions(featureBoth)\n Imp = 0.1\n oddsNew = ImprovedScore(tgtName, yourName, teamModels, featureImprove, teamTgtPipe, teamYourPipe, Imp)\n\n return odds, oddsNew, actions","def calc_metrics(pred, labels):\n pred_flat = np.argmax(pred, axis = 1).flatten()\n labels_flat = labels.flatten()\n \n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\n \n # sklearn takes first parameter as the true label\n precision = precision_score(labels_flat, pred_flat)\n recall = recall_score(labels_flat, pred_flat)\n \n return flat_accuracy, precision, recall","def predict_ensemble(test_df):\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \n for review in list(test_df.review)]\n model_paths = glob('output_*/model.tar.gz')\n all_predicted_labels = []\n for model_path in model_paths:\n archive = load_archive(model_path) # load trained model\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \n for instance in instances]\n all_predicted_labels.append(predicted_labels)\n all_predicted_labels = np.array(all_predicted_labels)\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\n test_df['rating'] = predicted_labels_vote\n return test_df.drop('review', axis=1)","def accuracies(actual_labels, predicted_labels):\n acc = 0\n letter_acc = 0\n letter_cnt = 0\n cnt = 0\n for i in range(len(actual_labels)):\n predicted_output = predicted_labels[i]\n actual_output = actual_labels[i]\n cnt += 1\n for j in range(min(len(predicted_output), len(actual_output))):\n if predicted_output[j] == actual_output[j]:\n letter_acc += 1\n letter_cnt += max(len(predicted_output), len(actual_output))\n if actual_output == predicted_output:\n acc += 1\n final_accuracy = np.round((acc / len(actual_labels)) * 100, 2)\n final_letter_accuracy = np.round((letter_acc / letter_cnt) * 100, 2)\n return final_accuracy, final_letter_accuracy","def eval_foreign(cls_prob, dtrain):\n \n labels = dtrain.get_label()\n pred = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\n users_idx = np.logical_or(labels != 7, labels != 10)\n#only retain the labels for users who chose foreign destinations\n labels = labels[users_idx]\n pred = pred[users_idx,:]\n labels = labels[:, None]\n return 'error', 1-ndcg(pred, labels)/len(labels)","def scores(self, y, y_pred):\n\n aucroc = 0.\n precision = 0.\n recall = 0.\n f1 = 0.\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\n label_ratios = np.mean(y, axis=0)\n\n if len(y) > 1:\n y_t = np.transpose(y)\n col_keep = np.ones(len(y_t), dtype=bool)\n for i, col_y in enumerate(y_t):\n if 0 not in col_y or 1 not in col_y:\n col_keep[i] = False\n\n if sum(col_keep) > 0:\n if not col_keep.all():\n y = np.transpose(y_t[col_keep])\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\n\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\n s = f1_score(y, self._round(y_pred), average=None)\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\n if sum(col_keep) > 1:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\n else:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\n elif self.verbose:\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n elif len(y) == 1:\n if self.verbose:\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n result = {\n 'aucroc': aucroc,\n 'precision': precision,\n 'recall': recall,\n 'f1': f1,\n 'aucroc_labs': aucroc_labs,\n 'precision_labs': precision_labs,\n 'recall_labs': recall_labs,\n 'f1_labs': f1_labs,\n 'label_ratios': label_ratios\n }\n\n return result","def string_f1_score(prediction, ground_truth):\n prediction_tokens = normalize_answer(prediction).split()\n ground_truth_tokens = normalize_answer(ground_truth).split()\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\n\n # (M,2), (1,M), (1,M), (1,3)\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\n\n # =========== GET ANSWERS\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\n answer_end = o_end.argmax()\n answer_type = o_type.argmax()\n if answer_type == 0:\n answer = \"yes\"\n elif answer_type == 1:\n answer = \"no\"\n elif answer_type == 2 and answer_end >= answer_start:\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\n else:\n answer = \"noanswer\"\n\n # =========== GET SUPPORTING FACTS\n pos = 0\n sup_fact_pairs = []\n for para, s_lens in zip(context, sentence_lengths):\n for j, s_len in enumerate(s_lens):\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\n # take avg of token-wise scores and round to 0 or 1\n try:\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\n except ZeroDivisionError:\n score = 0\n if score == 1:\n sup_fact_pairs.append([para[0], j])\n pos += s_len\n\n return answer, sup_fact_pairs","def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n \"\"\"Get n-gram level f-score.\"\"\"\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\n return f_score","def score(self, sentence):\n\n\n # TODO your code here\n score = 0.0 \n prevWord = \"\"\n prevPrevWord = \"\"\n newSentence = []\n for word in sentence:\n newSentence += word.split()\n for currentWord in sentence:\n currentWord = currentWord.strip(STRIP_CHARS)\n currentWord = currentWord.lower()\n if prevWord != \"\":\n if prevPrevWord != \"\":\n trigram = (prevPrevWord, prevWord, currentWord)\n trigramCount = self.trigramCounts[trigram]\n if trigramCount > 0:\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\n # Subtraction by 1 removes the add one count from the laplace\n # smoothing\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\n score -= math.log(self.totalBigramCounts)\n else:\n count = self.unigramCounts[currentWord]\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\n score -= math.log(self.total)\n else:\n prevPrevWord = prevWord\n prevWord = currentWord\n else:\n prevWord = currentWord\n return -score","def label_accuracy_score(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n # 一个batch里面可能有多个数据\n # 通过迭代器将一个个数据进行计算\n for lt, lp in zip(label_trues, label_preds):\n # numpy.ndarray.flatten将numpy对象拉成1维\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\n \"\"\"\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\n iu是召回率Recall，公式上面给出了\n mean_iu就是对iu求了一个平均\n freq是每一类被预测到的频率\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\n \"\"\"\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n # nanmean会自动忽略nan的元素求平均\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def evaluate_bias(ds: List[str], predicted: List[GENDER]) -> Dict:\r\n assert (len(ds) == len(predicted)) # must have same length to create tuples\r\n\r\n conf_dict = defaultdict(lambda: defaultdict(lambda: 0))\r\n total = defaultdict(lambda: 0) # increment values if we have any gender\r\n pred_cnt = defaultdict(lambda: 0)\r\n correct_cnt = defaultdict(lambda: 0) # increment values if true_gender == predicted_gender\r\n\r\n count_unknowns = defaultdict(lambda: 0)\r\n\r\n for (gold_gender, word_ind, sent, profession), pred_gender in zip(ds, predicted):\r\n # # IMPORTANTE NOTE :\r\n # need to works with .name of GENDER object for an unknown reason\r\n\r\n if isinstance(pred_gender, str): # can happen in spacy languages 'fr', 'es' or 'it\r\n pred_gender = SPACY_GENDER_TYPES[pred_gender]\r\n\r\n # tuples of values in ds and values in predicted\r\n if pred_gender.name == GENDER.ignore.name:\r\n continue # skip analysis of ignored words\r\n\r\n gold_gender = WB_GENDER_TYPES[gold_gender] # allows Winobias gender type conversion\r\n\r\n if pred_gender.name == GENDER.unknown.name:\r\n count_unknowns[gold_gender] += 1 # increment values for any unknown pred_gender\r\n\r\n profession = profession.lower()\r\n\r\n total[gold_gender] += 1\r\n\r\n if pred_gender.name == gold_gender.name:\r\n correct_cnt[gold_gender] += 1\r\n\r\n pred_cnt[pred_gender.name] += 1\r\n\r\n conf_dict[gold_gender][pred_gender] += 1\r\n\r\n all_total = sum(total.values())\r\n\r\n output_dict = {} # init output dictionnary\r\n # Compute metrics\r\n accuracy = round((sum(correct_cnt.values()) / all_total) * 100, 1) # compute accuracy\r\n output_dict['acc'] = accuracy\r\n\r\n if (total[GENDER.male] == 0) | (pred_cnt[GENDER.male.name] == 0): # Avoid ZeroDivisionError\r\n output_dict['f1_male'] = None\r\n else:\r\n recall_male = round((correct_cnt[GENDER.male] / total[GENDER.male]) * 100, 1) # compute metrics for male\r\n prec_male = round((correct_cnt[GENDER.male] / pred_cnt[GENDER.male.name]) * 100, 1)\r\n f1_male = round(calc_f1(prec_male, recall_male), 1)\r\n output_dict['f1_male'] = f1_male\r\n\r\n if (total[GENDER.female] == 0) | (pred_cnt[GENDER.female.name] == 0): # Avoid ZeroDivisionError\r\n output_dict['f1_female'] = None\r\n else:\r\n recall_female = round((correct_cnt[GENDER.female] / total[GENDER.female]) * 100, 1) # calcul metrics for female\r\n prec_female = round((correct_cnt[GENDER.female] / pred_cnt[GENDER.female.name]) * 100, 1)\r\n f1_female = round(calc_f1(prec_female, recall_female), 1)\r\n output_dict['f1_female'] = f1_female\r\n\r\n output_dict['unk_male'] = count_unknowns[GENDER.male]\r\n output_dict['unk_female'] = count_unknowns[GENDER.female]\r\n output_dict['unk_neutral'] = count_unknowns[GENDER.neutral]\r\n\r\n return output_dict","def _rouge_n_score(pred: Sequence[str], target: Sequence[str], n_gram: int) ->Dict[str, Tensor]:\n\n def _create_ngrams(tokens: Sequence[str], n: int) ->Counter:\n ngrams: Counter = Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams\n pred_ngrams, target_ngrams = _create_ngrams(pred, n_gram), _create_ngrams(target, n_gram)\n pred_len, target_len = sum(pred_ngrams.values()), sum(target_ngrams.values())\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n hits = sum(min(pred_ngrams[w], target_ngrams[w]) for w in set(pred_ngrams))\n return _compute_metrics(hits, max(pred_len, 1), max(target_len, 1))","def label_predict(self, sentence):\n index_words = FileUtils.index_sentence(sentence, self.word_to_index)\n chunks = FileUtils.divide_sentence(index_words, Settings.seq_size)\n result = np.zeros(Settings.class_num)\n if Settings.cuda:\n self.model.cuda()\n \n for chunk in chunks:\n with torch.no_grad():\n chunk = torch.from_numpy(np.asarray(chunk)).view(1, Settings.seq_size)\n if Settings.cuda:\n chunk = chunk.cuda()\n \n predict = self.model(chunk)\n if Settings.cuda:\n predict = predict.cpu()\n predict = predict.numpy()[0]\n result += predict\n result /= len(chunks)\n\n target_index = np.argmax(result) + 1\n label = self.index_to_label.get(str(target_index))\n score = np.max(result)\n return label, score","def find_best_combination(train_data, model, probabilities):\n logit_coef = 4\n\n df = pd.DataFrame(columns=['type', 'p1', 'p2', 'p3', 'p4', 'sentence'])\n average = np.array([0., 0.])\n nr_words = np.array([0, 0])\n for sent, label in train_data[['content', 'type']].values:\n words = model.get_line(sent.replace(\"\\n\", \"\"))[0]\n probs = np.array([])\n for word in words:\n word = word.lower().strip(',.?!\"\\'-~')\n if word == \"\":\n continue\n probs = np.append(probs, probabilities[word])\n average[label] += probabilities[word]\n nr_words[label] += 1\n\n p1 = np.mean(probs)\n\n probs_avoid_zero_division = np.array([max(1e-5, min(1 - 1e-5, p)) for p in probs])\n logit_probs = np.log(probs_avoid_zero_division / (1 - probs_avoid_zero_division)) / logit_coef\n logit_probs = [min(100, max(-100, l)) for l in logit_probs]\n p2 = 1 / (1 + np.exp(-np.mean(logit_probs)))\n\n p3 = np.prod(probs / 0.5) / 2\n\n p4 = np.prod((1 - probs) / 0.5) / 2\n\n df = df.append({'type': label, 'p1': p1, 'p2': p2, 'p3': min(p3, 1000), 'p4': p4, 'sentence': sent},\n ignore_index=True)\n\n avg_prob = sum(average) / sum(nr_words)\n print(f'Average probability of all words in train set: {avg_prob}')\n average = average / nr_words\n print(f'Average: {average}, number: {nr_words}')\n\n print('Mean:')\n l1 = df['p1'].values > 0.5\n print(sum(l1 == df['type'].values) / df.shape[0])\n print(sum((df['p1'].values > avg_prob) == df['type'].values) / df.shape[0])\n\n print('Logit:')\n l2 = df['p2'].values > 0.5\n print(sum(l2 == df['type'].values) / df.shape[0])\n print(sum((df['p2'].values > avg_prob) == df['type'].values) / df.shape[0])\n\n print('Product:')\n l3 = df['p3'].values > 1\n print(sum(l3 == df['type'].values) / df.shape[0])\n\n print('Product inverted:')\n l4 = df['p1'].values < 0.2\n print(sum(l4 == df['type'].values) / df.shape[0])\n\n return df, avg_prob","def calculate_bleu(lightning_model: pl.LightningModule, config: Namespace) -> float:\n\n valid_en = load_file(os.path.join(config.directory, 'valid_en.txt'))\n valid_ru = load_file(os.path.join(config.directory, 'valid_ru.txt'))\n\n predicted_texts = list()\n\n for i_batch in tqdm(range(math.ceil(len(valid_en) / config.batch_size)),\n desc='Inference', disable=not config.verbose):\n\n batch = valid_en[i_batch * config.batch_size:(i_batch + 1) * config.batch_size]\n tokenized_batch = lightning_model.sequence2sequence_preparer.source_tokenize(batch)\n translated_batch = lightning_model.model.generate(tokenized_batch)\n predicted_texts_batch = lightning_model.sequence2sequence_preparer.target_language_tokenizer.decode_batch(\n translated_batch)\n predicted_texts.extend(predicted_texts_batch)\n\n tokenized_predicted = [word_tokenize(sample) for sample in predicted_texts]\n tokenized_target = [[word_tokenize(sample)] for sample in valid_ru]\n\n score = corpus_bleu(tokenized_target, tokenized_predicted)\n\n return score","def test_classifiers(train_docs, train_target, test_docs, test_target, min_docs, K, K2, removeStopWords):\n # test_classifiers(train_docs, train_target, test_docs, test_targets, i, 3)\n X_train_counts, X_train_tfidf, X_test_counts, X_test_tfidf = extract_text_features(train_docs, test_docs, min_docs, removeStopWords)\n \n \n num_docs, vocab_size = X_train_counts.shape\n print('Number of (training) documents =',num_docs)\n print('Vocabulary size =',vocab_size)\n \n\n # Now evaluate the classifiers on the test data\n # Print out the accuracy as a percentage for each classifier.\n # np.mean() can be used to calculate the accuracy. Round the accuracy to 2 decimal places.\n\n #predict according to different classifier--evaluate results \n predicted_multNB = fit_and_predict_multinomialNB(X_train_tfidf, train_target, X_test_tfidf)\n predicted_bernNB = fit_and_predict_BernoulliNB(X_train_tfidf, train_target, X_test_tfidf)\n predicted_LR = fit_and_predict_LR(X_train_tfidf, train_target, X_test_tfidf)\n predicted_LR = fit_and_predict_LR(X_train_counts, train_target, X_test_counts)\n predicted_KNN = fit_and_predict_KNN(X_train_tfidf, train_target, X_test_tfidf, K)\n predicted_KNN2 = fit_and_predict_KNN(X_train_tfidf, train_target, X_test_tfidf, K2)\n \n predicted_base = np.array([FreqDist(test_target).most_common(1)[0][0]]*len(test_target))\n\n # count num of correct predictions / total\n np_test_target = np.array(test_target)\n base = np.sum(predicted_base == np_test_target)/len(np_test_target)*100\n multNB = np.sum(predicted_multNB == np_test_target)/len(np_test_target)*100\n bernNB = np.sum(predicted_bernNB == np_test_target)/len(np_test_target)*100\n LR = np.sum(predicted_LR == np_test_target)/len(np_test_target)*100\n KN = np.sum(predicted_KNN == np_test_target)/len(np_test_target)*100\n KN2 = np.sum(predicted_KNN2 == np_test_target)/len(np_test_target)*100\n\n \n print('\\tBase Accuracy: {:.3f}'.format(base))\n print('\\tAccuracy with multinomial naive Bayes: {:.2f}'.format(multNB))\n print('\\tAccuracy with Bernoulli naive Bayes: {:.2f}'.format(bernNB))\n print('\\tAccuracy with logistic regression: {:.2f}'.format(LR))\n print('\\tAccuracy with kNN, k={} classifier: {:2f}'.format(K, KN))\n print('\\tAccuracy with kNN, k={} classifier: {:.2f}'.format(K2, KN2))","def evaluate_ngrams(eval_dataset, trigram_counts, bigram_counts, unigram_counts, train_token_count, lambda1, lambda2):\n perplexity = 0\n ### YOUR CODE HERE\n raise NotImplementedError\n ### END YOUR CODE\n return perplexity","def qualify_words():\n config = get_config()\n\n all_feature_matrices = []\n all_opinion_matrices = []\n\n # first 5 parts are labeled, thus are useful\n all_feature_label_vectors = []\n all_opinion_label_vectors = []\n\n for fname in config.file_names:\n feature_X, feature_dims = load_feature_matrices(fname)\n opinion_X, opinion_dims = load_opinion_matrices(fname)\n feature_y = load_feature_labels(fname)\n opinion_y = load_opinion_labels(fname)\n\n # append to all collector\n all_feature_matrices.append(feature_X)\n all_feature_label_vectors.append(feature_y)\n all_opinion_matrices.append(opinion_X)\n all_opinion_label_vectors.append(opinion_y)\n # use first 5 for training\n # stack first 5\n feature_training_X = []\n feature_training_y = []\n opinion_training_X = []\n opinion_training_y = []\n for i in range(5):\n feature_training_X.append(all_feature_matrices[i])\n feature_training_y.append(all_feature_label_vectors[i])\n opinion_training_X.append(all_opinion_matrices[i])\n opinion_training_y.append(all_opinion_label_vectors[i])\n\n feature_training_X = np.hstack(feature_training_X)\n feature_training_y = np.hstack(feature_training_y)\n opinion_training_X = np.hstack(opinion_training_X)\n opinion_training_y = np.hstack(opinion_training_y)\n\n # using combination of rule and ranking score as features\n feature_model = MultinomialNB()\n opinion_model = MultinomialNB()\n\n # training\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\n\n # predicting on candidate aspects and opinions, extracted from amazon reviews\n for i in range(5, len(config.file_names)):\n fname = config.file_names[i]\n feature_pred = feature_model.predict_proba(\n np.transpose(all_feature_matrices[i]))[:,1]\n opinion_pred = opinion_model.predict_proba(\n np.transpose(all_opinion_matrices[i]))[:,1]\n # pickle the prediction results\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\n pickle.dump(feature_pred, f)\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\n pickle.dump(opinion_pred, f)","def ranked_accuracy(predictions, labels):\n rank1 = 0\n rank5 = 0\n\n for (pred, lbl) in zip(predictions, labels):\n pred = np.argsort(pred)[::-1]\n\n if lbl in pred[:5]:\n rank5+=1\n\n if lbl == pred[0]:\n rank1+=1\n\n rank1 /= float(len(labels))\n rank5 /= float(len(labels))\n\n return (rank1, rank5)","def predict(self):\r\n\r\n # reshape test_array since it is a single row of data\r\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\r\n # one hot encode user_array\r\n self.enc.fit(user_array)\r\n user_array = self.enc.transform(user_array)\r\n # create, train and predict the model with the dataset\r\n model = (\"Ridge\", linear_model.Ridge(alpha=0.01, random_state=4))\r\n model[1].fit(self.X_train, self.y_train)\r\n y_pred = model[1].predict(self.X_test)\r\n # predict with user provided chords\r\n y_usr = model[1].predict(user_array)\r\n if y_usr[0] < 0:\r\n y_usr[0] = 0\r\n acc = metrics.r2_score(self.y_test, y_pred)\r\n output = \"I am {}% sure that you like this progression.\".format('%.2f' % (100 * y_usr[0]))\r\n model_info = \"Predicted using a {} model with {} accuracy from {} data samples.\".format(model[0], '%.3f' % acc,\r\n self.data_count())\r\n return output, model_info","def LevDistMultilabels(y_true, y_pred):\n \n n = y_pred.shape[0]\n D = 0\n for i in range(n):\n D += LevenshteinDistance(y_pred[i,:], y_true[i,:])[-1, -1]\n return D/n","def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\n\n\t# set variables\n\trm1_vec = list()\n\tvocab = set()\n\tdoc_vecs = dict()\n\n\t# create document feature vectors for each feedback doc\n\tfor doc_id in ids_and_scores.keys():\n\t\t# convert current doc to bow format\n\t\tbow = ix.doc2bow(corpus[doc_id])\n\t\t# create document feature vector\n\t\tdfv = create_feature_vector(ix, term_dict, bow)\n\t\t# keep top 'fb_terms' from dfv\n\t\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\n\t\tvocab.update(dfv.keys())\n\t\tdoc_vecs[doc_id] = dfv\n\n\t# compute L1 norm for each document feature vector\n\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\n\n\t# loop over terms in vocab and compute RM1\n\tfor term in vocab:\n\t\tfb_weight = 0.0\n\t\t# loop over document feature vectors \n\t\tfor doc_id in doc_vecs.keys():\n\t\t\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\n\t\t\t\t# sum the score of current term across different docs to fb_weight\n\t\t\t\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\n\t\t# assign term w/ weight to RM1 feature vector\n\t\trm1_vec.append((term, fb_weight))\n\n\t# keep top 'fb_terms' from rm1_vec\n\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t# scale rm1_vec to L1 norm\n\treturn scale_to_L1_norm(rm1_vec)","def bert_score(preds: Union[List[str], Dict[str, Tensor]], target: Union[List[str], Dict[str, Tensor]], model_name_or_path: Optional[str]=None, num_layers: Optional[int]=None, all_layers: bool=False, model: Optional[Module]=None, user_tokenizer: Any=None, user_forward_fn: Callable[[Module, Dict[str, Tensor]], Tensor]=None, verbose: bool=False, idf: bool=False, device: Optional[Union[str, torch.device]]=None, max_length: int=512, batch_size: int=64, num_threads: int=4, return_hash: bool=False, lang: str='en', rescale_with_baseline: bool=False, baseline_path: Optional[str]=None, baseline_url: Optional[str]=None) ->Dict[str, Union[List[float], str]]:\n if len(preds) != len(target):\n raise ValueError('Number of predicted and reference sententes must be the same!')\n if verbose and not _TQDM_AVAILABLE:\n raise ModuleNotFoundError('An argument `verbose = True` requires `tqdm` package be installed. Install with `pip install tqdm`.')\n if model is None:\n if not _TRANSFORMERS_AVAILABLE:\n raise ModuleNotFoundError('`bert_score` metric with default models requires `transformers` package be installed. Either install with `pip install transformers>=4.0` or `pip install torchmetrics[text]`.')\n if model_name_or_path is None:\n warn(f'The argument `model_name_or_path` was not specified while it is required when default `transformers` model are used.It is, therefore, used the default recommended model - {_DEFAULT_MODEL}.')\n tokenizer = AutoTokenizer.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\n model = AutoModel.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\n else:\n tokenizer = user_tokenizer\n model.eval()\n model\n try:\n if num_layers and num_layers > model.config.num_hidden_layers:\n raise ValueError(f'num_layers={num_layers} is forbidden for {model_name_or_path}. Please use num_layers <= {model.config.num_hidden_layers}')\n except AttributeError:\n warn('It was not possible to retrieve the parameter `num_layers` from the model specification.')\n _are_empty_lists = all(isinstance(text, list) and len(text) == 0 for text in (preds, target))\n _are_valid_lists = all(isinstance(text, list) and len(text) > 0 and isinstance(text[0], str) for text in (preds, target))\n _are_valid_tensors = all(isinstance(text, dict) and isinstance(text['input_ids'], Tensor) for text in (preds, target))\n if _are_empty_lists:\n warn('Predictions and references are empty.')\n output_dict: Dict[str, Union[List[float], str]] = {'precision': [0.0], 'recall': [0.0], 'f1': [0.0]}\n if return_hash:\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\n return output_dict\n baseline = _load_baseline(lang, model_name_or_path, baseline_path, baseline_url) if rescale_with_baseline else None\n if _are_valid_lists:\n target_dataset = TextDataset(target, tokenizer, max_length, idf=idf)\n preds_dataset = TextDataset(preds, tokenizer, max_length, idf=idf, tokens_idf=target_dataset.tokens_idf)\n elif _are_valid_tensors:\n target_dataset = TokenizedDataset(**target, idf=idf)\n preds_dataset = TokenizedDataset(**preds, idf=idf, tokens_idf=target_dataset.tokens_idf)\n else:\n raise ValueError('Invalid input provided.')\n target_loader = DataLoader(target_dataset, batch_size=batch_size, num_workers=num_threads)\n preds_loader = DataLoader(preds_dataset, batch_size=batch_size, num_workers=num_threads)\n target_embeddings, target_idf_scale = _get_embeddings_and_idf_scale(target_loader, target_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\n preds_embeddings, preds_idf_scale = _get_embeddings_and_idf_scale(preds_loader, preds_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\n precision, recall, f1_score = _get_precision_recall_f1(preds_embeddings, target_embeddings, preds_idf_scale, target_idf_scale)\n if baseline is not None:\n precision, recall, f1_score = _rescale_metrics_with_baseline(precision, recall, f1_score, baseline, num_layers, all_layers)\n output_dict = {'precision': precision.tolist(), 'recall': recall.tolist(), 'f1': f1_score.tolist()}\n if return_hash:\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\n return output_dict","def cal_err(label_scores, predicted_scores, top_k_int=1, use_predicted_order=False):\n \n if not use_predicted_order:\n max_label_score = tf.reduce_max(label_scores)\n sorted_labels, predicted_order, sorted_predictions = _get_ranking_orders(\n label_scores, predicted_scores, top_k_int=top_k_int)\n else:\n indices = tf.range(top_k_int)\n predicted_order = tf.gather(predicted_scores, indices)\n max_label_score = tf.reduce_max(label_scores)\n\n predicted_relevance = _get_relevance_scores(predicted_order)\n predicted_relevance_ratio = predicted_relevance / (2**max_label_score)\n _ratio = 1- predicted_relevance_ratio\n prob_stepdown = tf.cumprod(_ratio, exclusive=True)\n cur_rank = tf.range(top_k_int) + 1\n cur_rank = tf.cast(cur_rank, dtype=tf.float32)\n cur_rank = tf.reshape(cur_rank, [-1, 1])\n products = tf.multiply(predicted_relevance_ratio, prob_stepdown)\n products = tf.cast(products, dtype=tf.float32)\n errs = tf.divide(products, cur_rank)\n err = tf.reduce_sum(errs)\n return err","def train_label_weigthed(self, train_dataset, validation_dataset, label, lr = 0.02, epochs_num = 100, batch_size = 40, alpha = 0, momentum = 0.9):\n \n def get_proportions(dataset):\n \n positive_label = dataset.labels_tensor[:,label].sum()\n \n negative_label = (1 - dataset.labels_tensor[:,label]).sum()\n \n total_examples = positive_label + negative_label\n \n imbalance = abs(positive_label - 0.5) > 0.4\n \n if imbalance:\n \n if positive_label < negative_label:\n \n w_p = 1\n \n w_n = positive_label / negative_label\n \n else:\n \n w_p = negative_label / positive_label\n \n w_n = 1\n \n else:\n \n w_p = w_n = 1\n \n return w_p, w_n\n \n def get_w(labels, w_p, w_n):\n \n positives = labels\n \n negatives = 1 - labels\n \n w = w_p * positives + w_n * negatives\n \n return w\n \n# positive_label = train_dataset.labels_tensor[:,label].sum()\n \n# negative_label = (1 - train_dataset.labels_tensor[:,label]).sum()\n \n# total_examples = positive_label + negative_label\n \n# print('num examples {}'.format(positive_label + negative_label))\n \n# print('% positive labels: {}'.format(positive_label/total_examples))\n \n# print('% negative labels: {}'.format(negative_label/total_examples))\n \n# imbalance = abs(positive_label - 0.5) > 0.4\n \n# if imbalance:\n \n# if positive_label < negative_label:\n \n# w_p = 1\n \n# w_n = positive_label / negative_label\n \n# else:\n \n# w_p = negative_label / positive_label\n \n# w_n = 1\n \n# else:\n \n# w_p = w_n = 1\n \n# print('w_p: {}'.format(w_p))\n \n# print('w_n: {}'.format(w_n))\n\n w_p, w_n = get_proportions(train_dataset) \n \n label_name = train_dataset.labels.items()[label][0]\n \n print(\"Training label {} ... \".format(label_name))\n \n optimizer = SGD(self.parameters(), lr = lr, weight_decay = alpha, momentum = momentum)\n\n train_losses = []\n\n validation_losses = []\n\n epochs = []\n\n start = time.time()\n\n remaining_time = 0\n\n train_dataloader = DataLoader(train_dataset, batch_size = batch_size, collate_fn = PPD.collate_data)\n \n validation_segments, validation_labels = PPD.collate_data(validation_dataset)\n \n weight_matrix_v = get_w(validation_labels[:,label].unsqueeze(1), w_p, w_n)\n \n criterion_v = nn.BCELoss(weight=weight_matrix_v.float())\n \n print('w_p: {} and w_n: {}'.format(w_p, w_n))\n\n for epoch in range(epochs_num):\n\n for i_batch, sample_batched in enumerate(train_dataloader):\n\n input = sample_batched[0]\n\n target = sample_batched[1][:,label].unsqueeze(1)\n \n weight_matrix = w_p * target + w_n * (1 - target)\n \n criterion = nn.BCELoss(weight=weight_matrix.float())\n\n self.zero_grad()\n\n output = self(input)\n\n train_loss = criterion(output, target.float())\n\n train_loss.backward()\n\n optimizer.step()\n\n validation_loss = criterion_v(self(validation_segments.long()), validation_labels[:,label].unsqueeze(1).float())\n\n end = time.time()\n\n remaining_time = remaining_time * 0.90 + ((end - start) * (epochs_num - epoch + 1) / (epoch + 1)) * 0.1\n\n remaining_time_corrected = remaining_time / (1 - (0.9 ** (epoch + 1)))\n\n epoch_str = \"last epoch finished: \" + str(epoch)\n\n progress_str = \"progress: \" + str((epoch + 1) * 100 / epochs_num) + \"%\"\n\n time_str = \"time: \" + str(remaining_time_corrected / 60) + \" mins\"\n\n sys.stdout.write(\"\\r\" + epoch_str + \" -- \" + progress_str + \" -- \" + time_str)\n\n sys.stdout.flush()\n\n train_losses.append(train_loss.item())\n\n validation_losses.append(validation_loss.item())\n\n epochs.append(epoch)\n\n print(\"\\n\" + \"Training completed. Total training time: \" + str(round((end - start) / 60, 2)) + \" mins\")\n\n return epochs, train_losses, validation_losses","def learn_bpe(strings: List[str], pair_percent_threshold: float, char_percent_threshold:float, with_position:bool) -> dict:\n\n vocab = get_vocab(strings)\n percent = 1.0\n # 待改进，这里如果 pair_percent_threshold <=0，则会死循环\n while percent >= pair_percent_threshold:\n pair2freq = pair_freq_stats(vocab, with_position)\n best = max(pair2freq, key=pair2freq.get)\n percent = pair2freq.get(best) / len(strings)\n if percent >= pair_percent_threshold:\n vocab = merge_vocab(best, vocab, with_position)\n\n bpe_tokens = get_tokens(vocab, pair_percent_threshold, len(strings), char_percent_threshold, with_position)\n if with_position:\n bpe_tokens = sorted(bpe_tokens, key=lambda x: len(x[0]), reverse=True)\n else:\n bpe_tokens = sorted(bpe_tokens, key=len, reverse=True)\n bpe_token_dict = {'with_position':with_position,\n 'tokens': bpe_tokens}\n return bpe_token_dict","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def prediction(score, test_y, lossname):\n if lossname == 'contrastive_loss':\n prediction = sigmoid(euclidean_distance(score))\n\n threshold = 0.5\n correction = 0\n error = 0\n\n for i in range(len(prediction)):\n if prediction[i] >= threshold:\n pred = 1\n else:\n pred = 0\n \n if pred == test_y[i]:\n correction += 1\n else:\n error += 1\n \n accuracy = 1.0 * correction / (correction + error)\n \n return correction, error, accuracy","def get_relevances(self):\n\n # Backpropagate softmax value\n # relevances = [tf.nn.softmax(self.activations[0])*tf.cast(self.y, tf.float32)]\n\n # Backpropagate a value from given labels y\n relevances = [tf.cast(self.y, tf.float32)]\n\n loc_poly = [pol for pol in self.polynomials]\n loc_pooling = [p for p in self.model.p]\n print(\"\\n Relevance calculation:\")\n for i in range(1, len(\n self.activations)): # start from 1 (not 0) penultimate activations since relevances already contains logits.\n name = self.activations[i - 1].name.split('/')\n if 'logits' in name[0] or 'fc' in name[0]:\n print(\"\\tFully connected:\", name[0])\n relevances.append(self.prop_fc(name[0], self.activations[i], relevances[-1]))\n elif 'flatten' in name[0]:\n print(\"\\tFlatten layer:\", name[0])\n relevances.append(self.prop_flatten(self.activations[i], relevances[-1]))\n # print(\"\\n\")\n elif 'pooling' in name[1]:\n # TODO: incorporate pooling type and value into name\n print(\"\\tPooling:\", name[0] + \" \" + name[1])\n p = loc_pooling.pop()\n relevances.append(self.prop_max_pool(self.activations[i], relevances[-1], ksize=[1, p, 1, 1],\n strides=[1, p, 1, 1]))\n elif 'conv' in name[0]:\n if len(loc_poly) > 1:\n print(\"\\tConvolution: \", name[0], \"\\n\")\n relevances.append(self.prop_gconv(name[0], self.activations[i], relevances[-1],\n polynomials=loc_poly.pop()))\n else:\n print(\"\\tConvolution, the first layer:\", name[0], \"\\n\")\n relevances.append(self.prop_gconv_first_conv_layer(name[0], self.activations[i], relevances[-1],\n polynomials=loc_poly.pop()))\n else:\n raise 'Error parsing layer'\n\n return relevances","def main(path: str, boundary: str, keep_accents: bool):\n print(f\"Calculating transitional probabilities over {path}...\")\n sub_boundary: str = \"S\" if boundary == \"W\" else \"P\"\n # get the input, both with and without word boundaries\n input: str = \"\"\n for line in open(path):\n input += line.strip()\n # if we're finding syllable boundaries, we don't care about word boundaries\n if boundary == \"S\":\n input = remove_boundaries(input, \"W\")\n # remove accents from the input\n if not keep_accents:\n input2 = \"\"\n for char in input:\n if char != \"0\" and char != \"1\" and char != \"2\":\n input2 += char\n input = input2\n input_without_word_boundaries = remove_boundaries(input, boundary)\n # calculate the transitional probabilites of words from the transitions between syllables\n transitional_probabilities = get_transitional_probabilities(\n input_without_word_boundaries, sub_boundary\n )\n # generate over the entire input using these transitional probabilities\n generated = predict_word_boundaries(\n input_without_word_boundaries,\n sub_boundary,\n boundary,\n transitional_probabilities,\n )\n # evaluate utterance by utterance and average the precision and recall\n test_correct = [utt for utt in input.split(\"U\") if utt]\n test_generated = [utt for utt in generated.split(\"U\") if utt]\n print(f\"Evaluating {len(test_correct)} predictions ...\")\n total_correct = 0\n total_generated = 0\n total_right = 0\n for i in range(0, len(test_correct)):\n correct = [w for w in test_correct[i].split(boundary) if w]\n generated = [w for w in test_generated[i].split(boundary) if w]\n total_right += len([w for w in correct if w in generated])\n total_correct += len(correct)\n total_generated += len(generated)\n precision: float = total_right / total_generated\n recall: float = total_right / total_correct\n print(\"===============================================================\")\n print(f\"Precision: {precision * 100 : .3f}%\")\n print(f\"Recall: {recall * 100: .3f}%\")\n print(f\"F-score: {(2 * precision * recall) / (precision + recall) * 100: .3f}%\")","def score(self, predictions):\n return 0.","def eval_all(cls_prob, dtrain):\n #determine the top k predictions\n labels = dtrain.get_label()\n top_k = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\n# top_k = cls_prob.argsort(axis = 1)[:,:k:-1]\n #convert true values and compared with predictions to check for equality\n labels = labels[:, None]\n return 'error', 1-ndcg(top_k, labels)/len(labels)","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\n # TODO: Write your code here\n # return predicted labels of development set\n #\n ### len(train_set) 8000, len(dev) = 5000 P(pos) = 0.8 \n #### 0.55, 4.0, 0.30 ----------- 0.766\n #### 0.25 3.5 0.3 -------------- 0.766\n print(pos_prior)\n smoothing_parameter = 3.5\n pos_total_word = 0\n neg_total_word = 0\n pos_word_dict = {}\n neg_word_dict = {}\n dicts = [neg_word_dict, pos_word_dict]\n for i, sentence in enumerate(train_set):\n\n if train_labels[i] == 1: # positive reviews\n for word in sentence:\n pos_total_word += 1 \n if word in stop_words:\n continue\n if word in pos_word_dict:\n pos_word_dict[word] += 1\n else :\n pos_word_dict[word] = 1\n\n else: # negative reviews\n for word in sentence:\n neg_total_word += 1 \n if word in stop_words:\n continue\n if word in neg_word_dict:\n neg_word_dict[word] += 1\n else :\n neg_word_dict[word] = 1\n\n\n prob = {}\n denominator_pos = pos_total_word + smoothing_parameter * (len(pos_word_dict) + 1)\n denominator_neg = neg_total_word + smoothing_parameter * (len(neg_word_dict) + 1)\n de = [denominator_neg, denominator_pos]\n\n for t, dictionary in enumerate(dicts):\n for key, value in dictionary.items():\n if key not in prob:\n prob[key] = {0 : 0, 1 : 0}\n if smoothing_parameter != 0:\n prob[key][1 - t] = -1 * np.log(smoothing_parameter / de[t]) \n # print(prob[key][1 - t])\n\n prob[key][t] = -1 * np.log((value + smoothing_parameter) / de[t]) \n \n\n revised_prob = {}\n for key, value in prob.items():\n if np.abs(value[0] - value[1]) >= 0.25:\n revised_prob[key] = value \n\n print(len(revised_prob))\n\n dev_labels = []\n num_0 = 0\n for i, sentence in enumerate(dev_set):\n pos_odd = -1 * np.log(pos_prior)\n neg_odd = -1 * np.log(1.0 - pos_prior)\n for word in sentence:\n if word in revised_prob:\n pos_odd += revised_prob[word][1]\n neg_odd += revised_prob[word][0]\n \n if pos_odd > neg_odd:\n num_0 += 1\n dev_labels.append(1 if pos_odd <= neg_odd else 0)\n print(num_0)\n\n \n #### bigram model \n \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n return dev_labels","def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\n # TODO: Write your code here\n # Bag of words model\n smoothing_parameter = .007 # override smoothing parameter\n posWordBag = {}\n negWordBag = {}\n for reviewIndex, review in enumerate(train_set):\n for word in review:\n if isWordTooCommon(word) == True: # If word is too common, skip the word\n continue\n else:\n if train_labels[reviewIndex] == 1: # Positive\n if word not in posWordBag.keys():\n posWordBag[word] = 1\n else:\n posWordBag[word] += 1\n elif train_labels[reviewIndex] == 0: # Negative\n if word not in negWordBag.keys():\n negWordBag[word] = 1\n else:\n negWordBag[word] += 1\n \n posProbList, posUNK = genProb(posWordBag, smoothing_parameter)\n negProbList, negUNK = genProb(negWordBag, smoothing_parameter)\n\n # Done with training. Now development with MAP\n dev_labels = []\n for devRev in dev_set:\n reviewIsPos = math.log10(pos_prior)\n reviewIsNeg = math.log10(1 - pos_prior)\n for word in devRev:\n if isWordTooCommon(word) == True: # If word is too common, skip the word\n continue\n else:\n if word in posProbList.keys():\n reviewIsPos += posProbList[word]\n else:\n reviewIsPos += posUNK\n if word in negProbList.keys():\n reviewIsNeg += negProbList[word]\n else:\n reviewIsNeg += negUNK\n if reviewIsPos < reviewIsNeg:\n dev_labels.append(0)\n else:\n dev_labels.append(1)\n\n # return predicted labels of development set\n return dev_labels","def score(self, X_test: List[str], y_test: List[str]) -> int:\n predictions_count = 0\n right_predictions_count = 0\n\n for i in range(len(X_test)):\n label = self.predict(X_test[i].split())\n predictions_count += 1\n right_predictions_count += 1 if label == y_test[i] else 0\n\n return right_predictions_count / predictions_count","def predict(self, uid, iid, r_ui=None, clip=True, verbose=False):\n\n # Iterate over the components and build up an aggregate score using the weights.\n # Clip the estimate into [lower_bound, higher_bound] if clip parameter is True. See algo_base.py.\n # Create a new Prediction object. Retain any Prediction \"details\" values\n # in a new dictionary.\n try:\n iuid = self.trainset.to_inner_uid(uid)\n except ValueError:\n iuid = 'UKN__' + str(uid)\n try:\n iiid = self.trainset.to_inner_iid(iid)\n except ValueError:\n iiid = 'UKN__' + str(iid) \n \n details = {}\n try:\n cnt = 0\n est = 0.0\n for comp in self._components:\n pred = comp.estimate(iuid, iiid)\n if type(pred) == tuple:\n \tpred = pred[0]\n \t\n est += pred[0] * self._weights[cnt]\n cnt += 1 \n \n # If the details dict was also returned\n if isinstance(est, tuple):\n est, details = est\n\n details['was_impossible'] = False\n\n except:\n est = self.trainset.global_mean\n details['was_impossible'] = True\n details['reason'] = str('PredictionImpossible')\n \n\n# clip estimate into [lower_bound, higher_bound]\n if clip:\n lower_bound, higher_bound = self.trainset.rating_scale\n est = min(higher_bound, est)\n est = max(lower_bound, est)\n\n pred = Prediction(uid, iid, r_ui, est, details)\n\n if verbose:\n print(pred)\n\n return pred","def calc_ac_score(labels_true, labels_pred):\n nclass = len(np.unique(labels_true))\n labels_size = len(labels_true)\n mat = labels_size * np.ones((nclass, nclass))\n \n idx = 0\n \n for i in range(labels_size):\n mat[labels_pred[i], labels_true[i]] -= 1.0\n \n munkres = Munkres()\n mapping = munkres.compute(mat)\n \n ac = 0.0\n\n for i in range(labels_size):\n val = mapping[labels_pred[i]][1]\n if val == labels_true[i]:\n ac += 1.0\n\n ac = ac / labels_size \n \n return ac","def calc_performance_given_labels(self, cutoff, ligand_labels):\n performance = defaultdict(dict)\n num_ligands = np.shape(ligand_labels)[1]\n\n if num_ligands > 1: # ligand-type assessment\n # calc per-ligand assessment for multi-label prediction\n for i in range(0, num_ligands):\n tp = fp = tn = fn = 0\n cross_pred = [0, 0, 0, 0]\n for idx, lig in enumerate(ligand_labels):\n if self.predictions[idx, i] >= cutoff: # predicted as binding to this ligand\n cross_prediction = False\n true_prediction = False\n\n for j in range(0, num_ligands):\n if i == j: # same as predicted ligand\n if lig[j] >= self.bind_cutoff: # also annotated to this ligand\n tp += 1\n cross_pred[i] += 1\n true_prediction = True\n else:\n fp += 1\n else:\n if lig[j] >= self.bind_cutoff and not true_prediction:\n cross_pred[j] += 1\n cross_prediction = True\n\n if not true_prediction and not cross_prediction:\n # residues is not annotated to bind any of the ligands\n cross_pred[3] += 1\n else:\n if lig[i] >= cutoff:\n fn += 1\n else:\n tn += 1\n\n if i == 0:\n ligand = 'metal'\n elif i == 1:\n ligand = 'nucleic'\n else:\n ligand = 'small'\n\n bound = False\n if (tp + fn) > 0:\n bound = True\n acc, prec, recall, f1, mcc = PerformanceAssessment.calc_performance_measurements(tp, fp, tn, fn)\n # calculate performance measurements for negatives\n _, neg_p, neg_r, neg_f1, _ = PerformanceAssessment.calc_performance_measurements(tn, fn, tp, fp)\n\n performance[ligand] = {'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn, 'acc': acc, 'prec': prec,\n 'recall': recall, 'f1': f1, 'neg_prec': neg_p, 'neg_recall': neg_r,\n 'neg_f1': neg_f1, 'mcc': mcc, 'bound': bound,\n 'cross_prediction': cross_pred}\n\n # get overall performance\n reduced_labels = np.sum(ligand_labels > cutoff, axis=1)\n if len(self.predictions.shape) == 1:\n reduced_predictions = (self.predictions >= cutoff)\n else:\n reduced_predictions = np.sum(self.predictions >= cutoff, axis=1)\n\n tp = np.sum(np.logical_and(reduced_labels > 0, reduced_predictions > 0))\n fp = np.sum(np.logical_and(reduced_labels == 0, reduced_predictions > 0))\n tn = np.sum(np.logical_and(reduced_labels == 0, reduced_predictions == 0))\n fn = np.sum(np.logical_and(reduced_labels > 0, reduced_predictions == 0))\n\n acc, prec, recall, f1, mcc = PerformanceAssessment.calc_performance_measurements(tp, fp, tn, fn)\n _, neg_p, neg_r, neg_f1, _ = PerformanceAssessment.calc_performance_measurements(tn, fn, tp, fp)\n performance['overall'] = {'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn, 'acc': acc, 'prec': prec, 'recall': recall,\n 'f1': f1, 'neg_prec': neg_p, 'neg_recall': neg_r, 'neg_f1': neg_f1, 'mcc': mcc,\n 'bound': True, 'cross_prediction': [0, 0, 0, 0]}\n\n return performance","def get_recall(y_true, y_pred):\n true_entities_filter = (y_true != 3).astype(\"int\") # of the words that truly has a NER class\n recall_correct_entities = (y_pred[np.where(true_entities_filter)] == y_true[np.where(true_entities_filter)]).astype(\"int\")\n recall = np.sum(recall_correct_entities)/np.sum(true_entities_filter)\n return recall","def _bleu(ref_file, trans_file, subword_option=None, lower_case=False):\n max_order = 4\n smooth = False\n\n ref_files = [ref_file]\n reference_text = []\n for reference_filename in ref_files:\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(reference_filename, \"rb\")) as fh:\n reference_text.append(fh.readlines())\n\n per_segment_references = []\n for references in zip(*reference_text):\n reference_list = []\n for reference in references:\n reference = _clean(reference, subword_option, lower_case=lower_case)\n reference_list.append(reference.split())\n per_segment_references.append(reference_list)\n\n translations = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(trans_file, \"rb\")) as fh:\n for line in fh:\n line = _clean(line, subword_option=None, lower_case=lower_case)\n translations.append(line.split())\n\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\n per_segment_references, translations, max_order, smooth)\n return 100 * bleu_score","def run_evaluate_compound(self, data):\n tp = 0\n tn = 0\n fp = 0\n fn = 0\n for words, labels, pos in minbatch_generator(data, self.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\n if not type(labels_pred) == list:\n labels_pred = labels_pred.tolist()\n for i, label_actual in enumerate(labels):\n # we have to now find all aspect terms. That is, merge consecutive B \n # with I's until we get an O or B\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\n for a_term in a_terms_actual:\n # say we have [1,2,3] as our a_term. we have to make sure that our \n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\n a_term_pred = []\n for index in a_term:\n if not label_actual[index] == labels_pred[i][index]:\n fn += 1\n break\n else:\n tp += 1\n for index in non_a_terms_actual:\n if label_actual[index] == labels_pred[i][index]:\n tn += 1\n else:\n fp += 1\n\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\n metrics = dict()\n metrics[\"p_1\"] = precision\n metrics[\"f_1\"] = fscore\n metrics[\"r_1\"] = recall\n return metrics","def most_probable_class(text, weights):\n\n pos_weights = weights['positive']\n neg_weights = weights['negative']\n neu_weights = weights['neutral']\n features = calculate_features(text)\n pos_numerator = 0.0\n neg_numerator = 0.0\n neu_numerator = 0.0\n denominator = 0.0\n for f in features:\n if f in pos_weights and f in neg_weights and f in neu_weights:\n pos_numerator += pos_weights[f] * features[f]\n neg_numerator += neg_weights[f] * features[f]\n neu_numerator += neu_weights[f] * features[f]\n denominator += pos_numerator + neg_numerator + neu_numerator\n else:\n pos_numerator += 0\n neg_numerator += 0\n neu_numerator += 0\n denominator += pos_numerator + neg_numerator + neu_numerator\n\n pos_prob = (\"positive\", exp(pos_numerator))# /exp(denominator))\n neg_prob = (\"negative\", exp(neg_numerator))# /exp(denominator))\n neu_prob = (\"neutral\", exp(neu_numerator))# /exp(denominator))\n return max(neu_prob, neg_prob, pos_prob, key=lambda x: x[1])","def compute_precision(gold_dict, src_word2ind, trg_word2ind, src_words, trg_words, scores, args, BATCH_SIZE=20, verbose = False):\n oov = set()\n correct = 0\n n,m = scores.shape # The actual size of mapping computed, might be smaller that total size of dict\n\n precisions = {}\n if verbose:\n print('@{:2} {:10} {:30} {:30}'.format('k', 'Src','Predicted','Gold'))\n print_row = '{:2} {:10} {:30} {:30} {}'\n\n for k in [1,5,10]:\n correct = 0\n for src_idx,tgt_idx in gold_dict.items():\n if src_idx > n or np.all([e>m for e in tgt_idx]):#Src word not in mapping\n oov.add(src_idx)\n continue\n else:\n knn = np.argpartition(scores[src_idx,:], -k)[-k:] # argpartition returns top k not in order\n knn_sort = knn[np.argsort(-scores[src_idx,knn])] # With - to get descending order\n if set(knn_sort).intersection(tgt_idx):\n correct +=1\n correct_string = ' '\n else:\n correct_string = 'X'\n if verbose:\n src_str = src_words[src_idx]\n pred_str = ','.join([trg_words[k] for k in knn_sort])\n gold_str = ','.join([trg_words[k] for k in tgt_idx])\n print(print_row.format(k,src_str,pred_str,gold_str,correct_string))\n\n\n coverage = len(gold_dict.keys()) / (len(gold_dict.keys()) + len(oov))\n if verbose:\n print('Coverage: {:7.2%} Precision @{:2}:{:7.2%}'.format(coverage, k, correct / len(gold_dict)))\n precisions[k] = correct / len(gold_dict)\n return precisions","def compute_accuracy(Y_test, Y_pred):\n number_correct_prediction = 0\n for i in range(len(Y_pred)): # They have the same length\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\n if id_test == id_pred:\n number_correct_prediction += 1\n\n percentage_correct = number_correct_prediction / len(Y_pred)\n\n return percentage_correct","def test_score_text4(self):\n\t\ttest = sentiment.LibraryRun(self.text3, self.lib)\n\t\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\n\t\t_, obj_ut = test.score_text(matches, end_threshold=0.5)\n\t\tself.assertEqual(obj_ut, {'not good': [[2, -1, 0]], \n\t\t\t'not very good': [[4, -1.5, 0]]})","def predict_and_analyze(dta, clf, eval_tweets):\n for tweet in eval_tweets:\n tweet['prediction'] = clf.predict([w2v_vector(dta, tweet['text'])])[0]\n\n metrics = {'tp': 0, 'fp': 0, 'tn': 0, 'fn': 0,\n 'precision': 0, 'recall': 0, 'f1': 0}\n for tweet in eval_tweets:\n actual_label = tweet['label']\n prediction = tweet['prediction']\n if actual_label == prediction:\n if prediction == 'relevant':\n metrics['tp'] += 1\n else:\n metrics['tn'] += 1\n else:\n if prediction == 'relevant':\n metrics['fp'] += 1\n else:\n metrics['fn'] += 1\n metrics['precision'] = float(metrics['tp']) / (metrics['tp'] + metrics['fp'])\n metrics['recall'] = float(metrics['tp']) / (metrics['tp'] + metrics['fn'])\n metrics['f1'] = 2 * ((metrics['precision'] * metrics['recall']) /\n (metrics['precision'] + metrics['recall']))\n return metrics","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def ratio(n1,n2, explain=0, optimize=False):\n weight_normal_form = 5.0 #distance between soundexes of normal form\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\n weight_initials = 2 #distance between initials\n\n nf1 = n1.guess_normal_form()\n nf2 = n2.guess_normal_form()\n\n if not nf1 or not nf2:\n return 0.0\n elif nf1 == nf2:\n return 1.0\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\n \n #create a simkplified soundex set for this name\n #remove stopwords\n# nf1 = remove_stopwords( nf1)\n# nf2 = remove_stopwords( nf2)\n \n se1 = n1.get_normal_form_soundex()\n se2 = n2.get_normal_form_soundex()\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\n \n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\n g1 = to_ascii(g1)\n g2 = to_ascii(g2)\n if not optimize:\n #de soundexes van de achternaam worden meegewoen\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\n g1_soundex = n1.geslachtsnaam_soundex()\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\n g2_soundex = n2.geslachtsnaam_soundex()\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\n else:\n ratio_geslachtsnaam1 = 1 \n weight_geslachtsnaam1 = 0\n \n #n de afstand van de woorden in de achtenraam zelf\n ratio_geslachtsnaam2 = Similarity.average_distance(\n re.split('[ \\.\\,\\-]', g1.lower()),\n re.split('[ \\.\\,\\-]', g2.lower()),\n levenshtein_ratio)\n n1_initials = n1.initials()\n n1_initials_lower = n1_initials.lower()\n n2_initials = n2.initials()\n n2_initials_lower = n2_initials.lower()\n n1_contains_initials = n1.contains_initials()\n n2_contains_initials = n2.contains_initials()\n #count initials only if we have more than one\n #(or perhaps make this: if we know the first name)\n if len(n1_initials) == 1 or len(n2_initials) == 1:\n #initials count much less if there is only one\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\n# ratio_initials = .5\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n elif n1_contains_initials or n2_contains_initials:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n weight_initials = weight_initials_if_one_name_is_in_initials\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n else:\n ratio_initials = 0.7\n \n if n1_contains_initials or n2_contains_initials:\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\n\n counter = (ratio_normal_form * weight_normal_form +\n ratio_normal_form_soundex * weight_normal_form_soundex +\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\n ratio_initials * weight_initials)\n numerator = (weight_normal_form + weight_normal_form_soundex +\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\n if numerator == 0:\n return 0.0\n final_ratio = counter/numerator\n\n if explain:\n s = '-' * 100 + '\\n'\n s += 'Naam1: %s [%s] [%s] %s\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\n s += 'Naam2: %s [%s] [%s] %s\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\n s += 'Similarity ratio: %s\\n' % final_ratio\n s += '--- REASONS' + '-' * 30 + '\\n'\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\n'\n s += format_s % ('\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\n s += '\\t' + '-' * 100 + '\\n'\n format_s = '\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\n'\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\n s += '\\tTOTAL (numerator) | %s (counter = %s)\\n' % (counter, numerator)\n \n return s\n return final_ratio","def validate(self, validate_data):\n with open(validate_data, 'r') as validate_data:\n true_positive = 0\n true_negative = 0\n false_positive = 0\n false_negative = 0\n result = {}\n for type in self.label_type_map:\n result[type] = []\n while True:\n tokens = validate_data.readline().split()\n pos = validate_data.readline().split()\n labels = validate_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Classify all named entities in a sentence 85\n curr_results = self.viterbi(tokens)\n for i in range(0, len(labels)):\n if curr_results[i] != 'O':\n if labels[i] == 'O':\n false_positive += 1 # Not 'O', but should be 'O'\n else:\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\n true_positive += 1 # Correct prediction\n else:\n if labels[i] == 'O':\n true_negative += 1 # Correct prediction of 'O'\n else:\n false_negative += 1 # Predicted 'O', not 'O'\n # Calculate precision - TP / (TP + FP)\n precision = float(true_positive) / float(true_positive + false_positive)\n # Calculate recall - TP / (TP + FN)\n recall = float(true_positive) / float(true_positive + false_negative)\n # Calculate F-Score - 2 * P * R / (P + R)\n f_score = float(2*precision * recall) / float(precision + recall)\n print \"Precision: \" + str(precision)\n print \"Recall: \" + str(recall)\n print \"F-score: \" + str(f_score)","def partial_match_score(\n truth: List[Rationale], pred: List[Rationale], thresholds: List[float]\n) -> List[PartialMatchScore]:\n\n ann_to_rat = _keyed_rationale_from_list(truth)\n pred_to_rat = _keyed_rationale_from_list(pred)\n\n num_classifications = {k: len(v) for k, v in pred_to_rat.items()}\n num_truth = {k: len(v) for k, v in ann_to_rat.items()}\n ious: Dict[str, Dict[str, float]] = defaultdict(dict)\n for k in set(ann_to_rat.keys()) | set(pred_to_rat.keys()):\n for p in pred_to_rat.get(k, []):\n best_iou = 0.0\n for t in ann_to_rat.get(k, []):\n num = len(\n set(range(p.start_token, p.end_token))\n & set(range(t.start_token, t.end_token))\n )\n denom = len(\n set(range(p.start_token, p.end_token))\n | set(range(t.start_token, t.end_token))\n )\n iou = 0 if denom == 0 else num / denom\n if iou > best_iou:\n best_iou = iou\n ious[k][p] = best_iou\n\n scores: List[PartialMatchScore] = []\n for threshold in thresholds:\n threshold_tps: Dict[str, float] = {}\n for k, vs in ious.items():\n threshold_tps[k] = sum(int(x >= threshold) for x in vs.values())\n micro_r = (\n sum(threshold_tps.values()) / sum(num_truth.values())\n if sum(num_truth.values()) > 0\n else 0\n )\n micro_p = (\n sum(threshold_tps.values()) / sum(num_classifications.values())\n if sum(num_classifications.values()) > 0\n else 0\n )\n micro_f1 = _f1(micro_r, micro_p)\n macro_rs = list(\n threshold_tps.get(k, 0.0) / n if n > 0 else 0 for k, n in num_truth.items()\n )\n macro_ps = list(\n threshold_tps.get(k, 0.0) / n if n > 0 else 0\n for k, n in num_classifications.items()\n )\n macro_r = sum(macro_rs) / len(macro_rs) if len(macro_rs) > 0 else 0\n macro_p = sum(macro_ps) / len(macro_ps) if len(macro_ps) > 0 else 0\n macro_f1 = _f1(macro_r, macro_p)\n\n scores.append(\n PartialMatchScore(\n threshold=threshold,\n micro=InstanceScore(p=micro_p, r=micro_r, f1=micro_f1),\n macro=InstanceScore(p=macro_p, r=macro_r, f1=macro_f1),\n )\n )\n\n return scores","def score(self, sentence):\n\n score = 0.0\n i = 0\n temp = \"\"\n for token in sentence:\n count = self.unigramCounts[token]\n if (i == 0):\n i = i + 1\n temp = token\n continue\n\n key = temp + \",\" + token\n bicount = self.bigramCounts[key]\n unicount = self.unigramCounts[temp]\n temp = token\n if bicount > 0 :\n\n score += (math.log(bicount) - math.log(unicount))\n else:\n unicount = self.unigramCounts[token]\n score += math.log(unicount + 1) + math.log(0.4)\n score -= math.log(self.total + len(self.unigramCounts))\n\n return score","def get_q_probs(dataset):\n\n total_tokens = 0\n trigram_count_dict = {}\n bigram_count_dict = {}\n unigram_count_dict = {}\n for sentence in dataset:\n # Tag Token counter\n total_tokens += len(sentence)\n # Make the sentence will be only tags\n sentence = [word[1] for word in sentence]\n\n # Count the trigram model\n first_word = sentence[:-2]\n second_word = sentence[1:-1]\n third_word = sentence[2:]\n for i in range(len(first_word)):\n trigram = (first_word[i], second_word[i], third_word[i])\n if trigram in trigram_count_dict:\n trigram_count_dict[trigram] += 1\n else:\n trigram_count_dict[trigram] = 1\n\n # Count the bigram model\n first_word = sentence[:-1]\n second_word = sentence[1:]\n for i in range(len(first_word)):\n brigram = (first_word[i], second_word[i])\n if brigram in bigram_count_dict:\n bigram_count_dict[brigram] += 1\n else:\n bigram_count_dict[brigram] = 1\n\n # Count the unigram model\n for i in range(len(sentence)):\n unigram = (sentence[i])\n if unigram in unigram_count_dict:\n unigram_count_dict[unigram] += 1\n else:\n unigram_count_dict[unigram] = 1\n\n # Get the unique taggs\n e_tag_counts = unigram_count_dict.keys()\n return total_tokens, trigram_count_dict, bigram_count_dict, unigram_count_dict, e_tag_counts","def klue_re_auprc(probs, labels):\n labels = np.eye(30)[labels]\n\n score = np.zeros((30,))\n for c in range(30):\n targets_c = labels.take([c], axis=1).ravel()\n preds_c = probs.take([c], axis=1).ravel()\n precision, recall, _ = metrics.precision_recall_curve(\n targets_c, preds_c)\n score[c] = metrics.auc(recall, precision)\n return np.average(score) * 100.0"],"string":"[\n \"def score(self, target_text, prediction_text):\\n bleu_score = sacrebleu.corpus_bleu([prediction_text], [[target_text]],\\n smooth_method=\\\"exp\\\",\\n smooth_value=0.0,\\n force=False,\\n lowercase=False,\\n tokenize=\\\"intl\\\",\\n use_effective_order=False)\\n return {\\\"bleu\\\": BleuScore(bleu_score.score)}\",\n \"def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n if smooth:\\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\\n bleu = brevity_penalty * geometric_mean\\n return bleu\",\n \"def _bleu_score_update(\\n preds: Sequence[str],\\n target: Sequence[Sequence[str]],\\n numerator: Tensor,\\n denominator: Tensor,\\n preds_len: Tensor,\\n target_len: Tensor,\\n n_gram: int = 4,\\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\\n) -> Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\\n\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n\\n ngram_counter_clip = preds_counter & target_counter\\n\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n\\n return preds_len, target_len\",\n \"def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n ngram_counter_clip = preds_counter & target_counter\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n return preds_len, target_len\",\n \"def bleu_score(\\n preds: Union[str, Sequence[str]],\\n target: Sequence[Union[str, Sequence[str]]],\\n n_gram: int = 4,\\n smooth: bool = False,\\n weights: Optional[Sequence[float]] = None,\\n) -> Tensor:\\n preds_ = [preds] if isinstance(preds, str) else preds\\n target_ = [[tgt] if isinstance(tgt, str) else tgt for tgt in target]\\n\\n if len(preds_) != len(target_):\\n raise ValueError(f\\\"Corpus has different size {len(preds_)} != {len(target_)}\\\")\\n\\n if weights is not None and len(weights) != n_gram:\\n raise ValueError(f\\\"List of weights has different weights than `n_gram`: {len(weights)} != {n_gram}\\\")\\n if weights is None:\\n weights = [1.0 / n_gram] * n_gram\\n\\n numerator = torch.zeros(n_gram)\\n denominator = torch.zeros(n_gram)\\n preds_len = tensor(0.0)\\n target_len = tensor(0.0)\\n\\n preds_len, target_len = _bleu_score_update(\\n preds_, target_, numerator, denominator, preds_len, target_len, n_gram, _tokenize_fn\\n )\\n\\n return _bleu_score_compute(preds_len, target_len, numerator, denominator, n_gram, weights, smooth)\",\n \"def _bleu_score_compute(\\n preds_len: Tensor,\\n target_len: Tensor,\\n numerator: Tensor,\\n denominator: Tensor,\\n n_gram: int,\\n weights: Sequence[float],\\n smooth: bool,\\n) -> Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n\\n if smooth:\\n precision_scores = torch.div(\\n torch.add(numerator, torch.ones(n_gram, device=device)),\\n torch.add(denominator, torch.ones(n_gram, device=device)),\\n )\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\\n return brevity_penalty * geometric_mean\",\n \"def calculate_bleu(output_lns, refs_lns):\\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)\",\n \"def bleu_score(references, generated, n_gram=4, smooth=False):\\r\\n formatted_ref = [[ref] for ref in references]\\r\\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\\r\\n return bleu_s * 100\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\\n best_f_score = tensor(0.0)\\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n for target in targets:\\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\\n if f_score > best_f_score:\\n best_f_score = f_score\\n best_matching_char_n_grams = matching_char_n_grams\\n best_matching_word_n_grams = matching_word_n_grams\\n best_target_char_n_grams = target_char_n_grams\\n best_target_word_n_grams = target_word_n_grams\\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams\",\n \"def recognize_ngram(models: dict, test_set: SinglesData,probs,BIC_guesses):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n probabilities = []\\n guesses = []\\n\\n model = arpa.loadf(\\\"devel-lm-M3.sri.lm\\\")\\n lm = model[0] # ARPA files may contain several models.\\n # TODO implement the recognizer\\n # return probabilities, guesses\\n test_sequences = list(test_set.get_all_Xlengths().values())\\n word_keys = list(test_set.get_all_Xlengths().keys())\\n i = -1 \\n for sentence in test_set.sentences_index.values():\\n f = {}\\n maxs = float(\\\"-inf\\\")\\n prob = []\\n words = []\\n\\n sentenceLength = 0\\n for word_index in sentence:\\n i+=1\\n word = test_set.wordlist[word_index]\\n sentenceLength+=1\\n try:\\n f[word] = probs[word][i]\\n except:\\n f[word] = float(\\\"-inf\\\")\\n prob.append(f[word]) ## These are Just the probabilities unchanged from the BIC recognizer.\\n \\n # Find Six most probable words and generate the possible permutations \\n sixwords = sorted(f,key=f.get,reverse=True)[:6]\\n for k in permutations(sixwords, r=sentenceLength):\\n l = 0\\n for j in range(len(k)):\\n l += f[k[j]]\\n try:\\n sentenceLP = l + 13*lm.log_s(\\\" \\\".join(k)) ## According to one student in the forum 13 is the best hyperparameter\\n if sentenceLP > maxs: ## https://discussions.udacity.com/t/slm-data-for-this-asl-dataset/230822/8?u=spiros\\n sentence = \\\" \\\".join(k)\\n maxs = sentenceLP\\n words = list(k)\\n except:\\n pass\\n\\n if(words == []):\\n words = BIC_guesses[len(guesses):len(guesses)+sentenceLength] ## Fall back to BIC guesses\\n probabilities.append(prob) \\n guesses += words\\n return (probabilities,guesses)\",\n \"def _score_ngrams(target_ngrams, prediction_ngrams):\\n\\n intersection_ngrams_count = 0\\n for ngram in six.iterkeys(target_ngrams):\\n intersection_ngrams_count += min(target_ngrams[ngram],\\n prediction_ngrams[ngram])\\n target_ngrams_count = sum(target_ngrams.values())\\n prediction_ngrams_count = sum(prediction_ngrams.values())\\n\\n precision = intersection_ngrams_count / max(prediction_ngrams_count, 1)\\n recall = intersection_ngrams_count / max(target_ngrams_count, 1)\\n fmeasure = scoring.fmeasure(precision, recall)\\n\\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)\",\n \"def evaluate_bleu_score(cls, predictions, targets, ticks=False, corpus=True):\\n if ticks:\\n ref_sentences = cls._ticks_to_sentences(targets)\\n cand_sentences = cls._ticks_to_sentences(predictions)\\n else:\\n ref_sentences = [[str(x) for x in seq] for seq in predictions]\\n cand_sentences = [[str(x) for x in seq] for seq in targets]\\n\\n if corpus: bleu_score = corpus_bleu([[l] for l in ref_sentences], cand_sentences)\\n else:\\n bleu_score = 0.0\\n num_sentences = 0\\n\\n for i in tqdm(range(len(ref_sentences))):\\n sentence_bleu_score = sentence_bleu(ref_sentences[i], cand_sentences[i])\\n print(sentence_bleu_score)\\n bleu_score += sentence_bleu_score\\n num_sentences += 1\\n\\n bleu_score /= num_sentences\\n\\n return bleu_score\",\n \"def computeErrorRate(test_set, words_likely_tags):\\n # initiate vars\\n known_words = {} # those two dictionaries are optional, just for debuging\\n unknown_words = {} # those two dictionaries are optional, just for debuging\\n correct_predictions = 0\\n total_predictions = 0\\n correct_unknown_predictions = 0\\n total_unknown_predictions = 0\\n\\n for i in range(len(test_set)): # iterate sentences\\n test_sent = test_set[i]\\n for j in range(len(test_sent)): # iterate words in sent\\n w = test_sent[j][WORD]\\n t = test_sent[j][TAG]\\n\\n # known words\\n if w in words_likely_tags:\\n if w in known_words:\\n known_words[w][COUNTER_SHOWS] += 1\\n if t == words_likely_tags[w]: # same tag\\n known_words[w][COUNTER_EQUAL] += 1\\n correct_predictions += 1\\n else:\\n if t == words_likely_tags[w]: # same tag\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_predictions += 1\\n else:\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_predictions += 1\\n # unknown words\\n else: # w not in words_likely_tags, treat w as unknown_word\\n if w in unknown_words:\\n unknown_words[w][COUNTER_SHOWS] += 1\\n if t == UNKNOWN_TAG:\\n # same tag as our model predicts for unknown words\\n unknown_words[w][COUNTER_EQUAL] += 1\\n correct_unknown_predictions += 1\\n else:\\n if t == UNKNOWN_TAG: # same tag\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_unknown_predictions += 1\\n else:\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_unknown_predictions += 1\\n\\n # print('correct_predictions......... = ', correct_predictions)\\n # print('total_predictions........... = ', total_predictions)\\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\\n # print('total_unknown_predictions... = ', total_unknown_predictions)\\n err_rate_known = 1 - correct_predictions/total_predictions\\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\\n # total_err = err_rate_known + err_rate_unknown\\n tot_pred = total_predictions + total_unknown_predictions\\n corr_pred = correct_predictions + correct_unknown_predictions\\n total_err = 1 - corr_pred/tot_pred\\n\\n return err_rate_known, err_rate_unknown, total_err\",\n \"def compute_bleu(reference_corpus, translation_corpus, max_order=4,\\n use_bp=True):\\n reference_length = 0\\n translation_length = 0\\n bp = 1.0\\n geo_mean = 0\\n\\n matches_by_order = [0] * max_order\\n possible_matches_by_order = [0] * max_order\\n precisions = []\\n\\n for (references, translations) in zip(reference_corpus, translation_corpus):\\n reference_length += len(references)\\n translation_length += len(translations)\\n ref_ngram_counts = _get_ngrams_with_counter(references, max_order)\\n translation_ngram_counts = _get_ngrams_with_counter(translations, max_order)\\n\\n overlap = dict((ngram,\\n min(count, translation_ngram_counts[ngram]))\\n for ngram, count in ref_ngram_counts.items())\\n\\n for ngram in overlap:\\n matches_by_order[len(ngram) - 1] += overlap[ngram]\\n for ngram in translation_ngram_counts:\\n possible_matches_by_order[len(ngram) - 1] += translation_ngram_counts[\\n ngram]\\n\\n precisions = [0] * max_order\\n smooth = 1.0\\n\\n for i in xrange(0, max_order):\\n if possible_matches_by_order[i] > 0:\\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[i]\\n if matches_by_order[i] > 0:\\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[\\n i]\\n else:\\n smooth *= 2\\n precisions[i] = 1.0 / (smooth * possible_matches_by_order[i])\\n else:\\n precisions[i] = 0.0\\n\\n if max(precisions) > 0:\\n p_log_sum = sum(math.log(p) for p in precisions if p)\\n geo_mean = math.exp(p_log_sum / max_order)\\n\\n if use_bp:\\n ratio = translation_length / reference_length\\n bp = math.exp(1 - 1. / ratio) if ratio < 1.0 else 1.0\\n bleu = geo_mean * bp\\n return np.float32(bleu)\",\n \"def compute_bleu(correct: List[int],\\n total: List[int],\\n sys_len: int,\\n ref_len: int,\\n smooth_method = 'none',\\n smooth_value = None,\\n use_effective_order = False) -> BLEU:\\n if smooth_method in SMOOTH_VALUE_DEFAULT and smooth_value is None:\\n smooth_value = SMOOTH_VALUE_DEFAULT[smooth_method]\\n\\n precisions = [0 for x in range(NGRAM_ORDER)]\\n\\n smooth_mteval = 1.\\n effective_order = NGRAM_ORDER\\n for n in range(1, NGRAM_ORDER + 1):\\n if smooth_method == 'add-k' and n > 1:\\n correct[n-1] += smooth_value\\n total[n-1] += smooth_value\\n if total[n-1] == 0:\\n break\\n\\n if use_effective_order:\\n effective_order = n\\n\\n if correct[n-1] == 0:\\n if smooth_method == 'exp':\\n smooth_mteval *= 2\\n precisions[n-1] = 100. / (smooth_mteval * total[n-1])\\n elif smooth_method == 'floor':\\n precisions[n-1] = 100. * smooth_value / total[n-1]\\n else:\\n precisions[n-1] = 100. * correct[n-1] / total[n-1]\\n\\n # If the system guesses no i-grams, 1 <= i <= NGRAM_ORDER, the BLEU score is 0 (technically undefined).\\n # This is a problem for sentence-level BLEU or a corpus of short sentences, where systems will get no credit\\n # if sentence lengths fall under the NGRAM_ORDER threshold. This fix scales NGRAM_ORDER to the observed\\n # maximum order. It is only available through the API and off by default\\n\\n brevity_penalty = 1.0\\n if sys_len < ref_len:\\n brevity_penalty = math.exp(1 - ref_len / sys_len) if sys_len > 0 else 0.0\\n\\n score = brevity_penalty * math.exp(sum(map(my_log, precisions[:effective_order])) / effective_order)\\n\\n return BLEU(score, correct, total, precisions, brevity_penalty, sys_len, ref_len)\",\n \"def eval_metrics_for_seqtags(self, predicted_answers):\\n total_correct_in_all = 0\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids, include padding ids.\\n correct_label_indices = sample['correct_seq_labels']\\n # use extend to add all the labels in the seq, include the head padding and tail padding\\n label_true.extend(correct_label_indices)\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n label_pred.extend(sample['pred_seq_tags'])\\n\\n if total_correct_in_all != 0:\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\\n title='Confusion matrix when seq labeling, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\\n title='Normalized confusion matrix when seq labeling')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def prediction_processing(predictions, labels, threshold, step_nb):\\n new_labels = []\\n new_predictions = []\\n number_sequences = step_nb//50\\n\\n for k in range(len(labels)//number_sequences):\\n total_prediction = 0\\n isLabelTrue = labels[number_sequences*k]\\n for i in range(number_sequences):\\n total_prediction += (1/predictions[number_sequences*k+i])\\n if not(isLabelTrue == (labels[number_sequences*k+i])):\\n logger.error('Problem.')\\n if total_prediction > threshold:\\n total_prediction = False\\n else:\\n total_prediction = True\\n new_labels.append(isLabelTrue)\\n new_predictions.append(total_prediction)\\n\\n recall_1 = recall_score(new_labels, new_predictions)\\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\\n precision_1 = precision_score(new_labels, new_predictions)\\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)\",\n \"def predict(self, test_vectors):\\n # Calculate the best matching label for each node\\n if not self.ready_for_prediction:\\n # totals = sum((node.labels for node in self.codebook), Counter())\\n for node in self.codebook:\\n # Remove unlabeled hits\\n try:\\n node.labels.pop(None)\\n except KeyError:\\n pass\\n # # Take into account small clusters. A frequency approach\\n # freq_counter = Counter({label: count / totals[label]\\n # for label, count in node.labels.items()})\\n # if len(freq_counter) > 0:\\n # node.label = freq_counter.most_common(1)[0][0]\\n # else:\\n # node.label = ''\\n # Or ignore small clusters and just aim for accuracy\\n if len(node.labels) > 0:\\n node.label = node.labels.most_common(1)[0][0]\\n else:\\n node.label = ''\\n self.ready_for_prediction = True\\n\\n # Return the label of the best matching unit for the given test_vectors\\n if isinstance(test_vectors, collections.Iterable):\\n return [self.bmu(test_vector).label for test_vector in test_vectors]\\n else:\\n return self.bmu(test_vectors).label\",\n \"def score_sequence(seq, ngramlogprobs):\\n return\",\n \"def predictability(self):\\n temp = self.probs\\n for n in range(10):\\n temp = temp.dot(temp)\\n final = temp[0,:]\\n #Let's assume that all words have unique initial letters\\n probs = map(len, self.words)\\n probs = array(probs)\\n probs = (probs + self.probs.max(1)-1)/probs\\n return sum(final*probs)\",\n \"def score(label_recall, label_precision, pred_recall, pred_precision):\\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\\n\\n return 0.4*f11 + 0.6*f12\",\n \"def compute_blue_ngram(x1_list,x2_list):\\r\\n count_dict={}\\r\\n count_dict_clip={}\\r\\n #1. count for each token at predict sentence side.\\r\\n for token in x1_list:\\r\\n if token not in count_dict:\\r\\n count_dict[token]=1\\r\\n else:\\r\\n count_dict[token]=count_dict[token]+1\\r\\n count=np.sum([value for key,value in count_dict.items()])\\r\\n\\r\\n #2.count for tokens existing in predict sentence for target sentence side.\\r\\n for token in x2_list:\\r\\n if token in count_dict:\\r\\n if token not in count_dict_clip:\\r\\n count_dict_clip[token]=1\\r\\n else:\\r\\n count_dict_clip[token]=count_dict_clip[token]+1\\r\\n\\r\\n #3. clip value to ceiling value for that token\\r\\n count_dict_clip={key:(value if value<=count_dict[key] else count_dict[key]) for key,value in count_dict_clip.items()}\\r\\n count_clip=np.sum([value for key,value in count_dict_clip.items()])\\r\\n result=float(count_clip)/(float(count)+0.00000001)\\r\\n return result\",\n \"def classify(texts: List[str], params: Any) -> List[str]:\\n\\n alpha = 1\\n token_probs_pos = params[\\\"token_probs_pos\\\"]\\n token_probs_neg = params[\\\"token_probs_neg\\\"]\\n all_words = params[\\\"all_words\\\"]\\n M = len(all_words)\\n cnt_pos_docs = params[\\\"cnt_pos_docs\\\"]\\n cnt_neg_docs = params[\\\"cnt_neg_docs\\\"]\\n\\n sum_len_neg = params[\\\"sum_len_neg\\\"]\\n sum_len_pos = params[\\\"sum_len_pos\\\"]\\n pos_dict = params[\\\"pos_dict\\\"]\\n neg_dict = params[\\\"neg_dict\\\"]\\n\\n\\n test_texts = preprocessing(texts)\\n test_tokenized_texts = text_to_tokens(test_texts)\\n \\n res = []\\n log_pos_probablity = 0\\n log_neg_probablity = 0\\n i = 0\\n for text in test_tokenized_texts:\\n if (i % 5000 == 0):\\n print(\\\"Classified\\\", i, \\\"texts\\\")\\n i += 1\\n log_pos_probablity = log(cnt_pos_docs)\\n log_neg_probablity = log(cnt_neg_docs)\\n for token in text:\\n if (token_probs_pos[token] == 0):\\n token_probs_pos[token] = alpha / (alpha * M + sum_len_pos)\\n else:\\n log_pos_probablity += log(token_probs_pos[token])\\n if (token_probs_neg[token] == 0):\\n token_probs_neg[token] = alpha / (alpha * M + sum_len_neg)\\n else:\\n log_neg_probablity += log(token_probs_neg[token])\\n if (log_neg_probablity > log_pos_probablity):\\n res.append(\\\"neg\\\")\\n #for token in text:\\n # all_words.add(token)\\n # M = len(all_words)\\n # neg_dict[token] += text[token]\\n # sum_len_neg += text[token]\\n # token_probs_neg[token] = (alpha + neg_dict[token]) / (alpha * M + sum_len_neg)\\n\\n else:\\n res.append(\\\"pos\\\")\\n #for token in text:\\n # all_words.add(token)\\n # M = len(all_words)\\n # pos_dict[token] += text[token]\\n # sum_len_pos += text[token]\\n # token_probs_pos[token] = (alpha + pos_dict[token]) / (alpha * M + sum_len_pos)\\n\\n\\n \\n print('Predicted labels counts:')\\n print(count_labels(res))\\n return res\",\n \"def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\\\\n \\\"missing keys: {}\\\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\\n scores = {}\\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\\n for i, bleu_score in enumerate(bleu_scores):\\n scores['Bleu-%d' % (i + 1)] = bleu_score\\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\\n scores['Rouge-L'] = rouge_score\\n return scores\",\n \"def eval_metrics_for_multiclass(self, predicted_answers):\\n total_correct_in_all = 0\\n total_pred_in_all = len(predicted_answers)\\n # initial a dict for total correct in topK counting.\\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\\n max_topK = max(self.topK_list)\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids\\n correct_label_indices = sample['correct_labels']\\n # current case, we only have a majority lable for the correct label\\n label_true.append(correct_label_indices[0])\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\\n top1_pred = sorted_probs_max_topK[0]\\n label_pred.append(top1_pred['label_index'])\\n\\n # for all topK predictions\\n for i in range(len(sorted_probs_max_topK)):\\n pred = sorted_probs_max_topK[i]\\n for topK in self.topK_list:\\n if i >= topK:\\n continue\\n else:\\n total_pred_in_topK[topK] += 1\\n if pred['label_index'] in correct_label_indices:\\n total_correct_in_topK[topK] += 1\\n\\n if total_correct_in_all != 0:\\n # recall@K\\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\\n # assign recall@K into metrics\\n for k, v in recall_at_K.items():\\n # Jie\\n # 1 means the greater the better.\\n # -1 means the smaller the better.\\n metrics['R@{}'.format(k)] = (1, v)\\n\\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\\n # here return all the p,r,f for each label, then we compute the micro average later.\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\\n title='Confusion matrix, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\\n title='Normalized confusion matrix')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def evaluate_ngrams(eval_dataset, trigram_counts, bigram_counts, unigram_counts, train_token_count, lambda1, lambda2):\\n perplexity = 0\\n\\n ### YOUR CODE HERE\\n def calc_prob(sentense, i, word, trigram_counts, bigram_counts, unigram_counts, train_token_count, model):\\n prob = 0.0\\n prev_word = sentense[i - 1]\\n prev_to_prev_word = sentense[i - 2]\\n\\n if model == \\\"unigram\\\":\\n if word in unigram_counts:\\n prob = (unigram_counts[word] + 0.0) / train_token_count\\n else:\\n prob = (unigram_counts[word_to_num['UUUNKKK']] + 0.0) / \\\\\\n train_token_count\\n\\n if model == \\\"bigram\\\":\\n if (prev_word, word) in bigram_counts:\\n prob = (bigram_counts[(prev_word, word)] + 0.0) / \\\\\\n unigram_counts[prev_word]\\n # print(num_to_word[prev_word] ,num_to_word[word])\\n # print(bigram_counts[(prev_word, word)])\\n # print(unigram_counts[prev_word])\\n # print(\\\"---------------------------\\\")\\n else:\\n prob = 0.0\\n\\n if model == \\\"trigram\\\":\\n if (prev_to_prev_word, prev_word, word) in trigram_counts:\\n prob = (trigram_counts[(prev_to_prev_word, prev_word, word)] + 0.0) \\\\\\n / bigram_counts[(prev_to_prev_word, prev_word)]\\n # / bigram_counts[(prev_word, word)] #this according to lecture notes slide 27\\n else:\\n prob = 0.0\\n\\n return prob\\n\\n l = 0\\n num_of_words = 0\\n\\n ##########3\\n better_than_chance = 0\\n ###########\\n\\n for sentense in eval_dataset:\\n for i, word in enumerate(sentense[2:]):\\n num_of_words += 1\\n prob = lambda1 * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts, unigram_counts,\\n train_token_count, \\\"trigram\\\") + \\\\\\n lambda2 * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts, unigram_counts,\\n train_token_count, \\\"bigram\\\") + \\\\\\n (1 - lambda1 - lambda2) * calc_prob(sentense, i + 2, word, trigram_counts, bigram_counts,\\n unigram_counts, train_token_count, \\\"unigram\\\")\\n ######################################\\n if prob > (1.0 / vocabsize):\\n better_than_chance += 1\\n #########################\\n l += np.log2(prob)\\n l /= num_of_words\\n perplexity = 2 ** -l\\n\\n print(\\\"better_than_chance:\\\", (better_than_chance + 0.0) / num_of_words)\\n\\n ### END YOUR CODE\\n return perplexity\",\n \"def compute_score(predictions, references, vocab=None, beam_size=4):\\n assert np.rank(predictions) == 3\\n assert predictions.shape[0] == references.shape[0]\\n batch_size = predictions.shape[0]\\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\\n hypotheses_list = []\\n references_list = []\\n\\n for index in range(batch_size):\\n # All predictions in beam search are used for validation scores.\\n for b_index in range(beam_size):\\n h = predictions[index][b_index]\\n try:\\n eos_index = h.index(input_utils.EOS)\\n except ValueError:\\n eos_index = len(h)\\n hypotheses_list.append(h[:eos_index])\\n\\n ref = references[index][0].decode().split('|')\\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\\n references_list.append(ref_list)\\n\\n all_scores = collections.defaultdict(list)\\n for hypothesis, references in zip(hypotheses_list, references_list):\\n if vocab is not None and len(vocab):\\n # Skip PADDING, UNK, EOS, START (0-3).\\n hypothesis = [\\n vocab[word_id].numpy().decode()\\n for word_id in hypothesis\\n if word_id > 3\\n ]\\n\\n h_str = ' '.join(str(e) for e in hypothesis)\\n r_str = [' '.join(str(e) for e in ref) for ref in references]\\n\\n print('hypothesis: ', str(h_str))\\n print('references: ', str(r_str))\\n print('\\\\n')\\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\\n for key, score in scores.items():\\n all_scores[key].append(score)\\n score_names = [\\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\\n ]\\n\\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]\",\n \"def PredictReviewScore(self, sentences, label=0):\\n AdjR = 0.0\\n # if text.startswith(\\\"For more photos and reviews do check out fourleggedfoodies\\\"):\\n # x = 1\\n adjAll = []\\n for sentence in sentences:\\n adjectives, dependencies = self.ExtractSentDetails(sentence)\\n adjAll.extend(adjectives)\\n allAdjectives = adjectives | Angel.GlobalAdjList\\n AdjS = 0.0\\n words = wordpunct_tokenize(sentence[\\\"Text\\\"])\\n if len(words) <= 3:\\n allAdjectives |= set([x.lower() for x in words])\\n for i in range(len(words)):\\n word = words[i].lower()\\n if word in {\\\"but\\\", \\\"if\\\"}:\\n AdjS = 0.0\\n elif word in allAdjectives and word in self.lexicon:\\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\\n AdjR += AdjS\\n AdjR *= self.PredictBase(adjAll)\\n finalScore = AdjR\\n if self.DumpRequested(finalScore, label):\\n self.DumpDetails(sentences, label)\\n return finalScore\",\n \"def compute_confuse_matrix(y_targetlabel_list_single, y_logit_array_single, label_dict, name='default'):\\n #1.get target label and predict label\\n # y_target_labels=get_target_label_short(y_targetlabel_list_single) #e.g. y_targetlabel_list[0]=[2,12,88]\\n y_target_labels = y_targetlabel_list_single\\n\\n # y_predict_labels=[i for i in range(len(y_logit_array_single)) if y_logit_array_single[i]>=0.50] #TODO 0.5PW e.g.[2,12,13,10]\\n # y_predict_labels= y_logit_array_single.index(min(y_logit_array_single))\\n\\n flag = max(y_logit_array_single)\\n y_predict_labels = []\\n for i in range(len(y_logit_array_single)):\\n if abs(y_logit_array_single[i] - flag) < 0.1:\\n y_predict_labels.append(i)\\n\\n a = list(set(y_target_labels))\\n b = list(set(y_predict_labels))\\n acc = operator.eq(a,b)\\n\\n #if len(y_predict_labels)<1: y_predict_labels=[np.argmax(y_logit_array_single)] #TODO ADD 2018.05.29\\n if random.choice([x for x in range(random_number)]) ==1:\\n print(name+\\\".y_target_labels:\\\",y_target_labels,\\\";y_predict_labels:\\\",y_predict_labels) #debug purpose\\n\\n #2.count number of TP,FP,FN for each class\\n y_labels_unique=[]\\n y_labels_unique.extend(y_target_labels)\\n y_labels_unique.extend(y_predict_labels)\\n y_labels_unique=list(set(y_labels_unique))\\n for i,label in enumerate(y_labels_unique): #e.g. label=2\\n TP, FP, FN = label_dict[label]\\n if label in y_predict_labels and label in y_target_labels:#predict=1,truth=1 (TP)\\n TP=TP+1\\n elif label in y_predict_labels and label not in y_target_labels:#predict=1,truth=0(FP)\\n FP=FP+1\\n elif label not in y_predict_labels and label in y_target_labels:#predict=0,truth=1(FN)\\n FN=FN+1\\n label_dict[label] = (TP, FP, FN)\\n return label_dict, acc\",\n \"def performClassification(ngram, df, mode = None, split = 0.9):\\r\\n \\r\\n if type(mode) == str:\\r\\n X = df[mode.capitalize()]\\r\\n else:\\r\\n X = df.Features\\r\\n \\r\\n y = df.Label\\r\\n\\r\\n X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1, train_size = split)\\r\\n \\r\\n vect = CountVectorizer(analyzer='word', ngram_range=(ngram,ngram))\\r\\n \\r\\n X_train_dtm = vect.fit_transform(X_train)\\r\\n X_test_dtm = vect.transform(X_test)\\r\\n \\r\\n nb = MultinomialNB()\\r\\n svm = LinearSVC(random_state = 1)\\r\\n\\r\\n nb.fit(X_train_dtm, y_train)\\r\\n svm.fit(X_train_dtm, y_train)\\r\\n\\r\\n nb_pred_class = nb.predict(X_test_dtm)\\r\\n svm_pred_class = svm.predict(X_test_dtm)\\r\\n\\r\\n nb_accuracy = metrics.accuracy_score(y_test, nb_pred_class)\\r\\n nb_precision = metrics.precision_score(y_test, nb_pred_class, pos_label='negative')\\r\\n nb_recall = metrics.recall_score(y_test, nb_pred_class, pos_label='negative')\\r\\n nb_f1 = metrics.f1_score(y_test, nb_pred_class, pos_label='negative')\\r\\n\\r\\n svm_accuracy = metrics.accuracy_score(y_test, svm_pred_class)\\r\\n svm_precision = metrics.precision_score(y_test, svm_pred_class, pos_label='negative')\\r\\n svm_recall = metrics.recall_score(y_test, svm_pred_class, pos_label='negative')\\r\\n svm_f1 = metrics.f1_score(y_test, svm_pred_class, pos_label='negative')\\r\\n\\r\\n print('=====Naive Bayes===== \\\\t =====Linear SVC=====' )\\r\\n print('Accuracy score \\\\t\\\\t Accuracy score')\\r\\n print(round((nb_accuracy * 100), 1), '\\\\t\\\\t\\\\t', round((svm_accuracy * 100), 1), '\\\\n')\\r\\n print('Precision \\\\t\\\\t Precision')\\r\\n print(round((nb_precision * 100), 1), '\\\\t\\\\t\\\\t', round((svm_precision * 100), 1), '\\\\n')\\r\\n print('Recall \\\\t\\\\t\\\\t Recall')\\r\\n print(round((nb_recall * 100), 1), '\\\\t\\\\t\\\\t', round((svm_recall * 100), 1), '\\\\n')\\r\\n print('F1-score \\\\t\\\\t F1-score')\\r\\n print(round((nb_f1 * 100), 1), '\\\\t\\\\t\\\\t', round((svm_f1 * 100), 1))\",\n \"def predict(self, X):\\n words = X.split()\\n chance = []\\n for cur_label in self.model[\\\"labels\\\"]:\\n probability = self.model[\\\"labels\\\"][cur_label][\\\"probability\\\"]\\n total_grade = math.log(probability, math.e)\\n for word in words:\\n word_dict = self.model[\\\"words\\\"].get(word, None)\\n if word_dict:\\n total_grade += math.log(word_dict[cur_label], math.e)\\n chance.append((total_grade, cur_label))\\n _, prediction = max(chance)\\n return prediction\",\n \"def sentence_accuracy(references, predictions):\\n count = 0.0\\n match = 0.0\\n for label, pred in zip(references, predictions):\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def _word_accuracy(label_file, pred_file,subword_option=None):\\n\\n with open(label_file, \\\"r\\\", encoding='utf-8') as label_fh:\\n with open(pred_file, \\\"r\\\", encoding='utf-8') as pred_fh:\\n total_acc, total_count = 0., 0.\\n for sentence in label_fh:\\n sentence = \\\" \\\".join(_clean(sentence, subword_option))\\n labels = sentence.strip().split(\\\" \\\")\\n preds = \\\" \\\".join(_clean(pred_fh.readline(), subword_option))\\n preds = preds.strip().split(\\\" \\\")\\n match = 0.0\\n for pos in range(min(len(labels), len(preds))):\\n label = labels[pos]\\n pred = preds[pos]\\n if label == pred:\\n match += 1\\n total_acc += 100 * match / max(len(labels), len(preds))\\n total_count += 1\\n return total_acc / total_count\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def _self_bleu(completions: List[Sequence], **unused_kwargs) -> float:\\n completion_sequences: List[str] = [completion.text.strip() for completion in completions if completion.text.strip()]\\n\\n if len(completion_sequences) <= 1:\\n return 0\\n\\n scores = []\\n for i in range(len(completion_sequences)):\\n hypothesis = completion_sequences[i]\\n references = completion_sequences[:i] + completion_sequences[i + 1 :]\\n\\n # Enable `effective_order` for sentence-level BLEU.\\n score = BLEU(effective_order=True).sentence_score(hypothesis=hypothesis, references=references)\\n scores.append(score.score)\\n return sum(scores) / len(scores)\",\n \"def _accuracy(label_file, pred_file,subword_option=None):\\n\\n with open(label_file, \\\"r\\\", encoding='utf-8') as label_fh:\\n with open(pred_file, \\\"r\\\", encoding='utf-8') as pred_fh:\\n count = 0.0\\n match = 0.0\\n for label in label_fh:\\n label = label.strip()\\n label = \\\" \\\".join(_clean(label,subword_option))\\n pred = pred_fh.readline().strip()\\n pred = \\\" \\\".join(_clean(pred,subword_option))\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def word_accuracy(references, predictions):\\n total_acc, total_count = 0., 0.\\n for labels, preds in zip(references, predictions):\\n match = 0.0\\n for pos in range(min(len(labels), len(preds))):\\n label = labels[pos]\\n pred = preds[pos]\\n if label == pred:\\n match += 1\\n total_acc += 100 * match / max(len(labels), len(preds))\\n total_count += 1\\n return total_acc / total_count\",\n \"def predictRating(self, writtenReview):\\n totalScores = [0] * 6\\n sentence = writtenReview.split()\\n \\n for word in sentence:\\n if word in self.dictionary:\\n wordScores = self.dictionary[word].getTFIDF()\\n for i in range(1, len(totalScores)):\\n totalScores[i] += wordScores[i]\\n\\n maxIndex = totalScores.index(max(totalScores))\\n if maxIndex == 0:\\n return 5\\n return maxIndex\",\n \"def okapi_best_match(tf_q, idf_q, doc_len, avgdl, k=0.2, b=0.75):\\r\\n score = (tf_q * idf_q * (k + 1)) / (tf_q + k * (1 - b + b * doc_len / avgdl))\\r\\n return score\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\r\\n # TODO: Write your code here\\r\\n # return predicted labels of development set\\r\\n retval = []\\r\\n smoothing_parameter = 0.0055\\r\\n # Generate a unigram BOW for both positive and negative reviews, choose the top 2500 words\\r\\n pos_bow, neg_bow = generate_unigram_BOW(train_set, train_labels)\\r\\n sorted_pos = sorted(pos_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n sorted_neg = sorted(neg_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n pos_words = sorted_pos[:].copy()\\r\\n neg_words = sorted_neg[:].copy()\\r\\n\\r\\n pos_bi_bow, neg_bi_bow = generate_bigram_BOW(train_set, train_labels)\\r\\n sorted_bi_pos = sorted(pos_bi_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n sorted_bi_neg = sorted(neg_bi_bow.items(), key=lambda x: x[1], reverse = True)\\r\\n bi_pos_words = sorted_bi_pos[:].copy()\\r\\n bi_neg_words = sorted_bi_neg[:].copy()\\r\\n\\r\\n # Calculate the log probabilities each word given type\\r\\n pos_count = sum(pair[1] for pair in pos_words)\\r\\n neg_count = sum(pair[1] for pair in neg_words)\\r\\n bi_pos_count = sum(pair[1] for pair in bi_pos_words)\\r\\n bi_neg_count = sum(pair[1] for pair in bi_neg_words)\\r\\n\\r\\n log_probability_pos = {} #(word)->P(word|positive)\\r\\n log_probability_neg = {} #(word)->P(word|negative)\\r\\n log_prob_bi_pos = {}\\r\\n log_prob_bi_neg = {}\\r\\n\\r\\n for pair in pos_words:\\r\\n pos_prob = np.log((pair[1]+smoothing_parameter)/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\\r\\n log_probability_pos[pair[0]] = pos_prob\\r\\n\\r\\n for pair in neg_words:\\r\\n neg_prob = np.log((pair[1]+smoothing_parameter)/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\\r\\n log_probability_neg[pair[0]] = neg_prob\\r\\n\\r\\n for pair in bi_pos_words:\\r\\n bi_pos_prob = np.log((pair[1]+smoothing_parameter)/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\\r\\n log_prob_bi_pos[pair[0]] = bi_pos_prob\\r\\n\\r\\n for pair in bi_neg_words:\\r\\n bi_neg_prob = np.log((pair[1]+smoothing_parameter)/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\\r\\n log_prob_bi_neg[pair[0]] = bi_neg_prob\\r\\n # Finished training\\r\\n\\r\\n # For each of the new reviews from development data\\r\\n for review in dev_set:\\r\\n uni_pos = np.log(pos_prior)\\r\\n uni_neg = np.log(1 - pos_prior)\\r\\n for word in review:\\r\\n if word in log_probability_pos:\\r\\n uni_pos += log_probability_pos[word]\\r\\n elif word not in log_probability_pos:\\r\\n uni_pos += np.log(smoothing_parameter/(pos_count+smoothing_parameter*(len(pos_words) + 1)))\\r\\n\\r\\n if word in log_probability_neg:\\r\\n uni_neg += log_probability_neg[word]\\r\\n elif word not in log_probability_neg:\\r\\n uni_neg += np.log(smoothing_parameter/(neg_count+smoothing_parameter*(len(neg_words) + 1)))\\r\\n\\r\\n bi_pos = np.log(pos_prior)\\r\\n bi_neg = np.log(1 - pos_prior)\\r\\n for i in range(len(review)-1):\\r\\n currTuple = (review[i], review[i+1])\\r\\n if currTuple in log_prob_bi_pos:\\r\\n bi_pos += log_prob_bi_pos[currTuple]\\r\\n elif currTuple not in log_prob_bi_pos:\\r\\n bi_pos += np.log(smoothing_parameter/(bi_pos_count+smoothing_parameter*(len(bi_pos_words) + 1)))\\r\\n\\r\\n if currTuple in log_prob_bi_neg:\\r\\n bi_neg += log_prob_bi_neg[currTuple]\\r\\n elif currTuple not in log_prob_bi_neg:\\r\\n bi_neg += np.log(smoothing_parameter/(bi_neg_count+smoothing_parameter*(len(bi_neg_words) + 1)))\\r\\n\\r\\n MAP_pos = (1-0.4)*uni_pos + 0.4*bi_pos\\r\\n MAP_neg = (1-0.4)*uni_neg + 0.4*bi_neg\\r\\n\\r\\n if MAP_pos >= MAP_neg:\\r\\n retval.append(1)\\r\\n else:\\r\\n retval.append(0)\\r\\n\\r\\n return retval\",\n \"def evaluate(self, prediction_fn, save_dir=None, save_name=\\\"translation_eval.txt\\\", batched=None):\\n if batched:\\n src_sents = [src for (src, tgt) in self.task_data]\\n chunked_sents = list(chunks(src_sents, batched))\\n predictions = [prediction_fn(sents) for sents in tqdm.tqdm(chunked_sents, desc=\\\"predicting\\\", total=len(chunked_sents))]\\n predictions = [val for sublist in predictions for val in sublist] # flattening\\n else:\\n predictions = [prediction_fn(src) for (src, tgt) in tqdm.tqdm(self.task_data, desc=\\\"predicting\\\")]\\n \\n # BLEU calculation\\n BLEU_scores = []\\n for (src, tgt), pred in tqdm.tqdm(list(zip(self.task_data, predictions)), desc=\\\"calculating bleu\\\"):\\n BLEU_score = nltk_bleu(self.tgt_splitter(tgt), self.tgt_splitter(pred))\\n BLEU_scores.append(BLEU_score)\\n total_BLEU = np.average(BLEU_scores)\\n \\n # Write to file\\n if save_dir != None:\\n save_path = os.path.join(save_dir, save_name)\\n print(f\\\"saving translation eval to file: {save_path}\\\")\\n with open(save_path, \\\"w\\\", encoding=\\\"utf-8\\\") as out_fp:\\n for (src, tgt), pred, BLEU in zip(self.task_data, predictions, BLEU_scores):\\n\\n out_fp.write(\\\"SRC :\\\" + src + \\\"\\\\n\\\")\\n out_fp.write(\\\"TGT :\\\" + tgt + \\\"\\\\n\\\")\\n out_fp.write(\\\"PRED :\\\" + pred + \\\"\\\\n\\\")\\n out_fp.write(\\\"BLEU :\\\" + str(BLEU) + \\\"\\\\n\\\")\\n out_fp.write(\\\"\\\\n\\\")\\n\\n out_fp.write(\\\"\\\\n\\\\n| EVALUATION | BLEU: {:5.2f} |\\\\n\\\".format(total_BLEU))\\n print(\\\"| EVALUATION | BLEU: {:5.3f} |\\\".format(total_BLEU))\\n \\n return {\\\"BLEU\\\":total_BLEU}\",\n \"def _detection_scores(inputs, gt_boxes, gt_labels, model):\\n model = check_model('model', model, BlackModel)\\n boxes_and_confi, pred_labels = model.predict(*inputs)\\n det_scores = []\\n correct_labels_num = []\\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\\n iou_thres = 0.5\\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\\n gt_box_num = gt_box.shape[0]\\n score = 0\\n box_num = boxes.shape[0]\\n correct_label_flag = np.zeros(gt_label.shape)\\n for i in range(box_num):\\n pred_box = boxes[i]\\n max_iou_confi = 0\\n for j in range(gt_box_num):\\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\\n correct_label_flag[j] = 1\\n score += max_iou_confi\\n det_scores.append(score)\\n correct_labels_num.append(np.sum(correct_label_flag))\\n return np.array(det_scores), np.array(correct_labels_num)\",\n \"def _bleu(ref_file, trans_file,max_order=4, subword_option=None):\\n smooth = False\\n\\n ref_files = [ref_file]\\n reference_text = []\\n for reference_filename in ref_files:\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(reference_filename, \\\"rb\\\")) as fh:\\n reference_text.append(fh.readlines())\\n\\n per_segment_references = []\\n for references in zip(*reference_text):\\n reference_list = []\\n for reference in references:\\n reference = _clean(reference, subword_option)\\n reference_list.append(reference.split(\\\" \\\"))\\n per_segment_references.append(reference_list)\\n\\n print(per_segment_references[0:15])\\n\\n translations = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(trans_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n line = _clean(line, subword_option=subword_option)\\n translations.append(line.split(\\\" \\\"))\\n print(translations[0:15])\\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\\n per_segment_references, translations, max_order, smooth)\\n return 100 * bleu_score\",\n \"def label_accuracies(preds, labels):\\n num_correct = num_correct_fun(preds, labels)\\n return (num_correct / preds.size(0)) * 100.0\",\n \"def PredictMatch(yourName, tgtName, teamModels, db):\\n\\n teamTgtPipe, teamYourPipe = QueryTeamData(tgtName, yourName, db)\\n featureCoefTgt, probTgt = PredictOp(teamTgtPipe, teamYourPipe, tgtName, teamModels)\\n featureCoefYour, probYour = PredictOp(teamYourPipe, teamTgtPipe, yourName, teamModels)\\n odds = round(probYour / (probYour + probTgt), 2)\\n\\n # In featureCoefYour, you want INCREASE those with POSTIVE COEF, DECREASE those with NEGATIVE COEF\\n # In featureCoefTgt, you want to do the opposite\\n\\n # reverse both the sign of the coef, and '_op' in features so as to be the same with featureCoefYour\\n featureCoefTgt['coef'] = - featureCoefTgt['coef']\\n featureCoefTgt.features = [ii[:-3] if \\\"_op\\\" in ii else ii + '_op' for ii in featureCoefTgt.features]\\n\\n # Combine only the most important 10 features\\n # featureBoth = featureCoefTgt[11:].append(featureCoefYour[11:])\\n\\n # Combine only all the most important features\\n featureBoth = featureCoefTgt.append(featureCoefYour)\\n\\n # get action recommendations\\n # Somehow the pandas here uses a deprecated para cols, instaed of the new one subset\\n #featureBoth.drop_duplicates(subset = 'features', take_last = True, inplace = True)\\n featureBoth.drop_duplicates(cols = 'features', take_last = True, inplace = True)\\n actions, featureImprove = GetActions(featureBoth)\\n Imp = 0.1\\n oddsNew = ImprovedScore(tgtName, yourName, teamModels, featureImprove, teamTgtPipe, teamYourPipe, Imp)\\n\\n return odds, oddsNew, actions\",\n \"def calc_metrics(pred, labels):\\n pred_flat = np.argmax(pred, axis = 1).flatten()\\n labels_flat = labels.flatten()\\n \\n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\\n \\n # sklearn takes first parameter as the true label\\n precision = precision_score(labels_flat, pred_flat)\\n recall = recall_score(labels_flat, pred_flat)\\n \\n return flat_accuracy, precision, recall\",\n \"def predict_ensemble(test_df):\\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \\n for review in list(test_df.review)]\\n model_paths = glob('output_*/model.tar.gz')\\n all_predicted_labels = []\\n for model_path in model_paths:\\n archive = load_archive(model_path) # load trained model\\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \\n for instance in instances]\\n all_predicted_labels.append(predicted_labels)\\n all_predicted_labels = np.array(all_predicted_labels)\\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\\n test_df['rating'] = predicted_labels_vote\\n return test_df.drop('review', axis=1)\",\n \"def accuracies(actual_labels, predicted_labels):\\n acc = 0\\n letter_acc = 0\\n letter_cnt = 0\\n cnt = 0\\n for i in range(len(actual_labels)):\\n predicted_output = predicted_labels[i]\\n actual_output = actual_labels[i]\\n cnt += 1\\n for j in range(min(len(predicted_output), len(actual_output))):\\n if predicted_output[j] == actual_output[j]:\\n letter_acc += 1\\n letter_cnt += max(len(predicted_output), len(actual_output))\\n if actual_output == predicted_output:\\n acc += 1\\n final_accuracy = np.round((acc / len(actual_labels)) * 100, 2)\\n final_letter_accuracy = np.round((letter_acc / letter_cnt) * 100, 2)\\n return final_accuracy, final_letter_accuracy\",\n \"def eval_foreign(cls_prob, dtrain):\\n \\n labels = dtrain.get_label()\\n pred = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\\n users_idx = np.logical_or(labels != 7, labels != 10)\\n#only retain the labels for users who chose foreign destinations\\n labels = labels[users_idx]\\n pred = pred[users_idx,:]\\n labels = labels[:, None]\\n return 'error', 1-ndcg(pred, labels)/len(labels)\",\n \"def scores(self, y, y_pred):\\n\\n aucroc = 0.\\n precision = 0.\\n recall = 0.\\n f1 = 0.\\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n label_ratios = np.mean(y, axis=0)\\n\\n if len(y) > 1:\\n y_t = np.transpose(y)\\n col_keep = np.ones(len(y_t), dtype=bool)\\n for i, col_y in enumerate(y_t):\\n if 0 not in col_y or 1 not in col_y:\\n col_keep[i] = False\\n\\n if sum(col_keep) > 0:\\n if not col_keep.all():\\n y = np.transpose(y_t[col_keep])\\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\\n\\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\\n s = f1_score(y, self._round(y_pred), average=None)\\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\\n if sum(col_keep) > 1:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\\n else:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\\n elif self.verbose:\\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n elif len(y) == 1:\\n if self.verbose:\\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n result = {\\n 'aucroc': aucroc,\\n 'precision': precision,\\n 'recall': recall,\\n 'f1': f1,\\n 'aucroc_labs': aucroc_labs,\\n 'precision_labs': precision_labs,\\n 'recall_labs': recall_labs,\\n 'f1_labs': f1_labs,\\n 'label_ratios': label_ratios\\n }\\n\\n return result\",\n \"def string_f1_score(prediction, ground_truth):\\n prediction_tokens = normalize_answer(prediction).split()\\n ground_truth_tokens = normalize_answer(ground_truth).split()\\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def predict(net, query, context, graph, tokenizer, sentence_lengths, fb_passes=1):\\n\\n # (M,2), (1,M), (1,M), (1,3)\\n o_sup, o_start, o_end, o_type = net(query, context, graph, fb_passes=fb_passes)\\n\\n # =========== GET ANSWERS\\n answer_start = o_start.argmax() #TODO make sure that these tensors are all only containing one number!\\n answer_end = o_end.argmax()\\n answer_type = o_type.argmax()\\n if answer_type == 0:\\n answer = \\\"yes\\\"\\n elif answer_type == 1:\\n answer = \\\"no\\\"\\n elif answer_type == 2 and answer_end >= answer_start:\\n answer = tokenizer.decode(graph.tokens[answer_start: answer_end + 1])\\n else:\\n answer = \\\"noanswer\\\"\\n\\n # =========== GET SUPPORTING FACTS\\n pos = 0\\n sup_fact_pairs = []\\n for para, s_lens in zip(context, sentence_lengths):\\n for j, s_len in enumerate(s_lens):\\n #score = round(sum(o_sup.argmax([pos: pos + s_len])) / s_len)\\n # take avg of token-wise scores and round to 0 or 1\\n try:\\n score = round(float(sum([x.argmax() for x in o_sup.T[pos: pos + s_len]]) / float(s_len)))\\n except ZeroDivisionError:\\n score = 0\\n if score == 1:\\n sup_fact_pairs.append([para[0], j])\\n pos += s_len\\n\\n return answer, sup_fact_pairs\",\n \"def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n\\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n \\\"\\\"\\\"Get n-gram level f-score.\\\"\\\"\\\"\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\\n return f_score\",\n \"def score(self, sentence):\\n\\n\\n # TODO your code here\\n score = 0.0 \\n prevWord = \\\"\\\"\\n prevPrevWord = \\\"\\\"\\n newSentence = []\\n for word in sentence:\\n newSentence += word.split()\\n for currentWord in sentence:\\n currentWord = currentWord.strip(STRIP_CHARS)\\n currentWord = currentWord.lower()\\n if prevWord != \\\"\\\":\\n if prevPrevWord != \\\"\\\":\\n trigram = (prevPrevWord, prevWord, currentWord)\\n trigramCount = self.trigramCounts[trigram]\\n if trigramCount > 0:\\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\\n # Subtraction by 1 removes the add one count from the laplace\\n # smoothing\\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.totalBigramCounts)\\n else:\\n count = self.unigramCounts[currentWord]\\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.total)\\n else:\\n prevPrevWord = prevWord\\n prevWord = currentWord\\n else:\\n prevWord = currentWord\\n return -score\",\n \"def label_accuracy_score(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n # 一个batch里面可能有多个数据\\n # 通过迭代器将一个个数据进行计算\\n for lt, lp in zip(label_trues, label_preds):\\n # numpy.ndarray.flatten将numpy对象拉成1维\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n\\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\\n \\\"\\\"\\\"\\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\\n iu是召回率Recall，公式上面给出了\\n mean_iu就是对iu求了一个平均\\n freq是每一类被预测到的频率\\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\\n \\\"\\\"\\\"\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n # nanmean会自动忽略nan的元素求平均\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def evaluate_bias(ds: List[str], predicted: List[GENDER]) -> Dict:\\r\\n assert (len(ds) == len(predicted)) # must have same length to create tuples\\r\\n\\r\\n conf_dict = defaultdict(lambda: defaultdict(lambda: 0))\\r\\n total = defaultdict(lambda: 0) # increment values if we have any gender\\r\\n pred_cnt = defaultdict(lambda: 0)\\r\\n correct_cnt = defaultdict(lambda: 0) # increment values if true_gender == predicted_gender\\r\\n\\r\\n count_unknowns = defaultdict(lambda: 0)\\r\\n\\r\\n for (gold_gender, word_ind, sent, profession), pred_gender in zip(ds, predicted):\\r\\n # # IMPORTANTE NOTE :\\r\\n # need to works with .name of GENDER object for an unknown reason\\r\\n\\r\\n if isinstance(pred_gender, str): # can happen in spacy languages 'fr', 'es' or 'it\\r\\n pred_gender = SPACY_GENDER_TYPES[pred_gender]\\r\\n\\r\\n # tuples of values in ds and values in predicted\\r\\n if pred_gender.name == GENDER.ignore.name:\\r\\n continue # skip analysis of ignored words\\r\\n\\r\\n gold_gender = WB_GENDER_TYPES[gold_gender] # allows Winobias gender type conversion\\r\\n\\r\\n if pred_gender.name == GENDER.unknown.name:\\r\\n count_unknowns[gold_gender] += 1 # increment values for any unknown pred_gender\\r\\n\\r\\n profession = profession.lower()\\r\\n\\r\\n total[gold_gender] += 1\\r\\n\\r\\n if pred_gender.name == gold_gender.name:\\r\\n correct_cnt[gold_gender] += 1\\r\\n\\r\\n pred_cnt[pred_gender.name] += 1\\r\\n\\r\\n conf_dict[gold_gender][pred_gender] += 1\\r\\n\\r\\n all_total = sum(total.values())\\r\\n\\r\\n output_dict = {} # init output dictionnary\\r\\n # Compute metrics\\r\\n accuracy = round((sum(correct_cnt.values()) / all_total) * 100, 1) # compute accuracy\\r\\n output_dict['acc'] = accuracy\\r\\n\\r\\n if (total[GENDER.male] == 0) | (pred_cnt[GENDER.male.name] == 0): # Avoid ZeroDivisionError\\r\\n output_dict['f1_male'] = None\\r\\n else:\\r\\n recall_male = round((correct_cnt[GENDER.male] / total[GENDER.male]) * 100, 1) # compute metrics for male\\r\\n prec_male = round((correct_cnt[GENDER.male] / pred_cnt[GENDER.male.name]) * 100, 1)\\r\\n f1_male = round(calc_f1(prec_male, recall_male), 1)\\r\\n output_dict['f1_male'] = f1_male\\r\\n\\r\\n if (total[GENDER.female] == 0) | (pred_cnt[GENDER.female.name] == 0): # Avoid ZeroDivisionError\\r\\n output_dict['f1_female'] = None\\r\\n else:\\r\\n recall_female = round((correct_cnt[GENDER.female] / total[GENDER.female]) * 100, 1) # calcul metrics for female\\r\\n prec_female = round((correct_cnt[GENDER.female] / pred_cnt[GENDER.female.name]) * 100, 1)\\r\\n f1_female = round(calc_f1(prec_female, recall_female), 1)\\r\\n output_dict['f1_female'] = f1_female\\r\\n\\r\\n output_dict['unk_male'] = count_unknowns[GENDER.male]\\r\\n output_dict['unk_female'] = count_unknowns[GENDER.female]\\r\\n output_dict['unk_neutral'] = count_unknowns[GENDER.neutral]\\r\\n\\r\\n return output_dict\",\n \"def _rouge_n_score(pred: Sequence[str], target: Sequence[str], n_gram: int) ->Dict[str, Tensor]:\\n\\n def _create_ngrams(tokens: Sequence[str], n: int) ->Counter:\\n ngrams: Counter = Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\\n pred_ngrams, target_ngrams = _create_ngrams(pred, n_gram), _create_ngrams(target, n_gram)\\n pred_len, target_len = sum(pred_ngrams.values()), sum(target_ngrams.values())\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n hits = sum(min(pred_ngrams[w], target_ngrams[w]) for w in set(pred_ngrams))\\n return _compute_metrics(hits, max(pred_len, 1), max(target_len, 1))\",\n \"def label_predict(self, sentence):\\n index_words = FileUtils.index_sentence(sentence, self.word_to_index)\\n chunks = FileUtils.divide_sentence(index_words, Settings.seq_size)\\n result = np.zeros(Settings.class_num)\\n if Settings.cuda:\\n self.model.cuda()\\n \\n for chunk in chunks:\\n with torch.no_grad():\\n chunk = torch.from_numpy(np.asarray(chunk)).view(1, Settings.seq_size)\\n if Settings.cuda:\\n chunk = chunk.cuda()\\n \\n predict = self.model(chunk)\\n if Settings.cuda:\\n predict = predict.cpu()\\n predict = predict.numpy()[0]\\n result += predict\\n result /= len(chunks)\\n\\n target_index = np.argmax(result) + 1\\n label = self.index_to_label.get(str(target_index))\\n score = np.max(result)\\n return label, score\",\n \"def find_best_combination(train_data, model, probabilities):\\n logit_coef = 4\\n\\n df = pd.DataFrame(columns=['type', 'p1', 'p2', 'p3', 'p4', 'sentence'])\\n average = np.array([0., 0.])\\n nr_words = np.array([0, 0])\\n for sent, label in train_data[['content', 'type']].values:\\n words = model.get_line(sent.replace(\\\"\\\\n\\\", \\\"\\\"))[0]\\n probs = np.array([])\\n for word in words:\\n word = word.lower().strip(',.?!\\\"\\\\'-~')\\n if word == \\\"\\\":\\n continue\\n probs = np.append(probs, probabilities[word])\\n average[label] += probabilities[word]\\n nr_words[label] += 1\\n\\n p1 = np.mean(probs)\\n\\n probs_avoid_zero_division = np.array([max(1e-5, min(1 - 1e-5, p)) for p in probs])\\n logit_probs = np.log(probs_avoid_zero_division / (1 - probs_avoid_zero_division)) / logit_coef\\n logit_probs = [min(100, max(-100, l)) for l in logit_probs]\\n p2 = 1 / (1 + np.exp(-np.mean(logit_probs)))\\n\\n p3 = np.prod(probs / 0.5) / 2\\n\\n p4 = np.prod((1 - probs) / 0.5) / 2\\n\\n df = df.append({'type': label, 'p1': p1, 'p2': p2, 'p3': min(p3, 1000), 'p4': p4, 'sentence': sent},\\n ignore_index=True)\\n\\n avg_prob = sum(average) / sum(nr_words)\\n print(f'Average probability of all words in train set: {avg_prob}')\\n average = average / nr_words\\n print(f'Average: {average}, number: {nr_words}')\\n\\n print('Mean:')\\n l1 = df['p1'].values > 0.5\\n print(sum(l1 == df['type'].values) / df.shape[0])\\n print(sum((df['p1'].values > avg_prob) == df['type'].values) / df.shape[0])\\n\\n print('Logit:')\\n l2 = df['p2'].values > 0.5\\n print(sum(l2 == df['type'].values) / df.shape[0])\\n print(sum((df['p2'].values > avg_prob) == df['type'].values) / df.shape[0])\\n\\n print('Product:')\\n l3 = df['p3'].values > 1\\n print(sum(l3 == df['type'].values) / df.shape[0])\\n\\n print('Product inverted:')\\n l4 = df['p1'].values < 0.2\\n print(sum(l4 == df['type'].values) / df.shape[0])\\n\\n return df, avg_prob\",\n \"def calculate_bleu(lightning_model: pl.LightningModule, config: Namespace) -> float:\\n\\n valid_en = load_file(os.path.join(config.directory, 'valid_en.txt'))\\n valid_ru = load_file(os.path.join(config.directory, 'valid_ru.txt'))\\n\\n predicted_texts = list()\\n\\n for i_batch in tqdm(range(math.ceil(len(valid_en) / config.batch_size)),\\n desc='Inference', disable=not config.verbose):\\n\\n batch = valid_en[i_batch * config.batch_size:(i_batch + 1) * config.batch_size]\\n tokenized_batch = lightning_model.sequence2sequence_preparer.source_tokenize(batch)\\n translated_batch = lightning_model.model.generate(tokenized_batch)\\n predicted_texts_batch = lightning_model.sequence2sequence_preparer.target_language_tokenizer.decode_batch(\\n translated_batch)\\n predicted_texts.extend(predicted_texts_batch)\\n\\n tokenized_predicted = [word_tokenize(sample) for sample in predicted_texts]\\n tokenized_target = [[word_tokenize(sample)] for sample in valid_ru]\\n\\n score = corpus_bleu(tokenized_target, tokenized_predicted)\\n\\n return score\",\n \"def test_classifiers(train_docs, train_target, test_docs, test_target, min_docs, K, K2, removeStopWords):\\n # test_classifiers(train_docs, train_target, test_docs, test_targets, i, 3)\\n X_train_counts, X_train_tfidf, X_test_counts, X_test_tfidf = extract_text_features(train_docs, test_docs, min_docs, removeStopWords)\\n \\n \\n num_docs, vocab_size = X_train_counts.shape\\n print('Number of (training) documents =',num_docs)\\n print('Vocabulary size =',vocab_size)\\n \\n\\n # Now evaluate the classifiers on the test data\\n # Print out the accuracy as a percentage for each classifier.\\n # np.mean() can be used to calculate the accuracy. Round the accuracy to 2 decimal places.\\n\\n #predict according to different classifier--evaluate results \\n predicted_multNB = fit_and_predict_multinomialNB(X_train_tfidf, train_target, X_test_tfidf)\\n predicted_bernNB = fit_and_predict_BernoulliNB(X_train_tfidf, train_target, X_test_tfidf)\\n predicted_LR = fit_and_predict_LR(X_train_tfidf, train_target, X_test_tfidf)\\n predicted_LR = fit_and_predict_LR(X_train_counts, train_target, X_test_counts)\\n predicted_KNN = fit_and_predict_KNN(X_train_tfidf, train_target, X_test_tfidf, K)\\n predicted_KNN2 = fit_and_predict_KNN(X_train_tfidf, train_target, X_test_tfidf, K2)\\n \\n predicted_base = np.array([FreqDist(test_target).most_common(1)[0][0]]*len(test_target))\\n\\n # count num of correct predictions / total\\n np_test_target = np.array(test_target)\\n base = np.sum(predicted_base == np_test_target)/len(np_test_target)*100\\n multNB = np.sum(predicted_multNB == np_test_target)/len(np_test_target)*100\\n bernNB = np.sum(predicted_bernNB == np_test_target)/len(np_test_target)*100\\n LR = np.sum(predicted_LR == np_test_target)/len(np_test_target)*100\\n KN = np.sum(predicted_KNN == np_test_target)/len(np_test_target)*100\\n KN2 = np.sum(predicted_KNN2 == np_test_target)/len(np_test_target)*100\\n\\n \\n print('\\\\tBase Accuracy: {:.3f}'.format(base))\\n print('\\\\tAccuracy with multinomial naive Bayes: {:.2f}'.format(multNB))\\n print('\\\\tAccuracy with Bernoulli naive Bayes: {:.2f}'.format(bernNB))\\n print('\\\\tAccuracy with logistic regression: {:.2f}'.format(LR))\\n print('\\\\tAccuracy with kNN, k={} classifier: {:2f}'.format(K, KN))\\n print('\\\\tAccuracy with kNN, k={} classifier: {:.2f}'.format(K2, KN2))\",\n \"def evaluate_ngrams(eval_dataset, trigram_counts, bigram_counts, unigram_counts, train_token_count, lambda1, lambda2):\\n perplexity = 0\\n ### YOUR CODE HERE\\n raise NotImplementedError\\n ### END YOUR CODE\\n return perplexity\",\n \"def qualify_words():\\n config = get_config()\\n\\n all_feature_matrices = []\\n all_opinion_matrices = []\\n\\n # first 5 parts are labeled, thus are useful\\n all_feature_label_vectors = []\\n all_opinion_label_vectors = []\\n\\n for fname in config.file_names:\\n feature_X, feature_dims = load_feature_matrices(fname)\\n opinion_X, opinion_dims = load_opinion_matrices(fname)\\n feature_y = load_feature_labels(fname)\\n opinion_y = load_opinion_labels(fname)\\n\\n # append to all collector\\n all_feature_matrices.append(feature_X)\\n all_feature_label_vectors.append(feature_y)\\n all_opinion_matrices.append(opinion_X)\\n all_opinion_label_vectors.append(opinion_y)\\n # use first 5 for training\\n # stack first 5\\n feature_training_X = []\\n feature_training_y = []\\n opinion_training_X = []\\n opinion_training_y = []\\n for i in range(5):\\n feature_training_X.append(all_feature_matrices[i])\\n feature_training_y.append(all_feature_label_vectors[i])\\n opinion_training_X.append(all_opinion_matrices[i])\\n opinion_training_y.append(all_opinion_label_vectors[i])\\n\\n feature_training_X = np.hstack(feature_training_X)\\n feature_training_y = np.hstack(feature_training_y)\\n opinion_training_X = np.hstack(opinion_training_X)\\n opinion_training_y = np.hstack(opinion_training_y)\\n\\n # using combination of rule and ranking score as features\\n feature_model = MultinomialNB()\\n opinion_model = MultinomialNB()\\n\\n # training\\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\\n\\n # predicting on candidate aspects and opinions, extracted from amazon reviews\\n for i in range(5, len(config.file_names)):\\n fname = config.file_names[i]\\n feature_pred = feature_model.predict_proba(\\n np.transpose(all_feature_matrices[i]))[:,1]\\n opinion_pred = opinion_model.predict_proba(\\n np.transpose(all_opinion_matrices[i]))[:,1]\\n # pickle the prediction results\\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\\n pickle.dump(feature_pred, f)\\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\\n pickle.dump(opinion_pred, f)\",\n \"def ranked_accuracy(predictions, labels):\\n rank1 = 0\\n rank5 = 0\\n\\n for (pred, lbl) in zip(predictions, labels):\\n pred = np.argsort(pred)[::-1]\\n\\n if lbl in pred[:5]:\\n rank5+=1\\n\\n if lbl == pred[0]:\\n rank1+=1\\n\\n rank1 /= float(len(labels))\\n rank5 /= float(len(labels))\\n\\n return (rank1, rank5)\",\n \"def predict(self):\\r\\n\\r\\n # reshape test_array since it is a single row of data\\r\\n user_array = np.asanyarray(self.test_array).reshape(1, -1)\\r\\n # one hot encode user_array\\r\\n self.enc.fit(user_array)\\r\\n user_array = self.enc.transform(user_array)\\r\\n # create, train and predict the model with the dataset\\r\\n model = (\\\"Ridge\\\", linear_model.Ridge(alpha=0.01, random_state=4))\\r\\n model[1].fit(self.X_train, self.y_train)\\r\\n y_pred = model[1].predict(self.X_test)\\r\\n # predict with user provided chords\\r\\n y_usr = model[1].predict(user_array)\\r\\n if y_usr[0] < 0:\\r\\n y_usr[0] = 0\\r\\n acc = metrics.r2_score(self.y_test, y_pred)\\r\\n output = \\\"I am {}% sure that you like this progression.\\\".format('%.2f' % (100 * y_usr[0]))\\r\\n model_info = \\\"Predicted using a {} model with {} accuracy from {} data samples.\\\".format(model[0], '%.3f' % acc,\\r\\n self.data_count())\\r\\n return output, model_info\",\n \"def LevDistMultilabels(y_true, y_pred):\\n \\n n = y_pred.shape[0]\\n D = 0\\n for i in range(n):\\n D += LevenshteinDistance(y_pred[i,:], y_true[i,:])[-1, -1]\\n return D/n\",\n \"def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\\n\\n\\t# set variables\\n\\trm1_vec = list()\\n\\tvocab = set()\\n\\tdoc_vecs = dict()\\n\\n\\t# create document feature vectors for each feedback doc\\n\\tfor doc_id in ids_and_scores.keys():\\n\\t\\t# convert current doc to bow format\\n\\t\\tbow = ix.doc2bow(corpus[doc_id])\\n\\t\\t# create document feature vector\\n\\t\\tdfv = create_feature_vector(ix, term_dict, bow)\\n\\t\\t# keep top 'fb_terms' from dfv\\n\\t\\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t\\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\\n\\t\\tvocab.update(dfv.keys())\\n\\t\\tdoc_vecs[doc_id] = dfv\\n\\n\\t# compute L1 norm for each document feature vector\\n\\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\\n\\n\\t# loop over terms in vocab and compute RM1\\n\\tfor term in vocab:\\n\\t\\tfb_weight = 0.0\\n\\t\\t# loop over document feature vectors \\n\\t\\tfor doc_id in doc_vecs.keys():\\n\\t\\t\\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\\n\\t\\t\\t\\t# sum the score of current term across different docs to fb_weight\\n\\t\\t\\t\\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\\n\\t\\t# assign term w/ weight to RM1 feature vector\\n\\t\\trm1_vec.append((term, fb_weight))\\n\\n\\t# keep top 'fb_terms' from rm1_vec\\n\\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t# scale rm1_vec to L1 norm\\n\\treturn scale_to_L1_norm(rm1_vec)\",\n \"def bert_score(preds: Union[List[str], Dict[str, Tensor]], target: Union[List[str], Dict[str, Tensor]], model_name_or_path: Optional[str]=None, num_layers: Optional[int]=None, all_layers: bool=False, model: Optional[Module]=None, user_tokenizer: Any=None, user_forward_fn: Callable[[Module, Dict[str, Tensor]], Tensor]=None, verbose: bool=False, idf: bool=False, device: Optional[Union[str, torch.device]]=None, max_length: int=512, batch_size: int=64, num_threads: int=4, return_hash: bool=False, lang: str='en', rescale_with_baseline: bool=False, baseline_path: Optional[str]=None, baseline_url: Optional[str]=None) ->Dict[str, Union[List[float], str]]:\\n if len(preds) != len(target):\\n raise ValueError('Number of predicted and reference sententes must be the same!')\\n if verbose and not _TQDM_AVAILABLE:\\n raise ModuleNotFoundError('An argument `verbose = True` requires `tqdm` package be installed. Install with `pip install tqdm`.')\\n if model is None:\\n if not _TRANSFORMERS_AVAILABLE:\\n raise ModuleNotFoundError('`bert_score` metric with default models requires `transformers` package be installed. Either install with `pip install transformers>=4.0` or `pip install torchmetrics[text]`.')\\n if model_name_or_path is None:\\n warn(f'The argument `model_name_or_path` was not specified while it is required when default `transformers` model are used.It is, therefore, used the default recommended model - {_DEFAULT_MODEL}.')\\n tokenizer = AutoTokenizer.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\\n model = AutoModel.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\\n else:\\n tokenizer = user_tokenizer\\n model.eval()\\n model\\n try:\\n if num_layers and num_layers > model.config.num_hidden_layers:\\n raise ValueError(f'num_layers={num_layers} is forbidden for {model_name_or_path}. Please use num_layers <= {model.config.num_hidden_layers}')\\n except AttributeError:\\n warn('It was not possible to retrieve the parameter `num_layers` from the model specification.')\\n _are_empty_lists = all(isinstance(text, list) and len(text) == 0 for text in (preds, target))\\n _are_valid_lists = all(isinstance(text, list) and len(text) > 0 and isinstance(text[0], str) for text in (preds, target))\\n _are_valid_tensors = all(isinstance(text, dict) and isinstance(text['input_ids'], Tensor) for text in (preds, target))\\n if _are_empty_lists:\\n warn('Predictions and references are empty.')\\n output_dict: Dict[str, Union[List[float], str]] = {'precision': [0.0], 'recall': [0.0], 'f1': [0.0]}\\n if return_hash:\\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\\n return output_dict\\n baseline = _load_baseline(lang, model_name_or_path, baseline_path, baseline_url) if rescale_with_baseline else None\\n if _are_valid_lists:\\n target_dataset = TextDataset(target, tokenizer, max_length, idf=idf)\\n preds_dataset = TextDataset(preds, tokenizer, max_length, idf=idf, tokens_idf=target_dataset.tokens_idf)\\n elif _are_valid_tensors:\\n target_dataset = TokenizedDataset(**target, idf=idf)\\n preds_dataset = TokenizedDataset(**preds, idf=idf, tokens_idf=target_dataset.tokens_idf)\\n else:\\n raise ValueError('Invalid input provided.')\\n target_loader = DataLoader(target_dataset, batch_size=batch_size, num_workers=num_threads)\\n preds_loader = DataLoader(preds_dataset, batch_size=batch_size, num_workers=num_threads)\\n target_embeddings, target_idf_scale = _get_embeddings_and_idf_scale(target_loader, target_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\\n preds_embeddings, preds_idf_scale = _get_embeddings_and_idf_scale(preds_loader, preds_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\\n precision, recall, f1_score = _get_precision_recall_f1(preds_embeddings, target_embeddings, preds_idf_scale, target_idf_scale)\\n if baseline is not None:\\n precision, recall, f1_score = _rescale_metrics_with_baseline(precision, recall, f1_score, baseline, num_layers, all_layers)\\n output_dict = {'precision': precision.tolist(), 'recall': recall.tolist(), 'f1': f1_score.tolist()}\\n if return_hash:\\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\\n return output_dict\",\n \"def cal_err(label_scores, predicted_scores, top_k_int=1, use_predicted_order=False):\\n \\n if not use_predicted_order:\\n max_label_score = tf.reduce_max(label_scores)\\n sorted_labels, predicted_order, sorted_predictions = _get_ranking_orders(\\n label_scores, predicted_scores, top_k_int=top_k_int)\\n else:\\n indices = tf.range(top_k_int)\\n predicted_order = tf.gather(predicted_scores, indices)\\n max_label_score = tf.reduce_max(label_scores)\\n\\n predicted_relevance = _get_relevance_scores(predicted_order)\\n predicted_relevance_ratio = predicted_relevance / (2**max_label_score)\\n _ratio = 1- predicted_relevance_ratio\\n prob_stepdown = tf.cumprod(_ratio, exclusive=True)\\n cur_rank = tf.range(top_k_int) + 1\\n cur_rank = tf.cast(cur_rank, dtype=tf.float32)\\n cur_rank = tf.reshape(cur_rank, [-1, 1])\\n products = tf.multiply(predicted_relevance_ratio, prob_stepdown)\\n products = tf.cast(products, dtype=tf.float32)\\n errs = tf.divide(products, cur_rank)\\n err = tf.reduce_sum(errs)\\n return err\",\n \"def train_label_weigthed(self, train_dataset, validation_dataset, label, lr = 0.02, epochs_num = 100, batch_size = 40, alpha = 0, momentum = 0.9):\\n \\n def get_proportions(dataset):\\n \\n positive_label = dataset.labels_tensor[:,label].sum()\\n \\n negative_label = (1 - dataset.labels_tensor[:,label]).sum()\\n \\n total_examples = positive_label + negative_label\\n \\n imbalance = abs(positive_label - 0.5) > 0.4\\n \\n if imbalance:\\n \\n if positive_label < negative_label:\\n \\n w_p = 1\\n \\n w_n = positive_label / negative_label\\n \\n else:\\n \\n w_p = negative_label / positive_label\\n \\n w_n = 1\\n \\n else:\\n \\n w_p = w_n = 1\\n \\n return w_p, w_n\\n \\n def get_w(labels, w_p, w_n):\\n \\n positives = labels\\n \\n negatives = 1 - labels\\n \\n w = w_p * positives + w_n * negatives\\n \\n return w\\n \\n# positive_label = train_dataset.labels_tensor[:,label].sum()\\n \\n# negative_label = (1 - train_dataset.labels_tensor[:,label]).sum()\\n \\n# total_examples = positive_label + negative_label\\n \\n# print('num examples {}'.format(positive_label + negative_label))\\n \\n# print('% positive labels: {}'.format(positive_label/total_examples))\\n \\n# print('% negative labels: {}'.format(negative_label/total_examples))\\n \\n# imbalance = abs(positive_label - 0.5) > 0.4\\n \\n# if imbalance:\\n \\n# if positive_label < negative_label:\\n \\n# w_p = 1\\n \\n# w_n = positive_label / negative_label\\n \\n# else:\\n \\n# w_p = negative_label / positive_label\\n \\n# w_n = 1\\n \\n# else:\\n \\n# w_p = w_n = 1\\n \\n# print('w_p: {}'.format(w_p))\\n \\n# print('w_n: {}'.format(w_n))\\n\\n w_p, w_n = get_proportions(train_dataset) \\n \\n label_name = train_dataset.labels.items()[label][0]\\n \\n print(\\\"Training label {} ... \\\".format(label_name))\\n \\n optimizer = SGD(self.parameters(), lr = lr, weight_decay = alpha, momentum = momentum)\\n\\n train_losses = []\\n\\n validation_losses = []\\n\\n epochs = []\\n\\n start = time.time()\\n\\n remaining_time = 0\\n\\n train_dataloader = DataLoader(train_dataset, batch_size = batch_size, collate_fn = PPD.collate_data)\\n \\n validation_segments, validation_labels = PPD.collate_data(validation_dataset)\\n \\n weight_matrix_v = get_w(validation_labels[:,label].unsqueeze(1), w_p, w_n)\\n \\n criterion_v = nn.BCELoss(weight=weight_matrix_v.float())\\n \\n print('w_p: {} and w_n: {}'.format(w_p, w_n))\\n\\n for epoch in range(epochs_num):\\n\\n for i_batch, sample_batched in enumerate(train_dataloader):\\n\\n input = sample_batched[0]\\n\\n target = sample_batched[1][:,label].unsqueeze(1)\\n \\n weight_matrix = w_p * target + w_n * (1 - target)\\n \\n criterion = nn.BCELoss(weight=weight_matrix.float())\\n\\n self.zero_grad()\\n\\n output = self(input)\\n\\n train_loss = criterion(output, target.float())\\n\\n train_loss.backward()\\n\\n optimizer.step()\\n\\n validation_loss = criterion_v(self(validation_segments.long()), validation_labels[:,label].unsqueeze(1).float())\\n\\n end = time.time()\\n\\n remaining_time = remaining_time * 0.90 + ((end - start) * (epochs_num - epoch + 1) / (epoch + 1)) * 0.1\\n\\n remaining_time_corrected = remaining_time / (1 - (0.9 ** (epoch + 1)))\\n\\n epoch_str = \\\"last epoch finished: \\\" + str(epoch)\\n\\n progress_str = \\\"progress: \\\" + str((epoch + 1) * 100 / epochs_num) + \\\"%\\\"\\n\\n time_str = \\\"time: \\\" + str(remaining_time_corrected / 60) + \\\" mins\\\"\\n\\n sys.stdout.write(\\\"\\\\r\\\" + epoch_str + \\\" -- \\\" + progress_str + \\\" -- \\\" + time_str)\\n\\n sys.stdout.flush()\\n\\n train_losses.append(train_loss.item())\\n\\n validation_losses.append(validation_loss.item())\\n\\n epochs.append(epoch)\\n\\n print(\\\"\\\\n\\\" + \\\"Training completed. Total training time: \\\" + str(round((end - start) / 60, 2)) + \\\" mins\\\")\\n\\n return epochs, train_losses, validation_losses\",\n \"def learn_bpe(strings: List[str], pair_percent_threshold: float, char_percent_threshold:float, with_position:bool) -> dict:\\n\\n vocab = get_vocab(strings)\\n percent = 1.0\\n # 待改进，这里如果 pair_percent_threshold <=0，则会死循环\\n while percent >= pair_percent_threshold:\\n pair2freq = pair_freq_stats(vocab, with_position)\\n best = max(pair2freq, key=pair2freq.get)\\n percent = pair2freq.get(best) / len(strings)\\n if percent >= pair_percent_threshold:\\n vocab = merge_vocab(best, vocab, with_position)\\n\\n bpe_tokens = get_tokens(vocab, pair_percent_threshold, len(strings), char_percent_threshold, with_position)\\n if with_position:\\n bpe_tokens = sorted(bpe_tokens, key=lambda x: len(x[0]), reverse=True)\\n else:\\n bpe_tokens = sorted(bpe_tokens, key=len, reverse=True)\\n bpe_token_dict = {'with_position':with_position,\\n 'tokens': bpe_tokens}\\n return bpe_token_dict\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def prediction(score, test_y, lossname):\\n if lossname == 'contrastive_loss':\\n prediction = sigmoid(euclidean_distance(score))\\n\\n threshold = 0.5\\n correction = 0\\n error = 0\\n\\n for i in range(len(prediction)):\\n if prediction[i] >= threshold:\\n pred = 1\\n else:\\n pred = 0\\n \\n if pred == test_y[i]:\\n correction += 1\\n else:\\n error += 1\\n \\n accuracy = 1.0 * correction / (correction + error)\\n \\n return correction, error, accuracy\",\n \"def get_relevances(self):\\n\\n # Backpropagate softmax value\\n # relevances = [tf.nn.softmax(self.activations[0])*tf.cast(self.y, tf.float32)]\\n\\n # Backpropagate a value from given labels y\\n relevances = [tf.cast(self.y, tf.float32)]\\n\\n loc_poly = [pol for pol in self.polynomials]\\n loc_pooling = [p for p in self.model.p]\\n print(\\\"\\\\n Relevance calculation:\\\")\\n for i in range(1, len(\\n self.activations)): # start from 1 (not 0) penultimate activations since relevances already contains logits.\\n name = self.activations[i - 1].name.split('/')\\n if 'logits' in name[0] or 'fc' in name[0]:\\n print(\\\"\\\\tFully connected:\\\", name[0])\\n relevances.append(self.prop_fc(name[0], self.activations[i], relevances[-1]))\\n elif 'flatten' in name[0]:\\n print(\\\"\\\\tFlatten layer:\\\", name[0])\\n relevances.append(self.prop_flatten(self.activations[i], relevances[-1]))\\n # print(\\\"\\\\n\\\")\\n elif 'pooling' in name[1]:\\n # TODO: incorporate pooling type and value into name\\n print(\\\"\\\\tPooling:\\\", name[0] + \\\" \\\" + name[1])\\n p = loc_pooling.pop()\\n relevances.append(self.prop_max_pool(self.activations[i], relevances[-1], ksize=[1, p, 1, 1],\\n strides=[1, p, 1, 1]))\\n elif 'conv' in name[0]:\\n if len(loc_poly) > 1:\\n print(\\\"\\\\tConvolution: \\\", name[0], \\\"\\\\n\\\")\\n relevances.append(self.prop_gconv(name[0], self.activations[i], relevances[-1],\\n polynomials=loc_poly.pop()))\\n else:\\n print(\\\"\\\\tConvolution, the first layer:\\\", name[0], \\\"\\\\n\\\")\\n relevances.append(self.prop_gconv_first_conv_layer(name[0], self.activations[i], relevances[-1],\\n polynomials=loc_poly.pop()))\\n else:\\n raise 'Error parsing layer'\\n\\n return relevances\",\n \"def main(path: str, boundary: str, keep_accents: bool):\\n print(f\\\"Calculating transitional probabilities over {path}...\\\")\\n sub_boundary: str = \\\"S\\\" if boundary == \\\"W\\\" else \\\"P\\\"\\n # get the input, both with and without word boundaries\\n input: str = \\\"\\\"\\n for line in open(path):\\n input += line.strip()\\n # if we're finding syllable boundaries, we don't care about word boundaries\\n if boundary == \\\"S\\\":\\n input = remove_boundaries(input, \\\"W\\\")\\n # remove accents from the input\\n if not keep_accents:\\n input2 = \\\"\\\"\\n for char in input:\\n if char != \\\"0\\\" and char != \\\"1\\\" and char != \\\"2\\\":\\n input2 += char\\n input = input2\\n input_without_word_boundaries = remove_boundaries(input, boundary)\\n # calculate the transitional probabilites of words from the transitions between syllables\\n transitional_probabilities = get_transitional_probabilities(\\n input_without_word_boundaries, sub_boundary\\n )\\n # generate over the entire input using these transitional probabilities\\n generated = predict_word_boundaries(\\n input_without_word_boundaries,\\n sub_boundary,\\n boundary,\\n transitional_probabilities,\\n )\\n # evaluate utterance by utterance and average the precision and recall\\n test_correct = [utt for utt in input.split(\\\"U\\\") if utt]\\n test_generated = [utt for utt in generated.split(\\\"U\\\") if utt]\\n print(f\\\"Evaluating {len(test_correct)} predictions ...\\\")\\n total_correct = 0\\n total_generated = 0\\n total_right = 0\\n for i in range(0, len(test_correct)):\\n correct = [w for w in test_correct[i].split(boundary) if w]\\n generated = [w for w in test_generated[i].split(boundary) if w]\\n total_right += len([w for w in correct if w in generated])\\n total_correct += len(correct)\\n total_generated += len(generated)\\n precision: float = total_right / total_generated\\n recall: float = total_right / total_correct\\n print(\\\"===============================================================\\\")\\n print(f\\\"Precision: {precision * 100 : .3f}%\\\")\\n print(f\\\"Recall: {recall * 100: .3f}%\\\")\\n print(f\\\"F-score: {(2 * precision * recall) / (precision + recall) * 100: .3f}%\\\")\",\n \"def score(self, predictions):\\n return 0.\",\n \"def eval_all(cls_prob, dtrain):\\n #determine the top k predictions\\n labels = dtrain.get_label()\\n top_k = cls_prob.argsort(axis = 1)[:,::-1][:,:5]\\n# top_k = cls_prob.argsort(axis = 1)[:,:k:-1]\\n #convert true values and compared with predictions to check for equality\\n labels = labels[:, None]\\n return 'error', 1-ndcg(top_k, labels)/len(labels)\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\n # TODO: Write your code here\\n # return predicted labels of development set\\n #\\n ### len(train_set) 8000, len(dev) = 5000 P(pos) = 0.8 \\n #### 0.55, 4.0, 0.30 ----------- 0.766\\n #### 0.25 3.5 0.3 -------------- 0.766\\n print(pos_prior)\\n smoothing_parameter = 3.5\\n pos_total_word = 0\\n neg_total_word = 0\\n pos_word_dict = {}\\n neg_word_dict = {}\\n dicts = [neg_word_dict, pos_word_dict]\\n for i, sentence in enumerate(train_set):\\n\\n if train_labels[i] == 1: # positive reviews\\n for word in sentence:\\n pos_total_word += 1 \\n if word in stop_words:\\n continue\\n if word in pos_word_dict:\\n pos_word_dict[word] += 1\\n else :\\n pos_word_dict[word] = 1\\n\\n else: # negative reviews\\n for word in sentence:\\n neg_total_word += 1 \\n if word in stop_words:\\n continue\\n if word in neg_word_dict:\\n neg_word_dict[word] += 1\\n else :\\n neg_word_dict[word] = 1\\n\\n\\n prob = {}\\n denominator_pos = pos_total_word + smoothing_parameter * (len(pos_word_dict) + 1)\\n denominator_neg = neg_total_word + smoothing_parameter * (len(neg_word_dict) + 1)\\n de = [denominator_neg, denominator_pos]\\n\\n for t, dictionary in enumerate(dicts):\\n for key, value in dictionary.items():\\n if key not in prob:\\n prob[key] = {0 : 0, 1 : 0}\\n if smoothing_parameter != 0:\\n prob[key][1 - t] = -1 * np.log(smoothing_parameter / de[t]) \\n # print(prob[key][1 - t])\\n\\n prob[key][t] = -1 * np.log((value + smoothing_parameter) / de[t]) \\n \\n\\n revised_prob = {}\\n for key, value in prob.items():\\n if np.abs(value[0] - value[1]) >= 0.25:\\n revised_prob[key] = value \\n\\n print(len(revised_prob))\\n\\n dev_labels = []\\n num_0 = 0\\n for i, sentence in enumerate(dev_set):\\n pos_odd = -1 * np.log(pos_prior)\\n neg_odd = -1 * np.log(1.0 - pos_prior)\\n for word in sentence:\\n if word in revised_prob:\\n pos_odd += revised_prob[word][1]\\n neg_odd += revised_prob[word][0]\\n \\n if pos_odd > neg_odd:\\n num_0 += 1\\n dev_labels.append(1 if pos_odd <= neg_odd else 0)\\n print(num_0)\\n\\n \\n #### bigram model \\n \\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n return dev_labels\",\n \"def naiveBayes(train_set, train_labels, dev_set, smoothing_parameter, pos_prior):\\n # TODO: Write your code here\\n # Bag of words model\\n smoothing_parameter = .007 # override smoothing parameter\\n posWordBag = {}\\n negWordBag = {}\\n for reviewIndex, review in enumerate(train_set):\\n for word in review:\\n if isWordTooCommon(word) == True: # If word is too common, skip the word\\n continue\\n else:\\n if train_labels[reviewIndex] == 1: # Positive\\n if word not in posWordBag.keys():\\n posWordBag[word] = 1\\n else:\\n posWordBag[word] += 1\\n elif train_labels[reviewIndex] == 0: # Negative\\n if word not in negWordBag.keys():\\n negWordBag[word] = 1\\n else:\\n negWordBag[word] += 1\\n \\n posProbList, posUNK = genProb(posWordBag, smoothing_parameter)\\n negProbList, negUNK = genProb(negWordBag, smoothing_parameter)\\n\\n # Done with training. Now development with MAP\\n dev_labels = []\\n for devRev in dev_set:\\n reviewIsPos = math.log10(pos_prior)\\n reviewIsNeg = math.log10(1 - pos_prior)\\n for word in devRev:\\n if isWordTooCommon(word) == True: # If word is too common, skip the word\\n continue\\n else:\\n if word in posProbList.keys():\\n reviewIsPos += posProbList[word]\\n else:\\n reviewIsPos += posUNK\\n if word in negProbList.keys():\\n reviewIsNeg += negProbList[word]\\n else:\\n reviewIsNeg += negUNK\\n if reviewIsPos < reviewIsNeg:\\n dev_labels.append(0)\\n else:\\n dev_labels.append(1)\\n\\n # return predicted labels of development set\\n return dev_labels\",\n \"def score(self, X_test: List[str], y_test: List[str]) -> int:\\n predictions_count = 0\\n right_predictions_count = 0\\n\\n for i in range(len(X_test)):\\n label = self.predict(X_test[i].split())\\n predictions_count += 1\\n right_predictions_count += 1 if label == y_test[i] else 0\\n\\n return right_predictions_count / predictions_count\",\n \"def predict(self, uid, iid, r_ui=None, clip=True, verbose=False):\\n\\n # Iterate over the components and build up an aggregate score using the weights.\\n # Clip the estimate into [lower_bound, higher_bound] if clip parameter is True. See algo_base.py.\\n # Create a new Prediction object. Retain any Prediction \\\"details\\\" values\\n # in a new dictionary.\\n try:\\n iuid = self.trainset.to_inner_uid(uid)\\n except ValueError:\\n iuid = 'UKN__' + str(uid)\\n try:\\n iiid = self.trainset.to_inner_iid(iid)\\n except ValueError:\\n iiid = 'UKN__' + str(iid) \\n \\n details = {}\\n try:\\n cnt = 0\\n est = 0.0\\n for comp in self._components:\\n pred = comp.estimate(iuid, iiid)\\n if type(pred) == tuple:\\n \\tpred = pred[0]\\n \\t\\n est += pred[0] * self._weights[cnt]\\n cnt += 1 \\n \\n # If the details dict was also returned\\n if isinstance(est, tuple):\\n est, details = est\\n\\n details['was_impossible'] = False\\n\\n except:\\n est = self.trainset.global_mean\\n details['was_impossible'] = True\\n details['reason'] = str('PredictionImpossible')\\n \\n\\n# clip estimate into [lower_bound, higher_bound]\\n if clip:\\n lower_bound, higher_bound = self.trainset.rating_scale\\n est = min(higher_bound, est)\\n est = max(lower_bound, est)\\n\\n pred = Prediction(uid, iid, r_ui, est, details)\\n\\n if verbose:\\n print(pred)\\n\\n return pred\",\n \"def calc_ac_score(labels_true, labels_pred):\\n nclass = len(np.unique(labels_true))\\n labels_size = len(labels_true)\\n mat = labels_size * np.ones((nclass, nclass))\\n \\n idx = 0\\n \\n for i in range(labels_size):\\n mat[labels_pred[i], labels_true[i]] -= 1.0\\n \\n munkres = Munkres()\\n mapping = munkres.compute(mat)\\n \\n ac = 0.0\\n\\n for i in range(labels_size):\\n val = mapping[labels_pred[i]][1]\\n if val == labels_true[i]:\\n ac += 1.0\\n\\n ac = ac / labels_size \\n \\n return ac\",\n \"def calc_performance_given_labels(self, cutoff, ligand_labels):\\n performance = defaultdict(dict)\\n num_ligands = np.shape(ligand_labels)[1]\\n\\n if num_ligands > 1: # ligand-type assessment\\n # calc per-ligand assessment for multi-label prediction\\n for i in range(0, num_ligands):\\n tp = fp = tn = fn = 0\\n cross_pred = [0, 0, 0, 0]\\n for idx, lig in enumerate(ligand_labels):\\n if self.predictions[idx, i] >= cutoff: # predicted as binding to this ligand\\n cross_prediction = False\\n true_prediction = False\\n\\n for j in range(0, num_ligands):\\n if i == j: # same as predicted ligand\\n if lig[j] >= self.bind_cutoff: # also annotated to this ligand\\n tp += 1\\n cross_pred[i] += 1\\n true_prediction = True\\n else:\\n fp += 1\\n else:\\n if lig[j] >= self.bind_cutoff and not true_prediction:\\n cross_pred[j] += 1\\n cross_prediction = True\\n\\n if not true_prediction and not cross_prediction:\\n # residues is not annotated to bind any of the ligands\\n cross_pred[3] += 1\\n else:\\n if lig[i] >= cutoff:\\n fn += 1\\n else:\\n tn += 1\\n\\n if i == 0:\\n ligand = 'metal'\\n elif i == 1:\\n ligand = 'nucleic'\\n else:\\n ligand = 'small'\\n\\n bound = False\\n if (tp + fn) > 0:\\n bound = True\\n acc, prec, recall, f1, mcc = PerformanceAssessment.calc_performance_measurements(tp, fp, tn, fn)\\n # calculate performance measurements for negatives\\n _, neg_p, neg_r, neg_f1, _ = PerformanceAssessment.calc_performance_measurements(tn, fn, tp, fp)\\n\\n performance[ligand] = {'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn, 'acc': acc, 'prec': prec,\\n 'recall': recall, 'f1': f1, 'neg_prec': neg_p, 'neg_recall': neg_r,\\n 'neg_f1': neg_f1, 'mcc': mcc, 'bound': bound,\\n 'cross_prediction': cross_pred}\\n\\n # get overall performance\\n reduced_labels = np.sum(ligand_labels > cutoff, axis=1)\\n if len(self.predictions.shape) == 1:\\n reduced_predictions = (self.predictions >= cutoff)\\n else:\\n reduced_predictions = np.sum(self.predictions >= cutoff, axis=1)\\n\\n tp = np.sum(np.logical_and(reduced_labels > 0, reduced_predictions > 0))\\n fp = np.sum(np.logical_and(reduced_labels == 0, reduced_predictions > 0))\\n tn = np.sum(np.logical_and(reduced_labels == 0, reduced_predictions == 0))\\n fn = np.sum(np.logical_and(reduced_labels > 0, reduced_predictions == 0))\\n\\n acc, prec, recall, f1, mcc = PerformanceAssessment.calc_performance_measurements(tp, fp, tn, fn)\\n _, neg_p, neg_r, neg_f1, _ = PerformanceAssessment.calc_performance_measurements(tn, fn, tp, fp)\\n performance['overall'] = {'tp': tp, 'fp': fp, 'tn': tn, 'fn': fn, 'acc': acc, 'prec': prec, 'recall': recall,\\n 'f1': f1, 'neg_prec': neg_p, 'neg_recall': neg_r, 'neg_f1': neg_f1, 'mcc': mcc,\\n 'bound': True, 'cross_prediction': [0, 0, 0, 0]}\\n\\n return performance\",\n \"def get_recall(y_true, y_pred):\\n true_entities_filter = (y_true != 3).astype(\\\"int\\\") # of the words that truly has a NER class\\n recall_correct_entities = (y_pred[np.where(true_entities_filter)] == y_true[np.where(true_entities_filter)]).astype(\\\"int\\\")\\n recall = np.sum(recall_correct_entities)/np.sum(true_entities_filter)\\n return recall\",\n \"def _bleu(ref_file, trans_file, subword_option=None, lower_case=False):\\n max_order = 4\\n smooth = False\\n\\n ref_files = [ref_file]\\n reference_text = []\\n for reference_filename in ref_files:\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(reference_filename, \\\"rb\\\")) as fh:\\n reference_text.append(fh.readlines())\\n\\n per_segment_references = []\\n for references in zip(*reference_text):\\n reference_list = []\\n for reference in references:\\n reference = _clean(reference, subword_option, lower_case=lower_case)\\n reference_list.append(reference.split())\\n per_segment_references.append(reference_list)\\n\\n translations = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(trans_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n line = _clean(line, subword_option=None, lower_case=lower_case)\\n translations.append(line.split())\\n\\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\\n per_segment_references, translations, max_order, smooth)\\n return 100 * bleu_score\",\n \"def run_evaluate_compound(self, data):\\n tp = 0\\n tn = 0\\n fp = 0\\n fn = 0\\n for words, labels, pos in minbatch_generator(data, self.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\\n if not type(labels_pred) == list:\\n labels_pred = labels_pred.tolist()\\n for i, label_actual in enumerate(labels):\\n # we have to now find all aspect terms. That is, merge consecutive B \\n # with I's until we get an O or B\\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\\n for a_term in a_terms_actual:\\n # say we have [1,2,3] as our a_term. we have to make sure that our \\n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\\n a_term_pred = []\\n for index in a_term:\\n if not label_actual[index] == labels_pred[i][index]:\\n fn += 1\\n break\\n else:\\n tp += 1\\n for index in non_a_terms_actual:\\n if label_actual[index] == labels_pred[i][index]:\\n tn += 1\\n else:\\n fp += 1\\n\\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\\n metrics = dict()\\n metrics[\\\"p_1\\\"] = precision\\n metrics[\\\"f_1\\\"] = fscore\\n metrics[\\\"r_1\\\"] = recall\\n return metrics\",\n \"def most_probable_class(text, weights):\\n\\n pos_weights = weights['positive']\\n neg_weights = weights['negative']\\n neu_weights = weights['neutral']\\n features = calculate_features(text)\\n pos_numerator = 0.0\\n neg_numerator = 0.0\\n neu_numerator = 0.0\\n denominator = 0.0\\n for f in features:\\n if f in pos_weights and f in neg_weights and f in neu_weights:\\n pos_numerator += pos_weights[f] * features[f]\\n neg_numerator += neg_weights[f] * features[f]\\n neu_numerator += neu_weights[f] * features[f]\\n denominator += pos_numerator + neg_numerator + neu_numerator\\n else:\\n pos_numerator += 0\\n neg_numerator += 0\\n neu_numerator += 0\\n denominator += pos_numerator + neg_numerator + neu_numerator\\n\\n pos_prob = (\\\"positive\\\", exp(pos_numerator))# /exp(denominator))\\n neg_prob = (\\\"negative\\\", exp(neg_numerator))# /exp(denominator))\\n neu_prob = (\\\"neutral\\\", exp(neu_numerator))# /exp(denominator))\\n return max(neu_prob, neg_prob, pos_prob, key=lambda x: x[1])\",\n \"def compute_precision(gold_dict, src_word2ind, trg_word2ind, src_words, trg_words, scores, args, BATCH_SIZE=20, verbose = False):\\n oov = set()\\n correct = 0\\n n,m = scores.shape # The actual size of mapping computed, might be smaller that total size of dict\\n\\n precisions = {}\\n if verbose:\\n print('@{:2} {:10} {:30} {:30}'.format('k', 'Src','Predicted','Gold'))\\n print_row = '{:2} {:10} {:30} {:30} {}'\\n\\n for k in [1,5,10]:\\n correct = 0\\n for src_idx,tgt_idx in gold_dict.items():\\n if src_idx > n or np.all([e>m for e in tgt_idx]):#Src word not in mapping\\n oov.add(src_idx)\\n continue\\n else:\\n knn = np.argpartition(scores[src_idx,:], -k)[-k:] # argpartition returns top k not in order\\n knn_sort = knn[np.argsort(-scores[src_idx,knn])] # With - to get descending order\\n if set(knn_sort).intersection(tgt_idx):\\n correct +=1\\n correct_string = ' '\\n else:\\n correct_string = 'X'\\n if verbose:\\n src_str = src_words[src_idx]\\n pred_str = ','.join([trg_words[k] for k in knn_sort])\\n gold_str = ','.join([trg_words[k] for k in tgt_idx])\\n print(print_row.format(k,src_str,pred_str,gold_str,correct_string))\\n\\n\\n coverage = len(gold_dict.keys()) / (len(gold_dict.keys()) + len(oov))\\n if verbose:\\n print('Coverage: {:7.2%} Precision @{:2}:{:7.2%}'.format(coverage, k, correct / len(gold_dict)))\\n precisions[k] = correct / len(gold_dict)\\n return precisions\",\n \"def compute_accuracy(Y_test, Y_pred):\\n number_correct_prediction = 0\\n for i in range(len(Y_pred)): # They have the same length\\n id_pred = np.argmax(Y_pred[i]) # Take the argmax of the prediction\\n id_test = np.where(Y_test[i] == 1.)[0][0] # Take the real position of the POS tag\\n if id_test == id_pred:\\n number_correct_prediction += 1\\n\\n percentage_correct = number_correct_prediction / len(Y_pred)\\n\\n return percentage_correct\",\n \"def test_score_text4(self):\\n\\t\\ttest = sentiment.LibraryRun(self.text3, self.lib)\\n\\t\\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\\n\\t\\t_, obj_ut = test.score_text(matches, end_threshold=0.5)\\n\\t\\tself.assertEqual(obj_ut, {'not good': [[2, -1, 0]], \\n\\t\\t\\t'not very good': [[4, -1.5, 0]]})\",\n \"def predict_and_analyze(dta, clf, eval_tweets):\\n for tweet in eval_tweets:\\n tweet['prediction'] = clf.predict([w2v_vector(dta, tweet['text'])])[0]\\n\\n metrics = {'tp': 0, 'fp': 0, 'tn': 0, 'fn': 0,\\n 'precision': 0, 'recall': 0, 'f1': 0}\\n for tweet in eval_tweets:\\n actual_label = tweet['label']\\n prediction = tweet['prediction']\\n if actual_label == prediction:\\n if prediction == 'relevant':\\n metrics['tp'] += 1\\n else:\\n metrics['tn'] += 1\\n else:\\n if prediction == 'relevant':\\n metrics['fp'] += 1\\n else:\\n metrics['fn'] += 1\\n metrics['precision'] = float(metrics['tp']) / (metrics['tp'] + metrics['fp'])\\n metrics['recall'] = float(metrics['tp']) / (metrics['tp'] + metrics['fn'])\\n metrics['f1'] = 2 * ((metrics['precision'] * metrics['recall']) /\\n (metrics['precision'] + metrics['recall']))\\n return metrics\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def ratio(n1,n2, explain=0, optimize=False):\\n weight_normal_form = 5.0 #distance between soundexes of normal form\\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\\n weight_initials = 2 #distance between initials\\n\\n nf1 = n1.guess_normal_form()\\n nf2 = n2.guess_normal_form()\\n\\n if not nf1 or not nf2:\\n return 0.0\\n elif nf1 == nf2:\\n return 1.0\\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\\n \\n #create a simkplified soundex set for this name\\n #remove stopwords\\n# nf1 = remove_stopwords( nf1)\\n# nf2 = remove_stopwords( nf2)\\n \\n se1 = n1.get_normal_form_soundex()\\n se2 = n2.get_normal_form_soundex()\\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\\n \\n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\\n g1 = to_ascii(g1)\\n g2 = to_ascii(g2)\\n if not optimize:\\n #de soundexes van de achternaam worden meegewoen\\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\\n g1_soundex = n1.geslachtsnaam_soundex()\\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\\n g2_soundex = n2.geslachtsnaam_soundex()\\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\\n else:\\n ratio_geslachtsnaam1 = 1 \\n weight_geslachtsnaam1 = 0\\n \\n #n de afstand van de woorden in de achtenraam zelf\\n ratio_geslachtsnaam2 = Similarity.average_distance(\\n re.split('[ \\\\.\\\\,\\\\-]', g1.lower()),\\n re.split('[ \\\\.\\\\,\\\\-]', g2.lower()),\\n levenshtein_ratio)\\n n1_initials = n1.initials()\\n n1_initials_lower = n1_initials.lower()\\n n2_initials = n2.initials()\\n n2_initials_lower = n2_initials.lower()\\n n1_contains_initials = n1.contains_initials()\\n n2_contains_initials = n2.contains_initials()\\n #count initials only if we have more than one\\n #(or perhaps make this: if we know the first name)\\n if len(n1_initials) == 1 or len(n2_initials) == 1:\\n #initials count much less if there is only one\\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\\n# ratio_initials = .5\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n elif n1_contains_initials or n2_contains_initials:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n weight_initials = weight_initials_if_one_name_is_in_initials\\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n else:\\n ratio_initials = 0.7\\n \\n if n1_contains_initials or n2_contains_initials:\\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \\n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\\n\\n counter = (ratio_normal_form * weight_normal_form +\\n ratio_normal_form_soundex * weight_normal_form_soundex +\\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\\n ratio_initials * weight_initials)\\n numerator = (weight_normal_form + weight_normal_form_soundex +\\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\\n if numerator == 0:\\n return 0.0\\n final_ratio = counter/numerator\\n\\n if explain:\\n s = '-' * 100 + '\\\\n'\\n s += 'Naam1: %s [%s] [%s] %s\\\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\\n s += 'Naam2: %s [%s] [%s] %s\\\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\\n s += 'Similarity ratio: %s\\\\n' % final_ratio\\n s += '--- REASONS' + '-' * 30 + '\\\\n'\\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\\\n'\\n s += format_s % ('\\\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\\n s += '\\\\t' + '-' * 100 + '\\\\n'\\n format_s = '\\\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\\\n'\\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\\n s += '\\\\tTOTAL (numerator) | %s (counter = %s)\\\\n' % (counter, numerator)\\n \\n return s\\n return final_ratio\",\n \"def validate(self, validate_data):\\n with open(validate_data, 'r') as validate_data:\\n true_positive = 0\\n true_negative = 0\\n false_positive = 0\\n false_negative = 0\\n result = {}\\n for type in self.label_type_map:\\n result[type] = []\\n while True:\\n tokens = validate_data.readline().split()\\n pos = validate_data.readline().split()\\n labels = validate_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Classify all named entities in a sentence 85\\n curr_results = self.viterbi(tokens)\\n for i in range(0, len(labels)):\\n if curr_results[i] != 'O':\\n if labels[i] == 'O':\\n false_positive += 1 # Not 'O', but should be 'O'\\n else:\\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\\n true_positive += 1 # Correct prediction\\n else:\\n if labels[i] == 'O':\\n true_negative += 1 # Correct prediction of 'O'\\n else:\\n false_negative += 1 # Predicted 'O', not 'O'\\n # Calculate precision - TP / (TP + FP)\\n precision = float(true_positive) / float(true_positive + false_positive)\\n # Calculate recall - TP / (TP + FN)\\n recall = float(true_positive) / float(true_positive + false_negative)\\n # Calculate F-Score - 2 * P * R / (P + R)\\n f_score = float(2*precision * recall) / float(precision + recall)\\n print \\\"Precision: \\\" + str(precision)\\n print \\\"Recall: \\\" + str(recall)\\n print \\\"F-score: \\\" + str(f_score)\",\n \"def partial_match_score(\\n truth: List[Rationale], pred: List[Rationale], thresholds: List[float]\\n) -> List[PartialMatchScore]:\\n\\n ann_to_rat = _keyed_rationale_from_list(truth)\\n pred_to_rat = _keyed_rationale_from_list(pred)\\n\\n num_classifications = {k: len(v) for k, v in pred_to_rat.items()}\\n num_truth = {k: len(v) for k, v in ann_to_rat.items()}\\n ious: Dict[str, Dict[str, float]] = defaultdict(dict)\\n for k in set(ann_to_rat.keys()) | set(pred_to_rat.keys()):\\n for p in pred_to_rat.get(k, []):\\n best_iou = 0.0\\n for t in ann_to_rat.get(k, []):\\n num = len(\\n set(range(p.start_token, p.end_token))\\n & set(range(t.start_token, t.end_token))\\n )\\n denom = len(\\n set(range(p.start_token, p.end_token))\\n | set(range(t.start_token, t.end_token))\\n )\\n iou = 0 if denom == 0 else num / denom\\n if iou > best_iou:\\n best_iou = iou\\n ious[k][p] = best_iou\\n\\n scores: List[PartialMatchScore] = []\\n for threshold in thresholds:\\n threshold_tps: Dict[str, float] = {}\\n for k, vs in ious.items():\\n threshold_tps[k] = sum(int(x >= threshold) for x in vs.values())\\n micro_r = (\\n sum(threshold_tps.values()) / sum(num_truth.values())\\n if sum(num_truth.values()) > 0\\n else 0\\n )\\n micro_p = (\\n sum(threshold_tps.values()) / sum(num_classifications.values())\\n if sum(num_classifications.values()) > 0\\n else 0\\n )\\n micro_f1 = _f1(micro_r, micro_p)\\n macro_rs = list(\\n threshold_tps.get(k, 0.0) / n if n > 0 else 0 for k, n in num_truth.items()\\n )\\n macro_ps = list(\\n threshold_tps.get(k, 0.0) / n if n > 0 else 0\\n for k, n in num_classifications.items()\\n )\\n macro_r = sum(macro_rs) / len(macro_rs) if len(macro_rs) > 0 else 0\\n macro_p = sum(macro_ps) / len(macro_ps) if len(macro_ps) > 0 else 0\\n macro_f1 = _f1(macro_r, macro_p)\\n\\n scores.append(\\n PartialMatchScore(\\n threshold=threshold,\\n micro=InstanceScore(p=micro_p, r=micro_r, f1=micro_f1),\\n macro=InstanceScore(p=macro_p, r=macro_r, f1=macro_f1),\\n )\\n )\\n\\n return scores\",\n \"def score(self, sentence):\\n\\n score = 0.0\\n i = 0\\n temp = \\\"\\\"\\n for token in sentence:\\n count = self.unigramCounts[token]\\n if (i == 0):\\n i = i + 1\\n temp = token\\n continue\\n\\n key = temp + \\\",\\\" + token\\n bicount = self.bigramCounts[key]\\n unicount = self.unigramCounts[temp]\\n temp = token\\n if bicount > 0 :\\n\\n score += (math.log(bicount) - math.log(unicount))\\n else:\\n unicount = self.unigramCounts[token]\\n score += math.log(unicount + 1) + math.log(0.4)\\n score -= math.log(self.total + len(self.unigramCounts))\\n\\n return score\",\n \"def get_q_probs(dataset):\\n\\n total_tokens = 0\\n trigram_count_dict = {}\\n bigram_count_dict = {}\\n unigram_count_dict = {}\\n for sentence in dataset:\\n # Tag Token counter\\n total_tokens += len(sentence)\\n # Make the sentence will be only tags\\n sentence = [word[1] for word in sentence]\\n\\n # Count the trigram model\\n first_word = sentence[:-2]\\n second_word = sentence[1:-1]\\n third_word = sentence[2:]\\n for i in range(len(first_word)):\\n trigram = (first_word[i], second_word[i], third_word[i])\\n if trigram in trigram_count_dict:\\n trigram_count_dict[trigram] += 1\\n else:\\n trigram_count_dict[trigram] = 1\\n\\n # Count the bigram model\\n first_word = sentence[:-1]\\n second_word = sentence[1:]\\n for i in range(len(first_word)):\\n brigram = (first_word[i], second_word[i])\\n if brigram in bigram_count_dict:\\n bigram_count_dict[brigram] += 1\\n else:\\n bigram_count_dict[brigram] = 1\\n\\n # Count the unigram model\\n for i in range(len(sentence)):\\n unigram = (sentence[i])\\n if unigram in unigram_count_dict:\\n unigram_count_dict[unigram] += 1\\n else:\\n unigram_count_dict[unigram] = 1\\n\\n # Get the unique taggs\\n e_tag_counts = unigram_count_dict.keys()\\n return total_tokens, trigram_count_dict, bigram_count_dict, unigram_count_dict, e_tag_counts\",\n \"def klue_re_auprc(probs, labels):\\n labels = np.eye(30)[labels]\\n\\n score = np.zeros((30,))\\n for c in range(30):\\n targets_c = labels.take([c], axis=1).ravel()\\n preds_c = probs.take([c], axis=1).ravel()\\n precision, recall, _ = metrics.precision_recall_curve(\\n targets_c, preds_c)\\n score[c] = metrics.auc(recall, precision)\\n return np.average(score) * 100.0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.676764","0.6673371","0.6643084","0.66368395","0.6494957","0.6433774","0.6251299","0.61644274","0.6140684","0.6140684","0.6137825","0.61087483","0.60575855","0.6050852","0.5999082","0.5985014","0.596442","0.5956953","0.5927048","0.5841247","0.5831066","0.58238924","0.581668","0.58036244","0.58029187","0.5771284","0.5756139","0.5750312","0.5743853","0.5728939","0.5724057","0.5723333","0.57225895","0.5702672","0.5675382","0.56579095","0.5651216","0.5646461","0.5639689","0.563831","0.5627981","0.56212664","0.56051487","0.5573661","0.55726683","0.5570496","0.55701745","0.55666685","0.556155","0.5539436","0.553248","0.55163795","0.5506397","0.55036473","0.55004007","0.54992026","0.5493779","0.5480349","0.54799175","0.5476884","0.5464457","0.54621375","0.54602575","0.545258","0.5451745","0.5451585","0.54507947","0.54452395","0.5441403","0.5434454","0.5430273","0.5420899","0.5419169","0.5418637","0.54173213","0.54070973","0.5406796","0.54018855","0.53985924","0.5395494","0.53904986","0.53899175","0.5385599","0.538299","0.5382689","0.5379393","0.5375705","0.5370868","0.5368494","0.53634834","0.53611994","0.5357166","0.53514624","0.53447336","0.5343525","0.53410125","0.53393245","0.53320557","0.53265107","0.5322295"],"string":"[\n \"0.676764\",\n \"0.6673371\",\n \"0.6643084\",\n \"0.66368395\",\n \"0.6494957\",\n \"0.6433774\",\n \"0.6251299\",\n \"0.61644274\",\n \"0.6140684\",\n \"0.6140684\",\n \"0.6137825\",\n \"0.61087483\",\n \"0.60575855\",\n \"0.6050852\",\n \"0.5999082\",\n \"0.5985014\",\n \"0.596442\",\n \"0.5956953\",\n \"0.5927048\",\n \"0.5841247\",\n \"0.5831066\",\n \"0.58238924\",\n \"0.581668\",\n \"0.58036244\",\n \"0.58029187\",\n \"0.5771284\",\n \"0.5756139\",\n \"0.5750312\",\n \"0.5743853\",\n \"0.5728939\",\n \"0.5724057\",\n \"0.5723333\",\n \"0.57225895\",\n \"0.5702672\",\n \"0.5675382\",\n \"0.56579095\",\n \"0.5651216\",\n \"0.5646461\",\n \"0.5639689\",\n \"0.563831\",\n \"0.5627981\",\n \"0.56212664\",\n \"0.56051487\",\n \"0.5573661\",\n \"0.55726683\",\n \"0.5570496\",\n \"0.55701745\",\n \"0.55666685\",\n \"0.556155\",\n \"0.5539436\",\n \"0.553248\",\n \"0.55163795\",\n \"0.5506397\",\n \"0.55036473\",\n \"0.55004007\",\n \"0.54992026\",\n \"0.5493779\",\n \"0.5480349\",\n \"0.54799175\",\n \"0.5476884\",\n \"0.5464457\",\n \"0.54621375\",\n \"0.54602575\",\n \"0.545258\",\n \"0.5451745\",\n \"0.5451585\",\n \"0.54507947\",\n \"0.54452395\",\n \"0.5441403\",\n \"0.5434454\",\n \"0.5430273\",\n \"0.5420899\",\n \"0.5419169\",\n \"0.5418637\",\n \"0.54173213\",\n \"0.54070973\",\n \"0.5406796\",\n \"0.54018855\",\n \"0.53985924\",\n \"0.5395494\",\n \"0.53904986\",\n \"0.53899175\",\n \"0.5385599\",\n \"0.538299\",\n \"0.5382689\",\n \"0.5379393\",\n \"0.5375705\",\n \"0.5370868\",\n \"0.5368494\",\n \"0.53634834\",\n \"0.53611994\",\n \"0.5357166\",\n \"0.53514624\",\n \"0.53447336\",\n \"0.5343525\",\n \"0.53410125\",\n \"0.53393245\",\n \"0.53320557\",\n \"0.53265107\",\n \"0.5322295\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5997709"},"document_rank":{"kind":"string","value":"15"}}},{"rowIdx":85167,"cells":{"query":{"kind":"string","value":"Extracts all ngrams up to a given maximum order from an input segment."},"document":{"kind":"string","value":"def _get_ngrams_with_counter(segment, max_order):\n ngram_counts = collections.Counter()\n for order in xrange(1, max_order + 1):\n for i in xrange(0, len(segment) - order + 1):\n ngram = tuple(segment[i:i + order])\n ngram_counts[ngram] += 1\n return ngram_counts"},"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 extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\n\n ngrams = Counter() # type: Counter\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\n\n ngrams = Counter()\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ngrams[ngram] += 1\n\n return ngrams","def get_ngrams(seq, n):\n return","def ngrams(word, size):\n expanded = \"^\" + word + \"$\"\n for start in range(len(expanded) - size + 1):\n yield expanded[start:start + size]","def _get_ngrams(segments, order):\n ngram_counts = collections.Counter()\n for seg in segments:\n for i in range(0, len(seg) - order + 1):\n ngram = tuple(seg[i:i+order])\n ngram_counts[ngram] += 1\n return ngram_counts","def ngramas(n, string):\n\n ngrams = []\n i = 0\n while i + n < len(string):\n ngrams.append(string[i:i + n])\n i += 1\n\n return ngrams","def ngrams_(text, n):\n return zip(*[text[i:] for i in range(n)])","def get_ngrams(s, ngram_range=1):\n # tokens = s.split()\n # return filter(lambda token: len(token)>1, tokens)\n # return bigrams(s.split()) # NLTK bigrams method\n words = s.split()\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]","def ngrams(text, n):\n return chain(*[ngrams_(text, i) for i in range(n + 1)])","def _ngrams(self, string_):\n def find_ngrams(input_list, n):\n return zip(*[input_list[i:] for i in range(n)])\n\n ngrams = []\n tokens = string_.split()\n\n for size in range(1, self._ngram_range + 1):\n tuples = find_ngrams(tokens, size)\n concatenated = [\"_\".join(tuple_) for tuple_ in tuples]\n ngrams.extend(concatenated)\n\n return \" \".join(ngrams)","def ngrams(word, n):\n word = list(word)\n # insert extra tokens\n word.insert(0, '$')\n word.append('$')\n\n output = []\n for i in range(len(word) - n + 1):\n # print(i)\n # print(word[i:i + n])\n output.append(''.join(word[i:i + n]))\n return output","def n_grams(tokens, n):\n return zip(*[tokens[i:] for i in range(n)])","def extract_n_grams(string, n, overlap=0, unique=True):\n if n > len(string):\n return [] \n\n n_grams = []\n step = n - overlap\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\n\n if unique:\n n_grams = list(set(n_grams))\n\n n_grams = [g+\"\\n\" for g in n_grams]\n\n return n_grams","def _get_exact_k_skip_n_grams(arr, n, k):\n for i in range(len(arr) - n - k + 1):\n part = arr[i:i+n+k]\n\n if k == 0:\n yield part\n else:\n for j in combinations(part[1:-1], n - 2):\n yield tuple([part[0]] + list(j) + [part[-1]])","def word2ngrams(text, n=3):\n return [text[i:i+n] for i in range(len(text)-n+1)]","def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\"|\"):\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\n s = tokenizer(s)\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\n return ngrams","def find_ngrams(input_list, n=3):\n return zip(*[input_list[i:] for i in range(n)])","def get_all(splitted_string, word_ngram, sort_ngrams=False):\n for ngram in range(1, word_ngram + 1):\n for word_pos in range(len(splitted_string) - ngram + 1):\n if sort_ngrams:\n yield (\"_\".join(sorted(splitted_string[word_pos:word_pos + ngram])))\n else:\n yield (\"_\".join(splitted_string[word_pos:word_pos + ngram]))","def ngrams(words, n=1):\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]","def find_all_ngrams(dataset, n):\n return zip(*[dataset[i:] for i in xrange(n)])","def get_nnp_ngrams(original_text, highlight=4, minsize=0):\n minsize = minsize-1\n if minsize<0:\n minsize = 0 \n \n tokens = nltk.wordpunct_tokenize(original_text)\n tagged = nltk.word_tokenize(original_text)\n tagged = nltk.pos_tag(tokens)\n #for word in tagged:\n # print word\n doc_length = len(tokens)\n counter = 0\n counter2 = 0\n if highlight==0:\n concated_test = doc_length # This is set to doc_length but could be anything recommend 3.\n else:\n concated_test = highlight\n list_of_NNPs = []\n while counter < (doc_length-1):\n while counter2 < concated_test:\n counter2 = counter2+1\n counter3 = 0\n #print '--------------------'\n temp_array = []\n all_nnp = True\n while counter3 < counter2:\n if counter < (doc_length-counter3):\n #print tokens[counter+counter3],tagged[counter+counter3][1]\n temp_array.append(tokens[counter+counter3])\n if tagged[counter+counter3][1] != 'NNP':\n all_nnp = False\n counter3 = counter3+1\n counter3 = 0\n if all_nnp == True:\n if(len(temp_array)>minsize):\n list_of_NNPs.append(temp_array)\n #print 'added to main array'\n #else:\n #print 'not all NNPs'\n counter2 = 0\n counter = counter+1\n #for ngram in list_of_NNPs:\n # print ngram\n import itertools\n list_of_NNPs.sort()\n unique_NNPs = list(list_of_NNPs for list_of_NNPs,_ in itertools.groupby(list_of_NNPs))\n return unique_NNPs","def segment(text):\n if not text: return []\n candidates = ([first]+segment(rest) for first,rest in splits(text))\n return max(candidates, key=Pwords)","def ngrams(text, n):\n grams = zip(*[text[i:] for i in range(n)])\n return [''.join(gram) for gram in grams]","def iter_ngrams(self, sentence, n):\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]","def ngrams(name_string, n=3):\n\n string = re.sub(r'[,-./]|\\sBD', r'', name_string)\n n_grams = zip(*[string[i:] for i in range(n)])\n return [''.join(n_gram) for n_gram in n_grams]","def sent2ngrams(text, n=3):\n if n == \"word\":\n return text.split()\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))","def get_ngram(n, sentence):\n if n == 1:\n return sentence\n \n # create phrases model to find words and ngrams that occur at least once\n ngram = Phraser(Phrases(sentence, min_count=1, threshold=1))\n\n # for bigrams and higher grams\n for i in range(3,n):\n ngram = Phraser(Phrases(ngram[sentence], min_count=1, threshold=1))\n return ngram[sentence]","def build_ngrams(tokens, n=2):\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\n return ngrams","def ngrammer(text, gramsize = 3, threshold = 4):\n # we need to import this in order to find the duplicates:\n import nltk\n from nltk.util import ngrams\n from collections import defaultdict\n # get ngrams of gramsize \n if type(text) != list:\n text = tokenised = nltk.word_tokenize(text)\n text = [token for token in text if token.isalnum()]\n # get ngrams of gramsize \n raw_grams = ngrams(text, gramsize)\n \n # a subdefinition to get duplicate lists in a list\n def list_duplicates(seq):\n tally = defaultdict(list)\n for i,item in enumerate(seq):\n tally[item].append(i)\n # return to us the index and the ngram itself:\n return ((len(locs),key) for key,locs in tally.items() \n if len(locs) > threshold)\n\n # use our duplication detector to find duplicates\n dupes = list_duplicates(raw_grams)\n # return them, sorted by most frequent\n return sorted(dupes, reverse = True)","def get_ngrams(tokens, min_n, max_n):\n all_ngrams = list()\n n_tokens = len(tokens)\n for i in range(n_tokens):\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\n all_ngrams.append(\" \".join(tokens[i:j]))\n return all_ngrams","def words_to_ngrams(words, max_order):\n d = defaultdict(int)\n\n # Iterate over word indices as start pointers\n for i in range(len(words)):\n # Sliding windows\n for j in range(min(max_order, len(words) - i)):\n # Increment counter, keep keys as tuples\n d[tuple(words[i: i+j+1])] += 1\n\n return d","def get_grams(candidate, n):\n words = candidate.split(' ')\n # print(words)\n grams = list()\n for i in range(len(words) - n + 1):\n # print(words[i:i+n])\n grams.append(' '.join(words[i:i+n]))\n return grams","def getgrams(text, tokendict):\n n = len(text)\n grams = []\n # Get lower-case of words\n if n >= 1:\n grams.append(tokendict[text[0]].lemma.lower())\n grams.append(tokendict[text[-1]].lemma.lower())\n grams.append(tokendict[text[0]].pos)\n grams.append(tokendict[text[-1]].pos)\n if n >= 2:\n token = tokendict[text[0]].lemma.lower() \\\n + ' ' + tokendict[text[1]].lemma.lower()\n grams.append(token)\n token = tokendict[text[-2]].lemma.lower() \\\n + ' ' + tokendict[text[-1]].lemma.lower()\n grams.append(token)\n return grams","def ngrams(iterable, n=1):\n return zip(*(iterable[i:] for i in range(n)))","def ngram(self,phrase,n,unity=\"w\"):\n return self._support.ngram(phrase,n,unity)","def get_ngrams(sequence, n):\n length = len(sequence)\n #if only require 1-gram, then we need to add one START and one END to the sequence. \n if n==1 or n==2:\n sequence=[\"START\"]*n+sequence+[\"STOP\"]\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\n #if require multi-grams, use the common calculation below.\n else:\n sequence = [\"START\"]*(n-1)+sequence+[\"STOP\"]\n end = 1\n if n==2:\n end = n\n result = []\n temp = ()\n #the process to construct the tuple-based array.\n for i in range(0,length+end):\n temp = tuple(sequence[i:i+n])\n\n result.append(temp)\n return result","def extract_ngrams(self, sequence):\n sequence = self.prefix + sequence + self.suffix\n for i, event in enumerate(sequence[self.n:], self.n):\n yield event, sequence[i-self.n: i]","def get_lemma_ngrams(s, t, i, ngram_size):\n ngrams = {\"uni\":1, \"bi\":2, \"tri\":3}\n if i < s.length-(ngrams[ngram_size]-1):\n lemma_ngrams = []\n for j in range(ngrams[ngram_size]):\n if s.nodes[i+j].lemma:\n lemma_ngrams.append(s.nodes[i+j].lemma[0]) #only keeps the first lemma\n else:\n lemma_ngrams.append(s.nodes[i+j].word + \"*\") #no lemma, word form* instead\n if len(lemma_ngrams) > 1:\n return tuple(lemma_ngrams)\n return lemma_ngrams[0] #or better to keep them all?\n else:\n return []","def n_grama(sentence, n):\n t = tokenize(sentence)\n n_grams = zip(*[t[i:] for i in range(n)])\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))","def precook(s, n=4, out=False):\n words = s.split()\n counts = defaultdict(int)\n for k in xrange(1,n+1):\n for i in xrange(len(words)-k+1):\n ngram = tuple(words[i:i+k])\n counts[ngram] += 1\n return counts","def chngrams(string=\"\", n=3, top=None, threshold=0, exclude=[], **kwargs):\n\t# An optional dict-parameter can be used to specify a subclass of dict,\n\t# e.g., count(words, dict=readonlydict) as used in Document.\n\tcount = defaultdict(int)\n\tif n > 0:\n\t\tfor i in xrange(len(string)-n+1):\n\t\t\tw = string[i:i+n]\n\t\t\tif w not in exclude:\n\t\t\t\tcount[w] += 1\n\tif threshold > 0:\n\t\tcount = dict((k, v) for k, v in count.items() if v > threshold)\n\tif top is not None:\n\t\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\n\treturn kwargs.get(\"dict\", dict)(count)","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(uncased)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def ngrams(n, target):\n chars = collections.deque()\n while True:\n chars.append((yield))\n if len(chars) == n: \n target.send(chars)\n chars.popleft()","def ngramify(word: str,\n max_ngram_size: int):\n chars = list(word)\n ngram_tuples = []\n ngrams = []\n # Take all n-grams with length in [2, max_ngram_size]\n for i in range(2, max_ngram_size + 1):\n pw = list(pairwise(chars, i))\n ngram_tuples += pw\n for e in ngram_tuples:\n if None not in e:\n ngrams.append(''.join(e))\n # Append the list of characters, to avoid an unnecessary call for pairwise(_, 1).\n return list(word) + ngrams","def test_top_n_grams():\n ngrams = NgramFrequencies()\n unigrams_dic = {\n \"COUNT\": 10,\n \"time_burton's\": 5,\n \"burton's_corpse\": 4,\n \"corpse_bride\": 1\n }\n top_n_unigrams = ngrams.top_n_grams(unigrams_dic, 2)\n assert top_n_unigrams == [\n (\"time_burton's\", 0.5),\n (\"burton's_corpse\", 0.4)\n ]","def compute_ngrams(str, n=2):\n #split the string\n st = tuple(str.split())\n #not list of list but list of tuple..\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\n dgram = {}\n #convert ngram into dictionary:\n for key in gram:\n dgram.setdefault(key[0],[]).append(key[1:])\n return dgram","def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\n\n def _skip(gram):\n if not filter_fn:\n return False\n return filter_fn(gram)\n\n words = self.words(True)\n ngrams = [(s, e + 1)\n for s in range(len(words))\n for e in range(s, min(s + n, len(words)))\n if not _skip(words[s:e + 1])]\n\n # Concatenate into strings\n if as_strings:\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\n\n return ngrams","def segment(text, WORDS) -> List[Word]:\n Pword = Bag(WORDS)\n if not text: \n return []\n else:\n candidates = ([first] + segment(rest, WORDS)\n for (first, rest) in splits(text, 1))\n return max(candidates, key=lambda x: Pwords(x, Pword))","def n_grams(tokens, n=1):\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\n shiftedTokens = (shiftToken(i) for i in range(n))\n tupleNGrams = zip(*shiftedTokens)\n return tupleNGrams","def word_ngrams(sent, n):\n\t\n\t# EXAMPLES \n\t# > word_ngrams(tokenize('hello world'), 1)\n\t# [('hello',), ('world',)]\n\t# > word_ngrams(tokenize('hello world'), 2)\n\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\n\n\t# YOUR CODE HERE\n\ttokenized_sent = tokenize(sent)\n\tif n != 1:\n\t\ttokenized_sent.insert(0, '<s>')\n\t\ttokenized_sent.append('</s>')\n\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]","def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\n\n words = [word for word in sent.split() if word not in string.punctuation]\n\n rows = [words[i:] for i in range(n)]\n\n return zip(*rows)","def ngrams(sequence, n):\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\n sequence = list(sequence)\n count = max(0, len(sequence) - n + 1)\n return [tuple(sequence[i:i+n]) for i in range(count)]","def range_ngrams(tokens, ngramRange=(1,2)):\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))","def similar_ngrams(ngram, morph_model, lm, nbest):\n w1 = ngram[0]\n w2 = ngram[1]\n nbest_max = 3 # Limit for number of segmentations/word\n sim_ngrams = []\n \n # Preserve only the longest segment of each segmentation\n viterbi_nbest_1 = morph_model.viterbi_nbest(w1, nbest)\n viterbi_nbest_2 = morph_model.viterbi_nbest(w2, nbest)\n segmentations1 = [max([viterbi_nbest_1[i][0] \n for i in range(len(viterbi_nbest_1))][j], key=len)\n for j in range(len(viterbi_nbest_1))]\n segmentations2 = [max([viterbi_nbest_2[i][0] \n for i in range(len(viterbi_nbest_2))][j], key=len) \n for j in range(len(viterbi_nbest_2))]\n \n # Remove duplicates and too short word segments\n segmentations1 = [segment for segment in list(dict.fromkeys(segmentations1)) \n if len(segment)>=min(3,len(w1))]\n segmentations2 = [segment for segment in list(dict.fromkeys(segmentations2)) \n if len(segment)>=min(3,len(w2))]\n \n #print(segmentations1)\n #print(segmentations2)\n \n # Put the first word of the bigram itself (w1) to the beginning of the list\n # of words similar to w1.\n similar_words_1 = [w1]\n similar_words_2 = []\n \n # Collect the words from the LM vocabulary that contain\n # the same segment as one of the words of the bigram\n for word in lm.vocab:\n for word1 in segmentations1:\n if word1 in word:\n similar_words_1.append(word)\n for word2 in segmentations2:\n if word2 in word:\n similar_words_2.append(word)\n \n # Make ngrams using all possible combinations of the\n # words found from the LM vocabulary and return the ones\n # that have non-zero probability. Because w1 itself is in the beginning of\n # the list of words similar to w1, bigrams with non-zero probability\n # [w1, _ ] will be returned first (if such bigrams exist)\n for pair in list(itertools.product(similar_words_1, similar_words_2)):\n logscore = lm.logscore(pair[1], [pair[0]])\n if logscore > -float('inf'):\n sim_ngrams.append(pair[0] + ' ' + pair[1])# + ' ' + str(round(logscore)))\n if len(sim_ngrams) > 4:\n break\n \n # If no similar ngrams, try one more time with more word segmentations\n if not sim_ngrams and nbest<nbest_max:\n nbest += 1\n sim_ngrams = similar_ngrams(ngram, morph_model, lm, nbest)\n \n # Remove duplicates\n sim_ngrams = list(dict.fromkeys(sim_ngrams))\n return sim_ngrams","def n_gram(list, n):\n ngrams = zip(*[list[i:] for i in range(n)])\n return [\" \".join(ngram) for ngram in ngrams]","def _generateNgrams(self,text,n=2):\n token = Utilities.CVTokeniser(text)\n # token = nltk.word_tokenize(text)\n computedNgrams=ngrams(token,n)\n return Counter(computedNgrams)","def get_ngrams(sequence, n):\n\n # Set prefix and postfix\n prefix = \"START\"\n postfix = \"STOP\"\n # Append 1 prefix regardless of value of n\n sequence.insert(0, prefix)\n for i in range(n - 2) :\n sequence.insert(0, prefix)\n sequence.append(postfix)\n\n # Check if 1 <= n <= len(sequence)\n if (n > len(sequence)) :\n print(sequence)\n assert 1 <= n\n assert n <= len(sequence)\n\n # Create n-gram sequence\n n_gram_sequence = []\n for i in range(n, len(sequence) + 1) :\n temp_sequence = []\n for j in range(i - n, i) :\n temp_sequence.append(sequence[j])\n n_gram_sequence.append(tuple(temp_sequence))\n return n_gram_sequence","def get_ngrams(sequence, n):\n # Example: n = 3, length = 4\n # we want 0:3, 1:4\n\n result = []\n if n == 1:\n result.append(tuple([\"START\"]))\n result.append(tuple([\"STOP\"]))\n\n if n == 3 and len(sequence) == 1:\n result.append(tuple([\"START\",\"START\",sequence[0]]))\n result.append(tuple([\"START\",sequence[0],\"STOP\"]))\n return result\n\n if n > 1 :\n for i in range(n-1):\n result.append(tuple([\"START\"]*(n-1-i)+ sequence[:i+1]))\n result.append(tuple(sequence[-n+1:] + [\"STOP\"]))\n\n for i in range(len(sequence)-n+1):\n result.append(tuple(sequence[i:i+n]))\n return result","def get_n_minus_1_grams(n_grams: str) -> str:\n return n_grams.rsplit(' ')[0]","def get_ngrams(stats,s,t,i):\n #lemma ngrams\n ngram_sizes = [\"bi\", \"tri\"]\n for ngram_size in ngram_sizes:\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\n if lm_ngram:\n put_feature_value_list(stats,\"lemma_\" + ngram_size + \"gr\", lm_ngram)\n\n #POS and deprel bigrams\n if i < s.length-1:\n put_feature_value_list(stats,\"deprels_bigr\", (t.deprel,s.nodes[i+1].deprel))\n put_feature_value_list(stats,\"pos_bigr\", (t.pos,s.nodes[i+1].pos))\n \n #POS and deprel trigrams\n if i < s.length-2:\n put_feature_value_list(stats,\"deprels_trigr\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\n put_feature_value_list(stats,\"pos_trigr\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\n\n return stats","def get_all_ngrams():\n grams = ()\n for i in range(0, 40):\n text_i = read_file(str(i))\n curr_grams = ngramize(text_i, n)\n grams = chain(grams, curr_grams)\n return grams","def get_ngrams(self, n = None):\n if not n:\n n = self.N\n\n temp = []\n for sent in self.get_sentences():\n temp.extend(list(sent))\n\n return nltk.ngrams(temp, n)","def num_bigram(doc):\n matched_spans = []\n matches = matcher(doc)\n for match_id, start, end in matches:\n span = doc[start:end]\n matched_spans.append(span)\n for span in matched_spans: # merge into one token after collecting all matches\n span.merge()\n return doc","def find_ngrams(self, n):\n\n output = {}\n\n for i in range(len(self.text)-n+1):\n s = ' '.join(self.text[i:i+n])\n # if s is not already in dictionary, set value to 0\n output.setdefault(s, 0)\n output[s] += 1\n return output","def ngramify(corpus, n):\r\n unlist = 0\r\n if type(corpus[0]) is not list:\r\n corpus = [corpus]\r\n unlist = 1\r\n new_corpus = []\r\n for line in corpus:\r\n new_line = []\r\n for gram in range(len(line) - n + 1):\r\n new_gram = \"\"\r\n for i in range(n):\r\n if i != 0:\r\n new_gram += \" \"\r\n new_gram += line[gram + i]\r\n new_line.append(new_gram)\r\n new_corpus.append(new_line)\r\n if unlist:\r\n return new_corpus[0]\r\n return new_corpus","def top_ngrams(ngram_dict,ntop):\n # get list of all ngrams and counts\n ngrams = ngram_dict.items()\n # sort according to the count\n # we use a python lambda function here to say that we want to sort by the\n # second item in the tuples contained in the list\n ngrams.sort(key=lambda x: x[1], reverse=True)\n # return the top ngrams\n return ngrams[0:ntop]","def get_ngrams(self, s, ngmin, ngmax, separator=\"\",\n bos=\"<\", eos=\">\", suffix=\"\", flatten=True):\n\n # return a single dummy feature if there are no applicable ngrams\n # probably resulting in a mojority-class classifier\n if ngmax == 0 or (ngmax - ngmin < 0) :\n return ['__dummy__']\n\n ngrams = [[] for x in range(1, ngmax + 1)]\n s = [bos] + s + [eos]\n for i, ch in enumerate(s):\n for ngsize in range(ngmin, ngmax + 1):\n if (i + ngsize) <= len(s):\n ngrams[ngsize - 1].append(\n separator.join(s[i:i+ngsize]) + suffix)\n if flatten:\n ngrams = [ng for nglist in ngrams for ng in nglist]\n return ngrams","def extract_char_ngrams(s: str, n: int) -> Counter:\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])","def ngrams(self):\n return self.root.ngrams()","def nbest(self, score_fn, n):\n return [p for p, s in self.score_ngrams(score_fn)[:n]]","def k_skip_n_grams(arr, n, k):\n if n == 0:\n return\n\n if n == 1:\n for e in arr:\n yield e\n return\n\n for i in range(0, min(len(arr) - n, k) + 1):\n yield from _get_exact_k_skip_n_grams(arr, n, i)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n # words = _split_into_words(sentences)\n\n words = sum(sentences, [])\n # words = [w for w in words if w not in stopwords]\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n # words = _split_into_words(sentences)\n\n words = sum(sentences, [])\n # words = [w for w in words if w not in stopwords]\n return _get_ngrams(n, words)","def make_chains(text_string):\n\n chains = {}\n n = 2\n # n = int(raw_input(\"Enter the number of ngrams you want? >\"))\n # your code goes here\n words = text_string.split()\n for i in range(len(words) - 1):\n ngram = tuple(words[i: i + n])\n if i >= len(words) - n:\n chains[ngram] = None\n else:\n nth_word = words[i + n]\n if ngram not in chains:\n chains[ngram] = [nth_word]\n else:\n chains[ngram].append(nth_word)\n return (chains, n)","def generate_ngrams(tokens, ngram_size, *, include_terminator = False):\n \n if ngram_size <= 0:\n raise Exception(\"ngram size must be positive\")\n\n if not include_terminator:\n for token_index in range(len(tokens)):\n leader = get_leader(tokens, token_index, ngram_size - 1)\n token = tokens[token_index]\n \n yield leader, token\n else:\n for token_index in range(len(tokens) + 1):\n leader = get_leader(tokens, token_index, ngram_size - 1)\n token = tokens[token_index] if token_index < len(tokens) else None\n\n yield leader, token","def everygrams(seq):\n for n in range(1, len(seq) + 1):\n for ng in nltk.util.ngrams(seq, n):\n yield ng","def create_ngrams(word_list, n):\n yield zip(*[word_list[i:] for i in range(n)])","def create_ngrams(self, tokens):\n ngrams = []\n for i in range(len(tokens)- self.N + 1):\n ngrams.append(tuple(tokens[i:i+self.N]))\n return ngrams","def _create_ngrams(tokens, n):\n\n ngrams = collections.Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams","def _precook(s, n=4, out=False):\n if isinstance(s,str):\n words = s.split()\n # print(words)\n elif isinstance(s,list) or isinstance(s,tuple):\n words = s\n else:\n raise NotImplementedError(type(s))\n counts = defaultdict(int)\n for k in range(1, n + 1):\n for i in range(len(words) - k + 1):\n ngram = tuple(words[i:i + k])\n counts[ngram] += 1\n return (len(words), counts)","def _get_bag_of_pos_ngram(words, index, window_size, N):\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\n words = [bos] * (window_size + N) + words + [eos] * (window_size + N)\n index += (window_size + N)\n return [\n \"_\".join([_get_word_feature(w) for w in words[i:i+N]])\n for i in range(index-window_size, index+window_size+1)]","def get_top_tweet_ngrams(corpus, dim=2, n=None):\r\n vec = CountVectorizer(ngram_range=(dim, dim)).fit(corpus)\r\n bag_of_words = vec.transform(corpus)\r\n sum_words = bag_of_words.sum(axis=0) \r\n words_freq = [(word, sum_words[0, idx]) for word, idx in vec.vocabulary_.items()]\r\n words_freq =sorted(words_freq, key = lambda x: x[1], reverse=True)\r\n return words_freq[:n]","def segment_words(self, string):\n words = []\n\n word_begin = 0\n while word_begin < len(string):\n word_options = self.find_prefixes(string[word_begin:])\n if len(word_options) > 0:\n best_word = self.unigram_provider.get_most_frequent_word(word_options)\n else:\n best_word = string[word_begin:word_begin+1]\n words.append(best_word)\n word_begin += len(best_word)\n\n return words","def transform_ngrams(self, words):\n return words if self.n_grams == 1 else [self.connector.join(words[i:i + self.n_grams]) for i in range(len(words) - self.n_grams + 1)]","def sized_ngrams(self, size):\n return self.root.sized_ngrams(size)","def read_ngrams(filename, length):\n ngram = deque(' ' * length)\n\n with open(filename) as file:\n for line in file:\n for char in line:\n ngram.popleft()\n ngram.append(char)\n \n if is_valid_ngram(ngram):\n yield ''.join(ngram)","def get(self, n):\n parts = [' '.join(g) for g in ngrams(self.words, n)]\n return get_occurences(parts)","def ngrams(self):\n return self.__ngrams(())","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = split_into_words(sentences)\n return _get_ngrams(n, words)","def build_model(self, text):\n text = '< ' * (self.n - 1) + text.replace(' . ', ' .%s ' % (' <' * (self.n - 1))) + ' >'\n tokens = self.split(text)\n self.corpus_len = len(tokens)\n self.n_grams_by_len = [{} for _ in range(self.n)]\n for i in range(len(tokens)): # for index in tokens\n for n in range(self.n): # for n-gram size from 1 to n:\n if i >= n: # if the index has advanced enough for this n\n n_gram = self.join(tokens[i - n: i + 1])\n n_grams = self.n_grams_by_len[n] # get dict for respective n\n n_grams[n_gram] = n_grams.get(n_gram, 0) + 1 # get dict for respective n\n return self.get_model()","def n_grammize(role):\n ngrams = []\n if isinstance(role,str):\n role = role.lower()\n role = role.split()\n if len(role)>2:\n for i in range(2, len(role)):\n ngrams.append((role[i-2], role[i-1], role[i]))\n if len(role)>1:\n for i in range(1, len(role)):\n ngrams.append((role[i-1], role[i]))\n for i in range(len(role)):\n ngrams.append(role[i])\n return ngrams","def ngrams(tokens,lang):\n stopwords = stops.stopwords[lang]\n max = len(tokens)\n ngrams = []\n left_punctuation = '!\"%&\\'()*+,-./:;<=>?[\\\\]^_`{|}~'\n\n for i in range(1,max):\n for j in xrange(0,len(tokens)-(i-1)):\n if __check_features(tokens[j:j+i],stopwords):\n ng_str = \" \".join(tokens[j:j+i])\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \n ngrams.append(ng_str)\n \n ng_str = \" \".join(tokens)\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \n ngrams.append(ng_str)\n return ngrams","def generate_ngrams(iterable, n):\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])","def full_ngrams(items, n):\n ngs = {}\n for i in xrange(1, n+1):\n ngs.update(gen_ngrams(items, i))\n return ngs","def sized_ngrams(self, size):\n return self.__sized_ngrams(size, ())","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def _get_word_ngrams(n, sentences):\n assert len(sentences) > 0\n assert n > 0\n\n words = _split_into_words(sentences)\n return _get_ngrams(n, words)","def add_ngram(sequences, token_indice, ngram_range=2):\n new_sequences = []\n for input_list in sequences:\n new_list = input_list[:]\n for ngram_value in range(2, ngram_range + 1):\n for i in range(len(new_list) - ngram_value + 1):\n ngram = tuple(new_list[i:i + ngram_value])\n if ngram in token_indice:\n new_list.append(token_indice[ngram])\n new_sequences.append(new_list)\n\n return new_sequences","def count_ngrams(lines, min_length=1, max_length=4):\n def add_queue():\n # Helper function to add n-grams at start of current queue to dict\n current = tuple(queue)\n for length in lengths:\n if len(current) >= length: # count n-grams up to length those in queue\n ngrams[length][current[:length]] += 1 # ngrams[length] => counter\n def eval_sequence_dtype(): \n if not lines: \n return False # no-op\n if isinstance(lines[0], str): \n return False\n elif hasattr(lines[0], '__iter__'): \n return True\n return False\n\n lengths = range(min_length, max_length + 1)\n ngrams = {length: collections.Counter() for length in lengths}\n queue = collections.deque(maxlen=max_length)\n\n # tokenized or not? \n is_tokenized = eval_sequence_dtype()\n # print('> tokenized? %s' % is_tokenized)\n\n # Loop through all lines and words and add n-grams to dict\n if is_tokenized: \n # print('input> lines: %s' % lines)\n for line in lines:\n for word in line:\n queue.append(word)\n if len(queue) >= max_length:\n add_queue() # this does the counting\n # print('+ line: %s\\n+ngrams: %s' % (line, ngrams))\n else: \n for line in lines:\n for word in tokenize(line):\n queue.append(word)\n if len(queue) >= max_length:\n add_queue()\n\n # Make sure we get the n-grams at the tail end of the queue\n while len(queue) > min_length:\n queue.popleft()\n add_queue()\n # print('+ line: %s\\n+ngrams: %s' % (line, ngrams))\n\n return ngrams"],"string":"[\n \"def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter() # type: Counter\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def extract_ngrams(line, min_order=1, max_order=NGRAM_ORDER) -> Counter:\\n\\n ngrams = Counter()\\n tokens = line.split()\\n for n in range(min_order, max_order + 1):\\n for i in range(0, len(tokens) - n + 1):\\n ngram = ' '.join(tokens[i: i + n])\\n ngrams[ngram] += 1\\n\\n return ngrams\",\n \"def get_ngrams(seq, n):\\n return\",\n \"def ngrams(word, size):\\n expanded = \\\"^\\\" + word + \\\"$\\\"\\n for start in range(len(expanded) - size + 1):\\n yield expanded[start:start + size]\",\n \"def _get_ngrams(segments, order):\\n ngram_counts = collections.Counter()\\n for seg in segments:\\n for i in range(0, len(seg) - order + 1):\\n ngram = tuple(seg[i:i+order])\\n ngram_counts[ngram] += 1\\n return ngram_counts\",\n \"def ngramas(n, string):\\n\\n ngrams = []\\n i = 0\\n while i + n < len(string):\\n ngrams.append(string[i:i + n])\\n i += 1\\n\\n return ngrams\",\n \"def ngrams_(text, n):\\n return zip(*[text[i:] for i in range(n)])\",\n \"def get_ngrams(s, ngram_range=1):\\n # tokens = s.split()\\n # return filter(lambda token: len(token)>1, tokens)\\n # return bigrams(s.split()) # NLTK bigrams method\\n words = s.split()\\n return [' '.join(words[i:i+ngram_range]) for i in range(len(words)-1)]\",\n \"def ngrams(text, n):\\n return chain(*[ngrams_(text, i) for i in range(n + 1)])\",\n \"def _ngrams(self, string_):\\n def find_ngrams(input_list, n):\\n return zip(*[input_list[i:] for i in range(n)])\\n\\n ngrams = []\\n tokens = string_.split()\\n\\n for size in range(1, self._ngram_range + 1):\\n tuples = find_ngrams(tokens, size)\\n concatenated = [\\\"_\\\".join(tuple_) for tuple_ in tuples]\\n ngrams.extend(concatenated)\\n\\n return \\\" \\\".join(ngrams)\",\n \"def ngrams(word, n):\\n word = list(word)\\n # insert extra tokens\\n word.insert(0, '$')\\n word.append('$')\\n\\n output = []\\n for i in range(len(word) - n + 1):\\n # print(i)\\n # print(word[i:i + n])\\n output.append(''.join(word[i:i + n]))\\n return output\",\n \"def n_grams(tokens, n):\\n return zip(*[tokens[i:] for i in range(n)])\",\n \"def extract_n_grams(string, n, overlap=0, unique=True):\\n if n > len(string):\\n return [] \\n\\n n_grams = []\\n step = n - overlap\\n n_grams = [string[i:i+n] for i in range(0, len(string)-step+1, step)]\\n\\n if unique:\\n n_grams = list(set(n_grams))\\n\\n n_grams = [g+\\\"\\\\n\\\" for g in n_grams]\\n\\n return n_grams\",\n \"def _get_exact_k_skip_n_grams(arr, n, k):\\n for i in range(len(arr) - n - k + 1):\\n part = arr[i:i+n+k]\\n\\n if k == 0:\\n yield part\\n else:\\n for j in combinations(part[1:-1], n - 2):\\n yield tuple([part[0]] + list(j) + [part[-1]])\",\n \"def word2ngrams(text, n=3):\\n return [text[i:i+n] for i in range(len(text)-n+1)]\",\n \"def get_ngrams(s, ngmin=1, ngmax=1, tokenizer=list, separator=\\\"|\\\"):\\n ngrams = [[] for x in range(ngmin, ngmax + 1)]\\n s = tokenizer(s)\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(separator.join(s[i:i+ngsize]))\\n return ngrams\",\n \"def find_ngrams(input_list, n=3):\\n return zip(*[input_list[i:] for i in range(n)])\",\n \"def get_all(splitted_string, word_ngram, sort_ngrams=False):\\n for ngram in range(1, word_ngram + 1):\\n for word_pos in range(len(splitted_string) - ngram + 1):\\n if sort_ngrams:\\n yield (\\\"_\\\".join(sorted(splitted_string[word_pos:word_pos + ngram])))\\n else:\\n yield (\\\"_\\\".join(splitted_string[word_pos:word_pos + ngram]))\",\n \"def ngrams(words, n=1):\\n return [tuple(words[j:j + n]) for j in range(len(words) - n + 1)]\",\n \"def find_all_ngrams(dataset, n):\\n return zip(*[dataset[i:] for i in xrange(n)])\",\n \"def get_nnp_ngrams(original_text, highlight=4, minsize=0):\\n minsize = minsize-1\\n if minsize<0:\\n minsize = 0 \\n \\n tokens = nltk.wordpunct_tokenize(original_text)\\n tagged = nltk.word_tokenize(original_text)\\n tagged = nltk.pos_tag(tokens)\\n #for word in tagged:\\n # print word\\n doc_length = len(tokens)\\n counter = 0\\n counter2 = 0\\n if highlight==0:\\n concated_test = doc_length # This is set to doc_length but could be anything recommend 3.\\n else:\\n concated_test = highlight\\n list_of_NNPs = []\\n while counter < (doc_length-1):\\n while counter2 < concated_test:\\n counter2 = counter2+1\\n counter3 = 0\\n #print '--------------------'\\n temp_array = []\\n all_nnp = True\\n while counter3 < counter2:\\n if counter < (doc_length-counter3):\\n #print tokens[counter+counter3],tagged[counter+counter3][1]\\n temp_array.append(tokens[counter+counter3])\\n if tagged[counter+counter3][1] != 'NNP':\\n all_nnp = False\\n counter3 = counter3+1\\n counter3 = 0\\n if all_nnp == True:\\n if(len(temp_array)>minsize):\\n list_of_NNPs.append(temp_array)\\n #print 'added to main array'\\n #else:\\n #print 'not all NNPs'\\n counter2 = 0\\n counter = counter+1\\n #for ngram in list_of_NNPs:\\n # print ngram\\n import itertools\\n list_of_NNPs.sort()\\n unique_NNPs = list(list_of_NNPs for list_of_NNPs,_ in itertools.groupby(list_of_NNPs))\\n return unique_NNPs\",\n \"def segment(text):\\n if not text: return []\\n candidates = ([first]+segment(rest) for first,rest in splits(text))\\n return max(candidates, key=Pwords)\",\n \"def ngrams(text, n):\\n grams = zip(*[text[i:] for i in range(n)])\\n return [''.join(gram) for gram in grams]\",\n \"def iter_ngrams(self, sentence, n):\\n return [tuple(sentence[i : i+n]) for i in range(len(sentence)-n+1)]\",\n \"def ngrams(name_string, n=3):\\n\\n string = re.sub(r'[,-./]|\\\\sBD', r'', name_string)\\n n_grams = zip(*[string[i:] for i in range(n)])\\n return [''.join(n_gram) for n_gram in n_grams]\",\n \"def sent2ngrams(text, n=3):\\n if n == \\\"word\\\":\\n return text.split()\\n return list(chain(*[word2ngrams(i,n) for i in text.lower().split()]))\",\n \"def get_ngram(n, sentence):\\n if n == 1:\\n return sentence\\n \\n # create phrases model to find words and ngrams that occur at least once\\n ngram = Phraser(Phrases(sentence, min_count=1, threshold=1))\\n\\n # for bigrams and higher grams\\n for i in range(3,n):\\n ngram = Phraser(Phrases(ngram[sentence], min_count=1, threshold=1))\\n return ngram[sentence]\",\n \"def build_ngrams(tokens, n=2):\\n ngrams = zip(*(islice(group, idx, None) for idx, group in enumerate(tee(tokens, n))))\\n return ngrams\",\n \"def ngrammer(text, gramsize = 3, threshold = 4):\\n # we need to import this in order to find the duplicates:\\n import nltk\\n from nltk.util import ngrams\\n from collections import defaultdict\\n # get ngrams of gramsize \\n if type(text) != list:\\n text = tokenised = nltk.word_tokenize(text)\\n text = [token for token in text if token.isalnum()]\\n # get ngrams of gramsize \\n raw_grams = ngrams(text, gramsize)\\n \\n # a subdefinition to get duplicate lists in a list\\n def list_duplicates(seq):\\n tally = defaultdict(list)\\n for i,item in enumerate(seq):\\n tally[item].append(i)\\n # return to us the index and the ngram itself:\\n return ((len(locs),key) for key,locs in tally.items() \\n if len(locs) > threshold)\\n\\n # use our duplication detector to find duplicates\\n dupes = list_duplicates(raw_grams)\\n # return them, sorted by most frequent\\n return sorted(dupes, reverse = True)\",\n \"def get_ngrams(tokens, min_n, max_n):\\n all_ngrams = list()\\n n_tokens = len(tokens)\\n for i in range(n_tokens):\\n for j in range(i + min_n, min(n_tokens, i + max_n) + 1):\\n all_ngrams.append(\\\" \\\".join(tokens[i:j]))\\n return all_ngrams\",\n \"def words_to_ngrams(words, max_order):\\n d = defaultdict(int)\\n\\n # Iterate over word indices as start pointers\\n for i in range(len(words)):\\n # Sliding windows\\n for j in range(min(max_order, len(words) - i)):\\n # Increment counter, keep keys as tuples\\n d[tuple(words[i: i+j+1])] += 1\\n\\n return d\",\n \"def get_grams(candidate, n):\\n words = candidate.split(' ')\\n # print(words)\\n grams = list()\\n for i in range(len(words) - n + 1):\\n # print(words[i:i+n])\\n grams.append(' '.join(words[i:i+n]))\\n return grams\",\n \"def getgrams(text, tokendict):\\n n = len(text)\\n grams = []\\n # Get lower-case of words\\n if n >= 1:\\n grams.append(tokendict[text[0]].lemma.lower())\\n grams.append(tokendict[text[-1]].lemma.lower())\\n grams.append(tokendict[text[0]].pos)\\n grams.append(tokendict[text[-1]].pos)\\n if n >= 2:\\n token = tokendict[text[0]].lemma.lower() \\\\\\n + ' ' + tokendict[text[1]].lemma.lower()\\n grams.append(token)\\n token = tokendict[text[-2]].lemma.lower() \\\\\\n + ' ' + tokendict[text[-1]].lemma.lower()\\n grams.append(token)\\n return grams\",\n \"def ngrams(iterable, n=1):\\n return zip(*(iterable[i:] for i in range(n)))\",\n \"def ngram(self,phrase,n,unity=\\\"w\\\"):\\n return self._support.ngram(phrase,n,unity)\",\n \"def get_ngrams(sequence, n):\\n length = len(sequence)\\n #if only require 1-gram, then we need to add one START and one END to the sequence. \\n if n==1 or n==2:\\n sequence=[\\\"START\\\"]*n+sequence+[\\\"STOP\\\"]\\n end = n+1 #end i means that when n==1, we need to read one more data, that is to the end of sequence, which is slightly different from when n>1.\\n #if require multi-grams, use the common calculation below.\\n else:\\n sequence = [\\\"START\\\"]*(n-1)+sequence+[\\\"STOP\\\"]\\n end = 1\\n if n==2:\\n end = n\\n result = []\\n temp = ()\\n #the process to construct the tuple-based array.\\n for i in range(0,length+end):\\n temp = tuple(sequence[i:i+n])\\n\\n result.append(temp)\\n return result\",\n \"def extract_ngrams(self, sequence):\\n sequence = self.prefix + sequence + self.suffix\\n for i, event in enumerate(sequence[self.n:], self.n):\\n yield event, sequence[i-self.n: i]\",\n \"def get_lemma_ngrams(s, t, i, ngram_size):\\n ngrams = {\\\"uni\\\":1, \\\"bi\\\":2, \\\"tri\\\":3}\\n if i < s.length-(ngrams[ngram_size]-1):\\n lemma_ngrams = []\\n for j in range(ngrams[ngram_size]):\\n if s.nodes[i+j].lemma:\\n lemma_ngrams.append(s.nodes[i+j].lemma[0]) #only keeps the first lemma\\n else:\\n lemma_ngrams.append(s.nodes[i+j].word + \\\"*\\\") #no lemma, word form* instead\\n if len(lemma_ngrams) > 1:\\n return tuple(lemma_ngrams)\\n return lemma_ngrams[0] #or better to keep them all?\\n else:\\n return []\",\n \"def n_grama(sentence, n):\\n t = tokenize(sentence)\\n n_grams = zip(*[t[i:] for i in range(n)])\\n return list(map(lambda n_gram: ' '.join(n_gram), n_grams))\",\n \"def precook(s, n=4, out=False):\\n words = s.split()\\n counts = defaultdict(int)\\n for k in xrange(1,n+1):\\n for i in xrange(len(words)-k+1):\\n ngram = tuple(words[i:i+k])\\n counts[ngram] += 1\\n return counts\",\n \"def chngrams(string=\\\"\\\", n=3, top=None, threshold=0, exclude=[], **kwargs):\\n\\t# An optional dict-parameter can be used to specify a subclass of dict,\\n\\t# e.g., count(words, dict=readonlydict) as used in Document.\\n\\tcount = defaultdict(int)\\n\\tif n > 0:\\n\\t\\tfor i in xrange(len(string)-n+1):\\n\\t\\t\\tw = string[i:i+n]\\n\\t\\t\\tif w not in exclude:\\n\\t\\t\\t\\tcount[w] += 1\\n\\tif threshold > 0:\\n\\t\\tcount = dict((k, v) for k, v in count.items() if v > threshold)\\n\\tif top is not None:\\n\\t\\tcount = dict(heapq.nsmallest(top, count.items(), key=lambda kv: (-kv[1], kv[0])))\\n\\treturn kwargs.get(\\\"dict\\\", dict)(count)\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(uncased)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def ngrams(n, target):\\n chars = collections.deque()\\n while True:\\n chars.append((yield))\\n if len(chars) == n: \\n target.send(chars)\\n chars.popleft()\",\n \"def ngramify(word: str,\\n max_ngram_size: int):\\n chars = list(word)\\n ngram_tuples = []\\n ngrams = []\\n # Take all n-grams with length in [2, max_ngram_size]\\n for i in range(2, max_ngram_size + 1):\\n pw = list(pairwise(chars, i))\\n ngram_tuples += pw\\n for e in ngram_tuples:\\n if None not in e:\\n ngrams.append(''.join(e))\\n # Append the list of characters, to avoid an unnecessary call for pairwise(_, 1).\\n return list(word) + ngrams\",\n \"def test_top_n_grams():\\n ngrams = NgramFrequencies()\\n unigrams_dic = {\\n \\\"COUNT\\\": 10,\\n \\\"time_burton's\\\": 5,\\n \\\"burton's_corpse\\\": 4,\\n \\\"corpse_bride\\\": 1\\n }\\n top_n_unigrams = ngrams.top_n_grams(unigrams_dic, 2)\\n assert top_n_unigrams == [\\n (\\\"time_burton's\\\", 0.5),\\n (\\\"burton's_corpse\\\", 0.4)\\n ]\",\n \"def compute_ngrams(str, n=2):\\n #split the string\\n st = tuple(str.split())\\n #not list of list but list of tuple..\\n gram = [st[x:x+n] for x in range(len(st)-n+1)]\\n dgram = {}\\n #convert ngram into dictionary:\\n for key in gram:\\n dgram.setdefault(key[0],[]).append(key[1:])\\n return dgram\",\n \"def ngrams(self, n=1, uncased=False, filter_fn=None, as_strings=True):\\n\\n def _skip(gram):\\n if not filter_fn:\\n return False\\n return filter_fn(gram)\\n\\n words = self.words(True)\\n ngrams = [(s, e + 1)\\n for s in range(len(words))\\n for e in range(s, min(s + n, len(words)))\\n if not _skip(words[s:e + 1])]\\n\\n # Concatenate into strings\\n if as_strings:\\n ngrams = ['{}'.format(' '.join(words[s:e])) for (s, e) in ngrams]\\n\\n return ngrams\",\n \"def segment(text, WORDS) -> List[Word]:\\n Pword = Bag(WORDS)\\n if not text: \\n return []\\n else:\\n candidates = ([first] + segment(rest, WORDS)\\n for (first, rest) in splits(text, 1))\\n return max(candidates, key=lambda x: Pwords(x, Pword))\",\n \"def n_grams(tokens, n=1):\\n shiftToken = lambda i: (el for j,el in enumerate(tokens) if j>=i)\\n shiftedTokens = (shiftToken(i) for i in range(n))\\n tupleNGrams = zip(*shiftedTokens)\\n return tupleNGrams\",\n \"def word_ngrams(sent, n):\\n\\t\\n\\t# EXAMPLES \\n\\t# > word_ngrams(tokenize('hello world'), 1)\\n\\t# [('hello',), ('world',)]\\n\\t# > word_ngrams(tokenize('hello world'), 2)\\n\\t# [('<s>', 'hello'), ('hello', 'world'), ('world', '</s>')]\\n\\n\\t# YOUR CODE HERE\\n\\ttokenized_sent = tokenize(sent)\\n\\tif n != 1:\\n\\t\\ttokenized_sent.insert(0, '<s>')\\n\\t\\ttokenized_sent.append('</s>')\\n\\treturn [tuple(tokenized_sent[i:i + n]) for i in range(0, len(tokenized_sent)-n+1)]\",\n \"def sent_to_n_grams(sent: str, n: int) -> Iterator[Tuple[str, ...]]:\\n\\n words = [word for word in sent.split() if word not in string.punctuation]\\n\\n rows = [words[i:] for i in range(n)]\\n\\n return zip(*rows)\",\n \"def ngrams(sequence, n):\\n # credit: http://stackoverflow.com/questions/2380394/simple-implementation-of-n-gram-tf-idf-and-cosine-similarity-in-python\\n sequence = list(sequence)\\n count = max(0, len(sequence) - n + 1)\\n return [tuple(sequence[i:i+n]) for i in range(count)]\",\n \"def range_ngrams(tokens, ngramRange=(1,2)):\\n return chain(*(n_grams(tokens, i) for i in range(*ngramRange)))\",\n \"def similar_ngrams(ngram, morph_model, lm, nbest):\\n w1 = ngram[0]\\n w2 = ngram[1]\\n nbest_max = 3 # Limit for number of segmentations/word\\n sim_ngrams = []\\n \\n # Preserve only the longest segment of each segmentation\\n viterbi_nbest_1 = morph_model.viterbi_nbest(w1, nbest)\\n viterbi_nbest_2 = morph_model.viterbi_nbest(w2, nbest)\\n segmentations1 = [max([viterbi_nbest_1[i][0] \\n for i in range(len(viterbi_nbest_1))][j], key=len)\\n for j in range(len(viterbi_nbest_1))]\\n segmentations2 = [max([viterbi_nbest_2[i][0] \\n for i in range(len(viterbi_nbest_2))][j], key=len) \\n for j in range(len(viterbi_nbest_2))]\\n \\n # Remove duplicates and too short word segments\\n segmentations1 = [segment for segment in list(dict.fromkeys(segmentations1)) \\n if len(segment)>=min(3,len(w1))]\\n segmentations2 = [segment for segment in list(dict.fromkeys(segmentations2)) \\n if len(segment)>=min(3,len(w2))]\\n \\n #print(segmentations1)\\n #print(segmentations2)\\n \\n # Put the first word of the bigram itself (w1) to the beginning of the list\\n # of words similar to w1.\\n similar_words_1 = [w1]\\n similar_words_2 = []\\n \\n # Collect the words from the LM vocabulary that contain\\n # the same segment as one of the words of the bigram\\n for word in lm.vocab:\\n for word1 in segmentations1:\\n if word1 in word:\\n similar_words_1.append(word)\\n for word2 in segmentations2:\\n if word2 in word:\\n similar_words_2.append(word)\\n \\n # Make ngrams using all possible combinations of the\\n # words found from the LM vocabulary and return the ones\\n # that have non-zero probability. Because w1 itself is in the beginning of\\n # the list of words similar to w1, bigrams with non-zero probability\\n # [w1, _ ] will be returned first (if such bigrams exist)\\n for pair in list(itertools.product(similar_words_1, similar_words_2)):\\n logscore = lm.logscore(pair[1], [pair[0]])\\n if logscore > -float('inf'):\\n sim_ngrams.append(pair[0] + ' ' + pair[1])# + ' ' + str(round(logscore)))\\n if len(sim_ngrams) > 4:\\n break\\n \\n # If no similar ngrams, try one more time with more word segmentations\\n if not sim_ngrams and nbest<nbest_max:\\n nbest += 1\\n sim_ngrams = similar_ngrams(ngram, morph_model, lm, nbest)\\n \\n # Remove duplicates\\n sim_ngrams = list(dict.fromkeys(sim_ngrams))\\n return sim_ngrams\",\n \"def n_gram(list, n):\\n ngrams = zip(*[list[i:] for i in range(n)])\\n return [\\\" \\\".join(ngram) for ngram in ngrams]\",\n \"def _generateNgrams(self,text,n=2):\\n token = Utilities.CVTokeniser(text)\\n # token = nltk.word_tokenize(text)\\n computedNgrams=ngrams(token,n)\\n return Counter(computedNgrams)\",\n \"def get_ngrams(sequence, n):\\n\\n # Set prefix and postfix\\n prefix = \\\"START\\\"\\n postfix = \\\"STOP\\\"\\n # Append 1 prefix regardless of value of n\\n sequence.insert(0, prefix)\\n for i in range(n - 2) :\\n sequence.insert(0, prefix)\\n sequence.append(postfix)\\n\\n # Check if 1 <= n <= len(sequence)\\n if (n > len(sequence)) :\\n print(sequence)\\n assert 1 <= n\\n assert n <= len(sequence)\\n\\n # Create n-gram sequence\\n n_gram_sequence = []\\n for i in range(n, len(sequence) + 1) :\\n temp_sequence = []\\n for j in range(i - n, i) :\\n temp_sequence.append(sequence[j])\\n n_gram_sequence.append(tuple(temp_sequence))\\n return n_gram_sequence\",\n \"def get_ngrams(sequence, n):\\n # Example: n = 3, length = 4\\n # we want 0:3, 1:4\\n\\n result = []\\n if n == 1:\\n result.append(tuple([\\\"START\\\"]))\\n result.append(tuple([\\\"STOP\\\"]))\\n\\n if n == 3 and len(sequence) == 1:\\n result.append(tuple([\\\"START\\\",\\\"START\\\",sequence[0]]))\\n result.append(tuple([\\\"START\\\",sequence[0],\\\"STOP\\\"]))\\n return result\\n\\n if n > 1 :\\n for i in range(n-1):\\n result.append(tuple([\\\"START\\\"]*(n-1-i)+ sequence[:i+1]))\\n result.append(tuple(sequence[-n+1:] + [\\\"STOP\\\"]))\\n\\n for i in range(len(sequence)-n+1):\\n result.append(tuple(sequence[i:i+n]))\\n return result\",\n \"def get_n_minus_1_grams(n_grams: str) -> str:\\n return n_grams.rsplit(' ')[0]\",\n \"def get_ngrams(stats,s,t,i):\\n #lemma ngrams\\n ngram_sizes = [\\\"bi\\\", \\\"tri\\\"]\\n for ngram_size in ngram_sizes:\\n lm_ngram = get_lemma_ngrams(s, t, i, ngram_size)\\n if lm_ngram:\\n put_feature_value_list(stats,\\\"lemma_\\\" + ngram_size + \\\"gr\\\", lm_ngram)\\n\\n #POS and deprel bigrams\\n if i < s.length-1:\\n put_feature_value_list(stats,\\\"deprels_bigr\\\", (t.deprel,s.nodes[i+1].deprel))\\n put_feature_value_list(stats,\\\"pos_bigr\\\", (t.pos,s.nodes[i+1].pos))\\n \\n #POS and deprel trigrams\\n if i < s.length-2:\\n put_feature_value_list(stats,\\\"deprels_trigr\\\", (t.deprel, s.nodes[i+1].deprel, s.nodes[i+2].deprel))\\n put_feature_value_list(stats,\\\"pos_trigr\\\", (t.pos, s.nodes[i+1].pos, s.nodes[i+2].pos))\\n\\n return stats\",\n \"def get_all_ngrams():\\n grams = ()\\n for i in range(0, 40):\\n text_i = read_file(str(i))\\n curr_grams = ngramize(text_i, n)\\n grams = chain(grams, curr_grams)\\n return grams\",\n \"def get_ngrams(self, n = None):\\n if not n:\\n n = self.N\\n\\n temp = []\\n for sent in self.get_sentences():\\n temp.extend(list(sent))\\n\\n return nltk.ngrams(temp, n)\",\n \"def num_bigram(doc):\\n matched_spans = []\\n matches = matcher(doc)\\n for match_id, start, end in matches:\\n span = doc[start:end]\\n matched_spans.append(span)\\n for span in matched_spans: # merge into one token after collecting all matches\\n span.merge()\\n return doc\",\n \"def find_ngrams(self, n):\\n\\n output = {}\\n\\n for i in range(len(self.text)-n+1):\\n s = ' '.join(self.text[i:i+n])\\n # if s is not already in dictionary, set value to 0\\n output.setdefault(s, 0)\\n output[s] += 1\\n return output\",\n \"def ngramify(corpus, n):\\r\\n unlist = 0\\r\\n if type(corpus[0]) is not list:\\r\\n corpus = [corpus]\\r\\n unlist = 1\\r\\n new_corpus = []\\r\\n for line in corpus:\\r\\n new_line = []\\r\\n for gram in range(len(line) - n + 1):\\r\\n new_gram = \\\"\\\"\\r\\n for i in range(n):\\r\\n if i != 0:\\r\\n new_gram += \\\" \\\"\\r\\n new_gram += line[gram + i]\\r\\n new_line.append(new_gram)\\r\\n new_corpus.append(new_line)\\r\\n if unlist:\\r\\n return new_corpus[0]\\r\\n return new_corpus\",\n \"def top_ngrams(ngram_dict,ntop):\\n # get list of all ngrams and counts\\n ngrams = ngram_dict.items()\\n # sort according to the count\\n # we use a python lambda function here to say that we want to sort by the\\n # second item in the tuples contained in the list\\n ngrams.sort(key=lambda x: x[1], reverse=True)\\n # return the top ngrams\\n return ngrams[0:ntop]\",\n \"def get_ngrams(self, s, ngmin, ngmax, separator=\\\"\\\",\\n bos=\\\"<\\\", eos=\\\">\\\", suffix=\\\"\\\", flatten=True):\\n\\n # return a single dummy feature if there are no applicable ngrams\\n # probably resulting in a mojority-class classifier\\n if ngmax == 0 or (ngmax - ngmin < 0) :\\n return ['__dummy__']\\n\\n ngrams = [[] for x in range(1, ngmax + 1)]\\n s = [bos] + s + [eos]\\n for i, ch in enumerate(s):\\n for ngsize in range(ngmin, ngmax + 1):\\n if (i + ngsize) <= len(s):\\n ngrams[ngsize - 1].append(\\n separator.join(s[i:i+ngsize]) + suffix)\\n if flatten:\\n ngrams = [ng for nglist in ngrams for ng in nglist]\\n return ngrams\",\n \"def extract_char_ngrams(s: str, n: int) -> Counter:\\n return Counter([s[i:i + n] for i in range(len(s) - n + 1)])\",\n \"def ngrams(self):\\n return self.root.ngrams()\",\n \"def nbest(self, score_fn, n):\\n return [p for p, s in self.score_ngrams(score_fn)[:n]]\",\n \"def k_skip_n_grams(arr, n, k):\\n if n == 0:\\n return\\n\\n if n == 1:\\n for e in arr:\\n yield e\\n return\\n\\n for i in range(0, min(len(arr) - n, k) + 1):\\n yield from _get_exact_k_skip_n_grams(arr, n, i)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n # words = _split_into_words(sentences)\\n\\n words = sum(sentences, [])\\n # words = [w for w in words if w not in stopwords]\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n # words = _split_into_words(sentences)\\n\\n words = sum(sentences, [])\\n # words = [w for w in words if w not in stopwords]\\n return _get_ngrams(n, words)\",\n \"def make_chains(text_string):\\n\\n chains = {}\\n n = 2\\n # n = int(raw_input(\\\"Enter the number of ngrams you want? >\\\"))\\n # your code goes here\\n words = text_string.split()\\n for i in range(len(words) - 1):\\n ngram = tuple(words[i: i + n])\\n if i >= len(words) - n:\\n chains[ngram] = None\\n else:\\n nth_word = words[i + n]\\n if ngram not in chains:\\n chains[ngram] = [nth_word]\\n else:\\n chains[ngram].append(nth_word)\\n return (chains, n)\",\n \"def generate_ngrams(tokens, ngram_size, *, include_terminator = False):\\n \\n if ngram_size <= 0:\\n raise Exception(\\\"ngram size must be positive\\\")\\n\\n if not include_terminator:\\n for token_index in range(len(tokens)):\\n leader = get_leader(tokens, token_index, ngram_size - 1)\\n token = tokens[token_index]\\n \\n yield leader, token\\n else:\\n for token_index in range(len(tokens) + 1):\\n leader = get_leader(tokens, token_index, ngram_size - 1)\\n token = tokens[token_index] if token_index < len(tokens) else None\\n\\n yield leader, token\",\n \"def everygrams(seq):\\n for n in range(1, len(seq) + 1):\\n for ng in nltk.util.ngrams(seq, n):\\n yield ng\",\n \"def create_ngrams(word_list, n):\\n yield zip(*[word_list[i:] for i in range(n)])\",\n \"def create_ngrams(self, tokens):\\n ngrams = []\\n for i in range(len(tokens)- self.N + 1):\\n ngrams.append(tuple(tokens[i:i+self.N]))\\n return ngrams\",\n \"def _create_ngrams(tokens, n):\\n\\n ngrams = collections.Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in xrange(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\",\n \"def _precook(s, n=4, out=False):\\n if isinstance(s,str):\\n words = s.split()\\n # print(words)\\n elif isinstance(s,list) or isinstance(s,tuple):\\n words = s\\n else:\\n raise NotImplementedError(type(s))\\n counts = defaultdict(int)\\n for k in range(1, n + 1):\\n for i in range(len(words) - k + 1):\\n ngram = tuple(words[i:i + k])\\n counts[ngram] += 1\\n return (len(words), counts)\",\n \"def _get_bag_of_pos_ngram(words, index, window_size, N):\\n bos = DummyWord(pos=utils.BEGIN_OF_SENTENCE, upos=utils.BEGIN_OF_SENTENCE, dependency_relation=utils.BEGIN_OF_SENTENCE)\\n eos = DummyWord(pos=utils.END_OF_SENTENCE, upos=utils.END_OF_SENTENCE, dependency_relation=utils.END_OF_SENTENCE)\\n words = [bos] * (window_size + N) + words + [eos] * (window_size + N)\\n index += (window_size + N)\\n return [\\n \\\"_\\\".join([_get_word_feature(w) for w in words[i:i+N]])\\n for i in range(index-window_size, index+window_size+1)]\",\n \"def get_top_tweet_ngrams(corpus, dim=2, n=None):\\r\\n vec = CountVectorizer(ngram_range=(dim, dim)).fit(corpus)\\r\\n bag_of_words = vec.transform(corpus)\\r\\n sum_words = bag_of_words.sum(axis=0) \\r\\n words_freq = [(word, sum_words[0, idx]) for word, idx in vec.vocabulary_.items()]\\r\\n words_freq =sorted(words_freq, key = lambda x: x[1], reverse=True)\\r\\n return words_freq[:n]\",\n \"def segment_words(self, string):\\n words = []\\n\\n word_begin = 0\\n while word_begin < len(string):\\n word_options = self.find_prefixes(string[word_begin:])\\n if len(word_options) > 0:\\n best_word = self.unigram_provider.get_most_frequent_word(word_options)\\n else:\\n best_word = string[word_begin:word_begin+1]\\n words.append(best_word)\\n word_begin += len(best_word)\\n\\n return words\",\n \"def transform_ngrams(self, words):\\n return words if self.n_grams == 1 else [self.connector.join(words[i:i + self.n_grams]) for i in range(len(words) - self.n_grams + 1)]\",\n \"def sized_ngrams(self, size):\\n return self.root.sized_ngrams(size)\",\n \"def read_ngrams(filename, length):\\n ngram = deque(' ' * length)\\n\\n with open(filename) as file:\\n for line in file:\\n for char in line:\\n ngram.popleft()\\n ngram.append(char)\\n \\n if is_valid_ngram(ngram):\\n yield ''.join(ngram)\",\n \"def get(self, n):\\n parts = [' '.join(g) for g in ngrams(self.words, n)]\\n return get_occurences(parts)\",\n \"def ngrams(self):\\n return self.__ngrams(())\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def build_model(self, text):\\n text = '< ' * (self.n - 1) + text.replace(' . ', ' .%s ' % (' <' * (self.n - 1))) + ' >'\\n tokens = self.split(text)\\n self.corpus_len = len(tokens)\\n self.n_grams_by_len = [{} for _ in range(self.n)]\\n for i in range(len(tokens)): # for index in tokens\\n for n in range(self.n): # for n-gram size from 1 to n:\\n if i >= n: # if the index has advanced enough for this n\\n n_gram = self.join(tokens[i - n: i + 1])\\n n_grams = self.n_grams_by_len[n] # get dict for respective n\\n n_grams[n_gram] = n_grams.get(n_gram, 0) + 1 # get dict for respective n\\n return self.get_model()\",\n \"def n_grammize(role):\\n ngrams = []\\n if isinstance(role,str):\\n role = role.lower()\\n role = role.split()\\n if len(role)>2:\\n for i in range(2, len(role)):\\n ngrams.append((role[i-2], role[i-1], role[i]))\\n if len(role)>1:\\n for i in range(1, len(role)):\\n ngrams.append((role[i-1], role[i]))\\n for i in range(len(role)):\\n ngrams.append(role[i])\\n return ngrams\",\n \"def ngrams(tokens,lang):\\n stopwords = stops.stopwords[lang]\\n max = len(tokens)\\n ngrams = []\\n left_punctuation = '!\\\"%&\\\\'()*+,-./:;<=>?[\\\\\\\\]^_`{|}~'\\n\\n for i in range(1,max):\\n for j in xrange(0,len(tokens)-(i-1)):\\n if __check_features(tokens[j:j+i],stopwords):\\n ng_str = \\\" \\\".join(tokens[j:j+i])\\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \\n ngrams.append(ng_str)\\n \\n ng_str = \\\" \\\".join(tokens)\\n ng_str = (ng_str.rstrip(string.punctuation)).lstrip(left_punctuation) \\n ngrams.append(ng_str)\\n return ngrams\",\n \"def generate_ngrams(iterable, n):\\n return zip(*[itertools.islice(it, i, None) for i, it in enumerate(itertools.tee(iterable, n))])\",\n \"def full_ngrams(items, n):\\n ngs = {}\\n for i in xrange(1, n+1):\\n ngs.update(gen_ngrams(items, i))\\n return ngs\",\n \"def sized_ngrams(self, size):\\n return self.__sized_ngrams(size, ())\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def _get_word_ngrams(n, sentences):\\n assert len(sentences) > 0\\n assert n > 0\\n\\n words = _split_into_words(sentences)\\n return _get_ngrams(n, words)\",\n \"def add_ngram(sequences, token_indice, ngram_range=2):\\n new_sequences = []\\n for input_list in sequences:\\n new_list = input_list[:]\\n for ngram_value in range(2, ngram_range + 1):\\n for i in range(len(new_list) - ngram_value + 1):\\n ngram = tuple(new_list[i:i + ngram_value])\\n if ngram in token_indice:\\n new_list.append(token_indice[ngram])\\n new_sequences.append(new_list)\\n\\n return new_sequences\",\n \"def count_ngrams(lines, min_length=1, max_length=4):\\n def add_queue():\\n # Helper function to add n-grams at start of current queue to dict\\n current = tuple(queue)\\n for length in lengths:\\n if len(current) >= length: # count n-grams up to length those in queue\\n ngrams[length][current[:length]] += 1 # ngrams[length] => counter\\n def eval_sequence_dtype(): \\n if not lines: \\n return False # no-op\\n if isinstance(lines[0], str): \\n return False\\n elif hasattr(lines[0], '__iter__'): \\n return True\\n return False\\n\\n lengths = range(min_length, max_length + 1)\\n ngrams = {length: collections.Counter() for length in lengths}\\n queue = collections.deque(maxlen=max_length)\\n\\n # tokenized or not? \\n is_tokenized = eval_sequence_dtype()\\n # print('> tokenized? %s' % is_tokenized)\\n\\n # Loop through all lines and words and add n-grams to dict\\n if is_tokenized: \\n # print('input> lines: %s' % lines)\\n for line in lines:\\n for word in line:\\n queue.append(word)\\n if len(queue) >= max_length:\\n add_queue() # this does the counting\\n # print('+ line: %s\\\\n+ngrams: %s' % (line, ngrams))\\n else: \\n for line in lines:\\n for word in tokenize(line):\\n queue.append(word)\\n if len(queue) >= max_length:\\n add_queue()\\n\\n # Make sure we get the n-grams at the tail end of the queue\\n while len(queue) > min_length:\\n queue.popleft()\\n add_queue()\\n # print('+ line: %s\\\\n+ngrams: %s' % (line, ngrams))\\n\\n return ngrams\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6581706","0.65742457","0.64183784","0.62482524","0.6233594","0.6122576","0.6087275","0.6044856","0.6036233","0.59712744","0.59699684","0.5965845","0.59467024","0.59328526","0.5909492","0.59071153","0.5855572","0.58542573","0.5828259","0.5820391","0.5790817","0.5778645","0.5733521","0.57269734","0.5721556","0.5710209","0.5698352","0.5690378","0.5677388","0.5666158","0.56612396","0.56337726","0.5581693","0.5578016","0.5547787","0.5531747","0.55116606","0.5491202","0.54860663","0.545467","0.54352796","0.54244983","0.5418517","0.5412889","0.54108334","0.539334","0.5389209","0.53829706","0.5352658","0.5349766","0.5348142","0.53157645","0.5307677","0.5303574","0.5297648","0.5292685","0.52769125","0.5274701","0.5249595","0.52459824","0.52385557","0.5232878","0.5212776","0.52083725","0.5190828","0.51833344","0.518021","0.5170491","0.5168471","0.51654017","0.516065","0.5152841","0.5152841","0.5126041","0.5123138","0.5115874","0.50895905","0.5085255","0.5083915","0.50773525","0.50764084","0.5074788","0.50738674","0.506045","0.5058405","0.5054586","0.5051654","0.50475496","0.5035622","0.50335836","0.50189173","0.5014867","0.5005244","0.5000812","0.49915493","0.49849224","0.49746135","0.49746135","0.49644735","0.49631172"],"string":"[\n \"0.6581706\",\n \"0.65742457\",\n \"0.64183784\",\n \"0.62482524\",\n \"0.6233594\",\n \"0.6122576\",\n \"0.6087275\",\n \"0.6044856\",\n \"0.6036233\",\n \"0.59712744\",\n \"0.59699684\",\n \"0.5965845\",\n \"0.59467024\",\n \"0.59328526\",\n \"0.5909492\",\n \"0.59071153\",\n \"0.5855572\",\n \"0.58542573\",\n \"0.5828259\",\n \"0.5820391\",\n \"0.5790817\",\n \"0.5778645\",\n \"0.5733521\",\n \"0.57269734\",\n \"0.5721556\",\n \"0.5710209\",\n \"0.5698352\",\n \"0.5690378\",\n \"0.5677388\",\n \"0.5666158\",\n \"0.56612396\",\n \"0.56337726\",\n \"0.5581693\",\n \"0.5578016\",\n \"0.5547787\",\n \"0.5531747\",\n \"0.55116606\",\n \"0.5491202\",\n \"0.54860663\",\n \"0.545467\",\n \"0.54352796\",\n \"0.54244983\",\n \"0.5418517\",\n \"0.5412889\",\n \"0.54108334\",\n \"0.539334\",\n \"0.5389209\",\n \"0.53829706\",\n \"0.5352658\",\n \"0.5349766\",\n \"0.5348142\",\n \"0.53157645\",\n \"0.5307677\",\n \"0.5303574\",\n \"0.5297648\",\n \"0.5292685\",\n \"0.52769125\",\n \"0.5274701\",\n \"0.5249595\",\n \"0.52459824\",\n \"0.52385557\",\n \"0.5232878\",\n \"0.5212776\",\n \"0.52083725\",\n \"0.5190828\",\n \"0.51833344\",\n \"0.518021\",\n \"0.5170491\",\n \"0.5168471\",\n \"0.51654017\",\n \"0.516065\",\n \"0.5152841\",\n \"0.5152841\",\n \"0.5126041\",\n \"0.5123138\",\n \"0.5115874\",\n \"0.50895905\",\n \"0.5085255\",\n \"0.5083915\",\n \"0.50773525\",\n \"0.50764084\",\n \"0.5074788\",\n \"0.50738674\",\n \"0.506045\",\n \"0.5058405\",\n \"0.5054586\",\n \"0.5051654\",\n \"0.50475496\",\n \"0.5035622\",\n \"0.50335836\",\n \"0.50189173\",\n \"0.5014867\",\n \"0.5005244\",\n \"0.5000812\",\n \"0.49915493\",\n \"0.49849224\",\n \"0.49746135\",\n \"0.49746135\",\n \"0.49644735\",\n \"0.49631172\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62992704"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":85168,"cells":{"query":{"kind":"string","value":"Computes BLEU score of translated segments against one or more references."},"document":{"kind":"string","value":"def compute_bleu(reference_corpus, translation_corpus, max_order=4,\n use_bp=True):\n reference_length = 0\n translation_length = 0\n bp = 1.0\n geo_mean = 0\n\n matches_by_order = [0] * max_order\n possible_matches_by_order = [0] * max_order\n precisions = []\n\n for (references, translations) in zip(reference_corpus, translation_corpus):\n reference_length += len(references)\n translation_length += len(translations)\n ref_ngram_counts = _get_ngrams_with_counter(references, max_order)\n translation_ngram_counts = _get_ngrams_with_counter(translations, max_order)\n\n overlap = dict((ngram,\n min(count, translation_ngram_counts[ngram]))\n for ngram, count in ref_ngram_counts.items())\n\n for ngram in overlap:\n matches_by_order[len(ngram) - 1] += overlap[ngram]\n for ngram in translation_ngram_counts:\n possible_matches_by_order[len(ngram) - 1] += translation_ngram_counts[\n ngram]\n\n precisions = [0] * max_order\n smooth = 1.0\n\n for i in xrange(0, max_order):\n if possible_matches_by_order[i] > 0:\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[i]\n if matches_by_order[i] > 0:\n precisions[i] = float(matches_by_order[i]) / possible_matches_by_order[\n i]\n else:\n smooth *= 2\n precisions[i] = 1.0 / (smooth * possible_matches_by_order[i])\n else:\n precisions[i] = 0.0\n\n if max(precisions) > 0:\n p_log_sum = sum(math.log(p) for p in precisions if p)\n geo_mean = math.exp(p_log_sum / max_order)\n\n if use_bp:\n ratio = translation_length / reference_length\n bp = math.exp(1 - 1. / ratio) if ratio < 1.0 else 1.0\n bleu = geo_mean * bp\n return np.float32(bleu)"},"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 bleu_score(references, generated, n_gram=4, smooth=False):\r\n formatted_ref = [[ref] for ref in references]\r\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\r\n return bleu_s * 100","def calculate_bleu(output_lns, refs_lns):\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)","def bleu(hypotheses, references):\n return sacrebleu.raw_corpus_bleu(sys_stream=hypotheses,\n ref_streams=[references]).score","def _compute_score(self):\n\n sgml_path = str(self.sgml_file.name)\n text_path = sgml_path.replace('.sgm', '.txt')\n ref_path = 'testsets/wmt18.ende.ref.txt'\n\n from sacrebleu import process_to_text, corpus_bleu\n from pathlib import Path\n\n if not Path(text_path).exists():\n process_to_text(sgml_path, text_path)\n\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\n\n bleu = corpus_bleu(hyp_stream, [ref_stream])\n\n self.score = bleu.score\n self.save()","def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\n \"missing keys: {}\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\n scores = {}\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\n for i, bleu_score in enumerate(bleu_scores):\n scores['Bleu-%d' % (i + 1)] = bleu_score\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\n scores['Rouge-L'] = rouge_score\n return scores","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\n return {\"bleu\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}","def _bleu(ref_file, trans_file, subword_option=None, lower_case=False):\n max_order = 4\n smooth = False\n\n ref_files = [ref_file]\n reference_text = []\n for reference_filename in ref_files:\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(reference_filename, \"rb\")) as fh:\n reference_text.append(fh.readlines())\n\n per_segment_references = []\n for references in zip(*reference_text):\n reference_list = []\n for reference in references:\n reference = _clean(reference, subword_option, lower_case=lower_case)\n reference_list.append(reference.split())\n per_segment_references.append(reference_list)\n\n translations = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(trans_file, \"rb\")) as fh:\n for line in fh:\n line = _clean(line, subword_option=None, lower_case=lower_case)\n translations.append(line.split())\n\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\n per_segment_references, translations, max_order, smooth)\n return 100 * bleu_score","def _self_bleu(completions: List[Sequence], **unused_kwargs) -> float:\n completion_sequences: List[str] = [completion.text.strip() for completion in completions if completion.text.strip()]\n\n if len(completion_sequences) <= 1:\n return 0\n\n scores = []\n for i in range(len(completion_sequences)):\n hypothesis = completion_sequences[i]\n references = completion_sequences[:i] + completion_sequences[i + 1 :]\n\n # Enable `effective_order` for sentence-level BLEU.\n score = BLEU(effective_order=True).sentence_score(hypothesis=hypothesis, references=references)\n scores.append(score.score)\n return sum(scores) / len(scores)","def bleu_score(output, reference):\n num_sentences = min(len(output), len(reference))\n for i in range(num_sentences):\n if i == 5:\n print(\"Do you want to calculate all sentences? (y/n)\")\n answer = input()\n if answer.lower() == 'n':\n break\n out_sentence, ref_sentence = output[i], reference[i]\n bleu_score = calculate_bleu(out_sentence, ref_sentence)\n print(\n f\"Sentence {i + 1}, Score: {bleu_score}\")","def _bleu(ref_file, trans_file,max_order=4, subword_option=None):\n smooth = False\n\n ref_files = [ref_file]\n reference_text = []\n for reference_filename in ref_files:\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(reference_filename, \"rb\")) as fh:\n reference_text.append(fh.readlines())\n\n per_segment_references = []\n for references in zip(*reference_text):\n reference_list = []\n for reference in references:\n reference = _clean(reference, subword_option)\n reference_list.append(reference.split(\" \"))\n per_segment_references.append(reference_list)\n\n print(per_segment_references[0:15])\n\n translations = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(trans_file, \"rb\")) as fh:\n for line in fh:\n line = _clean(line, subword_option=subword_option)\n translations.append(line.split(\" \"))\n print(translations[0:15])\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\n per_segment_references, translations, max_order, smooth)\n return 100 * bleu_score","def reference_stats(refs, output_len):\n\n ngrams = Counter()\n closest_diff = None\n closest_len = None\n\n for ref in refs:\n tokens = ref.split()\n reflen = len(tokens)\n diff = abs(output_len - reflen)\n if closest_diff is None or diff < closest_diff:\n closest_diff = diff\n closest_len = reflen\n elif diff == closest_diff:\n if reflen < closest_len:\n closest_len = reflen\n\n ngrams_ref = CachedBLEU.extract_ngrams(ref)\n for ngram in ngrams_ref.keys():\n ngrams[ngram] = max(ngrams[ngram], ngrams_ref[ngram])\n\n return ngrams, closest_diff, closest_len","def rouge_score(references, generated):\r\n score = rouge(generated, references)\r\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\r\n '''\r\n \"rouge_1/f_score\": rouge_1_f,\r\n \"rouge_1/r_score\": rouge_1_r,\r\n \"rouge_1/p_score\": rouge_1_p,\r\n \"rouge_2/f_score\": rouge_2_f,\r\n \"rouge_2/r_score\": rouge_2_r,\r\n \"rouge_2/p_score\": rouge_2_p,\r\n \"rouge_l/f_score\": rouge_l_f,\r\n \"rouge_l/r_score\": rouge_l_r,\r\n \"rouge_l/p_score\": rouge_l_p,\r\n '''\r\n return rouge_s","def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\n # sanity check\n assert len(list_of_references) == len(\n hypotheses\n ), \"The number of hypotheses and their reference(s) should be the same\"\n\n # sum matches and max-token-lengths over all sentences\n corpus_n_match = 0\n corpus_n_all = 0\n\n for references, hypothesis in zip(list_of_references, hypotheses):\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\n\n hyp_counts = []\n for reference in references:\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\n\n overlap_ngrams = ref_ngrams & hyp_ngrams\n tp = sum(overlap_ngrams.values()) # True positives.\n\n # While GLEU is defined as the minimum of precision and\n # recall, we can reduce the number of division operations by one by\n # instead finding the maximum of the denominators for the precision\n # and recall formulae, since the numerators are the same:\n # precision = tp / tpfp\n # recall = tp / tpfn\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\n n_all = max(tpfp, tpfn)\n\n if n_all > 0:\n hyp_counts.append((tp, n_all))\n\n # use the reference yielding the highest score\n if hyp_counts:\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\n corpus_n_match += n_match\n corpus_n_all += n_all\n\n # corner case: empty corpus or empty references---don't divide by zero!\n if corpus_n_all == 0:\n gleu_score = 0.0\n else:\n gleu_score = corpus_n_match / corpus_n_all\n\n return gleu_score","def bleu_stats(hypo, ref, bleu_len=5):\n stats = list()\n stats.append(len(hypo))\n stats.append(len(ref))\n for n in range(1, bleu_len):\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypo) + 1-n, 0]))\n return stats","def bleu_score(ref_file, hyp_file):\n command = 'perl scripts/multi-bleu.pl ' + ref_file + ' < ' + hyp_file\n c = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\n details, error = c.communicate()\n details, error = details.decode('utf-8'), error.decode('utf-8')\n if not details.startswith('BLEU ='):\n raise ValueError('Error in BLEU score computation:\\n%s' % error)\n else:\n BLEU_str = details.split(' ')[2][:-1]\n BLEU = float(BLEU_str)\n return BLEU, details","def compute_bleu(self, ref_ids_list: Iterable[Iterable[int]], hyp_ids_list: Iterable[Iterable[int]],\n ref_is_tensor: bool = False, hyp_is_tensor: bool = False,\n reader_level: ReaderLevel=ReaderLevel.WORD) -> Tuple[float, str, str]:\n assert len(ref_ids_list) == len(hyp_ids_list)\n refs = self.target_sentensify_all(ref_ids_list, input_is_tensor=ref_is_tensor, reader_level=reader_level)\n hyps = self.target_sentensify_all(hyp_ids_list, input_is_tensor=hyp_is_tensor, reader_level=reader_level)\n scores = [sentence_bleu(hyps[sid], refs[sid]) for sid in range(len(ref_ids_list))]\n random_index = choice(range(len(refs)))\n return sum(scores) / len(scores), refs[random_index], hyps[random_index]","def calculate_reference(gram_list, references):\r\n gram_sub_str = ' '.join(gram_list)\r\n gram_count = []\r\n for item in references:\r\n # calculate the count of the sub string\r\n gram_count.append(len(re.findall(gram_sub_str, item)))\r\n return gram_count","def sentence_accuracy(references, predictions):\n count = 0.0\n match = 0.0\n for label, pred in zip(references, predictions):\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def compute_score(predictions, references, vocab=None, beam_size=4):\n assert np.rank(predictions) == 3\n assert predictions.shape[0] == references.shape[0]\n batch_size = predictions.shape[0]\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\n hypotheses_list = []\n references_list = []\n\n for index in range(batch_size):\n # All predictions in beam search are used for validation scores.\n for b_index in range(beam_size):\n h = predictions[index][b_index]\n try:\n eos_index = h.index(input_utils.EOS)\n except ValueError:\n eos_index = len(h)\n hypotheses_list.append(h[:eos_index])\n\n ref = references[index][0].decode().split('|')\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\n references_list.append(ref_list)\n\n all_scores = collections.defaultdict(list)\n for hypothesis, references in zip(hypotheses_list, references_list):\n if vocab is not None and len(vocab):\n # Skip PADDING, UNK, EOS, START (0-3).\n hypothesis = [\n vocab[word_id].numpy().decode()\n for word_id in hypothesis\n if word_id > 3\n ]\n\n h_str = ' '.join(str(e) for e in hypothesis)\n r_str = [' '.join(str(e) for e in ref) for ref in references]\n\n print('hypothesis: ', str(h_str))\n print('references: ', str(r_str))\n print('\\n')\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\n for key, score in scores.items():\n all_scores[key].append(score)\n score_names = [\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\n ]\n\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]","def calculate_reference(gram_list, references):\n gram_sub_str = ' '.join(gram_list)\n gram_count = []\n for item in references:\n # calculate the count of the sub string\n gram_count.append(len(re.findall(gram_sub_str, item)))\n return gram_count","def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n ngram_counter_clip = preds_counter & target_counter\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n return preds_len, target_len","def _calc_multiple_alignment_score(wrapped_data : tuple) -> int: \n (start, finish) = wrapped_data \n score_sum = 0.\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\"Training process\"):\n score_sum += self.aligner.score(seq, dna_record.seq)\n return score_sum","def get_bleu(hypo, ref, seq_len=10, bleu_len=5):\n stats = np.array([0.]*seq_len)\n for h, r in zip(hypo, ref):\n h = np.trim_zeros(h)\n r = np.trim_zeros(r)\n stats += np.array(bleu_stats(h, r, bleu_len))\n return 100 * bleu(stats)","def score(self, *args, references=[], candidates=[], batch_size=None):\n assert not args, (\n \"The score function does not accept positional arguments. Please \"\n \"specify the name of the arguments explicitly, i.e., \"\n \"`score(references=..., candidates=...`)\")\n\n candidates, references = list(candidates), list(references)\n assert len(candidates) == len(references), (\n \"The number of candidate sentences must match the number of \"\n \"reference sentences.\")\n if not candidates:\n return []\n\n if not batch_size:\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\n\n all_results = []\n for i in range(0, len(candidates), batch_size):\n batch_ref = references[i:i + batch_size]\n batch_cand = candidates[i:i + batch_size]\n\n if self.serialize_input:\n tfrecords = [\n encoding.serialize_raw_example(r, c)\n for (r, c) in zip(batch_ref, batch_cand)\n ]\n predict_out = self.bleurt_model_ops(\n examples=tf.constant(tfrecords))[\"predictions\"].numpy()\n else:\n predict_out = self.bleurt_model_ops(\n references=tf.constant(batch_ref),\n candidates=tf.constant(batch_cand))[\"predictions\"].numpy()\n\n batch_results = predict_out.tolist()\n all_results.extend(batch_results)\n\n assert len(all_results) == len(candidates), (\n \"Number of predictions does not match sentences: {} vs. {}\".format(\n len(all_results), len(candidates)))\n return all_results","def chainFn(alignedSegments, refSeq, readSeq, scoreFn=\\\n lambda alignedSegment, refSeq, readSeq : \\\n sum([ length for op, length in alignedSegment.cigar if op == 0]), maxGap=200):\n #Score function is number of aligned pairs\n def getStartAndEndCoordinates(alignedSegment):\n \"\"\"Gets the start and end coordinates in both the reference and query, using coordinates\n relative to the original read and reference equence\n \"\"\"\n return alignedSegment.reference_start, getFirstNonClippedPositionInRead(alignedSegment, readSeq), \\\n alignedSegment.reference_end-1, getLastNonClippedPositionInRead(alignedSegment, readSeq) \n \n alignedSegmentToScores = dict([ (aR, scoreFn(aR, refSeq, readSeq)) for aR in alignedSegments])\n alignedSegmentToCoordinates = dict([ (aR, getStartAndEndCoordinates(aR)) for \\\n aR in alignedSegments])\n alignedSegmentPointers = {}\n \n #Currently uses sloppy quadratic algorithm to find highest chain\n alignedSegments = sorted(alignedSegments, key=lambda aR : alignedSegmentToCoordinates[aR][0]) \n #Sort by reference coordinate\n for i in xrange(len(alignedSegments)):\n aR = alignedSegments[i]\n rStart, qStart, rEnd, qEnd = alignedSegmentToCoordinates[aR]\n score = alignedSegmentToScores[aR]\n for j in xrange(i): #Look at earlier alignments in list\n aR2 = alignedSegments[j]\n rStart2, qStart2, rEnd2, qEnd2 = alignedSegmentToCoordinates[aR2]\n assert rStart2 <= rStart\n if rStart > rEnd2 and qStart > qEnd2 and aR.is_reverse == aR2.is_reverse and \\\n rStart - rEnd2 + qStart - qEnd2 <= maxGap and \\\n score + alignedSegmentToScores[aR2] > alignedSegmentToScores[aR]: \n #Conditions for a chain\n alignedSegmentToScores[aR] = score + alignedSegmentToScores[aR2]\n alignedSegmentPointers[aR] = aR2\n \n #Now find highest scoring alignment \n aR = max(alignedSegments, key=lambda aR : alignedSegmentToScores[aR])\n \n #Construct chain of alignedSegments\n chain = [ aR ]\n while aR in alignedSegmentPointers:\n aR = alignedSegmentPointers[aR]\n chain.append(aR)\n chain.reverse()\n \n return chain","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def evaluate_bleu_score(cls, predictions, targets, ticks=False, corpus=True):\n if ticks:\n ref_sentences = cls._ticks_to_sentences(targets)\n cand_sentences = cls._ticks_to_sentences(predictions)\n else:\n ref_sentences = [[str(x) for x in seq] for seq in predictions]\n cand_sentences = [[str(x) for x in seq] for seq in targets]\n\n if corpus: bleu_score = corpus_bleu([[l] for l in ref_sentences], cand_sentences)\n else:\n bleu_score = 0.0\n num_sentences = 0\n\n for i in tqdm(range(len(ref_sentences))):\n sentence_bleu_score = sentence_bleu(ref_sentences[i], cand_sentences[i])\n print(sentence_bleu_score)\n bleu_score += sentence_bleu_score\n num_sentences += 1\n\n bleu_score /= num_sentences\n\n return bleu_score","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def score(self, *args, references=[], candidates=[], batch_size=None):\n assert not args, (\n \"The score function does not accept positional arguments. Please \"\n \"specify the name of the arguments explicitly, i.e., \"\n \"`score(references=..., candidates=...`)\")\n\n candidates, references = list(candidates), list(references)\n assert len(candidates) == len(references), (\n \"The number of candidate sentences must match the number of \"\n \"reference sentences.\")\n if not candidates:\n return []\n\n if not batch_size:\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\n\n all_results = []\n for i in range(0, len(candidates), batch_size):\n batch_ref = references[i:i + batch_size]\n batch_cand = candidates[i:i + batch_size]\n input_ids, input_mask, segment_ids = encoding.encode_batch(\n batch_ref, batch_cand, self.tokenizer, self.max_seq_length)\n tf_input = {\n \"input_ids\": input_ids,\n \"input_mask\": input_mask,\n \"segment_ids\": segment_ids\n }\n predict_out = self._predictor.predict(tf_input)\n batch_results = predict_out.tolist()\n all_results.extend(batch_results)\n\n assert len(all_results) == len(candidates), (\n \"Number of predictions does not match sentences: {} vs. {}\".format(\n len(all_results), len(candidates)))\n return all_results","def word_accuracy(references, predictions):\n total_acc, total_count = 0., 0.\n for labels, preds in zip(references, predictions):\n match = 0.0\n for pos in range(min(len(labels), len(preds))):\n label = labels[pos]\n pred = preds[pos]\n if label == pred:\n match += 1\n total_acc += 100 * match / max(len(labels), len(preds))\n total_count += 1\n return total_acc / total_count","def rouge_l_sentence_level(eval_sentences, ref_sentences):\n\n f1_scores = []\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\n m = float(len(ref_sentence))\n n = float(len(eval_sentence))\n lcs = _len_lcs(eval_sentence, ref_sentence)\n f1_scores.append(_f_lcs(lcs, m, n))\n return np.mean(f1_scores, dtype=np.float32)","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def bleu_stats(hypothesis, reference):\n stats = []\n stats.append(len(hypothesis))\n stats.append(len(reference))\n for n in range(1, 5):\n s_ngrams = Counter(\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\n )\n r_ngrams = Counter(\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\n )\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n stats.append(max([len(hypothesis) + 1 - n, 0]))\n return stats","def corpus_score(self, sys_stream: Union[str, Iterable[str]],\n ref_streams: Union[str, List[Iterable[str]]],\n use_effective_order: bool = False) -> BLEUScore:\n\n # Add some robustness to the input arguments\n if isinstance(sys_stream, str):\n sys_stream = [sys_stream]\n\n if isinstance(ref_streams, str):\n ref_streams = [[ref_streams]]\n\n sys_len = 0\n ref_len = 0\n\n correct = [0 for n in range(self.NGRAM_ORDER)]\n total = [0 for n in range(self.NGRAM_ORDER)]\n\n # look for already-tokenized sentences\n tokenized_count = 0\n\n fhs = [sys_stream] + ref_streams\n for lines in zip_longest(*fhs):\n if None in lines:\n raise EOFError(\"Source and reference streams have different lengths!\")\n\n if self.lc:\n lines = [x.lower() for x in lines]\n\n if not (self.force or self.tokenizer.signature() == 'none') and lines[0].rstrip().endswith(' .'):\n tokenized_count += 1\n\n output, *refs = [self.tokenizer(x.rstrip()) for x in lines]\n\n output_len = len(output.split())\n ref_ngrams, closest_diff, closest_len = CachedBLEU.reference_stats(refs, output_len)\n\n sys_len += output_len\n ref_len += closest_len\n\n sys_ngrams = CachedBLEU.extract_ngrams(output)\n for ngram in sys_ngrams.keys():\n n = len(ngram.split())\n correct[n - 1] += min(sys_ngrams[ngram], ref_ngrams.get(ngram, 0))\n total[n - 1] += sys_ngrams[ngram]\n\n # Get BLEUScore object\n score = self.compute_bleu(\n correct, total, sys_len, ref_len,\n smooth_method=self.smooth_method, smooth_value=self.smooth_value,\n use_effective_order=use_effective_order)\n\n return score","def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\n \"\"\"return value is a sum of all alignment scores in input rangerange.\"\"\" \n (start, finish) = wrapped_data \n score_sum = 0.\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\"Training process\"):\n score_sum += self.aligner.score(seq, dna_record.seq)\n return score_sum\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))","def score(self, *args, references=[], candidates=[], batch_size=None):\n assert not args, (\n \"The score function does not accept positional arguments. Please \"\n \"specify the name of the arguments explicitly, i.e., \"\n \"`score(references=..., candidates=...`)\")\n\n candidates, references = list(candidates), list(references)\n assert len(candidates) == len(references), (\n \"The number of candidate sentences must match the number of \"\n \"reference sentences.\")\n n_items = len(candidates)\n if not candidates:\n return []\n\n if not batch_size:\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\n\n # Sorts the sentences by length.\n input_ids, input_mask, segment_ids = encoding.encode_batch(\n references, candidates, self.tokenizer, self.max_seq_length)\n seq_lengths = np.sum(input_mask, axis=1)\n sorted_indices = np.argsort(seq_lengths)\n assert sorted_indices.shape[0] == n_items\n\n all_results = np.repeat(self.DEFAULT_SCORE, n_items).astype(np.float64)\n batch_lens = []\n for i in range(0, n_items, batch_size):\n\n # Gets the ids of the examples in the batch.\n batch_indices = sorted_indices[i:i + batch_size]\n\n # Computes the max sequence length.\n batch_lenghts = seq_lengths[batch_indices]\n batch_max_len = max(max(batch_lenghts), 1)\n batch_lens.append(batch_max_len)\n\n # Retrieves the examples and truncates the extra padding.\n batch_input_ids = input_ids[batch_indices, :batch_max_len]\n batch_input_mask = input_mask[batch_indices, :batch_max_len]\n batch_segment_ids = segment_ids[batch_indices, :batch_max_len]\n\n # Runs the inference.\n tf_input = {\n \"input_ids\": batch_input_ids,\n \"input_mask\": batch_input_mask,\n \"segment_ids\": batch_segment_ids\n }\n predict_out = self._predictor.predict(tf_input)\n\n # Scatters the scores.\n all_results[batch_indices] = predict_out\n\n assert np.all(all_results > -1000), (\n \"Something went wrong while running the dynamic batching scorer.\")\n all_results = list(all_results)\n assert len(all_results) == n_items, (\n \"Number of predictions does not match sentences: {} vs. {}\".format(\n len(all_results), len(candidates)))\n\n logging.info(\"Average batch sequence length: {}\".format(\n np.mean(batch_lens)))\n\n return all_results","def _bleu_score_update(\n preds: Sequence[str],\n target: Sequence[Sequence[str]],\n numerator: Tensor,\n denominator: Tensor,\n preds_len: Tensor,\n target_len: Tensor,\n n_gram: int = 4,\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\n) -> Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\n\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n\n ngram_counter_clip = preds_counter & target_counter\n\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n\n return preds_len, target_len","def link_text_score(self, rows, wordids):\n # create default score of 0 fro each url\n linkscores = dict([(row[0], 0) for row in rows])\n for wordid in wordids:\n # get all the links\n cur = self.con.execute('select link.fromid,link.toid from linkwords,link where wordid=%d and linkwords.linkid=link.rowid' % wordid)\n for (fromid, toid) in cur:\n if toid in linkscores:\n # if word is in the link, get the links page score\n page_rank = self.con.execute('select score from pagerank where urlid=%d'\n % fromid).fetchone()[0]\n linkscores[toid] += page_rank\n maxscore = max(linkscores.values())\n if not maxscore:\n maxscore = 0.00001\n normalizedscores = dict([(u, float(l) / maxscore) for (u, l) in linkscores.items()])\n return normalizedscores","def calculate_score(s1, s2, l1, l2, startpoint):\n\n matched = \"\" # to hold string displaying alignments\n score = 0\n for i in range(l2):\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" # * indicates a match\n score = score + 1\n else:\n matched = matched + \"-\" # - indicates no match\n\n return score","def recall(self) -> float:\n if self.ref_ignored:\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\n self.num_ignored += num_ref_ignored\n # True Positive = the number of unignored reference mappings that are Positive\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\n # False Negative = the number of unignored reference mappings that are Negative\n fn = len(self.ref_set) - tp - num_ref_ignored\n return tp / (tp + fn)","def calculate_score(result):\n sample1=result['Sample1']\n sample2=result['Sample2']\n string1=paragraph_to_list(sample1)\n string2=paragraph_to_list(sample2)\n \n return round( strings_similarity(string1, string2), 2)\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\n #return round(0.5*(method_difflab+method_dict), 2)","def score(stripe1, stripe2):\n scr = 0\n count = 0\n for p1, p2 in zip(stripe1, stripe2):\n r = abs(p1[0] - p2[0])\n g = abs(p1[1] - p2[1])\n b = abs(p1[2] - p2[2])\n scr += r + g + b\n return scr","def compute_bleu(correct: List[int],\n total: List[int],\n sys_len: int,\n ref_len: int,\n smooth_method = 'none',\n smooth_value = None,\n use_effective_order = False) -> BLEU:\n if smooth_method in SMOOTH_VALUE_DEFAULT and smooth_value is None:\n smooth_value = SMOOTH_VALUE_DEFAULT[smooth_method]\n\n precisions = [0 for x in range(NGRAM_ORDER)]\n\n smooth_mteval = 1.\n effective_order = NGRAM_ORDER\n for n in range(1, NGRAM_ORDER + 1):\n if smooth_method == 'add-k' and n > 1:\n correct[n-1] += smooth_value\n total[n-1] += smooth_value\n if total[n-1] == 0:\n break\n\n if use_effective_order:\n effective_order = n\n\n if correct[n-1] == 0:\n if smooth_method == 'exp':\n smooth_mteval *= 2\n precisions[n-1] = 100. / (smooth_mteval * total[n-1])\n elif smooth_method == 'floor':\n precisions[n-1] = 100. * smooth_value / total[n-1]\n else:\n precisions[n-1] = 100. * correct[n-1] / total[n-1]\n\n # If the system guesses no i-grams, 1 <= i <= NGRAM_ORDER, the BLEU score is 0 (technically undefined).\n # This is a problem for sentence-level BLEU or a corpus of short sentences, where systems will get no credit\n # if sentence lengths fall under the NGRAM_ORDER threshold. This fix scales NGRAM_ORDER to the observed\n # maximum order. It is only available through the API and off by default\n\n brevity_penalty = 1.0\n if sys_len < ref_len:\n brevity_penalty = math.exp(1 - ref_len / sys_len) if sys_len > 0 else 0.0\n\n score = brevity_penalty * math.exp(sum(map(my_log, precisions[:effective_order])) / effective_order)\n\n return BLEU(score, correct, total, precisions, brevity_penalty, sys_len, ref_len)","def calculate_score(origin, sentences):\n result = 0\n if len(origin):\n result=sum(compare_with_bounds(origin, sentence) for sentence in sentences) / float(len(sentences))\n return result","def sentence_score(self, hypothesis: str, references: List[str]) -> CHRFScore:\n hypothesis, references = references[0], [hypothesis]\n\n assert not isinstance(references, str), \\\n \"sentence_score needs a list of references, not a single string\"\n stats = self.get_sentence_statistics(hypothesis, references)\n return self.compute_chrf(stats, self.order, self.beta)","def complementary_score(s1, s2) -> int:\n aligner = Align.PairwiseAligner()\n aligner.mode = 'local'\n aligner.open_gap_score = -1000 # Don't want any gaps!\n # score = the number of complementary nucleotides between s1 and s2.\n return aligner.score(str(s1), str(s2.complement()))","def score(self, valid_preds: Union[pd.DataFrame, np.ndarray]) -> float:\n\n valid_preds.columns = [\"id\"] + self.valid_target_columns\n valid_preds = self.valid_df[self.id_columns].merge(valid_preds, how = \"left\", on = \"id\")\n self.valid_preds = self.trans_30490_to_42840(valid_preds, self.valid_target_columns)\n self.rmsse = self.get_rmsse(self.valid_preds)\n self.contributors = pd.concat([self.weights, self.rmsse], axis = 1, sort = False).prod(axis = 1)\n \n return np.sum(self.contributors)","def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n if smooth:\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\n bleu = brevity_penalty * geometric_mean\n return bleu","def get_bleu(ref, hyp, tokenization=\"intl\"):\n BLEU = corpus_bleu(hyp, [ref], tokenize=tokenization)\n return BLEU.score","def match_score(seq1, seq2):\n\n seq1 = get_sequence_string(seq1)\n seq2 = get_sequence_string(seq2)\n score = align.localxx(seq1, seq2)[0][2]\n return score","def _rouge(ref_file, summarization_file, subword_option=None):\n\n references = []\n with codecs.getreader(\"utf-8\")(tf.gfile.GFile(ref_file, \"rb\")) as fh:\n for line in fh:\n references.append(_clean(line, subword_option))\n\n hypotheses = []\n with codecs.getreader(\"utf-8\")(\n tf.gfile.GFile(summarization_file, \"rb\")) as fh:\n for line in fh:\n hypotheses.append(_clean(line, subword_option=subword_option))\n\n rouge_score_map = rouge.rouge(hypotheses, references)\n return 100 * rouge_score_map[\"rouge_l/f_score\"]","def compare(strokes1, strokes2):\n\n score = 0\n for stroke_i in strokes1:\n match = identify(strokes2, stroke_i)\n score += match\n\n # draw1 = concat(strokes1)\n # draw2 = concat(strokes2)\n # draw1_length,_ = draw1.euclidian_length()\n # draw2_length,_ = draw2.euclidian_length()\n\n # tot_length = draw1_length# + draw2_length\n\n return score","def _score_sentence(self, feats, tags):\n score = torch.zeros((self.batch_size,1), device=self.device)\n tags = torch.cat([torch.full((self.batch_size, 1, 1), self.tag2idx[START_TAG], dtype=torch.long, device=self.device), tags],dim=1)\n for i in range(feats.shape[1]):\n feat = feats[:,i,:]\n \n score = score + self.transitions[tags[:,i+1], tags[:,i]] + feat.gather(dim=-1, index=tags[:,i+1])\n \n score = score + self.transitions[self.tag2idx[STOP_TAG], tags[:,-1]]\n\n return score","def get_bleu(hypotheses, reference):\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n for hyp, ref in zip(hypotheses, reference):\n stats += np.array(bleu_stats(hyp, ref))\n return 100 * bleu(stats)","def _calc_refs(counts):\n refs = 0\n for allele in counts.keys():\n refs += counts[allele]\n return refs","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2):\n #moves shorter sequence along longer, counting number of matches in\n #each position\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\"\n score = score + 1\n else:\n matched = matched + \"-\"\n\n # gives an output for each startpoint showing the number of matches where\n # * is a match and - is no match, position of the two sequences relative to\n # each other, and the number of matches for that startpoint.\n print(\".\" * startpoint + matched) \n print(\".\" * startpoint + s2)\n print(s1)\n print(score) \n print(\" \")\n\n return score","def word_error_rate(hypotheses, references):\n\n scores = 0\n words = 0\n len_diff = len(references) - len(hypotheses)\n if len_diff > 0:\n raise ValueError(\"Uneqal number of hypthoses and references: \"\n \"{0} and {1}\".format(len(hypotheses), len(references)))\n elif len_diff < 0:\n hypotheses = hypotheses[:len_diff]\n\n for h, r in zip(hypotheses, references):\n h_list = h.split()\n r_list = r.split()\n words += len(r_list)\n scores += __levenshtein(h_list, r_list)\n if words != 0:\n wer = 1.0*scores/words\n else:\n wer = float('inf')\n return wer, scores, words","def compute_path_score(self, pre_scores, label):\n point_score = tf.reduce_sum(tf.reduce_sum(pre_scores * label, axis=2), 1, keep_dims=True)\n label1 = tf.expand_dims(label[:, :-1], 3)\n label2 = tf.expand_dims(label[:, 1:], 2)\n label = label1 * label2\n trans = tf.expand_dims(tf.expand_dims(self.trans, 0), 0)\n trans_score = tf.reduce_sum(tf.reduce_sum(label * trans, [2, 3]), 1, keep_dims=True)\n return point_score + trans_score","def bert_score(preds: Union[List[str], Dict[str, Tensor]], target: Union[List[str], Dict[str, Tensor]], model_name_or_path: Optional[str]=None, num_layers: Optional[int]=None, all_layers: bool=False, model: Optional[Module]=None, user_tokenizer: Any=None, user_forward_fn: Callable[[Module, Dict[str, Tensor]], Tensor]=None, verbose: bool=False, idf: bool=False, device: Optional[Union[str, torch.device]]=None, max_length: int=512, batch_size: int=64, num_threads: int=4, return_hash: bool=False, lang: str='en', rescale_with_baseline: bool=False, baseline_path: Optional[str]=None, baseline_url: Optional[str]=None) ->Dict[str, Union[List[float], str]]:\n if len(preds) != len(target):\n raise ValueError('Number of predicted and reference sententes must be the same!')\n if verbose and not _TQDM_AVAILABLE:\n raise ModuleNotFoundError('An argument `verbose = True` requires `tqdm` package be installed. Install with `pip install tqdm`.')\n if model is None:\n if not _TRANSFORMERS_AVAILABLE:\n raise ModuleNotFoundError('`bert_score` metric with default models requires `transformers` package be installed. Either install with `pip install transformers>=4.0` or `pip install torchmetrics[text]`.')\n if model_name_or_path is None:\n warn(f'The argument `model_name_or_path` was not specified while it is required when default `transformers` model are used.It is, therefore, used the default recommended model - {_DEFAULT_MODEL}.')\n tokenizer = AutoTokenizer.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\n model = AutoModel.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\n else:\n tokenizer = user_tokenizer\n model.eval()\n model\n try:\n if num_layers and num_layers > model.config.num_hidden_layers:\n raise ValueError(f'num_layers={num_layers} is forbidden for {model_name_or_path}. Please use num_layers <= {model.config.num_hidden_layers}')\n except AttributeError:\n warn('It was not possible to retrieve the parameter `num_layers` from the model specification.')\n _are_empty_lists = all(isinstance(text, list) and len(text) == 0 for text in (preds, target))\n _are_valid_lists = all(isinstance(text, list) and len(text) > 0 and isinstance(text[0], str) for text in (preds, target))\n _are_valid_tensors = all(isinstance(text, dict) and isinstance(text['input_ids'], Tensor) for text in (preds, target))\n if _are_empty_lists:\n warn('Predictions and references are empty.')\n output_dict: Dict[str, Union[List[float], str]] = {'precision': [0.0], 'recall': [0.0], 'f1': [0.0]}\n if return_hash:\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\n return output_dict\n baseline = _load_baseline(lang, model_name_or_path, baseline_path, baseline_url) if rescale_with_baseline else None\n if _are_valid_lists:\n target_dataset = TextDataset(target, tokenizer, max_length, idf=idf)\n preds_dataset = TextDataset(preds, tokenizer, max_length, idf=idf, tokens_idf=target_dataset.tokens_idf)\n elif _are_valid_tensors:\n target_dataset = TokenizedDataset(**target, idf=idf)\n preds_dataset = TokenizedDataset(**preds, idf=idf, tokens_idf=target_dataset.tokens_idf)\n else:\n raise ValueError('Invalid input provided.')\n target_loader = DataLoader(target_dataset, batch_size=batch_size, num_workers=num_threads)\n preds_loader = DataLoader(preds_dataset, batch_size=batch_size, num_workers=num_threads)\n target_embeddings, target_idf_scale = _get_embeddings_and_idf_scale(target_loader, target_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\n preds_embeddings, preds_idf_scale = _get_embeddings_and_idf_scale(preds_loader, preds_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\n precision, recall, f1_score = _get_precision_recall_f1(preds_embeddings, target_embeddings, preds_idf_scale, target_idf_scale)\n if baseline is not None:\n precision, recall, f1_score = _rescale_metrics_with_baseline(precision, recall, f1_score, baseline, num_layers, all_layers)\n output_dict = {'precision': precision.tolist(), 'recall': recall.tolist(), 'f1': f1_score.tolist()}\n if return_hash:\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\n return output_dict","def substitution_score(substitution_matrix, seqA, seqB):\n return sum(compute_score_by_position(substitution_matrix, seqA, seqB))","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2): \n if (i + startpoint) < (l1 + l2 - 1): \n if l2 - i > startpoint + 1:\n matched = matched + \".\" #dots before they start overlapping\n elif s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" #matched bases\n score = score + 1 #adds one to score\n else:\n matched = matched + \"-\" #not matched bases\n shift, end_shift = startpoint * \".\", (l2 + l1 - startpoint - 2) * \".\"\n # dots at end, but only up until end of dots tailing l1\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\n # this formula. the below check stops it from getting less than l2.\n if startpoint < l1 - 1:\n print(shift + matched + end_shift)\n else:\n print(shift + matched + (l2 - 1) * \".\")\n print(shift + s2 + end_shift)\n print(s1)\n print(str(score) + \"\\n\")\n return score, matched, shift, end_shift","def compute_metrics_from_files(p_path_to_reference_file,\r\n p_path_to_candidate_file,\r\n p_max_bleu_order):\r\n\r\n reference_dictionary, reference_no_answer_query_ids = \\\r\n load_file(p_path_to_reference_file)\r\n candidate_dictionary, candidate_no_answer_query_ids = load_file(p_path_to_candidate_file)\r\n query_id_answerable = set(reference_dictionary.keys())-reference_no_answer_query_ids\r\n query_id_answerable_candidate = set(candidate_dictionary.keys())-candidate_no_answer_query_ids\r\n \r\n true_positives = len(query_id_answerable_candidate.intersection(query_id_answerable))\r\n false_negatives = len(query_id_answerable)-true_positives\r\n true_negatives = len(candidate_no_answer_query_ids.intersection(reference_no_answer_query_ids))\r\n false_positives = len(reference_no_answer_query_ids)-true_negatives\r\n precision = float(true_positives)/(true_positives+false_positives) if (true_positives+false_positives)>0 else 1.\r\n recall = float(true_positives)/(true_positives+false_negatives) if (true_positives+false_negatives)>0 else 1.\r\n F1 = 2 *((precision*recall)/(precision+recall))\r\n filtered_reference_dictionary = \\\r\n {key: value for key, value in reference_dictionary.items() \\\r\n if key not in reference_no_answer_query_ids}\r\n\r\n filtered_candidate_dictionary = \\\r\n {key: value for key, value in candidate_dictionary.items() \\\r\n if key not in reference_no_answer_query_ids}\r\n\r\n for query_id, answers in filtered_candidate_dictionary.items():\r\n assert \\\r\n len(answers) <= 1, \\\r\n 'query_id %d contains more than 1 answer \\\"%s\\\" in candidate file' % \\\r\n (query_id, str(answers))\r\n\r\n reference_query_ids = set(filtered_reference_dictionary.keys())\r\n candidate_query_ids = set(filtered_candidate_dictionary.keys())\r\n common_query_ids = reference_query_ids.intersection(candidate_query_ids)\r\n assert (len(common_query_ids) == len(reference_query_ids)) and \\\r\n (len(common_query_ids) == len(candidate_query_ids)), \\\r\n 'Reference and candidate files must share same query ids'\r\n\r\n all_scores = {}\r\n bleu_scores, _ = \\\r\n Bleu(p_max_bleu_order).compute_score(filtered_reference_dictionary, \\\r\n filtered_candidate_dictionary)\r\n for i, bleu_score in enumerate(bleu_scores):\r\n all_scores['bleu_%d' % (i+1)] = bleu_score\r\n\r\n rouge_score, _ = Rouge().compute_score(filtered_reference_dictionary, \\\r\n filtered_candidate_dictionary)\r\n all_scores['rouge_l'] = rouge_score\r\n all_scores['F1'] = F1\r\n similarity = 0\r\n for key in filtered_reference_dictionary:\r\n candidate_answer = nlp(filtered_candidate_dictionary[key][0])\r\n reference_answer = filtered_reference_dictionary[key]\r\n answersimilarity = 0\r\n for answer in reference_answer:\r\n answersimilarity += candidate_answer.similarity(nlp(answer))\r\n similarity += answersimilarity/len(reference_answer)\r\n semantic_similarity = similarity/len(filtered_reference_dictionary)\r\n all_scores['Semantic_Similarity'] = semantic_similarity\r\n return all_scores","def _score(self, features: Tensor, tags: Tensor, masks: Tensor):\n \n B, T, H = features.shape\n\n emit_scores = features.gather(dim=2, index=tags.unsqueeze(dim=-1)).squeeze(-1)\n\n start_tag = torch.full((B, 1), fill_value=self.start_idx, dtype=torch.long, device=self.device)\n tags = torch.cat([start_tag, tags], dim=1)\n transition_scores = self.transition_matrix[tags[:, 1:], tags[:, :-1]]\n last_tag = tags.gather(dim=1, index=masks.sum(dim=1).long().unsqueeze(1)).squeeze(1)\n last_score = self.transition_matrix[self.stop_idx, last_tag]\n score = ((transition_scores + emit_scores) * masks).sum(dim=1) + last_score\n return score","def calculate_p(candidate, reference):\n matches = 0\n for grama in candidate:\n if grama in reference:\n matches += 1\n return matches/len(candidate)","def compute_recall(pred_boxes, gt_boxes, iou):\n # Measure overlaps\n overlaps = compute_overlaps(pred_boxes, gt_boxes)\n iou_max = np.max(overlaps, axis=1)\n iou_argmax = np.argmax(overlaps, axis=1)\n positive_ids = np.where(iou_max >= iou)[0]\n matched_gt_boxes = iou_argmax[positive_ids]\n\n recall = len(set(matched_gt_boxes)) / gt_boxes.shape[0]\n return recall, positive_ids","def score(caches, endpoints, requests, videos):\n result = 0\n for endpoint in endpoints:\n for request in endpoint.requests:\n result += (endpoint.latence_to_dc - getLatency(request.video, endpoint.eid, caches, videos, endpoints)) * request.amount\n return result","def calculScore(self):\n for cell in self.notComputeRouter:\n if(cell.isCovered==True):\n self.score += 1000\n self.score += self.budget","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def compute_rouge_l(output, reference, mode='f'):\n assert mode in list('fpr') # F-1, precision, recall\n lcs = _lcs_len(output, reference)\n if lcs == 0:\n score = 0.0\n else:\n precision = lcs / len(output)\n recall = lcs / len(reference)\n f_score = 2 * (precision * recall) / (precision + recall)\n if mode == 'p':\n score = precision\n if mode == 'r':\n score = recall\n else:\n score = f_score\n return score","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def optimize_reference(self, num_targets):\n \n target_weights = np.ones(num_targets)\n target_weights = target_weights/sum(target_weights)\n \n #target_weights = [0.8,0.2]\n\n x0 = np.asarray(np.insert(np.zeros(self._refs.shape[0]-len(target_weights)),0,target_weights))\n print(x0)\n \n # num_weights = self._refs.shape[0]\n # x0 = np.ones(num_weights)/sum(np.ones(num_weights))\n\n #x0 = np.asarray([0.8,0.2,0,0,0,0,0,0])\n\n assert num_targets >= 1, 'num_targets >= 1'\n assert num_targets <= len(x0), 'num_targets < len(x0)'\n\n\n lsq = sciopt.least_squares(self.residual, \n x0, \n #args=(np.reshape(self._true, (1,36)), num_targets), \n args=(self._true, num_targets), \n bounds=(0,1), \n method='trf', \n tr_solver='lsmr', \n diff_step=0.1, \n loss='soft_l1',\n tr_options={'damp':1.0},\n ftol=1e-6,\n verbose=2) #diff_step=0.2, verbose=2)#, loss='linear')\n\n return (lsq.x/sum(lsq.x), lsq)","def score(self, sentence):\n\n\n # TODO your code here\n score = 0.0 \n prevWord = \"\"\n prevPrevWord = \"\"\n newSentence = []\n for word in sentence:\n newSentence += word.split()\n for currentWord in sentence:\n currentWord = currentWord.strip(STRIP_CHARS)\n currentWord = currentWord.lower()\n if prevWord != \"\":\n if prevPrevWord != \"\":\n trigram = (prevPrevWord, prevWord, currentWord)\n trigramCount = self.trigramCounts[trigram]\n if trigramCount > 0:\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\n # Subtraction by 1 removes the add one count from the laplace\n # smoothing\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\n score -= math.log(self.totalBigramCounts)\n else:\n count = self.unigramCounts[currentWord]\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\n score -= math.log(self.total)\n else:\n prevPrevWord = prevWord\n prevWord = currentWord\n else:\n prevWord = currentWord\n return -score","def alignScore():\n matrix = mapMatrix(\"BLOSUM62\")\n \n path = \"./data/\"\n for file in os.listdir(path):\n if file.endswith(\".fa\") or file.endswith(\".fasta\"):\n sequences = []\n input_sequences = SeqIO.parse(path + file, \"fasta\", \\\n IUPAC.protein)\n\n for record in input_sequences:\n seq = str(record.seq)\n sequences.append(seq) \n \n SumOfPairs = 0\n for pair in combinations(sequences, 2): \n SumOfPairs += pairwiseScore(pair[0], pair[1], matrix)\n \n print SumOfPairs","def calculate_recall(targets, preds):\n intersection_foreground = targets * preds\n n_intersection_foreground = float(np.sum(intersection_foreground))\n n_targets = float(np.sum(targets))\n\n return n_intersection_foreground / (n_targets + 1e-7)","def score_ref(matrix,seq,ns=True):\n specific_binding = sum([row[base_dict[b]] for row,b in zip(matrix,seq)])\n if ns:\n return log(exp(-beta*specific_binding) + exp(-beta*ns_binding_const))/-beta\n else:\n return specific_binding","def run_bertscore(\n mt: list, ref: list, model_type=\"xlm-roberta-base\", language=False, idf=False\n) -> (list, list, list):\n if language:\n precison, recall, f1 = bert_score.score(\n cands=mt,\n refs=ref,\n idf=idf,\n batch_size=32,\n lang=language,\n rescale_with_baseline=False,\n verbose=True,\n nthreads=4,\n )\n else:\n precison, recall, f1 = bert_score.score(\n cands=mt,\n refs=ref,\n idf=idf,\n batch_size=32,\n model_type=model_type,\n rescale_with_baseline=False,\n verbose=True,\n nthreads=4,\n )\n return precison, recall, f1","def score(PDBfile):\n from pro_angle import find_residue\n from Bio.PDB.PDBParser import PDBParser\n from pro_length import length\n \n (aas, gly, pro) = load_scores() ##define global tables\n score = 0 #initialize \n pars = PDBParser(PERMISSIVE = 1)\n struct = pars.get_structure(PDBfile.rstrip('.pdb'), PDBfile)\n model = struct.child_list[0]\n chain = model.child_list[0]\n pro_list = find_residue(chain, 'PRO')\n gly_list = find_residue(chain, 'GLY')\n aas_list = range(chain.child_list[1].id[1],\n chain.child_list[len(chain)-1].id[1])\n #need to remove pro/gly indices in first/last position\n if pro_list.count(1) > 0: \n pro_list.remove(1)\n if pro_list.count(len(chain)-1) > 0:\n pro_list.remove(len(chain)-1)\n if gly_list.count(1) > 0:\n gly_list.remove(1)\n if gly_list.count(len(chain)-1) > 0:\n gly_list.remove(len(chain)-1) \n try:\n for index in pro_list: \n aas_list.remove(index) #remove pros from aas_list\n for index in gly_list:\n aas_list.remove(index) #remove glys from aas_list\n except ValueError:\n print 'incosistency in PDB file - will return score = 0' \n return 0\n else:\n proscore = score_help(chain, pro_list, pro)\n glyscore = score_help(chain, gly_list, gly)\n aasscore = score_help(chain, aas_list, aas)\n score = proscore+glyscore+aasscore\n size=length(chain)\n try:\n score = (score/size)*1000 #normalize score\n return score\n except ZeroDivisionError:\n print \"calculated protein length 0 -> returning score 0\"\n score = 0\n return score","def fuzzy_match_strings(ref, val):\n if not ref or not val:\n return 0\n ref_q = to_q(ref)\n val_q = to_q(val)\n if ref_q or val_q:\n return 100 if ref_q == val_q else 0\n simplified_val = unidecode(val).lower()\n simplified_ref = unidecode(ref).lower()\n\n # Return symmetric score\n r1 = fuzz.token_sort_ratio(simplified_val, simplified_ref)\n r2 = fuzz.token_sort_ratio(simplified_ref, simplified_val)\n r2 = r1\n return int(0.5*(r1+r2))","def get_score(self,sentence_1, sentence_2):\n\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)","def rouge_n(evaluated_sentences, reference_sentences, n=2):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\n reference_count = len(reference_ngrams)\n evaluated_count = len(evaluated_ngrams)\n\n # Gets the overlapping ngrams between evaluated and reference\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if evaluated_count == 0:\n precision = 0.0\n else:\n precision = overlapping_count / evaluated_count\n\n if reference_count == 0:\n recall = 0.0\n else:\n recall = overlapping_count / reference_count\n\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\n\n # return overlapping_count / reference_count\n return f1_score, precision, recall","def calculate_bleu(candidate, reference):\n pn_sum = 0\n for n in range(1, 4):\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\n p = calculate_p(cand_grama, ref_grama)\n if p != 0:\n # If there are no matches between n_grams,\n # don't add nothing\n pn_sum += (0.33 * math.log(p))\n bp = calculate_bp_penality(candidate, reference)\n return bp * math.exp(pn_sum)","def evaluate(ref_file, trans_file, metric, subword_option=None,\n lower_case=False):\n # BLEU scores for translation task\n if metric.lower() == \"bleu\":\n evaluation_score = _bleu(\n ref_file,\n trans_file,\n subword_option=subword_option,\n lower_case=lower_case)\n else:\n raise ValueError(\"Unknown metric %s\" % metric)\n\n return evaluation_score","def _pg_bahdanau_score(processed_query, keys, coverage, coverage_vector):\n dtype = processed_query.dtype\n # Get the number of hidden units from the trailing dimension of keys\n num_units = keys.shape[2].value or tf.shape(keys)[2]\n # Reshape from [batch_size, ...] to [batch_size, 1, ...] for broadcasting.\n processed_query = tf.expand_dims(processed_query, 1)\n v = tf.get_variable('attention_v', [num_units], dtype = dtype)\n b = tf.get_variable(\n 'attention_b',\n [num_units],\n dtype = dtype,\n initializer = tf.zeros_initializer(),\n )\n if coverage:\n w_c = tf.get_variable('coverage_w', [num_units], dtype = dtype)\n # debug\n # coverage_vector = tf.Print(coverage_vector,[coverage_vector],message=\"score\")\n coverage_vector = tf.expand_dims(coverage_vector, -1)\n return tf.reduce_sum(\n v * tf.tanh(keys + processed_query + coverage_vector * w_c + b), [2]\n )\n else:\n return tf.reduce_sum(v * tf.tanh(keys + processed_query + b), [2])","def compute_readability(text):\n total_words = 0\n total_sentences = 0\n total_syllables = 0\n score = 0\n\n words = text.split()\n total_words = len(text.split()) \n total_sentences = count_sentences(text)\n total_syllables = count_syllables(words)\n \n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\n if score > 90.00:\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\n elif score <= 90.00 and score > 80.00:\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\n elif score <= 80.00 and score > 70.00:\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\n elif score <= 70.00 and score > 60.00:\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\n elif score <= 60.00 and score > 50.00:\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\n elif score <= 50.00 and score > 30.00:\n answer = 'Texto de nível Universitário, difícil de ler.'\n else:\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\n \n print('Pontuação Total:', score, answer)","def rouge_n(reference_sentences, evaluated_sentences, n=2):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\n reference_count = len(reference_ngrams)\n evaluated_count = len(evaluated_ngrams)\n\n # Gets the overlapping ngrams between evaluated and reference\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if evaluated_count == 0:\n precision = 0.0\n else:\n precision = overlapping_count / evaluated_count\n\n if reference_count == 0:\n recall = 0.0\n else:\n recall = overlapping_count / reference_count\n\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\n\n #just returning recall count in rouge, useful for our purpose\n return recall","def baseline_score(self,t0,t1):\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))","def _bleu_score_compute(\n preds_len: Tensor,\n target_len: Tensor,\n numerator: Tensor,\n denominator: Tensor,\n n_gram: int,\n weights: Sequence[float],\n smooth: bool,\n) -> Tensor:\n device = numerator.device\n if min(numerator) == 0.0:\n return tensor(0.0, device=device)\n\n if smooth:\n precision_scores = torch.div(\n torch.add(numerator, torch.ones(n_gram, device=device)),\n torch.add(denominator, torch.ones(n_gram, device=device)),\n )\n precision_scores[0] = numerator[0] / denominator[0]\n else:\n precision_scores = numerator / denominator\n\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\n return brevity_penalty * geometric_mean","def score_candidates(normal, position_difference, trial_normals, angle_weight):\n\n # We want all normals on the same side of the line, so flip those that aren't.\n flip_normal = is_opposite(trial_normals, normal)\n trial_normals[flip_normal, :] = -trial_normals[flip_normal, :]\n\n # Note that we have to add the relative pixel displacement on top of the subpixel displacements)\n distances = np.linalg.norm(position_difference, axis=1)\n angular_distances = np.arccos(np.dot(trial_normals, normal))\n return distances + angle_weight * angular_distances","def cumulative_bleu(references, sentence, n):\r\n weight = 1 / n\r\n scores = [ngram_modscore(references, sentence, i, weight)\r\n for i in range(1, n + 1)]\r\n closest = np.argmin(np.abs([len(ref) - len(sentence)\r\n for ref in references]))\r\n closest = len(references[closest])\r\n if len(sentence) >= closest:\r\n brevity = 1\r\n else:\r\n brevity = np.exp(1 - closest / len(sentence))\r\n return brevity * np.exp(sum(scores))","def compute_score(self, gts, res):\n\n assert(gts.keys() == res.keys())\n imgIds = gts.keys()\n\n cider_scorer = CiderScorer(n=self._n, sigma=self._sigma, \n document_frequency=self._doucument_frequency, \n ref_len=self._ref_len)\n\n for id in imgIds:\n hypo = res[id]\n ref = gts[id]\n\n # Sanity check.\n assert(type(hypo) is list)\n assert(len(hypo) == 1)\n assert(type(ref) is list)\n assert(len(ref) > 0)\n\n cider_scorer += (hypo[0], ref)\n\n (score, scores) = cider_scorer.compute_score()\n\n return score, scores","def score_segments(segs, truths, detected):\n matches = 0\n for seg in segs:\n truth_match = detected_match = False\n for truth in truths:\n if time_overlap(seg, truth):\n truth_match = True\n for det in detected:\n if time_overlap(seg, det):\n detected_match = True\n\n #assign basic score to segment (TP|TN|FP|FN)\n if truth_match:\n if detected_match:\n seg[\"score\"] = \"TP\"\n else:\n seg[\"score\"] = \"FN\"\n else:\n if detected_match:\n seg[\"score\"] = \"FP\"\n else:\n seg[\"score\"] = \"TN\"\n\n # assign error class to all FN and FP. fig 3, ward et al 2011\n prev_score = next_score = None\n for i in range(len(segs)):\n score = segs[i][\"score\"]\n if score == \"TP\" or score == \"TN\":\n continue \n\n if i < len(segs)-1:\n next_score = segs[i+1][\"score\"]\n\n if i > 0:\n prev_score = segs[i-1][\"score\"]\n\n if i == 0: #beginning of sequence\n\n if score == \"FP\":\n if next_score is None or next_score == \"TN\" or next_score == \"FN\":\n segs[i][\"err\"] = \"I\"\n elif next_score == \"TP\":\n segs[i][\"err\"] = \"Os\"\n else:\n warn(\"Unhandled error case: %s followed by %s\" % (score, next_score))\n\n elif score == \"FN\":\n if next_score is None or next_score == \"TN\" or next_score == \"FP\":\n segs[i][\"err\"] = \"D\"\n elif next_score == \"TP\":\n segs[i][\"err\"] = \"Us\"\n else:\n warn(\"Unhandled error case: %s followed by %s\" % (score, next_score))\n\n elif i == len(segs) - 1: #end of sequence\n\n if score == \"FP\":\n if prev_score == \"TN\" or prev_score == \"FN\":\n segs[i][\"err\"] = \"I\"\n elif prev_score == \"TP\":\n segs[i][\"err\"] = \"Oe\"\n else:\n warn(\"Unhandled error case: %s followed by %s\" % (score, next_score))\n \n elif score == \"FN\":\n if prev_score == None or prev_score == \"TN\" or prev_score == \"FP\":\n segs[i][\"err\"] = \"D\"\n elif prev_score == \"TP\":\n segs[i][\"err\"] = \"Ue\"\n else:\n warn(\"Unhandled error case: %s followed by %s\" % (score, next_score))\n\n else: #middle sequence\n\n if score == \"FP\":\n if next_score == \"TP\":\n if prev_score == \"TP\":\n segs[i][\"err\"] = \"M\"\n elif prev_score == \"TN\" or prev_score == \"FN\":\n segs[i][\"err\"] = \"Os\"\n else:\n warn(\"Unhandled error case: %s %s %s\" % (prev_score, score, next_score))\n\n elif next_score == \"TN\" or next_score == \"FN\":\n if prev_score == \"TN\" or prev_score == \"FN\":\n segs[i][\"err\"] = \"I\"\n elif prev_score == \"TP\":\n segs[i][\"err\"] = \"Oe\"\n else:\n warn(\"Unhandled error case: %s %s %s\" % (prev_score, score, next_score))\n else:\n warn(\"Unhandled error case: %s followed by %s\" % (score, next_score))\n\n elif score == \"FN\":\n\n if next_score == \"TP\":\n if prev_score == \"TP\":\n segs[i][\"err\"] = \"F\"\n elif prev_score == \"TN\" or prev_score == \"FP\":\n segs[i][\"err\"] = \"Us\"\n else:\n warn(\"Unhandled error case: %s %s %s\" % (prev_score, score, next_score))\n\n elif next_score == \"TN\" or next_score == \"FP\":\n if prev_score == \"TN\" or prev_score == \"FP\":\n segs[i][\"err\"] = \"D\"\n elif prev_score == \"TP\":\n segs[i][\"err\"] = \"Ue\"\n else:\n warn(\"Unhandled error case: %s %s %s\" % (prev_score, score, next_score))\n\n else:\n raise warn(\"Unknown score: %s\" % score)\n\n return segs","def calc_accuracy(self, top_matches):\n # Calculate Translation accuracy\n # Accuracy at K\n for k in [1, 5, 10]:\n top_k_matches = top_matches[:, :k]\n # Checks for one match\n one_matching = (top_k_matches == self.tgt_ind[:, None]).sum(1)\n # Checks for multiple translations\n matching = {}\n for i, src_id in enumerate(self.src_ind):\n matching[src_id] = min(matching.get(src_id, 0) + one_matching[i], 1)\n precision_at_k = 100 * np.mean(list(matching.values()))\n print(\"%i source words - Precision at k = %i: %f\" % (len(matching), k, precision_at_k))","def updateReferenceAndNormalize(m, ref, thresh):\n ref = list(ref)\n thresh = max(thresh,0)\n totals = np.sum(m[:4,], axis=0)\n idx = 0;\n b2i = BaseToInt()\n for i in totals:\n if i < thresh:\n bases = np.array(b2i.getPositions(ref[idx].capitalize()))\n m[:4, idx] = 0\n m[bases, idx] = 1.0/len(bases)\n else:\n m[:4,idx] = m[:4,idx]/i\n\n #DEBUG CODE#\n if (m[:4,idx] > 1).any():\n print(i)\n print (m[:4,idx])\n print(totals)\n #END DEBUG CODE#\n \n idx += 1","def rouge_n(eval_sentences, ref_sentences, n=2):\n f1_scores = []\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\n eval_ngrams = _get_ngrams(n, eval_sentence)\n ref_ngrams = _get_ngrams(n, ref_sentence)\n ref_count = len(ref_ngrams)\n eval_count = len(eval_ngrams)\n\n # Count the overlapping ngrams between evaluated and reference\n overlapping_ngrams = eval_ngrams.intersection(ref_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if eval_count == 0:\n precision = 0.0\n else:\n precision = float(overlapping_count) / eval_count\n if ref_count == 0:\n recall = 0.0\n else:\n recall = float(overlapping_count) / ref_count\n f1_scores.append(2.0 * ((precision * recall) / (precision + recall + 1e-8)))\n\n # return overlapping_count / reference_count\n return np.mean(f1_scores, dtype=np.float32)","def score_sentence(self, sentence):\n\t\t\n\t\t# YOUR CODE HERE","def _compute(self, references=None, models=None):\n \n config = self.config\n if references is None:\n self.logger.msg2(\"Working with all references\")\n references = get_ref_names(self.dbpath)\n \n self.logger.msg1(\"Dropping scores for \"+str(len(models))+ \" models\")\n delete_model_scores(self.dbpath, models)\n self.logger.msg2(\"Working with \" + str(len(references)) +\n \" references, \" + str(len(models)) + \" models\")\n packets = prep_compute_packets(config, \n references=references,\n models=models,\n log=self.logger.msg2) \n \n # run calculations on all the packets\n msg = str(config.cores)+ \" cores, \" + str(len(packets))+ \" packets\"\n self.logger.msg1(\"Scoring (\"+msg+\")\")\n run_packets(packets, config.cores)","def rouge_n(evaluated_sentences, reference_sentences, n=2):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\n reference_count = len(reference_ngrams)\n evaluated_count = len(evaluated_ngrams)\n\n # Gets the overlapping ngrams between evaluated and reference\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if evaluated_count == 0:\n precision = 0.0\n else:\n precision = overlapping_count / evaluated_count\n\n if reference_count == 0:\n recall = 0.0\n else:\n recall = overlapping_count / reference_count\n\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\n\n # return overlapping_count / reference_count\n return f1_score, precision, recall","def stereo_score(alignment):\n #dictionary with properties for each residue\n dic_prop = {'I': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\n 'L': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\n 'V': [1, 0, 1, 0, 0, 1, 0, 0, 0, 0],\n 'C': [1, 0, 1, 0, 0, 0, 0, 0, 0, 0],\n 'A': [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],\n 'G': [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],\n 'M': [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n 'F': [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],\n 'Y': [1, 1, 0, 0, 0, 0, 1, 0, 0, 0],\n 'W': [1, 1, 0, 0, 0, 0, 1, 0, 0, 0],\n 'H': [1, 1, 0, 0, 0, 0, 1, 1, 0, 1],\n 'K': [1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n 'R': [0, 1, 0, 0, 0, 0, 0, 1, 0, 1],\n 'E': [0, 1, 0, 0, 0, 0, 0, 0, 1, 1],\n 'Q': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n 'D': [0, 1, 1, 0, 0, 0, 0, 0, 1, 1],\n 'N': [0, 1, 1, 0, 0, 0, 0, 0, 0, 0],\n 'S': [0, 1, 1, 0, 1, 0, 0, 0, 0, 0],\n 'T': [1, 1, 1, 0, 0, 0, 0, 0, 0, 0],\n 'P': [0, 0, 1, 1, 0, 0, 0, 0, 0, 0],\n 'B': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n 'Z': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\n 'X': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n '-': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}\n score_list = []\n for i in range(0, alignment.get_alignment_length()):\n #extract the unique residues in the alignment\n column = ''.join(set(alignment[:, i]))\n stereo_list = []\n #loop through each residue\n for res in range(0, len(column)):\n #replace the residue with list of properties\n residue = column[res]\n #append the properties list to a\n stereo_prop = dic_prop.get(residue)\n stereo_list.append(stereo_prop)\n #number of common properties\n count_stereo = sum(len(set(i)) == 1 for i in zip(*stereo_list))\n #add the number of properties to a list\n score_list.append(count_stereo)\n score_list_final = [float(i*0.1) for i in score_list]\n return score_list_final","def score_help(chain, res_list, score_table):\n from pro_angle import calc_dihedral\n from math import floor\n \n score = float(0)\n for res in res_list:\n try:\n (phi,psi) = calc_dihedral(chain, res) \n indx = int(floor(phi/10)+18)\n indy = int(floor(psi/10)+18)\n temp = float(score_table[indy][indx])\n score = score + temp\n except ValueError:\n pass\n# print \"ValueError: asked for score of non-scorable residue\"\n return score"],"string":"[\n \"def bleu_score(references, generated, n_gram=4, smooth=False):\\r\\n formatted_ref = [[ref] for ref in references]\\r\\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\\r\\n return bleu_s * 100\",\n \"def calculate_bleu(output_lns, refs_lns):\\n return round(corpus_bleu(output_lns, [refs_lns]).score, 4)\",\n \"def bleu(hypotheses, references):\\n return sacrebleu.raw_corpus_bleu(sys_stream=hypotheses,\\n ref_streams=[references]).score\",\n \"def _compute_score(self):\\n\\n sgml_path = str(self.sgml_file.name)\\n text_path = sgml_path.replace('.sgm', '.txt')\\n ref_path = 'testsets/wmt18.ende.ref.txt'\\n\\n from sacrebleu import process_to_text, corpus_bleu\\n from pathlib import Path\\n\\n if not Path(text_path).exists():\\n process_to_text(sgml_path, text_path)\\n\\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\\n\\n bleu = corpus_bleu(hyp_stream, [ref_stream])\\n\\n self.score = bleu.score\\n self.save()\",\n \"def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\\\\n \\\"missing keys: {}\\\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\\n scores = {}\\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\\n for i, bleu_score in enumerate(bleu_scores):\\n scores['Bleu-%d' % (i + 1)] = bleu_score\\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\\n scores['Rouge-L'] = rouge_score\\n return scores\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def calculate_bleu(output_lns, refs_lns, **kwargs) -> dict:\\n return {\\\"bleu\\\": round(corpus_bleu(output_lns, [refs_lns], **kwargs).score, 4)}\",\n \"def _bleu(ref_file, trans_file, subword_option=None, lower_case=False):\\n max_order = 4\\n smooth = False\\n\\n ref_files = [ref_file]\\n reference_text = []\\n for reference_filename in ref_files:\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(reference_filename, \\\"rb\\\")) as fh:\\n reference_text.append(fh.readlines())\\n\\n per_segment_references = []\\n for references in zip(*reference_text):\\n reference_list = []\\n for reference in references:\\n reference = _clean(reference, subword_option, lower_case=lower_case)\\n reference_list.append(reference.split())\\n per_segment_references.append(reference_list)\\n\\n translations = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(trans_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n line = _clean(line, subword_option=None, lower_case=lower_case)\\n translations.append(line.split())\\n\\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\\n per_segment_references, translations, max_order, smooth)\\n return 100 * bleu_score\",\n \"def _self_bleu(completions: List[Sequence], **unused_kwargs) -> float:\\n completion_sequences: List[str] = [completion.text.strip() for completion in completions if completion.text.strip()]\\n\\n if len(completion_sequences) <= 1:\\n return 0\\n\\n scores = []\\n for i in range(len(completion_sequences)):\\n hypothesis = completion_sequences[i]\\n references = completion_sequences[:i] + completion_sequences[i + 1 :]\\n\\n # Enable `effective_order` for sentence-level BLEU.\\n score = BLEU(effective_order=True).sentence_score(hypothesis=hypothesis, references=references)\\n scores.append(score.score)\\n return sum(scores) / len(scores)\",\n \"def bleu_score(output, reference):\\n num_sentences = min(len(output), len(reference))\\n for i in range(num_sentences):\\n if i == 5:\\n print(\\\"Do you want to calculate all sentences? (y/n)\\\")\\n answer = input()\\n if answer.lower() == 'n':\\n break\\n out_sentence, ref_sentence = output[i], reference[i]\\n bleu_score = calculate_bleu(out_sentence, ref_sentence)\\n print(\\n f\\\"Sentence {i + 1}, Score: {bleu_score}\\\")\",\n \"def _bleu(ref_file, trans_file,max_order=4, subword_option=None):\\n smooth = False\\n\\n ref_files = [ref_file]\\n reference_text = []\\n for reference_filename in ref_files:\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(reference_filename, \\\"rb\\\")) as fh:\\n reference_text.append(fh.readlines())\\n\\n per_segment_references = []\\n for references in zip(*reference_text):\\n reference_list = []\\n for reference in references:\\n reference = _clean(reference, subword_option)\\n reference_list.append(reference.split(\\\" \\\"))\\n per_segment_references.append(reference_list)\\n\\n print(per_segment_references[0:15])\\n\\n translations = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(trans_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n line = _clean(line, subword_option=subword_option)\\n translations.append(line.split(\\\" \\\"))\\n print(translations[0:15])\\n # bleu_score, precisions, bp, ratio, translation_length, reference_length\\n bleu_score, _, _, _, _, _ = bleu.compute_bleu(\\n per_segment_references, translations, max_order, smooth)\\n return 100 * bleu_score\",\n \"def reference_stats(refs, output_len):\\n\\n ngrams = Counter()\\n closest_diff = None\\n closest_len = None\\n\\n for ref in refs:\\n tokens = ref.split()\\n reflen = len(tokens)\\n diff = abs(output_len - reflen)\\n if closest_diff is None or diff < closest_diff:\\n closest_diff = diff\\n closest_len = reflen\\n elif diff == closest_diff:\\n if reflen < closest_len:\\n closest_len = reflen\\n\\n ngrams_ref = CachedBLEU.extract_ngrams(ref)\\n for ngram in ngrams_ref.keys():\\n ngrams[ngram] = max(ngrams[ngram], ngrams_ref[ngram])\\n\\n return ngrams, closest_diff, closest_len\",\n \"def rouge_score(references, generated):\\r\\n score = rouge(generated, references)\\r\\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\\r\\n '''\\r\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\r\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\r\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\r\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\r\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\r\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\r\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\r\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\r\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\r\\n '''\\r\\n return rouge_s\",\n \"def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\\n # sanity check\\n assert len(list_of_references) == len(\\n hypotheses\\n ), \\\"The number of hypotheses and their reference(s) should be the same\\\"\\n\\n # sum matches and max-token-lengths over all sentences\\n corpus_n_match = 0\\n corpus_n_all = 0\\n\\n for references, hypothesis in zip(list_of_references, hypotheses):\\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\\n\\n hyp_counts = []\\n for reference in references:\\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\\n\\n overlap_ngrams = ref_ngrams & hyp_ngrams\\n tp = sum(overlap_ngrams.values()) # True positives.\\n\\n # While GLEU is defined as the minimum of precision and\\n # recall, we can reduce the number of division operations by one by\\n # instead finding the maximum of the denominators for the precision\\n # and recall formulae, since the numerators are the same:\\n # precision = tp / tpfp\\n # recall = tp / tpfn\\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\\n n_all = max(tpfp, tpfn)\\n\\n if n_all > 0:\\n hyp_counts.append((tp, n_all))\\n\\n # use the reference yielding the highest score\\n if hyp_counts:\\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\\n corpus_n_match += n_match\\n corpus_n_all += n_all\\n\\n # corner case: empty corpus or empty references---don't divide by zero!\\n if corpus_n_all == 0:\\n gleu_score = 0.0\\n else:\\n gleu_score = corpus_n_match / corpus_n_all\\n\\n return gleu_score\",\n \"def bleu_stats(hypo, ref, bleu_len=5):\\n stats = list()\\n stats.append(len(hypo))\\n stats.append(len(ref))\\n for n in range(1, bleu_len):\\n s_ngrams = Counter([tuple(hypo[i:i+n]) for i in range(len(hypo)+1-n)])\\n r_ngrams = Counter([tuple(ref[i:i+n]) for i in range(len(ref)+1-n)])\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypo) + 1-n, 0]))\\n return stats\",\n \"def bleu_score(ref_file, hyp_file):\\n command = 'perl scripts/multi-bleu.pl ' + ref_file + ' < ' + hyp_file\\n c = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\\n details, error = c.communicate()\\n details, error = details.decode('utf-8'), error.decode('utf-8')\\n if not details.startswith('BLEU ='):\\n raise ValueError('Error in BLEU score computation:\\\\n%s' % error)\\n else:\\n BLEU_str = details.split(' ')[2][:-1]\\n BLEU = float(BLEU_str)\\n return BLEU, details\",\n \"def compute_bleu(self, ref_ids_list: Iterable[Iterable[int]], hyp_ids_list: Iterable[Iterable[int]],\\n ref_is_tensor: bool = False, hyp_is_tensor: bool = False,\\n reader_level: ReaderLevel=ReaderLevel.WORD) -> Tuple[float, str, str]:\\n assert len(ref_ids_list) == len(hyp_ids_list)\\n refs = self.target_sentensify_all(ref_ids_list, input_is_tensor=ref_is_tensor, reader_level=reader_level)\\n hyps = self.target_sentensify_all(hyp_ids_list, input_is_tensor=hyp_is_tensor, reader_level=reader_level)\\n scores = [sentence_bleu(hyps[sid], refs[sid]) for sid in range(len(ref_ids_list))]\\n random_index = choice(range(len(refs)))\\n return sum(scores) / len(scores), refs[random_index], hyps[random_index]\",\n \"def calculate_reference(gram_list, references):\\r\\n gram_sub_str = ' '.join(gram_list)\\r\\n gram_count = []\\r\\n for item in references:\\r\\n # calculate the count of the sub string\\r\\n gram_count.append(len(re.findall(gram_sub_str, item)))\\r\\n return gram_count\",\n \"def sentence_accuracy(references, predictions):\\n count = 0.0\\n match = 0.0\\n for label, pred in zip(references, predictions):\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def compute_score(predictions, references, vocab=None, beam_size=4):\\n assert np.rank(predictions) == 3\\n assert predictions.shape[0] == references.shape[0]\\n batch_size = predictions.shape[0]\\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\\n hypotheses_list = []\\n references_list = []\\n\\n for index in range(batch_size):\\n # All predictions in beam search are used for validation scores.\\n for b_index in range(beam_size):\\n h = predictions[index][b_index]\\n try:\\n eos_index = h.index(input_utils.EOS)\\n except ValueError:\\n eos_index = len(h)\\n hypotheses_list.append(h[:eos_index])\\n\\n ref = references[index][0].decode().split('|')\\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\\n references_list.append(ref_list)\\n\\n all_scores = collections.defaultdict(list)\\n for hypothesis, references in zip(hypotheses_list, references_list):\\n if vocab is not None and len(vocab):\\n # Skip PADDING, UNK, EOS, START (0-3).\\n hypothesis = [\\n vocab[word_id].numpy().decode()\\n for word_id in hypothesis\\n if word_id > 3\\n ]\\n\\n h_str = ' '.join(str(e) for e in hypothesis)\\n r_str = [' '.join(str(e) for e in ref) for ref in references]\\n\\n print('hypothesis: ', str(h_str))\\n print('references: ', str(r_str))\\n print('\\\\n')\\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\\n for key, score in scores.items():\\n all_scores[key].append(score)\\n score_names = [\\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\\n ]\\n\\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]\",\n \"def calculate_reference(gram_list, references):\\n gram_sub_str = ' '.join(gram_list)\\n gram_count = []\\n for item in references:\\n # calculate the count of the sub string\\n gram_count.append(len(re.findall(gram_sub_str, item)))\\n return gram_count\",\n \"def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n ngram_counter_clip = preds_counter & target_counter\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n return preds_len, target_len\",\n \"def _calc_multiple_alignment_score(wrapped_data : tuple) -> int: \\n (start, finish) = wrapped_data \\n score_sum = 0.\\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\\\"Training process\\\"):\\n score_sum += self.aligner.score(seq, dna_record.seq)\\n return score_sum\",\n \"def get_bleu(hypo, ref, seq_len=10, bleu_len=5):\\n stats = np.array([0.]*seq_len)\\n for h, r in zip(hypo, ref):\\n h = np.trim_zeros(h)\\n r = np.trim_zeros(r)\\n stats += np.array(bleu_stats(h, r, bleu_len))\\n return 100 * bleu(stats)\",\n \"def score(self, *args, references=[], candidates=[], batch_size=None):\\n assert not args, (\\n \\\"The score function does not accept positional arguments. Please \\\"\\n \\\"specify the name of the arguments explicitly, i.e., \\\"\\n \\\"`score(references=..., candidates=...`)\\\")\\n\\n candidates, references = list(candidates), list(references)\\n assert len(candidates) == len(references), (\\n \\\"The number of candidate sentences must match the number of \\\"\\n \\\"reference sentences.\\\")\\n if not candidates:\\n return []\\n\\n if not batch_size:\\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\\n\\n all_results = []\\n for i in range(0, len(candidates), batch_size):\\n batch_ref = references[i:i + batch_size]\\n batch_cand = candidates[i:i + batch_size]\\n\\n if self.serialize_input:\\n tfrecords = [\\n encoding.serialize_raw_example(r, c)\\n for (r, c) in zip(batch_ref, batch_cand)\\n ]\\n predict_out = self.bleurt_model_ops(\\n examples=tf.constant(tfrecords))[\\\"predictions\\\"].numpy()\\n else:\\n predict_out = self.bleurt_model_ops(\\n references=tf.constant(batch_ref),\\n candidates=tf.constant(batch_cand))[\\\"predictions\\\"].numpy()\\n\\n batch_results = predict_out.tolist()\\n all_results.extend(batch_results)\\n\\n assert len(all_results) == len(candidates), (\\n \\\"Number of predictions does not match sentences: {} vs. {}\\\".format(\\n len(all_results), len(candidates)))\\n return all_results\",\n \"def chainFn(alignedSegments, refSeq, readSeq, scoreFn=\\\\\\n lambda alignedSegment, refSeq, readSeq : \\\\\\n sum([ length for op, length in alignedSegment.cigar if op == 0]), maxGap=200):\\n #Score function is number of aligned pairs\\n def getStartAndEndCoordinates(alignedSegment):\\n \\\"\\\"\\\"Gets the start and end coordinates in both the reference and query, using coordinates\\n relative to the original read and reference equence\\n \\\"\\\"\\\"\\n return alignedSegment.reference_start, getFirstNonClippedPositionInRead(alignedSegment, readSeq), \\\\\\n alignedSegment.reference_end-1, getLastNonClippedPositionInRead(alignedSegment, readSeq) \\n \\n alignedSegmentToScores = dict([ (aR, scoreFn(aR, refSeq, readSeq)) for aR in alignedSegments])\\n alignedSegmentToCoordinates = dict([ (aR, getStartAndEndCoordinates(aR)) for \\\\\\n aR in alignedSegments])\\n alignedSegmentPointers = {}\\n \\n #Currently uses sloppy quadratic algorithm to find highest chain\\n alignedSegments = sorted(alignedSegments, key=lambda aR : alignedSegmentToCoordinates[aR][0]) \\n #Sort by reference coordinate\\n for i in xrange(len(alignedSegments)):\\n aR = alignedSegments[i]\\n rStart, qStart, rEnd, qEnd = alignedSegmentToCoordinates[aR]\\n score = alignedSegmentToScores[aR]\\n for j in xrange(i): #Look at earlier alignments in list\\n aR2 = alignedSegments[j]\\n rStart2, qStart2, rEnd2, qEnd2 = alignedSegmentToCoordinates[aR2]\\n assert rStart2 <= rStart\\n if rStart > rEnd2 and qStart > qEnd2 and aR.is_reverse == aR2.is_reverse and \\\\\\n rStart - rEnd2 + qStart - qEnd2 <= maxGap and \\\\\\n score + alignedSegmentToScores[aR2] > alignedSegmentToScores[aR]: \\n #Conditions for a chain\\n alignedSegmentToScores[aR] = score + alignedSegmentToScores[aR2]\\n alignedSegmentPointers[aR] = aR2\\n \\n #Now find highest scoring alignment \\n aR = max(alignedSegments, key=lambda aR : alignedSegmentToScores[aR])\\n \\n #Construct chain of alignedSegments\\n chain = [ aR ]\\n while aR in alignedSegmentPointers:\\n aR = alignedSegmentPointers[aR]\\n chain.append(aR)\\n chain.reverse()\\n \\n return chain\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def evaluate_bleu_score(cls, predictions, targets, ticks=False, corpus=True):\\n if ticks:\\n ref_sentences = cls._ticks_to_sentences(targets)\\n cand_sentences = cls._ticks_to_sentences(predictions)\\n else:\\n ref_sentences = [[str(x) for x in seq] for seq in predictions]\\n cand_sentences = [[str(x) for x in seq] for seq in targets]\\n\\n if corpus: bleu_score = corpus_bleu([[l] for l in ref_sentences], cand_sentences)\\n else:\\n bleu_score = 0.0\\n num_sentences = 0\\n\\n for i in tqdm(range(len(ref_sentences))):\\n sentence_bleu_score = sentence_bleu(ref_sentences[i], cand_sentences[i])\\n print(sentence_bleu_score)\\n bleu_score += sentence_bleu_score\\n num_sentences += 1\\n\\n bleu_score /= num_sentences\\n\\n return bleu_score\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def score(self, *args, references=[], candidates=[], batch_size=None):\\n assert not args, (\\n \\\"The score function does not accept positional arguments. Please \\\"\\n \\\"specify the name of the arguments explicitly, i.e., \\\"\\n \\\"`score(references=..., candidates=...`)\\\")\\n\\n candidates, references = list(candidates), list(references)\\n assert len(candidates) == len(references), (\\n \\\"The number of candidate sentences must match the number of \\\"\\n \\\"reference sentences.\\\")\\n if not candidates:\\n return []\\n\\n if not batch_size:\\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\\n\\n all_results = []\\n for i in range(0, len(candidates), batch_size):\\n batch_ref = references[i:i + batch_size]\\n batch_cand = candidates[i:i + batch_size]\\n input_ids, input_mask, segment_ids = encoding.encode_batch(\\n batch_ref, batch_cand, self.tokenizer, self.max_seq_length)\\n tf_input = {\\n \\\"input_ids\\\": input_ids,\\n \\\"input_mask\\\": input_mask,\\n \\\"segment_ids\\\": segment_ids\\n }\\n predict_out = self._predictor.predict(tf_input)\\n batch_results = predict_out.tolist()\\n all_results.extend(batch_results)\\n\\n assert len(all_results) == len(candidates), (\\n \\\"Number of predictions does not match sentences: {} vs. {}\\\".format(\\n len(all_results), len(candidates)))\\n return all_results\",\n \"def word_accuracy(references, predictions):\\n total_acc, total_count = 0., 0.\\n for labels, preds in zip(references, predictions):\\n match = 0.0\\n for pos in range(min(len(labels), len(preds))):\\n label = labels[pos]\\n pred = preds[pos]\\n if label == pred:\\n match += 1\\n total_acc += 100 * match / max(len(labels), len(preds))\\n total_count += 1\\n return total_acc / total_count\",\n \"def rouge_l_sentence_level(eval_sentences, ref_sentences):\\n\\n f1_scores = []\\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\\n m = float(len(ref_sentence))\\n n = float(len(eval_sentence))\\n lcs = _len_lcs(eval_sentence, ref_sentence)\\n f1_scores.append(_f_lcs(lcs, m, n))\\n return np.mean(f1_scores, dtype=np.float32)\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def bleu_stats(hypothesis, reference):\\n stats = []\\n stats.append(len(hypothesis))\\n stats.append(len(reference))\\n for n in range(1, 5):\\n s_ngrams = Counter(\\n [tuple(hypothesis[i:i + n]) for i in range(len(hypothesis) + 1 - n)]\\n )\\n r_ngrams = Counter(\\n [tuple(reference[i:i + n]) for i in range(len(reference) + 1 - n)]\\n )\\n stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\\n stats.append(max([len(hypothesis) + 1 - n, 0]))\\n return stats\",\n \"def corpus_score(self, sys_stream: Union[str, Iterable[str]],\\n ref_streams: Union[str, List[Iterable[str]]],\\n use_effective_order: bool = False) -> BLEUScore:\\n\\n # Add some robustness to the input arguments\\n if isinstance(sys_stream, str):\\n sys_stream = [sys_stream]\\n\\n if isinstance(ref_streams, str):\\n ref_streams = [[ref_streams]]\\n\\n sys_len = 0\\n ref_len = 0\\n\\n correct = [0 for n in range(self.NGRAM_ORDER)]\\n total = [0 for n in range(self.NGRAM_ORDER)]\\n\\n # look for already-tokenized sentences\\n tokenized_count = 0\\n\\n fhs = [sys_stream] + ref_streams\\n for lines in zip_longest(*fhs):\\n if None in lines:\\n raise EOFError(\\\"Source and reference streams have different lengths!\\\")\\n\\n if self.lc:\\n lines = [x.lower() for x in lines]\\n\\n if not (self.force or self.tokenizer.signature() == 'none') and lines[0].rstrip().endswith(' .'):\\n tokenized_count += 1\\n\\n output, *refs = [self.tokenizer(x.rstrip()) for x in lines]\\n\\n output_len = len(output.split())\\n ref_ngrams, closest_diff, closest_len = CachedBLEU.reference_stats(refs, output_len)\\n\\n sys_len += output_len\\n ref_len += closest_len\\n\\n sys_ngrams = CachedBLEU.extract_ngrams(output)\\n for ngram in sys_ngrams.keys():\\n n = len(ngram.split())\\n correct[n - 1] += min(sys_ngrams[ngram], ref_ngrams.get(ngram, 0))\\n total[n - 1] += sys_ngrams[ngram]\\n\\n # Get BLEUScore object\\n score = self.compute_bleu(\\n correct, total, sys_len, ref_len,\\n smooth_method=self.smooth_method, smooth_value=self.smooth_value,\\n use_effective_order=use_effective_order)\\n\\n return score\",\n \"def get_multiple_align_score(self, seq : Seq, dna_sequences : numpy_array, tasks : list, pool : ThreadPool) -> float: \\n def _calc_multiple_alignment_score(wrapped_data : tuple) -> int:\\n \\\"\\\"\\\"return value is a sum of all alignment scores in input rangerange.\\\"\\\"\\\" \\n (start, finish) = wrapped_data \\n score_sum = 0.\\n for dna_record in tqdm(dna_sequences[start : finish + 1], total=(finish + 1 - start), desc=\\\"Training process\\\"):\\n score_sum += self.aligner.score(seq, dna_record.seq)\\n return score_sum\\n return sum(s for s in pool.map(_calc_multiple_alignment_score, tasks))\",\n \"def score(self, *args, references=[], candidates=[], batch_size=None):\\n assert not args, (\\n \\\"The score function does not accept positional arguments. Please \\\"\\n \\\"specify the name of the arguments explicitly, i.e., \\\"\\n \\\"`score(references=..., candidates=...`)\\\")\\n\\n candidates, references = list(candidates), list(references)\\n assert len(candidates) == len(references), (\\n \\\"The number of candidate sentences must match the number of \\\"\\n \\\"reference sentences.\\\")\\n n_items = len(candidates)\\n if not candidates:\\n return []\\n\\n if not batch_size:\\n batch_size = DEFAULT_BLEURT_BATCH_SIZE\\n\\n # Sorts the sentences by length.\\n input_ids, input_mask, segment_ids = encoding.encode_batch(\\n references, candidates, self.tokenizer, self.max_seq_length)\\n seq_lengths = np.sum(input_mask, axis=1)\\n sorted_indices = np.argsort(seq_lengths)\\n assert sorted_indices.shape[0] == n_items\\n\\n all_results = np.repeat(self.DEFAULT_SCORE, n_items).astype(np.float64)\\n batch_lens = []\\n for i in range(0, n_items, batch_size):\\n\\n # Gets the ids of the examples in the batch.\\n batch_indices = sorted_indices[i:i + batch_size]\\n\\n # Computes the max sequence length.\\n batch_lenghts = seq_lengths[batch_indices]\\n batch_max_len = max(max(batch_lenghts), 1)\\n batch_lens.append(batch_max_len)\\n\\n # Retrieves the examples and truncates the extra padding.\\n batch_input_ids = input_ids[batch_indices, :batch_max_len]\\n batch_input_mask = input_mask[batch_indices, :batch_max_len]\\n batch_segment_ids = segment_ids[batch_indices, :batch_max_len]\\n\\n # Runs the inference.\\n tf_input = {\\n \\\"input_ids\\\": batch_input_ids,\\n \\\"input_mask\\\": batch_input_mask,\\n \\\"segment_ids\\\": batch_segment_ids\\n }\\n predict_out = self._predictor.predict(tf_input)\\n\\n # Scatters the scores.\\n all_results[batch_indices] = predict_out\\n\\n assert np.all(all_results > -1000), (\\n \\\"Something went wrong while running the dynamic batching scorer.\\\")\\n all_results = list(all_results)\\n assert len(all_results) == n_items, (\\n \\\"Number of predictions does not match sentences: {} vs. {}\\\".format(\\n len(all_results), len(candidates)))\\n\\n logging.info(\\\"Average batch sequence length: {}\\\".format(\\n np.mean(batch_lens)))\\n\\n return all_results\",\n \"def _bleu_score_update(\\n preds: Sequence[str],\\n target: Sequence[Sequence[str]],\\n numerator: Tensor,\\n denominator: Tensor,\\n preds_len: Tensor,\\n target_len: Tensor,\\n n_gram: int = 4,\\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\\n) -> Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\\n\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n\\n ngram_counter_clip = preds_counter & target_counter\\n\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n\\n return preds_len, target_len\",\n \"def link_text_score(self, rows, wordids):\\n # create default score of 0 fro each url\\n linkscores = dict([(row[0], 0) for row in rows])\\n for wordid in wordids:\\n # get all the links\\n cur = self.con.execute('select link.fromid,link.toid from linkwords,link where wordid=%d and linkwords.linkid=link.rowid' % wordid)\\n for (fromid, toid) in cur:\\n if toid in linkscores:\\n # if word is in the link, get the links page score\\n page_rank = self.con.execute('select score from pagerank where urlid=%d'\\n % fromid).fetchone()[0]\\n linkscores[toid] += page_rank\\n maxscore = max(linkscores.values())\\n if not maxscore:\\n maxscore = 0.00001\\n normalizedscores = dict([(u, float(l) / maxscore) for (u, l) in linkscores.items()])\\n return normalizedscores\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n\\n matched = \\\"\\\" # to hold string displaying alignments\\n score = 0\\n for i in range(l2):\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" # * indicates a match\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\" # - indicates no match\\n\\n return score\",\n \"def recall(self) -> float:\\n if self.ref_ignored:\\n num_ref_ignored = len(self.ref_set) - len(self.ref_unignored_set)\\n self.num_ignored += num_ref_ignored\\n # True Positive = the number of unignored reference mappings that are Positive\\n tp = len(self.ref_unignored_set.intersection(self.pre_set))\\n # False Negative = the number of unignored reference mappings that are Negative\\n fn = len(self.ref_set) - tp - num_ref_ignored\\n return tp / (tp + fn)\",\n \"def calculate_score(result):\\n sample1=result['Sample1']\\n sample2=result['Sample2']\\n string1=paragraph_to_list(sample1)\\n string2=paragraph_to_list(sample2)\\n \\n return round( strings_similarity(string1, string2), 2)\\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\\n #return round(0.5*(method_difflab+method_dict), 2)\",\n \"def score(stripe1, stripe2):\\n scr = 0\\n count = 0\\n for p1, p2 in zip(stripe1, stripe2):\\n r = abs(p1[0] - p2[0])\\n g = abs(p1[1] - p2[1])\\n b = abs(p1[2] - p2[2])\\n scr += r + g + b\\n return scr\",\n \"def compute_bleu(correct: List[int],\\n total: List[int],\\n sys_len: int,\\n ref_len: int,\\n smooth_method = 'none',\\n smooth_value = None,\\n use_effective_order = False) -> BLEU:\\n if smooth_method in SMOOTH_VALUE_DEFAULT and smooth_value is None:\\n smooth_value = SMOOTH_VALUE_DEFAULT[smooth_method]\\n\\n precisions = [0 for x in range(NGRAM_ORDER)]\\n\\n smooth_mteval = 1.\\n effective_order = NGRAM_ORDER\\n for n in range(1, NGRAM_ORDER + 1):\\n if smooth_method == 'add-k' and n > 1:\\n correct[n-1] += smooth_value\\n total[n-1] += smooth_value\\n if total[n-1] == 0:\\n break\\n\\n if use_effective_order:\\n effective_order = n\\n\\n if correct[n-1] == 0:\\n if smooth_method == 'exp':\\n smooth_mteval *= 2\\n precisions[n-1] = 100. / (smooth_mteval * total[n-1])\\n elif smooth_method == 'floor':\\n precisions[n-1] = 100. * smooth_value / total[n-1]\\n else:\\n precisions[n-1] = 100. * correct[n-1] / total[n-1]\\n\\n # If the system guesses no i-grams, 1 <= i <= NGRAM_ORDER, the BLEU score is 0 (technically undefined).\\n # This is a problem for sentence-level BLEU or a corpus of short sentences, where systems will get no credit\\n # if sentence lengths fall under the NGRAM_ORDER threshold. This fix scales NGRAM_ORDER to the observed\\n # maximum order. It is only available through the API and off by default\\n\\n brevity_penalty = 1.0\\n if sys_len < ref_len:\\n brevity_penalty = math.exp(1 - ref_len / sys_len) if sys_len > 0 else 0.0\\n\\n score = brevity_penalty * math.exp(sum(map(my_log, precisions[:effective_order])) / effective_order)\\n\\n return BLEU(score, correct, total, precisions, brevity_penalty, sys_len, ref_len)\",\n \"def calculate_score(origin, sentences):\\n result = 0\\n if len(origin):\\n result=sum(compare_with_bounds(origin, sentence) for sentence in sentences) / float(len(sentences))\\n return result\",\n \"def sentence_score(self, hypothesis: str, references: List[str]) -> CHRFScore:\\n hypothesis, references = references[0], [hypothesis]\\n\\n assert not isinstance(references, str), \\\\\\n \\\"sentence_score needs a list of references, not a single string\\\"\\n stats = self.get_sentence_statistics(hypothesis, references)\\n return self.compute_chrf(stats, self.order, self.beta)\",\n \"def complementary_score(s1, s2) -> int:\\n aligner = Align.PairwiseAligner()\\n aligner.mode = 'local'\\n aligner.open_gap_score = -1000 # Don't want any gaps!\\n # score = the number of complementary nucleotides between s1 and s2.\\n return aligner.score(str(s1), str(s2.complement()))\",\n \"def score(self, valid_preds: Union[pd.DataFrame, np.ndarray]) -> float:\\n\\n valid_preds.columns = [\\\"id\\\"] + self.valid_target_columns\\n valid_preds = self.valid_df[self.id_columns].merge(valid_preds, how = \\\"left\\\", on = \\\"id\\\")\\n self.valid_preds = self.trans_30490_to_42840(valid_preds, self.valid_target_columns)\\n self.rmsse = self.get_rmsse(self.valid_preds)\\n self.contributors = pd.concat([self.weights, self.rmsse], axis = 1, sort = False).prod(axis = 1)\\n \\n return np.sum(self.contributors)\",\n \"def _bleu_score_compute(preds_len: Tensor, target_len: Tensor, numerator: Tensor, denominator: Tensor, n_gram: int, weights: Sequence[float], smooth: bool) ->Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n if smooth:\\n precision_scores = torch.div(torch.add(numerator, torch.ones(n_gram, device=device)), torch.add(denominator, torch.ones(n_gram, device=device)))\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - target_len / preds_len)\\n bleu = brevity_penalty * geometric_mean\\n return bleu\",\n \"def get_bleu(ref, hyp, tokenization=\\\"intl\\\"):\\n BLEU = corpus_bleu(hyp, [ref], tokenize=tokenization)\\n return BLEU.score\",\n \"def match_score(seq1, seq2):\\n\\n seq1 = get_sequence_string(seq1)\\n seq2 = get_sequence_string(seq2)\\n score = align.localxx(seq1, seq2)[0][2]\\n return score\",\n \"def _rouge(ref_file, summarization_file, subword_option=None):\\n\\n references = []\\n with codecs.getreader(\\\"utf-8\\\")(tf.gfile.GFile(ref_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n references.append(_clean(line, subword_option))\\n\\n hypotheses = []\\n with codecs.getreader(\\\"utf-8\\\")(\\n tf.gfile.GFile(summarization_file, \\\"rb\\\")) as fh:\\n for line in fh:\\n hypotheses.append(_clean(line, subword_option=subword_option))\\n\\n rouge_score_map = rouge.rouge(hypotheses, references)\\n return 100 * rouge_score_map[\\\"rouge_l/f_score\\\"]\",\n \"def compare(strokes1, strokes2):\\n\\n score = 0\\n for stroke_i in strokes1:\\n match = identify(strokes2, stroke_i)\\n score += match\\n\\n # draw1 = concat(strokes1)\\n # draw2 = concat(strokes2)\\n # draw1_length,_ = draw1.euclidian_length()\\n # draw2_length,_ = draw2.euclidian_length()\\n\\n # tot_length = draw1_length# + draw2_length\\n\\n return score\",\n \"def _score_sentence(self, feats, tags):\\n score = torch.zeros((self.batch_size,1), device=self.device)\\n tags = torch.cat([torch.full((self.batch_size, 1, 1), self.tag2idx[START_TAG], dtype=torch.long, device=self.device), tags],dim=1)\\n for i in range(feats.shape[1]):\\n feat = feats[:,i,:]\\n \\n score = score + self.transitions[tags[:,i+1], tags[:,i]] + feat.gather(dim=-1, index=tags[:,i+1])\\n \\n score = score + self.transitions[self.tag2idx[STOP_TAG], tags[:,-1]]\\n\\n return score\",\n \"def get_bleu(hypotheses, reference):\\n stats = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\\n for hyp, ref in zip(hypotheses, reference):\\n stats += np.array(bleu_stats(hyp, ref))\\n return 100 * bleu(stats)\",\n \"def _calc_refs(counts):\\n refs = 0\\n for allele in counts.keys():\\n refs += counts[allele]\\n return refs\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2):\\n #moves shorter sequence along longer, counting number of matches in\\n #each position\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\"\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\"\\n\\n # gives an output for each startpoint showing the number of matches where\\n # * is a match and - is no match, position of the two sequences relative to\\n # each other, and the number of matches for that startpoint.\\n print(\\\".\\\" * startpoint + matched) \\n print(\\\".\\\" * startpoint + s2)\\n print(s1)\\n print(score) \\n print(\\\" \\\")\\n\\n return score\",\n \"def word_error_rate(hypotheses, references):\\n\\n scores = 0\\n words = 0\\n len_diff = len(references) - len(hypotheses)\\n if len_diff > 0:\\n raise ValueError(\\\"Uneqal number of hypthoses and references: \\\"\\n \\\"{0} and {1}\\\".format(len(hypotheses), len(references)))\\n elif len_diff < 0:\\n hypotheses = hypotheses[:len_diff]\\n\\n for h, r in zip(hypotheses, references):\\n h_list = h.split()\\n r_list = r.split()\\n words += len(r_list)\\n scores += __levenshtein(h_list, r_list)\\n if words != 0:\\n wer = 1.0*scores/words\\n else:\\n wer = float('inf')\\n return wer, scores, words\",\n \"def compute_path_score(self, pre_scores, label):\\n point_score = tf.reduce_sum(tf.reduce_sum(pre_scores * label, axis=2), 1, keep_dims=True)\\n label1 = tf.expand_dims(label[:, :-1], 3)\\n label2 = tf.expand_dims(label[:, 1:], 2)\\n label = label1 * label2\\n trans = tf.expand_dims(tf.expand_dims(self.trans, 0), 0)\\n trans_score = tf.reduce_sum(tf.reduce_sum(label * trans, [2, 3]), 1, keep_dims=True)\\n return point_score + trans_score\",\n \"def bert_score(preds: Union[List[str], Dict[str, Tensor]], target: Union[List[str], Dict[str, Tensor]], model_name_or_path: Optional[str]=None, num_layers: Optional[int]=None, all_layers: bool=False, model: Optional[Module]=None, user_tokenizer: Any=None, user_forward_fn: Callable[[Module, Dict[str, Tensor]], Tensor]=None, verbose: bool=False, idf: bool=False, device: Optional[Union[str, torch.device]]=None, max_length: int=512, batch_size: int=64, num_threads: int=4, return_hash: bool=False, lang: str='en', rescale_with_baseline: bool=False, baseline_path: Optional[str]=None, baseline_url: Optional[str]=None) ->Dict[str, Union[List[float], str]]:\\n if len(preds) != len(target):\\n raise ValueError('Number of predicted and reference sententes must be the same!')\\n if verbose and not _TQDM_AVAILABLE:\\n raise ModuleNotFoundError('An argument `verbose = True` requires `tqdm` package be installed. Install with `pip install tqdm`.')\\n if model is None:\\n if not _TRANSFORMERS_AVAILABLE:\\n raise ModuleNotFoundError('`bert_score` metric with default models requires `transformers` package be installed. Either install with `pip install transformers>=4.0` or `pip install torchmetrics[text]`.')\\n if model_name_or_path is None:\\n warn(f'The argument `model_name_or_path` was not specified while it is required when default `transformers` model are used.It is, therefore, used the default recommended model - {_DEFAULT_MODEL}.')\\n tokenizer = AutoTokenizer.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\\n model = AutoModel.from_pretrained(model_name_or_path or _DEFAULT_MODEL)\\n else:\\n tokenizer = user_tokenizer\\n model.eval()\\n model\\n try:\\n if num_layers and num_layers > model.config.num_hidden_layers:\\n raise ValueError(f'num_layers={num_layers} is forbidden for {model_name_or_path}. Please use num_layers <= {model.config.num_hidden_layers}')\\n except AttributeError:\\n warn('It was not possible to retrieve the parameter `num_layers` from the model specification.')\\n _are_empty_lists = all(isinstance(text, list) and len(text) == 0 for text in (preds, target))\\n _are_valid_lists = all(isinstance(text, list) and len(text) > 0 and isinstance(text[0], str) for text in (preds, target))\\n _are_valid_tensors = all(isinstance(text, dict) and isinstance(text['input_ids'], Tensor) for text in (preds, target))\\n if _are_empty_lists:\\n warn('Predictions and references are empty.')\\n output_dict: Dict[str, Union[List[float], str]] = {'precision': [0.0], 'recall': [0.0], 'f1': [0.0]}\\n if return_hash:\\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\\n return output_dict\\n baseline = _load_baseline(lang, model_name_or_path, baseline_path, baseline_url) if rescale_with_baseline else None\\n if _are_valid_lists:\\n target_dataset = TextDataset(target, tokenizer, max_length, idf=idf)\\n preds_dataset = TextDataset(preds, tokenizer, max_length, idf=idf, tokens_idf=target_dataset.tokens_idf)\\n elif _are_valid_tensors:\\n target_dataset = TokenizedDataset(**target, idf=idf)\\n preds_dataset = TokenizedDataset(**preds, idf=idf, tokens_idf=target_dataset.tokens_idf)\\n else:\\n raise ValueError('Invalid input provided.')\\n target_loader = DataLoader(target_dataset, batch_size=batch_size, num_workers=num_threads)\\n preds_loader = DataLoader(preds_dataset, batch_size=batch_size, num_workers=num_threads)\\n target_embeddings, target_idf_scale = _get_embeddings_and_idf_scale(target_loader, target_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\\n preds_embeddings, preds_idf_scale = _get_embeddings_and_idf_scale(preds_loader, preds_dataset.max_length, model, device, num_layers, all_layers, idf, verbose, user_forward_fn)\\n precision, recall, f1_score = _get_precision_recall_f1(preds_embeddings, target_embeddings, preds_idf_scale, target_idf_scale)\\n if baseline is not None:\\n precision, recall, f1_score = _rescale_metrics_with_baseline(precision, recall, f1_score, baseline, num_layers, all_layers)\\n output_dict = {'precision': precision.tolist(), 'recall': recall.tolist(), 'f1': f1_score.tolist()}\\n if return_hash:\\n output_dict.update({'hash': _get_hash(model_name_or_path, num_layers, idf)})\\n return output_dict\",\n \"def substitution_score(substitution_matrix, seqA, seqB):\\n return sum(compute_score_by_position(substitution_matrix, seqA, seqB))\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2): \\n if (i + startpoint) < (l1 + l2 - 1): \\n if l2 - i > startpoint + 1:\\n matched = matched + \\\".\\\" #dots before they start overlapping\\n elif s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" #matched bases\\n score = score + 1 #adds one to score\\n else:\\n matched = matched + \\\"-\\\" #not matched bases\\n shift, end_shift = startpoint * \\\".\\\", (l2 + l1 - startpoint - 2) * \\\".\\\"\\n # dots at end, but only up until end of dots tailing l1\\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\\n # this formula. the below check stops it from getting less than l2.\\n if startpoint < l1 - 1:\\n print(shift + matched + end_shift)\\n else:\\n print(shift + matched + (l2 - 1) * \\\".\\\")\\n print(shift + s2 + end_shift)\\n print(s1)\\n print(str(score) + \\\"\\\\n\\\")\\n return score, matched, shift, end_shift\",\n \"def compute_metrics_from_files(p_path_to_reference_file,\\r\\n p_path_to_candidate_file,\\r\\n p_max_bleu_order):\\r\\n\\r\\n reference_dictionary, reference_no_answer_query_ids = \\\\\\r\\n load_file(p_path_to_reference_file)\\r\\n candidate_dictionary, candidate_no_answer_query_ids = load_file(p_path_to_candidate_file)\\r\\n query_id_answerable = set(reference_dictionary.keys())-reference_no_answer_query_ids\\r\\n query_id_answerable_candidate = set(candidate_dictionary.keys())-candidate_no_answer_query_ids\\r\\n \\r\\n true_positives = len(query_id_answerable_candidate.intersection(query_id_answerable))\\r\\n false_negatives = len(query_id_answerable)-true_positives\\r\\n true_negatives = len(candidate_no_answer_query_ids.intersection(reference_no_answer_query_ids))\\r\\n false_positives = len(reference_no_answer_query_ids)-true_negatives\\r\\n precision = float(true_positives)/(true_positives+false_positives) if (true_positives+false_positives)>0 else 1.\\r\\n recall = float(true_positives)/(true_positives+false_negatives) if (true_positives+false_negatives)>0 else 1.\\r\\n F1 = 2 *((precision*recall)/(precision+recall))\\r\\n filtered_reference_dictionary = \\\\\\r\\n {key: value for key, value in reference_dictionary.items() \\\\\\r\\n if key not in reference_no_answer_query_ids}\\r\\n\\r\\n filtered_candidate_dictionary = \\\\\\r\\n {key: value for key, value in candidate_dictionary.items() \\\\\\r\\n if key not in reference_no_answer_query_ids}\\r\\n\\r\\n for query_id, answers in filtered_candidate_dictionary.items():\\r\\n assert \\\\\\r\\n len(answers) <= 1, \\\\\\r\\n 'query_id %d contains more than 1 answer \\\\\\\"%s\\\\\\\" in candidate file' % \\\\\\r\\n (query_id, str(answers))\\r\\n\\r\\n reference_query_ids = set(filtered_reference_dictionary.keys())\\r\\n candidate_query_ids = set(filtered_candidate_dictionary.keys())\\r\\n common_query_ids = reference_query_ids.intersection(candidate_query_ids)\\r\\n assert (len(common_query_ids) == len(reference_query_ids)) and \\\\\\r\\n (len(common_query_ids) == len(candidate_query_ids)), \\\\\\r\\n 'Reference and candidate files must share same query ids'\\r\\n\\r\\n all_scores = {}\\r\\n bleu_scores, _ = \\\\\\r\\n Bleu(p_max_bleu_order).compute_score(filtered_reference_dictionary, \\\\\\r\\n filtered_candidate_dictionary)\\r\\n for i, bleu_score in enumerate(bleu_scores):\\r\\n all_scores['bleu_%d' % (i+1)] = bleu_score\\r\\n\\r\\n rouge_score, _ = Rouge().compute_score(filtered_reference_dictionary, \\\\\\r\\n filtered_candidate_dictionary)\\r\\n all_scores['rouge_l'] = rouge_score\\r\\n all_scores['F1'] = F1\\r\\n similarity = 0\\r\\n for key in filtered_reference_dictionary:\\r\\n candidate_answer = nlp(filtered_candidate_dictionary[key][0])\\r\\n reference_answer = filtered_reference_dictionary[key]\\r\\n answersimilarity = 0\\r\\n for answer in reference_answer:\\r\\n answersimilarity += candidate_answer.similarity(nlp(answer))\\r\\n similarity += answersimilarity/len(reference_answer)\\r\\n semantic_similarity = similarity/len(filtered_reference_dictionary)\\r\\n all_scores['Semantic_Similarity'] = semantic_similarity\\r\\n return all_scores\",\n \"def _score(self, features: Tensor, tags: Tensor, masks: Tensor):\\n \\n B, T, H = features.shape\\n\\n emit_scores = features.gather(dim=2, index=tags.unsqueeze(dim=-1)).squeeze(-1)\\n\\n start_tag = torch.full((B, 1), fill_value=self.start_idx, dtype=torch.long, device=self.device)\\n tags = torch.cat([start_tag, tags], dim=1)\\n transition_scores = self.transition_matrix[tags[:, 1:], tags[:, :-1]]\\n last_tag = tags.gather(dim=1, index=masks.sum(dim=1).long().unsqueeze(1)).squeeze(1)\\n last_score = self.transition_matrix[self.stop_idx, last_tag]\\n score = ((transition_scores + emit_scores) * masks).sum(dim=1) + last_score\\n return score\",\n \"def calculate_p(candidate, reference):\\n matches = 0\\n for grama in candidate:\\n if grama in reference:\\n matches += 1\\n return matches/len(candidate)\",\n \"def compute_recall(pred_boxes, gt_boxes, iou):\\n # Measure overlaps\\n overlaps = compute_overlaps(pred_boxes, gt_boxes)\\n iou_max = np.max(overlaps, axis=1)\\n iou_argmax = np.argmax(overlaps, axis=1)\\n positive_ids = np.where(iou_max >= iou)[0]\\n matched_gt_boxes = iou_argmax[positive_ids]\\n\\n recall = len(set(matched_gt_boxes)) / gt_boxes.shape[0]\\n return recall, positive_ids\",\n \"def score(caches, endpoints, requests, videos):\\n result = 0\\n for endpoint in endpoints:\\n for request in endpoint.requests:\\n result += (endpoint.latence_to_dc - getLatency(request.video, endpoint.eid, caches, videos, endpoints)) * request.amount\\n return result\",\n \"def calculScore(self):\\n for cell in self.notComputeRouter:\\n if(cell.isCovered==True):\\n self.score += 1000\\n self.score += self.budget\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def compute_rouge_l(output, reference, mode='f'):\\n assert mode in list('fpr') # F-1, precision, recall\\n lcs = _lcs_len(output, reference)\\n if lcs == 0:\\n score = 0.0\\n else:\\n precision = lcs / len(output)\\n recall = lcs / len(reference)\\n f_score = 2 * (precision * recall) / (precision + recall)\\n if mode == 'p':\\n score = precision\\n if mode == 'r':\\n score = recall\\n else:\\n score = f_score\\n return score\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def optimize_reference(self, num_targets):\\n \\n target_weights = np.ones(num_targets)\\n target_weights = target_weights/sum(target_weights)\\n \\n #target_weights = [0.8,0.2]\\n\\n x0 = np.asarray(np.insert(np.zeros(self._refs.shape[0]-len(target_weights)),0,target_weights))\\n print(x0)\\n \\n # num_weights = self._refs.shape[0]\\n # x0 = np.ones(num_weights)/sum(np.ones(num_weights))\\n\\n #x0 = np.asarray([0.8,0.2,0,0,0,0,0,0])\\n\\n assert num_targets >= 1, 'num_targets >= 1'\\n assert num_targets <= len(x0), 'num_targets < len(x0)'\\n\\n\\n lsq = sciopt.least_squares(self.residual, \\n x0, \\n #args=(np.reshape(self._true, (1,36)), num_targets), \\n args=(self._true, num_targets), \\n bounds=(0,1), \\n method='trf', \\n tr_solver='lsmr', \\n diff_step=0.1, \\n loss='soft_l1',\\n tr_options={'damp':1.0},\\n ftol=1e-6,\\n verbose=2) #diff_step=0.2, verbose=2)#, loss='linear')\\n\\n return (lsq.x/sum(lsq.x), lsq)\",\n \"def score(self, sentence):\\n\\n\\n # TODO your code here\\n score = 0.0 \\n prevWord = \\\"\\\"\\n prevPrevWord = \\\"\\\"\\n newSentence = []\\n for word in sentence:\\n newSentence += word.split()\\n for currentWord in sentence:\\n currentWord = currentWord.strip(STRIP_CHARS)\\n currentWord = currentWord.lower()\\n if prevWord != \\\"\\\":\\n if prevPrevWord != \\\"\\\":\\n trigram = (prevPrevWord, prevWord, currentWord)\\n trigramCount = self.trigramCounts[trigram]\\n if trigramCount > 0:\\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\\n # Subtraction by 1 removes the add one count from the laplace\\n # smoothing\\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.totalBigramCounts)\\n else:\\n count = self.unigramCounts[currentWord]\\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.total)\\n else:\\n prevPrevWord = prevWord\\n prevWord = currentWord\\n else:\\n prevWord = currentWord\\n return -score\",\n \"def alignScore():\\n matrix = mapMatrix(\\\"BLOSUM62\\\")\\n \\n path = \\\"./data/\\\"\\n for file in os.listdir(path):\\n if file.endswith(\\\".fa\\\") or file.endswith(\\\".fasta\\\"):\\n sequences = []\\n input_sequences = SeqIO.parse(path + file, \\\"fasta\\\", \\\\\\n IUPAC.protein)\\n\\n for record in input_sequences:\\n seq = str(record.seq)\\n sequences.append(seq) \\n \\n SumOfPairs = 0\\n for pair in combinations(sequences, 2): \\n SumOfPairs += pairwiseScore(pair[0], pair[1], matrix)\\n \\n print SumOfPairs\",\n \"def calculate_recall(targets, preds):\\n intersection_foreground = targets * preds\\n n_intersection_foreground = float(np.sum(intersection_foreground))\\n n_targets = float(np.sum(targets))\\n\\n return n_intersection_foreground / (n_targets + 1e-7)\",\n \"def score_ref(matrix,seq,ns=True):\\n specific_binding = sum([row[base_dict[b]] for row,b in zip(matrix,seq)])\\n if ns:\\n return log(exp(-beta*specific_binding) + exp(-beta*ns_binding_const))/-beta\\n else:\\n return specific_binding\",\n \"def run_bertscore(\\n mt: list, ref: list, model_type=\\\"xlm-roberta-base\\\", language=False, idf=False\\n) -> (list, list, list):\\n if language:\\n precison, recall, f1 = bert_score.score(\\n cands=mt,\\n refs=ref,\\n idf=idf,\\n batch_size=32,\\n lang=language,\\n rescale_with_baseline=False,\\n verbose=True,\\n nthreads=4,\\n )\\n else:\\n precison, recall, f1 = bert_score.score(\\n cands=mt,\\n refs=ref,\\n idf=idf,\\n batch_size=32,\\n model_type=model_type,\\n rescale_with_baseline=False,\\n verbose=True,\\n nthreads=4,\\n )\\n return precison, recall, f1\",\n \"def score(PDBfile):\\n from pro_angle import find_residue\\n from Bio.PDB.PDBParser import PDBParser\\n from pro_length import length\\n \\n (aas, gly, pro) = load_scores() ##define global tables\\n score = 0 #initialize \\n pars = PDBParser(PERMISSIVE = 1)\\n struct = pars.get_structure(PDBfile.rstrip('.pdb'), PDBfile)\\n model = struct.child_list[0]\\n chain = model.child_list[0]\\n pro_list = find_residue(chain, 'PRO')\\n gly_list = find_residue(chain, 'GLY')\\n aas_list = range(chain.child_list[1].id[1],\\n chain.child_list[len(chain)-1].id[1])\\n #need to remove pro/gly indices in first/last position\\n if pro_list.count(1) > 0: \\n pro_list.remove(1)\\n if pro_list.count(len(chain)-1) > 0:\\n pro_list.remove(len(chain)-1)\\n if gly_list.count(1) > 0:\\n gly_list.remove(1)\\n if gly_list.count(len(chain)-1) > 0:\\n gly_list.remove(len(chain)-1) \\n try:\\n for index in pro_list: \\n aas_list.remove(index) #remove pros from aas_list\\n for index in gly_list:\\n aas_list.remove(index) #remove glys from aas_list\\n except ValueError:\\n print 'incosistency in PDB file - will return score = 0' \\n return 0\\n else:\\n proscore = score_help(chain, pro_list, pro)\\n glyscore = score_help(chain, gly_list, gly)\\n aasscore = score_help(chain, aas_list, aas)\\n score = proscore+glyscore+aasscore\\n size=length(chain)\\n try:\\n score = (score/size)*1000 #normalize score\\n return score\\n except ZeroDivisionError:\\n print \\\"calculated protein length 0 -> returning score 0\\\"\\n score = 0\\n return score\",\n \"def fuzzy_match_strings(ref, val):\\n if not ref or not val:\\n return 0\\n ref_q = to_q(ref)\\n val_q = to_q(val)\\n if ref_q or val_q:\\n return 100 if ref_q == val_q else 0\\n simplified_val = unidecode(val).lower()\\n simplified_ref = unidecode(ref).lower()\\n\\n # Return symmetric score\\n r1 = fuzz.token_sort_ratio(simplified_val, simplified_ref)\\n r2 = fuzz.token_sort_ratio(simplified_ref, simplified_val)\\n r2 = r1\\n return int(0.5*(r1+r2))\",\n \"def get_score(self,sentence_1, sentence_2):\\n\\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)\",\n \"def rouge_n(evaluated_sentences, reference_sentences, n=2):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\\n reference_count = len(reference_ngrams)\\n evaluated_count = len(evaluated_ngrams)\\n\\n # Gets the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if evaluated_count == 0:\\n precision = 0.0\\n else:\\n precision = overlapping_count / evaluated_count\\n\\n if reference_count == 0:\\n recall = 0.0\\n else:\\n recall = overlapping_count / reference_count\\n\\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\\n\\n # return overlapping_count / reference_count\\n return f1_score, precision, recall\",\n \"def calculate_bleu(candidate, reference):\\n pn_sum = 0\\n for n in range(1, 4):\\n cand_grama, ref_grama = n_grama(candidate, n), n_grama(reference, n)\\n p = calculate_p(cand_grama, ref_grama)\\n if p != 0:\\n # If there are no matches between n_grams,\\n # don't add nothing\\n pn_sum += (0.33 * math.log(p))\\n bp = calculate_bp_penality(candidate, reference)\\n return bp * math.exp(pn_sum)\",\n \"def evaluate(ref_file, trans_file, metric, subword_option=None,\\n lower_case=False):\\n # BLEU scores for translation task\\n if metric.lower() == \\\"bleu\\\":\\n evaluation_score = _bleu(\\n ref_file,\\n trans_file,\\n subword_option=subword_option,\\n lower_case=lower_case)\\n else:\\n raise ValueError(\\\"Unknown metric %s\\\" % metric)\\n\\n return evaluation_score\",\n \"def _pg_bahdanau_score(processed_query, keys, coverage, coverage_vector):\\n dtype = processed_query.dtype\\n # Get the number of hidden units from the trailing dimension of keys\\n num_units = keys.shape[2].value or tf.shape(keys)[2]\\n # Reshape from [batch_size, ...] to [batch_size, 1, ...] for broadcasting.\\n processed_query = tf.expand_dims(processed_query, 1)\\n v = tf.get_variable('attention_v', [num_units], dtype = dtype)\\n b = tf.get_variable(\\n 'attention_b',\\n [num_units],\\n dtype = dtype,\\n initializer = tf.zeros_initializer(),\\n )\\n if coverage:\\n w_c = tf.get_variable('coverage_w', [num_units], dtype = dtype)\\n # debug\\n # coverage_vector = tf.Print(coverage_vector,[coverage_vector],message=\\\"score\\\")\\n coverage_vector = tf.expand_dims(coverage_vector, -1)\\n return tf.reduce_sum(\\n v * tf.tanh(keys + processed_query + coverage_vector * w_c + b), [2]\\n )\\n else:\\n return tf.reduce_sum(v * tf.tanh(keys + processed_query + b), [2])\",\n \"def compute_readability(text):\\n total_words = 0\\n total_sentences = 0\\n total_syllables = 0\\n score = 0\\n\\n words = text.split()\\n total_words = len(text.split()) \\n total_sentences = count_sentences(text)\\n total_syllables = count_syllables(words)\\n \\n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\\n if score > 90.00:\\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\\n elif score <= 90.00 and score > 80.00:\\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\\n elif score <= 80.00 and score > 70.00:\\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\\n elif score <= 70.00 and score > 60.00:\\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\\n elif score <= 60.00 and score > 50.00:\\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\\n elif score <= 50.00 and score > 30.00:\\n answer = 'Texto de nível Universitário, difícil de ler.'\\n else:\\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\\n \\n print('Pontuação Total:', score, answer)\",\n \"def rouge_n(reference_sentences, evaluated_sentences, n=2):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\\n reference_count = len(reference_ngrams)\\n evaluated_count = len(evaluated_ngrams)\\n\\n # Gets the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if evaluated_count == 0:\\n precision = 0.0\\n else:\\n precision = overlapping_count / evaluated_count\\n\\n if reference_count == 0:\\n recall = 0.0\\n else:\\n recall = overlapping_count / reference_count\\n\\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\\n\\n #just returning recall count in rouge, useful for our purpose\\n return recall\",\n \"def baseline_score(self,t0,t1):\\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))\",\n \"def _bleu_score_compute(\\n preds_len: Tensor,\\n target_len: Tensor,\\n numerator: Tensor,\\n denominator: Tensor,\\n n_gram: int,\\n weights: Sequence[float],\\n smooth: bool,\\n) -> Tensor:\\n device = numerator.device\\n if min(numerator) == 0.0:\\n return tensor(0.0, device=device)\\n\\n if smooth:\\n precision_scores = torch.div(\\n torch.add(numerator, torch.ones(n_gram, device=device)),\\n torch.add(denominator, torch.ones(n_gram, device=device)),\\n )\\n precision_scores[0] = numerator[0] / denominator[0]\\n else:\\n precision_scores = numerator / denominator\\n\\n log_precision_scores = tensor(weights, device=device) * torch.log(precision_scores)\\n geometric_mean = torch.exp(torch.sum(log_precision_scores))\\n brevity_penalty = tensor(1.0, device=device) if preds_len > target_len else torch.exp(1 - (target_len / preds_len))\\n return brevity_penalty * geometric_mean\",\n \"def score_candidates(normal, position_difference, trial_normals, angle_weight):\\n\\n # We want all normals on the same side of the line, so flip those that aren't.\\n flip_normal = is_opposite(trial_normals, normal)\\n trial_normals[flip_normal, :] = -trial_normals[flip_normal, :]\\n\\n # Note that we have to add the relative pixel displacement on top of the subpixel displacements)\\n distances = np.linalg.norm(position_difference, axis=1)\\n angular_distances = np.arccos(np.dot(trial_normals, normal))\\n return distances + angle_weight * angular_distances\",\n \"def cumulative_bleu(references, sentence, n):\\r\\n weight = 1 / n\\r\\n scores = [ngram_modscore(references, sentence, i, weight)\\r\\n for i in range(1, n + 1)]\\r\\n closest = np.argmin(np.abs([len(ref) - len(sentence)\\r\\n for ref in references]))\\r\\n closest = len(references[closest])\\r\\n if len(sentence) >= closest:\\r\\n brevity = 1\\r\\n else:\\r\\n brevity = np.exp(1 - closest / len(sentence))\\r\\n return brevity * np.exp(sum(scores))\",\n \"def compute_score(self, gts, res):\\n\\n assert(gts.keys() == res.keys())\\n imgIds = gts.keys()\\n\\n cider_scorer = CiderScorer(n=self._n, sigma=self._sigma, \\n document_frequency=self._doucument_frequency, \\n ref_len=self._ref_len)\\n\\n for id in imgIds:\\n hypo = res[id]\\n ref = gts[id]\\n\\n # Sanity check.\\n assert(type(hypo) is list)\\n assert(len(hypo) == 1)\\n assert(type(ref) is list)\\n assert(len(ref) > 0)\\n\\n cider_scorer += (hypo[0], ref)\\n\\n (score, scores) = cider_scorer.compute_score()\\n\\n return score, scores\",\n \"def score_segments(segs, truths, detected):\\n matches = 0\\n for seg in segs:\\n truth_match = detected_match = False\\n for truth in truths:\\n if time_overlap(seg, truth):\\n truth_match = True\\n for det in detected:\\n if time_overlap(seg, det):\\n detected_match = True\\n\\n #assign basic score to segment (TP|TN|FP|FN)\\n if truth_match:\\n if detected_match:\\n seg[\\\"score\\\"] = \\\"TP\\\"\\n else:\\n seg[\\\"score\\\"] = \\\"FN\\\"\\n else:\\n if detected_match:\\n seg[\\\"score\\\"] = \\\"FP\\\"\\n else:\\n seg[\\\"score\\\"] = \\\"TN\\\"\\n\\n # assign error class to all FN and FP. fig 3, ward et al 2011\\n prev_score = next_score = None\\n for i in range(len(segs)):\\n score = segs[i][\\\"score\\\"]\\n if score == \\\"TP\\\" or score == \\\"TN\\\":\\n continue \\n\\n if i < len(segs)-1:\\n next_score = segs[i+1][\\\"score\\\"]\\n\\n if i > 0:\\n prev_score = segs[i-1][\\\"score\\\"]\\n\\n if i == 0: #beginning of sequence\\n\\n if score == \\\"FP\\\":\\n if next_score is None or next_score == \\\"TN\\\" or next_score == \\\"FN\\\":\\n segs[i][\\\"err\\\"] = \\\"I\\\"\\n elif next_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Os\\\"\\n else:\\n warn(\\\"Unhandled error case: %s followed by %s\\\" % (score, next_score))\\n\\n elif score == \\\"FN\\\":\\n if next_score is None or next_score == \\\"TN\\\" or next_score == \\\"FP\\\":\\n segs[i][\\\"err\\\"] = \\\"D\\\"\\n elif next_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Us\\\"\\n else:\\n warn(\\\"Unhandled error case: %s followed by %s\\\" % (score, next_score))\\n\\n elif i == len(segs) - 1: #end of sequence\\n\\n if score == \\\"FP\\\":\\n if prev_score == \\\"TN\\\" or prev_score == \\\"FN\\\":\\n segs[i][\\\"err\\\"] = \\\"I\\\"\\n elif prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Oe\\\"\\n else:\\n warn(\\\"Unhandled error case: %s followed by %s\\\" % (score, next_score))\\n \\n elif score == \\\"FN\\\":\\n if prev_score == None or prev_score == \\\"TN\\\" or prev_score == \\\"FP\\\":\\n segs[i][\\\"err\\\"] = \\\"D\\\"\\n elif prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Ue\\\"\\n else:\\n warn(\\\"Unhandled error case: %s followed by %s\\\" % (score, next_score))\\n\\n else: #middle sequence\\n\\n if score == \\\"FP\\\":\\n if next_score == \\\"TP\\\":\\n if prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"M\\\"\\n elif prev_score == \\\"TN\\\" or prev_score == \\\"FN\\\":\\n segs[i][\\\"err\\\"] = \\\"Os\\\"\\n else:\\n warn(\\\"Unhandled error case: %s %s %s\\\" % (prev_score, score, next_score))\\n\\n elif next_score == \\\"TN\\\" or next_score == \\\"FN\\\":\\n if prev_score == \\\"TN\\\" or prev_score == \\\"FN\\\":\\n segs[i][\\\"err\\\"] = \\\"I\\\"\\n elif prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Oe\\\"\\n else:\\n warn(\\\"Unhandled error case: %s %s %s\\\" % (prev_score, score, next_score))\\n else:\\n warn(\\\"Unhandled error case: %s followed by %s\\\" % (score, next_score))\\n\\n elif score == \\\"FN\\\":\\n\\n if next_score == \\\"TP\\\":\\n if prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"F\\\"\\n elif prev_score == \\\"TN\\\" or prev_score == \\\"FP\\\":\\n segs[i][\\\"err\\\"] = \\\"Us\\\"\\n else:\\n warn(\\\"Unhandled error case: %s %s %s\\\" % (prev_score, score, next_score))\\n\\n elif next_score == \\\"TN\\\" or next_score == \\\"FP\\\":\\n if prev_score == \\\"TN\\\" or prev_score == \\\"FP\\\":\\n segs[i][\\\"err\\\"] = \\\"D\\\"\\n elif prev_score == \\\"TP\\\":\\n segs[i][\\\"err\\\"] = \\\"Ue\\\"\\n else:\\n warn(\\\"Unhandled error case: %s %s %s\\\" % (prev_score, score, next_score))\\n\\n else:\\n raise warn(\\\"Unknown score: %s\\\" % score)\\n\\n return segs\",\n \"def calc_accuracy(self, top_matches):\\n # Calculate Translation accuracy\\n # Accuracy at K\\n for k in [1, 5, 10]:\\n top_k_matches = top_matches[:, :k]\\n # Checks for one match\\n one_matching = (top_k_matches == self.tgt_ind[:, None]).sum(1)\\n # Checks for multiple translations\\n matching = {}\\n for i, src_id in enumerate(self.src_ind):\\n matching[src_id] = min(matching.get(src_id, 0) + one_matching[i], 1)\\n precision_at_k = 100 * np.mean(list(matching.values()))\\n print(\\\"%i source words - Precision at k = %i: %f\\\" % (len(matching), k, precision_at_k))\",\n \"def updateReferenceAndNormalize(m, ref, thresh):\\n ref = list(ref)\\n thresh = max(thresh,0)\\n totals = np.sum(m[:4,], axis=0)\\n idx = 0;\\n b2i = BaseToInt()\\n for i in totals:\\n if i < thresh:\\n bases = np.array(b2i.getPositions(ref[idx].capitalize()))\\n m[:4, idx] = 0\\n m[bases, idx] = 1.0/len(bases)\\n else:\\n m[:4,idx] = m[:4,idx]/i\\n\\n #DEBUG CODE#\\n if (m[:4,idx] > 1).any():\\n print(i)\\n print (m[:4,idx])\\n print(totals)\\n #END DEBUG CODE#\\n \\n idx += 1\",\n \"def rouge_n(eval_sentences, ref_sentences, n=2):\\n f1_scores = []\\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\\n eval_ngrams = _get_ngrams(n, eval_sentence)\\n ref_ngrams = _get_ngrams(n, ref_sentence)\\n ref_count = len(ref_ngrams)\\n eval_count = len(eval_ngrams)\\n\\n # Count the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = eval_ngrams.intersection(ref_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if eval_count == 0:\\n precision = 0.0\\n else:\\n precision = float(overlapping_count) / eval_count\\n if ref_count == 0:\\n recall = 0.0\\n else:\\n recall = float(overlapping_count) / ref_count\\n f1_scores.append(2.0 * ((precision * recall) / (precision + recall + 1e-8)))\\n\\n # return overlapping_count / reference_count\\n return np.mean(f1_scores, dtype=np.float32)\",\n \"def score_sentence(self, sentence):\\n\\t\\t\\n\\t\\t# YOUR CODE HERE\",\n \"def _compute(self, references=None, models=None):\\n \\n config = self.config\\n if references is None:\\n self.logger.msg2(\\\"Working with all references\\\")\\n references = get_ref_names(self.dbpath)\\n \\n self.logger.msg1(\\\"Dropping scores for \\\"+str(len(models))+ \\\" models\\\")\\n delete_model_scores(self.dbpath, models)\\n self.logger.msg2(\\\"Working with \\\" + str(len(references)) +\\n \\\" references, \\\" + str(len(models)) + \\\" models\\\")\\n packets = prep_compute_packets(config, \\n references=references,\\n models=models,\\n log=self.logger.msg2) \\n \\n # run calculations on all the packets\\n msg = str(config.cores)+ \\\" cores, \\\" + str(len(packets))+ \\\" packets\\\"\\n self.logger.msg1(\\\"Scoring (\\\"+msg+\\\")\\\")\\n run_packets(packets, config.cores)\",\n \"def rouge_n(evaluated_sentences, reference_sentences, n=2):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\\n reference_count = len(reference_ngrams)\\n evaluated_count = len(evaluated_ngrams)\\n\\n # Gets the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if evaluated_count == 0:\\n precision = 0.0\\n else:\\n precision = overlapping_count / evaluated_count\\n\\n if reference_count == 0:\\n recall = 0.0\\n else:\\n recall = overlapping_count / reference_count\\n\\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\\n\\n # return overlapping_count / reference_count\\n return f1_score, precision, recall\",\n \"def stereo_score(alignment):\\n #dictionary with properties for each residue\\n dic_prop = {'I': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\\n 'L': [1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\\n 'V': [1, 0, 1, 0, 0, 1, 0, 0, 0, 0],\\n 'C': [1, 0, 1, 0, 0, 0, 0, 0, 0, 0],\\n 'A': [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],\\n 'G': [1, 0, 1, 0, 1, 0, 0, 0, 0, 0],\\n 'M': [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\\n 'F': [1, 0, 0, 0, 0, 0, 1, 0, 0, 0],\\n 'Y': [1, 1, 0, 0, 0, 0, 1, 0, 0, 0],\\n 'W': [1, 1, 0, 0, 0, 0, 1, 0, 0, 0],\\n 'H': [1, 1, 0, 0, 0, 0, 1, 1, 0, 1],\\n 'K': [1, 1, 0, 0, 0, 0, 0, 1, 0, 1],\\n 'R': [0, 1, 0, 0, 0, 0, 0, 1, 0, 1],\\n 'E': [0, 1, 0, 0, 0, 0, 0, 0, 1, 1],\\n 'Q': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\\n 'D': [0, 1, 1, 0, 0, 0, 0, 0, 1, 1],\\n 'N': [0, 1, 1, 0, 0, 0, 0, 0, 0, 0],\\n 'S': [0, 1, 1, 0, 1, 0, 0, 0, 0, 0],\\n 'T': [1, 1, 1, 0, 0, 0, 0, 0, 0, 0],\\n 'P': [0, 0, 1, 1, 0, 0, 0, 0, 0, 0],\\n 'B': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\\n 'Z': [0, 1, 0, 0, 0, 0, 0, 0, 0, 0],\\n 'X': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\\n '-': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}\\n score_list = []\\n for i in range(0, alignment.get_alignment_length()):\\n #extract the unique residues in the alignment\\n column = ''.join(set(alignment[:, i]))\\n stereo_list = []\\n #loop through each residue\\n for res in range(0, len(column)):\\n #replace the residue with list of properties\\n residue = column[res]\\n #append the properties list to a\\n stereo_prop = dic_prop.get(residue)\\n stereo_list.append(stereo_prop)\\n #number of common properties\\n count_stereo = sum(len(set(i)) == 1 for i in zip(*stereo_list))\\n #add the number of properties to a list\\n score_list.append(count_stereo)\\n score_list_final = [float(i*0.1) for i in score_list]\\n return score_list_final\",\n \"def score_help(chain, res_list, score_table):\\n from pro_angle import calc_dihedral\\n from math import floor\\n \\n score = float(0)\\n for res in res_list:\\n try:\\n (phi,psi) = calc_dihedral(chain, res) \\n indx = int(floor(phi/10)+18)\\n indy = int(floor(psi/10)+18)\\n temp = float(score_table[indy][indx])\\n score = score + temp\\n except ValueError:\\n pass\\n# print \\\"ValueError: asked for score of non-scorable residue\\\"\\n return score\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74093115","0.6367269","0.62644315","0.6251968","0.61092013","0.6055221","0.6055221","0.60060614","0.6000095","0.59870803","0.597151","0.5941071","0.59349793","0.59248674","0.5910593","0.57739943","0.5773284","0.5762745","0.57584465","0.57571113","0.5705359","0.5702861","0.5698308","0.56931525","0.56835896","0.5632568","0.56287336","0.5623143","0.56149894","0.5604428","0.55846876","0.5573291","0.55606073","0.55606073","0.55261797","0.5525443","0.55011725","0.5497569","0.54528344","0.54492676","0.5392853","0.53727007","0.53702146","0.5346801","0.5327871","0.53215575","0.53065246","0.52935255","0.52928466","0.52866703","0.52821374","0.52366453","0.5230499","0.52287835","0.52256584","0.52205044","0.521901","0.5212894","0.5202031","0.52005076","0.51959187","0.5191268","0.5180766","0.5178417","0.5170589","0.51689607","0.515748","0.51508254","0.51493615","0.5148362","0.5146201","0.5117657","0.5107008","0.5102962","0.5101389","0.5099821","0.50936437","0.5087701","0.5085734","0.50828326","0.5082646","0.5081321","0.5079868","0.50785327","0.5059538","0.505609","0.5054506","0.5047381","0.50462306","0.50363874","0.5033307","0.5033204","0.5025748","0.5025615","0.50253695","0.50177795","0.501536","0.5012367","0.50112736","0.50067747"],"string":"[\n \"0.74093115\",\n \"0.6367269\",\n \"0.62644315\",\n \"0.6251968\",\n \"0.61092013\",\n \"0.6055221\",\n \"0.6055221\",\n \"0.60060614\",\n \"0.6000095\",\n \"0.59870803\",\n \"0.597151\",\n \"0.5941071\",\n \"0.59349793\",\n \"0.59248674\",\n \"0.5910593\",\n \"0.57739943\",\n \"0.5773284\",\n \"0.5762745\",\n \"0.57584465\",\n \"0.57571113\",\n \"0.5705359\",\n \"0.5702861\",\n \"0.5698308\",\n \"0.56931525\",\n \"0.56835896\",\n \"0.5632568\",\n \"0.56287336\",\n \"0.5623143\",\n \"0.56149894\",\n \"0.5604428\",\n \"0.55846876\",\n \"0.5573291\",\n \"0.55606073\",\n \"0.55606073\",\n \"0.55261797\",\n \"0.5525443\",\n \"0.55011725\",\n \"0.5497569\",\n \"0.54528344\",\n \"0.54492676\",\n \"0.5392853\",\n \"0.53727007\",\n \"0.53702146\",\n \"0.5346801\",\n \"0.5327871\",\n \"0.53215575\",\n \"0.53065246\",\n \"0.52935255\",\n \"0.52928466\",\n \"0.52866703\",\n \"0.52821374\",\n \"0.52366453\",\n \"0.5230499\",\n \"0.52287835\",\n \"0.52256584\",\n \"0.52205044\",\n \"0.521901\",\n \"0.5212894\",\n \"0.5202031\",\n \"0.52005076\",\n \"0.51959187\",\n \"0.5191268\",\n \"0.5180766\",\n \"0.5178417\",\n \"0.5170589\",\n \"0.51689607\",\n \"0.515748\",\n \"0.51508254\",\n \"0.51493615\",\n \"0.5148362\",\n \"0.5146201\",\n \"0.5117657\",\n \"0.5107008\",\n \"0.5102962\",\n \"0.5101389\",\n \"0.5099821\",\n \"0.50936437\",\n \"0.5087701\",\n \"0.5085734\",\n \"0.50828326\",\n \"0.5082646\",\n \"0.5081321\",\n \"0.5079868\",\n \"0.50785327\",\n \"0.5059538\",\n \"0.505609\",\n \"0.5054506\",\n \"0.5047381\",\n \"0.50462306\",\n \"0.50363874\",\n \"0.5033307\",\n \"0.5033204\",\n \"0.5025748\",\n \"0.5025615\",\n \"0.50253695\",\n \"0.50177795\",\n \"0.501536\",\n \"0.5012367\",\n \"0.50112736\",\n \"0.50067747\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6329306"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":85169,"cells":{"query":{"kind":"string","value":"ROUGE2 F1 score computation between labels and predictions. This is an approximate ROUGE scoring method since we do not glue word pieces or decode the ids and tokenize the output."},"document":{"kind":"string","value":"def rouge_2_fscore(logits, labels):\n predictions = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)\n # TODO: Look into removing use of py_func\n rouge_2_f_score = tf.compat.v1.py_func(rouge_n, (predictions, labels), tf.float32)\n return rouge_2_f_score, tf.constant(1.0)"},"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 get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\"malaria\", confusion_matrix_title=\"\"):\n # demonstration of calculating metrics for a neural network model using sklearn\n if not binary_classifcation:\n # For multiclass classification.\n accuracy = accuracy_score(actual_labels, preds_labels)\n precision = precision_score(actual_labels, preds_labels, average=\"macro\")\n recall = recall_score(actual_labels, preds_labels, average=\"macro\")\n f1 = f1_score(actual_labels, preds_labels, average=\"macro\")\n print('Accuracy: %f' % accuracy)\n print('Precision: %f' % precision)\n print('Recall: %f' % recall)\n print('F1 score: %f' % f1)\n\n else:\n accuracy = accuracy_score(actual_labels, preds_labels)\n print('Accuracy: %f' % accuracy)\n # # precision tp / (tp + fp)\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Precision: %f' % precision)\n # recall: tp / (tp + fn)\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Recall: %f' % recall)\n # f1: 2 tp / (2 tp + fp + fn)\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\n print('F1 score: %f' % f1)\n # ROC AUC\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\n # print('ROC AUC: %f' % auc)\n\n # confusion matrix\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\n display_labels=list(np.unique(actual_labels)),\n cmap=plt.cm.Blues,\n normalize=None)\n disp.ax_.set_title(confusion_matrix_title)\n plt.show()\n matrix = confusion_matrix(actual_labels, preds_labels)\n print(matrix)\n # if plot_confusion_matrix:\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))","def f1_score_per_label(y_true, y_pred, threshold, eps=1e-9):\n \n y_pred = torch.ge(y_pred.float(), threshold).float()\n\n y_true = y_true.float()\n\n tp_l = (y_pred * y_true).sum(0).float()\n\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\n\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\n\n precision_label = tp_l.div(tp_l + fp_l + eps)\n\n recall_label = tp_l.div(tp_l + fn_l + eps)\n\n f1_label = (precision_label * recall_label).div(precision_label + recall_label + eps) * 2\n\n return f1_label, precision_label, recall_label","def string_f1_score(prediction, ground_truth):\n prediction_tokens = normalize_answer(prediction).split()\n ground_truth_tokens = normalize_answer(ground_truth).split()\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def _f1_score_(prediction, ground_truth):\n prediction_tokens = _normalize_answer(prediction).split()\n ground_truth_tokens = _normalize_answer(ground_truth).split()\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def _compute_f1_score(predicted_answer: str, target_answer: str) ->Tensor:\n target_tokens = _get_tokens(target_answer)\n predicted_tokens = _get_tokens(predicted_answer)\n common = Counter(target_tokens) & Counter(predicted_tokens)\n num_same = tensor(sum(common.values()))\n if len(target_tokens) == 0 or len(predicted_tokens) == 0:\n return tensor(int(target_tokens == predicted_tokens))\n if num_same == 0:\n return tensor(0.0)\n precision = 1.0 * num_same / tensor(len(predicted_tokens))\n recall = 1.0 * num_same / tensor(len(target_tokens))\n f1 = 2 * precision * recall / (precision + recall)\n return f1","def f1score(prediction,ytest):\n truepos = np.sum(ytest[prediction == 1])\n predpos = np.sum(prediction)\n actpos = np.sum(ytest)\n precision = truepos/predpos\n recall = truepos/actpos\n return 2*precision*recall/(precision + recall)","def f1_score(prediction, ground_truth):\n return precision_recall_f1(prediction, ground_truth)[2]","def f1(y_true, y_pred):\n p = precision(y_true, y_pred)\n r = recall(y_true, y_pred)\n score = 2 * p * r / (p + r)\n return score","def f1_score_model(self, model, X, y):\n\n prediction = model.predict_classes(X)\n f1_macro = f1_score(y, prediction, average='macro')\n f1_micro = f1_score(y, prediction, average='macro')\n print(\"f1_macro: \", f1_score(y, prediction, average='macro'))\n print(\"f1_micro: \", f1_score(y, prediction, average=\"micro\"))\n print(\"f1_weighted: \", f1_score(y, prediction, average=\"weighted\"))\n return f1_macro, f1_micro","def f1(gold_labels, predicted_labels):\n \n precision_value = float(precision(gold_labels, predicted_labels))\n recall_value = float(recall(gold_labels, predicted_labels))\n top = float(2 * precision_value * recall_value)\n bottom = precision_value + recall_value\n\n if(top == 0):\n return 0\n else:\n return float(top / bottom)","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\n\n y_pred = torch.ge(y_pred.float(), threshold).float()\n\n y_true = y_true.float()\n\n tp_l = (y_pred * y_true).sum(0).float()\n\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\n\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\n\n precision_label = tp_l.div(tp_l + fp_l + eps)\n\n recall_label = tp_l.div(tp_l + fn_l + eps)\n\n if macro:\n\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\n\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\n\n else: \n\n tp = tp_l.sum()\n\n fp = fp_l.sum()\n\n fn = fn_l.sum()\n\n precision = tp / (tp + fp + eps)\n\n recall = tp / (tp + fn + eps)\n\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\n\n return f1_micro.item(), precision.item(), recall.item()","def calculate_f1_score(y_test, y_pred):\n print('# Running precision, recall and F1-score')\n print('# F1-Score:\\t\\t%.2f' % (f1_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Precision:\\t\\t%.2f' % (precision_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Recall:\\t\\t%.2f' % (recall_score(y_test, y_pred, average=\"macro\") * 100))","def F1Score(labels, gold_file, wordnetCompression):\n\n gold_labels = []\n with open(gold_file, 'r') as file:\n for line in file:\n gold_labels.append(line.split()[1])\n\n flat_decoded_label_list = [item for sublist in labels for item in sublist]\n\n total = 0\n correct = 0\n if wordnetCompression:\n for i in range(len(gold_labels)):\n total += 1\n current_gold = gold_labels[i]\n pos = wn.lemma_from_key(current_gold).synset().pos()\n offset = wn.lemma_from_key(current_gold).synset().offset()\n wn_synset = \"wn:\" + str(offset).zfill( 8) + pos\n current_prediction = flat_decoded_label_list[i]\n #if len(current_prediction) > 1:\n # for elem in current_prediction:\n # if elem == current_gold:\n # correct += 1\n #else:\n if wn_synset == current_prediction:\n correct += 1\n else:\n for i in range(len(gold_labels)):\n if gold_labels[i] == flat_decoded_label_list[i]:\n correct += 1\n total += 1\n \n print(\"F1 SCORE: \", (correct/total)*100 )\n print(\"Total number of labels: \", total)\n print(\"Total correct: \", correct)\n print()","def evaluate_f1_ml(predict, truth):\n label_same = []\n label_predict = []\n label_truth = []\n label_f1 = []\n\n division = lambda x, y: (x * 1.0 / y) if y else 0\n f1 = lambda p, r: 2 * p * r / (p + r) if p + r else 0\n\n batch, label_size = predict.size()\n for i in range(label_size):\n cur_predict = predict[:, i]\n cur_truth = truth[:, i]\n\n predict_max = cur_predict.gt(0.5).long()\n cur_eq_num = (predict_max * cur_truth).sum().item()\n\n cur_predict_num = predict_max.sum().item()\n cur_truth_num = cur_truth.sum().item()\n\n cur_precision = division(cur_eq_num, cur_predict_num)\n cur_recall = division(cur_eq_num, cur_truth_num)\n cur_f1 = f1(cur_precision, cur_recall)\n\n label_same.append(cur_eq_num)\n label_predict.append(cur_predict_num)\n label_truth.append(cur_truth_num)\n label_f1.append(cur_f1)\n\n macro_f1 = sum(label_f1) / len(label_f1)\n micro_precision = division(sum(label_same), sum(label_predict))\n micro_recall = division(sum(label_same), sum(label_truth))\n micro_f1 = f1(micro_precision, micro_recall)\n\n return macro_f1, micro_f1, micro_precision, micro_recall, label_f1","def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12","def f1_score(self):\n self.overall_f1_score = f1_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_f1_score = f1_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)","def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\n -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray, np.ndarray]]:\n confusion = get_confusion_matrix(labels_true, labels_pred)\n n_labels = confusion.shape[0]\n counts_correct = confusion.diagonal()\n counts_true = confusion.dot(np.ones(n_labels))\n counts_pred = confusion.T.dot(np.ones(n_labels))\n mask = counts_true > 0\n recalls = np.zeros(n_labels)\n recalls[mask] = counts_correct[mask] / counts_true[mask]\n precisions = np.zeros(n_labels)\n mask = counts_pred > 0\n precisions[mask] = counts_correct[mask] / counts_pred[mask]\n f1_scores = np.zeros(n_labels)\n mask = (counts_true > 0) & (counts_pred > 0)\n f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])\n if return_precision_recall:\n return f1_scores, precisions, recalls\n else:\n return f1_scores","def klue_re_micro_f1(preds, labels):\n label_list = ['no_relation', 'org:top_members/employees', 'org:members',\n 'org:product', 'per:title', 'org:alternate_names',\n 'per:employee_of', 'org:place_of_headquarters', 'per:product',\n 'org:number_of_employees/members', 'per:children',\n 'per:place_of_residence', 'per:alternate_names',\n 'per:other_family', 'per:colleagues', 'per:origin', 'per:siblings',\n 'per:spouse', 'org:founded', 'org:political/religious_affiliation',\n 'org:member_of', 'per:parents', 'org:dissolved',\n 'per:schools_attended', 'per:date_of_death', 'per:date_of_birth',\n 'per:place_of_birth', 'per:place_of_death', 'org:founded_by',\n 'per:religion']\n no_relation_label_idx = label_list.index(\"no_relation\")\n label_indices = list(range(len(label_list)))\n label_indices.remove(no_relation_label_idx)\n return metrics.f1_score(labels, preds, average=\"micro\", labels=label_indices) * 100.0","def f1_score(model_id, test_set_id, rubric_id):\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\n\n for key in rubrication_result:\n if rubrication_result[key] == answers[key]:\n if rubrication_result[key] == 1:\n result['true_positive'] += 1\n else:\n result['true_negative'] += 1\n else:\n if rubrication_result[key] == 1:\n result['false_positive'] += 1\n else:\n result['false_negative'] += 1\n if (result['true_positive'] + result['false_positive']) > 0:\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\n else:\n result['precision'] = 0\n if (result['true_positive'] + result['false_negative']) > 0:\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\n else:\n result['recall'] = 0\n if (result['precision'] + result['recall']) > 0:\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\n else:\n result['f1'] = 0\n return result","def calf_f1(annotated_Y, predicted_Y):\n\n POSITIVE = ADR_MENTION_CLASS_LABEL\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\n\n tp = 0\n fp = 0\n fn = 0\n tn = 0\n\n total_actual_positives = 0\n total_actual_negatives = 0\n\n for index, actual in enumerate(annotated_Y):\n predicted = predicted_Y[index]\n\n if actual == POSITIVE:\n total_actual_positives += 1\n\n if predicted == POSITIVE:\n tp += 1\n elif predicted == NEGATIVE:\n fn += 1\n\n elif actual == NEGATIVE:\n total_actual_negatives += 1\n\n if predicted == POSITIVE:\n fp += 1\n elif predicted == NEGATIVE:\n tn += 1\n\n if (tp+fp) == 0:\n precision = 0\n else:\n precision = tp/(tp+fp)\n\n if (tp+fn) == 0:\n recall = 0\n else:\n recall = tp/(tp+fn)\n\n if (precision+recall) == 0:\n f1 = 0\n else:\n f1 = 2*precision*recall/(precision+recall)\n\n # print(\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\n # print(\"tp: {}, tn: {}, fp: {}, fn: {}\".format(tp, tn, fp, fn))\n # print(\" Accuracy: {}\".format((tp+tn)/(len(test_Y))))\n print(\" Precision: {}\".format(precision))\n print(\" Recall: {}\".format(recall))\n print(\" F1: {}\".format(f1))","def f1_score(y_true, y_pred):\n\ty_true = tf.cast(y_true, \"float32\")\n\ty_pred = tf.cast(tf.round(y_pred), \"float32\") # implicit 0.5 threshold via tf.round\n\ty_correct = y_true * y_pred\n\n\n\tsum_true = tf.reduce_sum(y_true, axis=1)\n\tsum_pred = tf.reduce_sum(y_pred, axis=1)\n\tsum_correct = tf.reduce_sum(y_correct, axis=1)\n\n\n\tprecision = sum_correct / sum_pred\n\trecall = sum_correct / sum_true\n\tf_score = 2 * precision * recall / (precision + recall)\n\tf_score = tf.where(tf.is_nan(f_score), tf.zeros_like(f_score), f_score)\n\n\n\treturn tf.reduce_mean(f_score)","def f1_score(self, y_true=None, y_pred=None, labels=None, average=\"macro\", decimal=None, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\n\n list_f1 = np.array([item[\"f1\"] for item in metrics.values()])\n list_weights = np.array([item[\"n_true\"] for item in metrics.values()])\n\n if average == \"micro\":\n tp_global = np.sum(np.diag(matrix))\n fp_global = fn_global = np.sum(matrix) - tp_global\n precision = tp_global / (tp_global + fp_global)\n recall = tp_global / (tp_global + fn_global)\n f1 = (2 * precision * recall) / (precision + recall)\n elif average == \"macro\":\n f1 = np.mean(list_f1)\n elif average == \"weighted\":\n f1 = np.dot(list_weights, list_f1) / np.sum(list_weights)\n else:\n f1 = dict([(label, np.round(item[\"f1\"], decimal)) for label, item in metrics.items()])\n return f1 if type(f1) == dict else np.round(f1, decimal)","def get_f1(self, predictions):\n preds = []\n ground_truth = []\n for index in range(len(self.test_data)):\n preds.append(predictions[index])\n ground_truth.append(self.test_data[index][self.target_attribute])\n f1 = metrics.f1_score(ground_truth,preds,labels=['win','loss','draw'],average='macro')\n return f1","def precision_recall_f1(prediction, ground_truth):\n if not isinstance(prediction, list):\n prediction_tokens = prediction.split()\n else:\n prediction_tokens = prediction\n if not isinstance(ground_truth, list):\n ground_truth_tokens = ground_truth.split()\n else:\n ground_truth_tokens = ground_truth\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0, 0, 0\n p = 1.0 * num_same / len(prediction_tokens)\n r = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * p * r) / (p + r)\n return p, r, f1","def F1_score(y_t, y_p, weights):\n\n P = Precision()\n R = Recall() #label per label evaluation\n F1_score_per_label = [] #store per label\n P_per_label = []\n R_per_label = []\n F1_tot = 0 #weighted sum\n\n for i in range(8):\n P.update_state( y_t[:,i], y_p[:,i] )\n R.update_state( y_t[:,i], y_p[:,i] )\n p = P.result().numpy()\n r = R.result().numpy()\n P.reset_states()\n R.reset_states()\n if p+r == 0:\n f1 = 0\n else:\n f1 = 2*p*r/ (p+r)\n F1_score_per_label.append(f1)\n P_per_label.append(p)\n R_per_label.append(r)\n\n F1_tot += f1*weights[i]\n\n return F1_score_per_label, P_per_label, R_per_label, F1_tot","def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\r\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\r\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\r\n\r\n if p + r > 0:\r\n return 2 * p * r / (p + r)\r\n else:\r\n return 0","def f1_score(self):","def f1_score(y_true, y_pred):\n num = 2 * precision_score(y_true, y_pred) * recall_score(y_true, y_pred)\n deno = (precision_score(y_true, y_pred) + recall_score(y_true, y_pred))\n return num / deno","def scores(self, y, y_pred):\n\n aucroc = 0.\n precision = 0.\n recall = 0.\n f1 = 0.\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\n label_ratios = np.mean(y, axis=0)\n\n if len(y) > 1:\n y_t = np.transpose(y)\n col_keep = np.ones(len(y_t), dtype=bool)\n for i, col_y in enumerate(y_t):\n if 0 not in col_y or 1 not in col_y:\n col_keep[i] = False\n\n if sum(col_keep) > 0:\n if not col_keep.all():\n y = np.transpose(y_t[col_keep])\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\n\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\n s = f1_score(y, self._round(y_pred), average=None)\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\n if sum(col_keep) > 1:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\n else:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\n elif self.verbose:\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n elif len(y) == 1:\n if self.verbose:\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n result = {\n 'aucroc': aucroc,\n 'precision': precision,\n 'recall': recall,\n 'f1': f1,\n 'aucroc_labs': aucroc_labs,\n 'precision_labs': precision_labs,\n 'recall_labs': recall_labs,\n 'f1_labs': f1_labs,\n 'label_ratios': label_ratios\n }\n\n return result","def get_f1_score(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\n -> Union[float, Tuple[float, float, float]]:\n values = set(labels_true[labels_true >= 0]) | set(labels_pred[labels_pred >= 0])\n if values != {0, 1}:\n raise ValueError('Labels must be binary. '\n 'Check get_f1_scores or get_average_f1_score for multi-label classification.')\n if return_precision_recall:\n f1_scores, precisions, recalls = get_f1_scores(labels_true, labels_pred, True)\n return f1_scores[1], precisions[1], recalls[1]\n else:\n f1_scores = get_f1_scores(labels_true, labels_pred, False)\n return f1_scores[1]","def get_f1(self, predicted, gold):\n correct_labeled = 0\n correct_unlabeled = 0\n num_predicted = 0\n num_gold = 0\n\n for p, g in zip(predicted, gold):\n if p != '_':\n num_predicted += 1\n if p == g:\n correct_labeled += 1\n correct_unlabeled += 1\n elif g != '_':\n correct_unlabeled += 1\n \n if g != '_':\n num_gold += 1\n \n if num_predicted == 0 or num_gold == 0:\n return 0, 0\n\n labeled_precision = correct_labeled / num_predicted\n labeled_recall = correct_labeled / num_gold\n labeled_f1 = (2 * labeled_precision * labeled_recall /\n (labeled_precision + labeled_recall))\n\n unlabeled_precision = correct_unlabeled / num_predicted\n unlabeled_recall = correct_unlabeled / num_gold\n unlabeled_f1 = (2 * unlabeled_precision * unlabeled_recall /\n (unlabeled_precision + unlabeled_recall))\n\n return labeled_f1, unlabeled_f1","def F1_score(y, model):\n\tp = precision(y, model)\n\tr = recall(y, model)\n\tf = 2*((p*r)/(p+r))\n\treturn f","def f1s_binary(y_i, predictions):\n assert len(y_i) == len(predictions)\n fp_1 = 0.0\n tp_1 = 0.0\n fn_1 = 0.0\n tn_1 = 0.0\n for y, y_pred in zip(y_i, predictions):\n for y_w, y_pred_w in zip(y, y_pred):\n if y_w == 0: # true class is 0\n if y_pred_w == 0:\n tp_1 += 1\n else:\n fn_1 += 1\n else: # true class is 1\n if y_pred_w == 0:\n fp_1 += 1\n else:\n tn_1 += 1\n tn_2 = tp_1\n fp_2 = fn_1\n fn_2 = fp_1\n tp_2 = tn_1\n precision_1 = tp_1 / (tp_1 + fp_1) if (tp_1 + fp_1) > 0 else 0\n precision_2 = tp_2 / (tp_2 + fp_2) if (tp_2 + fp_2) > 0 else 0\n recall_1 = tp_1 / (tp_1 + fn_1) if (tp_1 + fn_1) > 0 else 0\n recall_2 = tp_2 / (tp_2 + fn_2) if (tp_2 + fn_2) > 0 else 0\n f1_1 = 2 * (precision_1*recall_1) / (precision_1 + recall_1) if (precision_1 + recall_1) > 0 \\\n else 0\n f1_2 = 2 * (precision_2*recall_2) / (precision_2 + recall_2) if (precision_2 + recall_2) > 0 \\\n else 0\n return f1_1, f1_2","def evaluate(gold, predictions):\n # gold = {i[\"id\"]:i[\"label\"] for i in read(goldfile)}\n # sys = {i[\"id\"]:i[\"prediction\"] for i in read(sysfile)}\n\n labels, preds = [], []\n for idx in gold:\n labels.append(gold[idx])\n preds.append(predictions[idx])\n\n precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support(labels, preds, labels=[0, 1],\n average=\"macro\")\n print(\"F1-macro score for test data predictions are: %.4f\" % f1_macro)\n return preds","def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\r\n return self.f1score","def run_evaluate_compound(self, data):\n tp = 0\n tn = 0\n fp = 0\n fn = 0\n for words, labels, pos in minbatch_generator(data, self.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\n if not type(labels_pred) == list:\n labels_pred = labels_pred.tolist()\n for i, label_actual in enumerate(labels):\n # we have to now find all aspect terms. That is, merge consecutive B \n # with I's until we get an O or B\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\n for a_term in a_terms_actual:\n # say we have [1,2,3] as our a_term. we have to make sure that our \n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\n a_term_pred = []\n for index in a_term:\n if not label_actual[index] == labels_pred[i][index]:\n fn += 1\n break\n else:\n tp += 1\n for index in non_a_terms_actual:\n if label_actual[index] == labels_pred[i][index]:\n tn += 1\n else:\n fp += 1\n\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\n metrics = dict()\n metrics[\"p_1\"] = precision\n metrics[\"f_1\"] = fscore\n metrics[\"r_1\"] = recall\n return metrics","def f1_score(guess, answer):\n if guess is None or answer is None:\n return 0\n score = prec_recall_f1_score(normalize_answer(guess).split(), normalize_answer(answer).split())\n\n return score","def rouge_l_fscore(predictions, labels):\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\n tf.float32)\n return rouge_l_f_score, tf.constant(1.0)","def f1_score(confusion):\n sens = sensitivity(confusion)\n prec = precision(confusion)\n return 2 * sens * prec / (sens + prec)","def score_sc1(self, prediction_file):\n fh = TempFile()\n gs1, _ = self.download_gs()\n script = self.classpath + os.sep + \"DREAM_Olfaction_scoring_Q1.pl\"\n cmd = \"perl %s %s %s %s\"\n cmd = cmd % (script, prediction_file, fh.name, gs1)\n shellcmd(cmd)\n df = pd.read_csv(fh.name, sep='\\t', index_col=None).ix[0]\n fh.delete()\n return df\n\n\n # score sub1 = (zint +zple +zdec)/3\n # sigma_int = 0.0787\n # sigma_ple = 0.176\n # signa_dec = 0.0042\n\n # final is average of zscores","def get_f1_score(y_true, y_pred):\n cf_m = confusion_matrix(y_true, y_pred)\n print(\"tn:\",cf_m[0,0])\n print(\"fp:\",cf_m[0,1])\n print(\"fn:\",cf_m[1,0])\n print(\"tp:\",cf_m[1,1])\n precision = cf_m[1,1] / (cf_m[1,1] + cf_m[0,1])\n recall = cf_m[1,1] / (cf_m[1,1] + cf_m[1,0])\n f1 = 2 * (precision * recall) / (precision + recall)\n\n\n return precision, recall, f1","def eval_metrics_for_seqtags(self, predicted_answers):\n total_correct_in_all = 0\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids, include padding ids.\n correct_label_indices = sample['correct_seq_labels']\n # use extend to add all the labels in the seq, include the head padding and tail padding\n label_true.extend(correct_label_indices)\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n label_pred.extend(sample['pred_seq_tags'])\n\n if total_correct_in_all != 0:\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\n title='Confusion matrix when seq labeling, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\n title='Normalized confusion matrix when seq labeling')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def binary_f1_score(preds, y):\n rounded_predictions = torch.round(torch.sigmoid(preds))\n\n return f1_score(y.cpu().numpy(), rounded_predictions.cpu().numpy(), average='weighted')","def score(self, predicted_y, actual_y):\n\n self.labels = [0, 1, 2, 3]\n\n # Dictionary to store count of each label in predicted labels list\n self.total_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n # Dictionary to store count of each label in actual labels list\n self.total_actual_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n # Dictionary to store count of correctly predicted labels\n self.total_correct_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n for i in xrange(len(predicted_y)):\n # Extract predicted and actual labels for ith record\n predicted_label = predicted_y[i]\n actual_label = actual_y[i]\n\n # Increment the count of corrected predicted label if predicted and actual labels are same\n if predicted_label == actual_label:\n self.total_correct_prediction_count[actual_label] += 1\n\n # Increment total counts\n self.total_actual_count[actual_label] += 1\n self.total_prediction_count[predicted_label] += 1\n\n # Compute f1 scores of each label and return their mean\n return np.mean(self.__get_f1_scores__())","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def prediction_processing(predictions, labels, threshold, step_nb):\n new_labels = []\n new_predictions = []\n number_sequences = step_nb//50\n\n for k in range(len(labels)//number_sequences):\n total_prediction = 0\n isLabelTrue = labels[number_sequences*k]\n for i in range(number_sequences):\n total_prediction += (1/predictions[number_sequences*k+i])\n if not(isLabelTrue == (labels[number_sequences*k+i])):\n logger.error('Problem.')\n if total_prediction > threshold:\n total_prediction = False\n else:\n total_prediction = True\n new_labels.append(isLabelTrue)\n new_predictions.append(total_prediction)\n\n recall_1 = recall_score(new_labels, new_predictions)\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\n precision_1 = precision_score(new_labels, new_predictions)\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)","def f1_score(precision, recall):\n if precision + recall == 0:\n return 0\n return 2 * precision * recall / (precision + recall)","def score(self, data):\n\n score_mappings = {\n \"0\": np.log(self.class_zero_doc_count / self.total_docs),\n \"1\": np.log(self.class_one_doc_count / self.total_docs)\n }\n\n features = self.featurize(data)\n\n for f in features:\n\n if(f[0] in self.class_zero):\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\n else:\n cond_prob_zero = 0\n\n if(f[0] in self.class_one):\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\n else:\n cond_prob_one = 0\n\n score_mappings[\"0\"] += cond_prob_zero\n score_mappings[\"1\"] += cond_prob_one\n\n score_mappings[\"0\"] = np.exp(score_mappings[\"0\"])\n score_mappings[\"1\"] = np.exp(score_mappings[\"1\"])\n\n return score_mappings","def f1_score(true, pred, n_classes=2, pos_label=1, average=None, weights=None):\n\n if n_classes == 2:\n if np.sum(true * pred) == 0:\n f1 = 0.0\n else:\n f1 = skl_f1_score(true, pred, average='binary', labels=range(n_classes), pos_label=pos_label, sample_weight=weights)\n else:\n if average is None:\n f1 = skl_f1_score(true, pred, average='micro', labels=range(n_classes), pos_label=None, sample_weight=weights)\n else:\n f1 = skl_f1_score(true, pred, average=average, labels=range(n_classes), pos_label=None, sample_weight=weights)\n return f1","def evaluate(true_labels, predicted_labels):\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \n 2)\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \n average='weighted'), 2)\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\n average='weighted'), 2)\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \n average='weighted'), 2)\n \n return accuracy, precision, recall, f1","def f1_score(confusion):\n p = precision(confusion)\n r = sensitivity(confusion)\n F1 = (2 * p * r) / (p + r)\n return F1","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def scoring(estimator, features_test, labels_test):\n pred = estimator.predict(features_test)\n p = metrics.precision_score(labels_test, pred, average='micro')\n r = metrics.recall_score(labels_test, pred, average='micro')\n if p > 0.3 and r > 0.3:\n return metrics.f1_score(labels_test, pred, average='macro')\n return 0","def _eval_classifier(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\n try:\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\n except ValueError:\n auc_baseline = \"NA\"\n\n precision_sample = precision_score(y_label_sample, y_pred_sample)\n recall_sample = recall_score(y_label_sample, y_pred_sample)\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\n f1_sample = f1_score(y_label_sample, y_pred_sample)\n try:\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\n except ValueError:\n auc_sample = \"NA\"\n\n metrics_df = pd.DataFrame(\n {\n \"Accuracy\": [acc_baseline, acc_sample],\n \"Precision\": [precision_baseline, precision_sample],\n \"Recall\": [recall_baseline, recall_sample],\n \"F1\": [f1_baseline, f1_sample],\n \"AUC\": [auc_baseline, auc_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def PredictMatch(yourName, tgtName, teamModels, db):\n\n teamTgtPipe, teamYourPipe = QueryTeamData(tgtName, yourName, db)\n featureCoefTgt, probTgt = PredictOp(teamTgtPipe, teamYourPipe, tgtName, teamModels)\n featureCoefYour, probYour = PredictOp(teamYourPipe, teamTgtPipe, yourName, teamModels)\n odds = round(probYour / (probYour + probTgt), 2)\n\n # In featureCoefYour, you want INCREASE those with POSTIVE COEF, DECREASE those with NEGATIVE COEF\n # In featureCoefTgt, you want to do the opposite\n\n # reverse both the sign of the coef, and '_op' in features so as to be the same with featureCoefYour\n featureCoefTgt['coef'] = - featureCoefTgt['coef']\n featureCoefTgt.features = [ii[:-3] if \"_op\" in ii else ii + '_op' for ii in featureCoefTgt.features]\n\n # Combine only the most important 10 features\n # featureBoth = featureCoefTgt[11:].append(featureCoefYour[11:])\n\n # Combine only all the most important features\n featureBoth = featureCoefTgt.append(featureCoefYour)\n\n # get action recommendations\n # Somehow the pandas here uses a deprecated para cols, instaed of the new one subset\n #featureBoth.drop_duplicates(subset = 'features', take_last = True, inplace = True)\n featureBoth.drop_duplicates(cols = 'features', take_last = True, inplace = True)\n actions, featureImprove = GetActions(featureBoth)\n Imp = 0.1\n oddsNew = ImprovedScore(tgtName, yourName, teamModels, featureImprove, teamTgtPipe, teamYourPipe, Imp)\n\n return odds, oddsNew, actions","def f1_score_loss(predicted_probs: tf.Tensor, labels: tf.Tensor) -> tf.Tensor:\n # Apply a sharpened sigmoid function to approximate the threshold\n thresholded_predictions = predicted_probs - ONE_HALF\n level_predictions = 1.0 / (1.0 + tf.exp(BETA * thresholded_predictions)) # [B, L]\n # predictions = tf.reduce_prod(level_predictions, axis=-1, keepdims=True) # [B, 1]\n predictions = tf.exp(tf.reduce_sum(tf.log(level_predictions), axis=-1, keepdims=True)) # [B, 1]\n\n # Compute the (approximate) F1 score\n f1_score = 2 * tf.reduce_sum(predictions * labels) / (tf.reduce_sum(predictions) + tf.reduce_sum(labels))\n return 1.0 - f1_score","def accuracy(predictions, test_labels):\n return f1_score(test_labels, predictions, average='micro') * 100","def recall(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_neg = 0 #gold pos sys neg\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"1\" and predicted_labels[i] == \"0\"):\n false_neg += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_neg))","def score(self, sentence):\n score = 0.0\n V = len(self.f1) # vocabulary size\n for token in sentence:\n if token in self.f1: score += self.f1[token]\n else: score -= math.log10(self.total + V)\t\t # OOV \n return score","def evaluate(self, predicted_df):\n logging.info(\"Evaluating model: {}\".format(self.model_type))\n y_true = predicted_df[\"user_label\"].as_matrix()\n y_pred = predicted_df[\"label\"].as_matrix()\n\n scores_cols = [col for col in predicted_df.columns if col.startswith(\"scores_\")]\n print(\"scores_cols: {}\".format(scores_cols))\n\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\n print(\"predicted scores: {}\".format(y_pred_scores))\n y_true_scores = []\n for lab in predicted_df[\"user_label\"]:\n trues = [0 for _ in range(len(scores_cols))]\n if \"scores_\"+lab in scores_cols:\n trues[scores_cols.index(\"scores_\"+lab)] = 1\n y_true_scores.append(trues)\n print(\"true scores: {}\".format(y_true_scores))\n y_true_scores = np.array(y_true_scores)\n\n performance = {\"model\": self.model_type, \"description\": self.description}\n if 'categorical_accuracy' in self.metrics:\n logging.info(\"Calculating categorical accuracy for {}\".format(self))\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\n y_pred) # np.mean(y_pred == y_true)\n if 'fmeasure' in self.metrics:\n logging.info(\"Calculating fmeasure for {}\".format(self))\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\n if 'MRR' in self.metrics:\n logging.info(\"Calculating MRR for {}\".format(self))\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\n logging.info(\"Calculated performance: {}\".format(performance))\n print(performance)\n return pd.DataFrame(performance, index=[0])","def calculate_f1(fx, y):\n pred_idxs = fx.max(1, keepdim=True)[1]\n pred_names = [idx2target[i.item()] for i in pred_idxs]\n original_names = [idx2target[i.item()] for i in y]\n true_positive, false_positive, false_negative = 0, 0, 0\n for p, o in zip(pred_names, original_names):\n predicted_subtokens = p.split('|')\n original_subtokens = o.split('|')\n for subtok in predicted_subtokens:\n if subtok in original_subtokens:\n true_positive += 1\n else:\n false_positive += 1\n for subtok in original_subtokens:\n if not subtok in predicted_subtokens:\n false_negative += 1\n try:\n precision = true_positive / (true_positive + false_positive)\n recall = true_positive / (true_positive + false_negative)\n f1 = 2 * precision * recall / (precision + recall)\n except ZeroDivisionError:\n precision, recall, f1 = 0, 0, 0\n return precision, recall, f1","def calculate_f1_score(predictions, actuals):\n predictions = predictions > 0.5\n # fbeta_score throws a confusing error if inputs are not numpy arrays\n predictions, actuals, = np.array(predictions), np.array(actuals)\n # We need to use average='samples' here, any other average method will generate bogus results\n return fbeta_score(actuals, predictions, beta=1, average='samples')","def calculate_score(result):\n sample1=result['Sample1']\n sample2=result['Sample2']\n string1=paragraph_to_list(sample1)\n string2=paragraph_to_list(sample2)\n \n return round( strings_similarity(string1, string2), 2)\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\n #return round(0.5*(method_difflab+method_dict), 2)","def evaluate_nltk(self, X):\n X_, y_ = separate_labels_from_features(X)\n \n y = []\n n_sent_correct = 0\n num_sent = len(y_)\n \n for i in range(num_sent):\n sentence_correct = True\n for j in range(len(y_[i])):\n y.append(self.clf_nltk.classify(X_[i][j]))\n if y_[i][j] != y[-1]:\n sentence_correct = False\n \n if sentence_correct == True:\n n_sent_correct += 1\n \n y_ = flatten(y_)\n print(\"F1 score:\")\n print(sklearn.metrics.precision_recall_fscore_support(y_, y, average='micro'))\n print()\n print(\"Accuracy:\")\n print(sklearn.metrics.accuracy_score(y_, y))\n print()\n print(\"Sentence level accuracy:\")\n print(n_sent_correct / num_sent)\n print()\n print(\"F1 score per class:\")\n print(sklearn.metrics.precision_recall_fscore_support(y_, y))\n print()\n print(\"Confusion matrix:\")\n cfm = sklearn.metrics.confusion_matrix(y_, y)\n\n plot_confusion_matrix(cfm, np.unique(y_))\n \n print(np.unique(y_))\n print()\n print(print(np.unique(y)))","def compute(self) -> None:\n \n self.model.eval()\n \n with torch.no_grad():\n for (input, target, _) in self.loader:\n\n # self.model = self.model.train(False) # TEST @lacoupe\n output, _ = self.model(input)\n \n output = (output >= 0.5)\n \n for out, tar in zip(output, target):\n \n tar = bool(tar)\n \n if out and tar:\n self.confusion['true_positive'] += 1\n elif not out and not tar:\n self.confusion['true_negative'] += 1\n elif out and not tar:\n self.confusion['false_positive'] += 1\n elif not out and tar:\n self.confusion['false_negative'] += 1\n \n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\n / sum(list(self.confusion.values()))\n \n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\n self.precision = 0.\n else:\n self.precision = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\n \n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\n self.recall = 0.\n else:\n self.recall = self.confusion['true_positive'] \\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\n \n if (self.precision + self.recall) == 0.:\n self.f1_score = 0.\n else:\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)","def get_best_f1_metrics(self,\n verbose: bool = True) -> Tuple[int, int]:\n f1_scores = list()\n for i in self.search_space:\n classes = self.convert_classes(threshold=i)\n f1_scores.append(f1_score(classes, self.y_true))\n best_f1_score, best_f1_threshold = self._get_best_metrics(\n metric_type='f1_score',\n scores=f1_scores,\n greater_is_better=True,\n verbose=verbose\n )\n return best_f1_score, best_f1_threshold","def predict(self, x_val, y1_test=None, y2_test=None):\n if y1_test is None and y2_test is None:\n y1_test = np.ones(len(x_val))\n y2_test = y1_test\n score_model = False\n else:\n score_model = True\n\n self.stage_one.predict(x_val, y1_test)\n if score_model:\n stage_one_score = self.stage_one.score\n\n # This section will not generalize well beyond this specific dataset.\n if score_model:\n df = pd.DataFrame(data=[y1_test, self.stage_one.pred],\n columns=['y1_test', 'stage_one.pred'])\n df = pd.DataFrame(y1_test).rename(columns={'class_second': 'y1_test'})\n df['stage_one.pred'] = self.stage_one.pred\n df['tweets'] = x_val\n df['y2_test'] = y2_test\n\n # x2_val = df['tweets'].loc[df['stage_one.pred'] == 0]\n # y2_test_ = df['y2_test'].loc[df['stage_one.pred'] == 0]\n x2_val = df['tweets'].loc[df['stage_one.pred'] == 1]\n y2_test_ = df['y2_test'].loc[df['stage_one.pred'] == 1]\n else:\n # x2_val = x_val[self.stage_one.pred == 0]\n x2_val = x_val[self.stage_one.pred == 1]\n y2_test_ = np.ones(len(x2_val))\n\n self.stage_two.predict(x2_val, y2_test_)\n if score_model:\n stage_two_score = self.stage_two.score\n return (stage_one_score, stage_two_score, stage_one_score*stage_two_score)\n else:\n # return tweets that contain hate speech\n return x2_val[self.stage_two.pred == 0]","def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\n\n\t# set variables\n\trm1_vec = list()\n\tvocab = set()\n\tdoc_vecs = dict()\n\n\t# create document feature vectors for each feedback doc\n\tfor doc_id in ids_and_scores.keys():\n\t\t# convert current doc to bow format\n\t\tbow = ix.doc2bow(corpus[doc_id])\n\t\t# create document feature vector\n\t\tdfv = create_feature_vector(ix, term_dict, bow)\n\t\t# keep top 'fb_terms' from dfv\n\t\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\n\t\tvocab.update(dfv.keys())\n\t\tdoc_vecs[doc_id] = dfv\n\n\t# compute L1 norm for each document feature vector\n\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\n\n\t# loop over terms in vocab and compute RM1\n\tfor term in vocab:\n\t\tfb_weight = 0.0\n\t\t# loop over document feature vectors \n\t\tfor doc_id in doc_vecs.keys():\n\t\t\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\n\t\t\t\t# sum the score of current term across different docs to fb_weight\n\t\t\t\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\n\t\t# assign term w/ weight to RM1 feature vector\n\t\trm1_vec.append((term, fb_weight))\n\n\t# keep top 'fb_terms' from rm1_vec\n\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t# scale rm1_vec to L1 norm\n\treturn scale_to_L1_norm(rm1_vec)","def prec_recall_f1_score(pred_items, gold_items):\n common = Counter(gold_items) & Counter(pred_items)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(pred_items)\n recall = 1.0 * num_same / len(gold_items)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def f2_score(self, y_true=None, y_pred=None, labels=None, average=\"macro\", decimal=None, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\n\n list_f2 = np.array([item[\"f2\"] for item in metrics.values()])\n list_weights = np.array([item[\"n_true\"] for item in metrics.values()])\n\n if average == \"micro\":\n tp_global = np.sum(np.diag(matrix))\n fp_global = fn_global = np.sum(matrix) - tp_global\n precision = tp_global / (tp_global + fp_global)\n recall = tp_global / (tp_global + fn_global)\n f2 = (5 * precision * recall) / (4 * precision + recall)\n elif average == \"macro\":\n f2 = np.mean(list_f2)\n elif average == \"weighted\":\n f2 = np.dot(list_weights, list_f2) / np.sum(list_weights)\n else:\n f2 = dict([(label, np.round(item[\"f2\"], decimal)) for label, item in metrics.items()])\n return f2 if type(f2) == dict else np.round(f2, decimal)","def evaluate(ground_truth, prediction):\n\n def prfs_to_dict(prfs):\n \"\"\"Returns a precision_recall_fscore_support() result as a dict.\"\"\"\n return {\"precision\": prfs[0], \"recall\": prfs[1], \"fscore\": prfs[2]}\n\n results = {}\n items_count = len(ground_truth)\n\n # accuracy\n accuracy = accuracy_score(ground_truth, prediction)\n results[\"accuracy\"] = accuracy\n\n # confusion matrix\n categories = set(ground_truth) | set(prediction)\n confusions = {\n gold: {pred: 0 for pred in categories} for gold in categories\n }\n for g, p in zip(ground_truth, prediction):\n confusions[g][p] += 1\n results[\"confusions\"] = confusions\n\n # class wise precision, recall & f1\n classwise = precision_recall_fscore_support(\n ground_truth, prediction, average=None, warn_for=()\n )\n results[\"true_cat_dist\"] = list(classwise[-1])\n results[\"classwise\"] = {\n str(cl): prfs_to_dict(\n [classwise[0][cl], classwise[1][cl], classwise[2][cl]]\n )\n for cl in categories\n }\n\n # average precision, recall & f1\n results[\"macro_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"macro\",\n pos_label=None,\n warn_for=(),\n )\n )\n results[\"micro_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"micro\",\n pos_label=None,\n warn_for=(),\n )\n )\n results[\"weigh_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"weighted\",\n pos_label=None,\n warn_for=(),\n )\n )\n\n # marginals\n gold_category_distribution = {\n g: sum([confusions[g][p] for p in categories]) for g in categories\n }\n pred_category_distribution = {\n p: sum([confusions[g][p] for g in categories]) for p in categories\n }\n\n # kappa\n expected_agreement_fleiss = sum(\n [\n (\n (gold_category_distribution[c] + pred_category_distribution[c])\n / (2.0 * items_count)\n )\n ** 2\n for c in categories\n ]\n )\n expected_agreement_cohen = sum(\n [\n (float(gold_category_distribution[c]) / items_count)\n * (float(pred_category_distribution[c]) / items_count)\n for c in categories\n ]\n )\n kappa_fleiss = (\n 1.0\n * (accuracy - expected_agreement_fleiss)\n / (1 - expected_agreement_fleiss)\n )\n kappa_cohen = (\n 1.0\n * (accuracy - expected_agreement_cohen)\n / (1 - expected_agreement_cohen)\n )\n results[\"k_fleiss\"] = {\n \"k\": kappa_fleiss,\n \"AE\": expected_agreement_fleiss,\n \"AO\": accuracy,\n }\n results[\"k_cohen\"] = {\n \"k\": kappa_cohen,\n \"AE\": expected_agreement_cohen,\n \"AO\": accuracy,\n }\n\n return results","def get_f1(self,common_len,RTSummary,SystemSummary):\n recall = self.get_recall(common_len,RTSummary)\n precision = self.get_precision(common_len,SystemSummary)\n if precision<=0 or recall <=0:\n return 0.0\n else:\n return ((2 * recall * precision)/(recall + precision))","def _get_similarity_score(self, dict1, dict2):\n try:\n majorScoreDeterminer1 = ['primaryGenreId']\n majorScoreDeterminer2 = ['genreIds']\n Score = 0 # Base Score\n for items in majorScoreDeterminer2:\n\n for item1 in self._get_app_param_info(dict1, resultCount=1, resultKey=items):\n if item1 in self._get_app_param_info(dict2, resultCount=1, resultKey=items):\n if Score == 0: # Add 50% base score for this category.\n Score += 2 * .5\n Score += 2 * .5 / len(self._get_app_param_info(dict1, resultCount=1, resultKey=items))\n\n for items in majorScoreDeterminer1:\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\n self._get_app_param_info(dict1, resultCount=1, resultKey=items)):\n Score += (3 / len(majorScoreDeterminer1))\n\n nameMatchScore = difflib.SequenceMatcher(None,\n self._get_app_param_info(dict1, resultCount=1,\n resultKey='trackName'),\n self._get_app_param_info(dict2, resultCount=1,\n resultKey='trackName')).ratio()\n Score += nameMatchScore\n\n minorScoreDeterminer = ['isGameCenterEnabled', 'languageCodesISO2A', 'contentAdvisoryRating', 'artistId',\n 'formattedPrice']\n\n for items in minorScoreDeterminer:\n if items == \"formattedPrice\":\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \"Free\":\n Score += (4 / (len(minorScoreDeterminer)))\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \"Free\":\n continue\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \"Free\":\n continue\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \"Free\":\n Score += (4 / (len(minorScoreDeterminer)))\n else:\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)):\n Score += (4 / (len(minorScoreDeterminer)))\n Score = round(Score, 1)\n log_str = \"id\" + str(self._get_app_param_info(dict2, resultCount=1, resultKey='trackId')) + \" - \" + str(\n self._get_app_param_info(dict2, resultCount=1, resultKey='trackName')) + \"\\tScore: \" + str(Score)\n except AssertionError as e:\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n except TypeError as e:\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n except:\n e = sys.exc_info()[0]\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n else:\n return log_str","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def _accuracy(label_file, pred_file,subword_option=None):\n\n with open(label_file, \"r\", encoding='utf-8') as label_fh:\n with open(pred_file, \"r\", encoding='utf-8') as pred_fh:\n count = 0.0\n match = 0.0\n for label in label_fh:\n label = label.strip()\n label = \" \".join(_clean(label,subword_option))\n pred = pred_fh.readline().strip()\n pred = \" \".join(_clean(pred,subword_option))\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def _prec_recall_f1_score(pred_items, gold_items):\n common = Counter(gold_items) & Counter(pred_items)\n num_same = sum(common.values())\n if num_same == 0:\n return 0, 0, 0\n precision = 1.0 * num_same / len(pred_items)\n recall = 1.0 * num_same / len(gold_items)\n f1 = (2 * precision * recall) / (precision + recall)\n return precision, recall, f1","def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\n best_f_score = tensor(0.0)\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n for target in targets:\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\n if f_score > best_f_score:\n best_f_score = f_score\n best_matching_char_n_grams = matching_char_n_grams\n best_matching_word_n_grams = matching_word_n_grams\n best_target_char_n_grams = target_char_n_grams\n best_target_word_n_grams = target_word_n_grams\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams","def get_r2_score(ground_truth, predicted):\n residual = np.sum(np.square(np.subtract(ground_truth, predicted)))\n print(residual)\n total = np.sum(np.square(np.subtract(ground_truth, np.mean(ground_truth))))\n print(total)\n return np.subtract(1.0, np.divide(residual, (total + 0.00000000001)))","def get_f1(self, y_true, y_pred):\n precision = self.get_precision(y_true, y_pred)\n recall = self.get_recall(y_true, y_pred)\n f1 = 2*(precision*recall)/(precision + recall)\n return f1","def score(self, df: pd.DataFrame, label_column: str) -> float:\n assert label_column not in self.feature_columns, 'Label column is in the feature list.'\n assert label_column in df.columns, 'Label column is not in the dataframe.'\n\n rounded_preds = self.predict(df).round()\n return f1_score(df[label_column].values, rounded_preds)","def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy","def calc_metrics(pred, labels):\n pred_flat = np.argmax(pred, axis = 1).flatten()\n labels_flat = labels.flatten()\n \n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\n \n # sklearn takes first parameter as the true label\n precision = precision_score(labels_flat, pred_flat)\n recall = recall_score(labels_flat, pred_flat)\n \n return flat_accuracy, precision, recall","def validate(self, validate_data):\n with open(validate_data, 'r') as validate_data:\n true_positive = 0\n true_negative = 0\n false_positive = 0\n false_negative = 0\n result = {}\n for type in self.label_type_map:\n result[type] = []\n while True:\n tokens = validate_data.readline().split()\n pos = validate_data.readline().split()\n labels = validate_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Classify all named entities in a sentence 85\n curr_results = self.viterbi(tokens)\n for i in range(0, len(labels)):\n if curr_results[i] != 'O':\n if labels[i] == 'O':\n false_positive += 1 # Not 'O', but should be 'O'\n else:\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\n true_positive += 1 # Correct prediction\n else:\n if labels[i] == 'O':\n true_negative += 1 # Correct prediction of 'O'\n else:\n false_negative += 1 # Predicted 'O', not 'O'\n # Calculate precision - TP / (TP + FP)\n precision = float(true_positive) / float(true_positive + false_positive)\n # Calculate recall - TP / (TP + FN)\n recall = float(true_positive) / float(true_positive + false_negative)\n # Calculate F-Score - 2 * P * R / (P + R)\n f_score = float(2*precision * recall) / float(precision + recall)\n print \"Precision: \" + str(precision)\n print \"Recall: \" + str(recall)\n print \"F-score: \" + str(f_score)","def recall1(y_test, predictions):\n recall = 0.0\n\n for i in range(y_test.shape[0]):\n intersection = 0.0\n Yi = 0.0\n for j in range(y_test.shape[1]):\n Yi = Yi + int(y_test[i,j])\n\n if y_test[i,j] == 1 and int(predictions[i,j]) == 1:\n intersection = intersection + 1\n \n if Yi != 0:\n recall = recall + float(intersection/Yi) \n \n recall = recall/y_test.shape[0]\n return recall","def label_accuracy_score(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n # 一个batch里面可能有多个数据\n # 通过迭代器将一个个数据进行计算\n for lt, lp in zip(label_trues, label_preds):\n # numpy.ndarray.flatten将numpy对象拉成1维\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\n \"\"\"\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\n iu是召回率Recall，公式上面给出了\n mean_iu就是对iu求了一个平均\n freq是每一类被预测到的频率\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\n \"\"\"\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n # nanmean会自动忽略nan的元素求平均\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def score(self, x, y, verbose=False):\n y_pred = self.forward(x).T\n\n y_p = np.argmax(y_pred, axis=-1)\n y_t = np.argmax(y, axis=-1)\n fpr, tpr, thresholds = roc_curve(y_t, y_p, pos_label=2)\n\n metricas = {\n 'accuracy': accuracy_score(y_t, y_p),\n 'f1':f1_score(y_t, y_p, average='macro'),\n 'balanced accuracy': balanced_accuracy_score(y_t, y_p),\n 'auc': auc(fpr, tpr)\n }\n\n if verbose:\n print('Accuracy', metricas['accuracy'])\n print('F1-Macro', metricas['f1'])\n print('Balanced accuracy', metricas['balanced accuracy'])\n print('AUC', metricas['auc'])\n\n return metricas","def evaluate(predictions, documents):\n ###TODO\n x = 0.0\n y = 0 #true ham, classified spam\n z = 0 #true spam, classified ham\n \n for i in range(0,len(predictions)):\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\n z += 1\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\n y += 1 \n \n x = (len(documents) - (y+z)) / len(documents) \n return (x,y,z)\n pass","def evaluate(y_true, y_preds, labels=[0, 1, 2, 3, 4]):\n p_scores = []\n r_scroes = []\n for label in labels:\n p = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_preds == label).sum() + 0.001)\n p_scores.append(p)\n r = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_true == label).sum() + 0.001)\n r_scroes.append(r)\n p_scores = np.array(p_scores)\n r_scroes = np.array(r_scroes)\n f1 = 2 * (p_scores * r_scroes + 0.001) / (p_scores + r_scroes + 0.001)\n\n confmat = []\n for label in labels:\n conf = []\n for label2 in labels:\n conf.append(((y_preds == label) * (y_true == label2)).sum())\n confmat.append(conf)\n confmat = np.array(confmat)\n\n return p_scores, r_scroes, f1, confmat","def _get_precision_recall_f1(preds_embeddings: Tensor, target_embeddings: Tensor, preds_idf_scale: Tensor, target_idf_scale: Tensor) ->Tuple[Tensor, Tensor, Tensor]:\n cos_sim = torch.einsum('blpd, blrd -> blpr', preds_embeddings, target_embeddings)\n precision = _get_scaled_precision_or_recall(cos_sim, 'precision', preds_idf_scale)\n recall = _get_scaled_precision_or_recall(cos_sim, 'recall', target_idf_scale)\n f1_score = 2 * precision * recall / (precision + recall)\n f1_score = f1_score.masked_fill(torch.isnan(f1_score), 0.0)\n return precision, recall, f1_score","def evaluate(labels, predictions):\n #labels and predictions\n truePos = 0\n trueNeg = 0\n for data in range(len(labels)):\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\n truePos+=1\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\n trueNeg+=1\n sensitivity = truePos/(len(labels) + 1)\n specificity = trueNeg/(len(labels) + 1)\n return (sensitivity, specificity)\n \n\n #raise NotImplementedError","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n print('*'*20, '\\n')\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\n')\n print('*'*20)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def evaluate(self, sess, data_gen):\n pred_labels = np.array([], dtype=np.intp)\n labels = np.array([], dtype=np.intp)\n for inputs, seq_length, batch_labels in data_gen:\n feed_dict = self.create_feed_dict(inputs, seq_length, batch_labels,\n self.config.dropout)\n pred = sess.run(self.pred, feed_dict)\n pred = softmax(pred, -1)\n pred = binarize(pred[:, 1], self.threshold)\n\n pred_labels = np.concatenate((pred_labels, pred))\n labels = np.concatenate((labels, batch_labels))\n\n score = f1_score(labels, pred_labels)\n\n return score, pred_labels","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def _score_to_decision(self, score):","def scoring_function(self, model, y_true, y_predicted_probability):","def do_score_prediction(self):\n \n import iread.myio as mio\n from igui.score_canvas import ScoreCanvas\n exp_name = 'JPS_act_12_exp_4_accv_half_fc_j2'\n exp_name_base = 'ASM_act_12_exp_4'\n exp_base_folder = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp'\n exp_path = iu.fullfile(exp_base_folder, 'folder_%s' % exp_name, 'batches.meta')\n meta_base_path = iu.fullfile(exp_base_folder, 'folder_%s' % exp_name_base, 'batches.meta')\n meta = mio.unpickle(exp_path)\n meta_base = mio.unpickle(meta_base_path)\n images_path = meta_base['images_path']\n \n pred_pose = meta['feature_list'][0]\n gt_pose = meta['random_feature_list'][0]\n ntotal = gt_pose.shape[-1]\n print 'gt_pose_shape',gt_pose.shape\n print 'pred_pose_shape', pred_pose.shape\n ref_frame = 7600 # This is the index in test range\n ## ref_frame = 2600 # This is the index in test range\n test_range = self.test_data_provider.feature_range\n ref_idx = test_range[ref_frame]\n \n n_to_show = 1000\n \n idx_to_show = np.random.choice(ntotal, n_to_show - 1)\n idx_to_show = [ref_idx] + idx_to_show.tolist() \n idx_to_show = np.asarray(idx_to_show, dtype=np.int).flatten()\n \n ref_pose = pred_pose[...,ref_idx].reshape((-1,1),order='F') \n pose_to_eval =gt_pose[...,idx_to_show]\n output_feature_name = 'fc_2' # <------------------Parameter\n output_layer_idx = self.get_layer_idx(output_feature_name)\n\n # do it once <------------- Maybe it can support multiple batch in the future\n data_dim = self.model_state['layers'][output_layer_idx]['outputs']\n print 'data_dim', data_dim\n \n cur_data = [np.require(np.tile(ref_pose, [1,n_to_show]), \\\n dtype=np.single,requirements='C'), \\\n np.require(pose_to_eval.reshape((-1,n_to_show),order='F'),\\\n dtype=np.single,requirements='C'), \\\n np.require(np.zeros((1,n_to_show),dtype=np.single), \\\n requirements='C'),\n np.require(np.zeros((n_to_show,data_dim),dtype=np.single), \\\n requirements='C')]\n residuals = cur_data[1][...,0].reshape((-1,1),order='F') - cur_data[1]\n dp = self.test_data_provider\n mpjpe = dutils.calc_mpjpe_from_residual(residuals, dp.num_joints)\n\n gt_score = dp.calc_score(mpjpe, dp.mpjpe_factor/dp.max_depth,\\\n dp.mpjpe_offset/dp.max_depth).reshape((1,n_to_show)).flatten()\n self.libmodel.startFeatureWriter(cur_data, output_layer_idx)\n self.finish_batch()\n score = cur_data[-1].T\n print 'dim score', score.shape, 'dim gt_score', gt_score.shape\n score = score.flatten()\n # score = gt_score.flatten()\n def my_sort_f(k):\n if k == 0:\n return 10000000\n else:\n return score[k]\n sorted_idx = sorted(range(n_to_show), key=my_sort_f,reverse=True)\n s_to_show = [idx_to_show[k] for k in sorted_idx]\n sorted_score = np.asarray( [score[k] for k in sorted_idx])\n \n pose_to_plot = self.convert_relskel2rel(cur_data[1])\n sorted_pose = pose_to_plot[...,sorted_idx]\n class ScorePoseCanvas(ScoreCanvas):\n def __init__(self,data_dic):\n import iread.h36m_hmlpe as h36m\n ScoreCanvas.__init__(self,data_dic)\n self.pose_data = data_dic['pose_data']\n self.limbs = h36m.part_idx\n self.tmp = 0\n def show_image(self,ax):\n # ScoreCanvas.show_image(self,ax)\n # return\n import Image\n idx =self.cur_data_idx\n if idx == 0:\n self.tmp = self.tmp + 1\n if self.tmp == 1:\n img = self.load_image(idx)\n ax.imshow(np.asarray(img))\n return\n print 'Current data idx %d ' % self.cur_data_idx\n # params = {'elev':-89, 'azim':-107}\n # params = {'elev':-69, 'azim':-107}\n params = {'elev':-81, 'azim':-91} # frontal view\n fig = plt.figure(100)\n from mpl_toolkits.mplot3d import Axes3D\n import imgproc\n # new_ax = self.fig.add_axes( rng_rel,projection='polar')\n new_ax = fig.add_subplot(111,projection='3d')\n imgproc.turn_off_axis(new_ax)\n cur_pose = self.pose_data[...,idx].reshape((3,-1),order='F')\n dutils.show_3d_skeleton(cur_pose.T,\\\n self.limbs, params)\n xmin,xmax = np.min(cur_pose[0]),np.max(cur_pose[0])\n ymin,ymax = np.min(cur_pose[1]),np.max(cur_pose[1])\n zmin,zmax = np.min(cur_pose[2]),np.max(cur_pose[2])\n def extent(x,y,ratio):\n x = x + (x-y) * ratio\n y = y + (y-x) * ratio\n return -0.4,0.4\n r = 0.1\n new_ax.set_xlim(extent(xmin,xmax,r))\n new_ax.set_ylim(extent(ymin,ymax,r))\n new_ax.set_ylim(extent(zmin,zmax,r))\n tmp_folder = '/public/sijinli2/ibuffer/2014-CVPR2015/tmp/images'\n save_path = iu.fullfile(tmp_folder, 'tmp_image.png')\n plt.savefig(save_path)\n img = Image.open(save_path)\n plt.close(100)\n img_arr = np.asarray(img)\n s = np.int(img_arr.shape[0]/5.0)\n e = np.int(img_arr.shape[0] - s)\n s = 0\n e = img_arr.shape[0]\n img_arr = img_arr[s:e,:,:]\n ax.imshow(np.asarray(img_arr))\n # ax.plot([1,0,0],[0,1,0],[0,0,1])\n\n\n sc = ScorePoseCanvas({'x': np.asarray(range(len(idx_to_show))), 'y':sorted_score,\\\n 'images_path': [images_path[k] for k in s_to_show], \\\n 'pose_data':sorted_pose})\n sc.start()\n print 'max score is ' , sorted_score.max()\n gt_sort_idx = sorted(range(n_to_show), key=lambda k:gt_score[k], reverse=True)\n sorted_gt_score = np.asarray([gt_score[k] for k in gt_sort_idx])\n sorted_score_by_gt = [score[k] for k in gt_sort_idx]\n pl.plot(np.asarray(range(n_to_show)), sorted_gt_score, 'r', label='gt_score')\n pl.plot(np.asarray(range(n_to_show)), sorted_score_by_gt, 'g', label='pred_score')","def PredictReviewScore(self, sentences, label=0):\n AdjR = 0.0\n # if text.startswith(\"For more photos and reviews do check out fourleggedfoodies\"):\n # x = 1\n adjAll = []\n for sentence in sentences:\n adjectives, dependencies = self.ExtractSentDetails(sentence)\n adjAll.extend(adjectives)\n allAdjectives = adjectives | Angel.GlobalAdjList\n AdjS = 0.0\n words = wordpunct_tokenize(sentence[\"Text\"])\n if len(words) <= 3:\n allAdjectives |= set([x.lower() for x in words])\n for i in range(len(words)):\n word = words[i].lower()\n if word in {\"but\", \"if\"}:\n AdjS = 0.0\n elif word in allAdjectives and word in self.lexicon:\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\n AdjR += AdjS\n AdjR *= self.PredictBase(adjAll)\n finalScore = AdjR\n if self.DumpRequested(finalScore, label):\n self.DumpDetails(sentences, label)\n return finalScore","def eval_metrics_for_multiclass(self, predicted_answers):\n total_correct_in_all = 0\n total_pred_in_all = len(predicted_answers)\n # initial a dict for total correct in topK counting.\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\n max_topK = max(self.topK_list)\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids\n correct_label_indices = sample['correct_labels']\n # current case, we only have a majority lable for the correct label\n label_true.append(correct_label_indices[0])\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\n top1_pred = sorted_probs_max_topK[0]\n label_pred.append(top1_pred['label_index'])\n\n # for all topK predictions\n for i in range(len(sorted_probs_max_topK)):\n pred = sorted_probs_max_topK[i]\n for topK in self.topK_list:\n if i >= topK:\n continue\n else:\n total_pred_in_topK[topK] += 1\n if pred['label_index'] in correct_label_indices:\n total_correct_in_topK[topK] += 1\n\n if total_correct_in_all != 0:\n # recall@K\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\n # assign recall@K into metrics\n for k, v in recall_at_K.items():\n # Jie\n # 1 means the greater the better.\n # -1 means the smaller the better.\n metrics['R@{}'.format(k)] = (1, v)\n\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\n # here return all the p,r,f for each label, then we compute the micro average later.\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\n title='Confusion matrix, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\n title='Normalized confusion matrix')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics"],"string":"[\n \"def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\\\"malaria\\\", confusion_matrix_title=\\\"\\\"):\\n # demonstration of calculating metrics for a neural network model using sklearn\\n if not binary_classifcation:\\n # For multiclass classification.\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n precision = precision_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n recall = recall_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n f1 = f1_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n print('Accuracy: %f' % accuracy)\\n print('Precision: %f' % precision)\\n print('Recall: %f' % recall)\\n print('F1 score: %f' % f1)\\n\\n else:\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n print('Accuracy: %f' % accuracy)\\n # # precision tp / (tp + fp)\\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Precision: %f' % precision)\\n # recall: tp / (tp + fn)\\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Recall: %f' % recall)\\n # f1: 2 tp / (2 tp + fp + fn)\\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('F1 score: %f' % f1)\\n # ROC AUC\\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\\n # print('ROC AUC: %f' % auc)\\n\\n # confusion matrix\\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\\n display_labels=list(np.unique(actual_labels)),\\n cmap=plt.cm.Blues,\\n normalize=None)\\n disp.ax_.set_title(confusion_matrix_title)\\n plt.show()\\n matrix = confusion_matrix(actual_labels, preds_labels)\\n print(matrix)\\n # if plot_confusion_matrix:\\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))\",\n \"def f1_score_per_label(y_true, y_pred, threshold, eps=1e-9):\\n \\n y_pred = torch.ge(y_pred.float(), threshold).float()\\n\\n y_true = y_true.float()\\n\\n tp_l = (y_pred * y_true).sum(0).float()\\n\\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\\n\\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\\n\\n precision_label = tp_l.div(tp_l + fp_l + eps)\\n\\n recall_label = tp_l.div(tp_l + fn_l + eps)\\n\\n f1_label = (precision_label * recall_label).div(precision_label + recall_label + eps) * 2\\n\\n return f1_label, precision_label, recall_label\",\n \"def string_f1_score(prediction, ground_truth):\\n prediction_tokens = normalize_answer(prediction).split()\\n ground_truth_tokens = normalize_answer(ground_truth).split()\\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def _f1_score_(prediction, ground_truth):\\n prediction_tokens = _normalize_answer(prediction).split()\\n ground_truth_tokens = _normalize_answer(ground_truth).split()\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def _compute_f1_score(predicted_answer: str, target_answer: str) ->Tensor:\\n target_tokens = _get_tokens(target_answer)\\n predicted_tokens = _get_tokens(predicted_answer)\\n common = Counter(target_tokens) & Counter(predicted_tokens)\\n num_same = tensor(sum(common.values()))\\n if len(target_tokens) == 0 or len(predicted_tokens) == 0:\\n return tensor(int(target_tokens == predicted_tokens))\\n if num_same == 0:\\n return tensor(0.0)\\n precision = 1.0 * num_same / tensor(len(predicted_tokens))\\n recall = 1.0 * num_same / tensor(len(target_tokens))\\n f1 = 2 * precision * recall / (precision + recall)\\n return f1\",\n \"def f1score(prediction,ytest):\\n truepos = np.sum(ytest[prediction == 1])\\n predpos = np.sum(prediction)\\n actpos = np.sum(ytest)\\n precision = truepos/predpos\\n recall = truepos/actpos\\n return 2*precision*recall/(precision + recall)\",\n \"def f1_score(prediction, ground_truth):\\n return precision_recall_f1(prediction, ground_truth)[2]\",\n \"def f1(y_true, y_pred):\\n p = precision(y_true, y_pred)\\n r = recall(y_true, y_pred)\\n score = 2 * p * r / (p + r)\\n return score\",\n \"def f1_score_model(self, model, X, y):\\n\\n prediction = model.predict_classes(X)\\n f1_macro = f1_score(y, prediction, average='macro')\\n f1_micro = f1_score(y, prediction, average='macro')\\n print(\\\"f1_macro: \\\", f1_score(y, prediction, average='macro'))\\n print(\\\"f1_micro: \\\", f1_score(y, prediction, average=\\\"micro\\\"))\\n print(\\\"f1_weighted: \\\", f1_score(y, prediction, average=\\\"weighted\\\"))\\n return f1_macro, f1_micro\",\n \"def f1(gold_labels, predicted_labels):\\n \\n precision_value = float(precision(gold_labels, predicted_labels))\\n recall_value = float(recall(gold_labels, predicted_labels))\\n top = float(2 * precision_value * recall_value)\\n bottom = precision_value + recall_value\\n\\n if(top == 0):\\n return 0\\n else:\\n return float(top / bottom)\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\\n\\n y_pred = torch.ge(y_pred.float(), threshold).float()\\n\\n y_true = y_true.float()\\n\\n tp_l = (y_pred * y_true).sum(0).float()\\n\\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\\n\\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\\n\\n precision_label = tp_l.div(tp_l + fp_l + eps)\\n\\n recall_label = tp_l.div(tp_l + fn_l + eps)\\n\\n if macro:\\n\\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\\n\\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\\n\\n else: \\n\\n tp = tp_l.sum()\\n\\n fp = fp_l.sum()\\n\\n fn = fn_l.sum()\\n\\n precision = tp / (tp + fp + eps)\\n\\n recall = tp / (tp + fn + eps)\\n\\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\\n\\n return f1_micro.item(), precision.item(), recall.item()\",\n \"def calculate_f1_score(y_test, y_pred):\\n print('# Running precision, recall and F1-score')\\n print('# F1-Score:\\\\t\\\\t%.2f' % (f1_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Precision:\\\\t\\\\t%.2f' % (precision_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Recall:\\\\t\\\\t%.2f' % (recall_score(y_test, y_pred, average=\\\"macro\\\") * 100))\",\n \"def F1Score(labels, gold_file, wordnetCompression):\\n\\n gold_labels = []\\n with open(gold_file, 'r') as file:\\n for line in file:\\n gold_labels.append(line.split()[1])\\n\\n flat_decoded_label_list = [item for sublist in labels for item in sublist]\\n\\n total = 0\\n correct = 0\\n if wordnetCompression:\\n for i in range(len(gold_labels)):\\n total += 1\\n current_gold = gold_labels[i]\\n pos = wn.lemma_from_key(current_gold).synset().pos()\\n offset = wn.lemma_from_key(current_gold).synset().offset()\\n wn_synset = \\\"wn:\\\" + str(offset).zfill( 8) + pos\\n current_prediction = flat_decoded_label_list[i]\\n #if len(current_prediction) > 1:\\n # for elem in current_prediction:\\n # if elem == current_gold:\\n # correct += 1\\n #else:\\n if wn_synset == current_prediction:\\n correct += 1\\n else:\\n for i in range(len(gold_labels)):\\n if gold_labels[i] == flat_decoded_label_list[i]:\\n correct += 1\\n total += 1\\n \\n print(\\\"F1 SCORE: \\\", (correct/total)*100 )\\n print(\\\"Total number of labels: \\\", total)\\n print(\\\"Total correct: \\\", correct)\\n print()\",\n \"def evaluate_f1_ml(predict, truth):\\n label_same = []\\n label_predict = []\\n label_truth = []\\n label_f1 = []\\n\\n division = lambda x, y: (x * 1.0 / y) if y else 0\\n f1 = lambda p, r: 2 * p * r / (p + r) if p + r else 0\\n\\n batch, label_size = predict.size()\\n for i in range(label_size):\\n cur_predict = predict[:, i]\\n cur_truth = truth[:, i]\\n\\n predict_max = cur_predict.gt(0.5).long()\\n cur_eq_num = (predict_max * cur_truth).sum().item()\\n\\n cur_predict_num = predict_max.sum().item()\\n cur_truth_num = cur_truth.sum().item()\\n\\n cur_precision = division(cur_eq_num, cur_predict_num)\\n cur_recall = division(cur_eq_num, cur_truth_num)\\n cur_f1 = f1(cur_precision, cur_recall)\\n\\n label_same.append(cur_eq_num)\\n label_predict.append(cur_predict_num)\\n label_truth.append(cur_truth_num)\\n label_f1.append(cur_f1)\\n\\n macro_f1 = sum(label_f1) / len(label_f1)\\n micro_precision = division(sum(label_same), sum(label_predict))\\n micro_recall = division(sum(label_same), sum(label_truth))\\n micro_f1 = f1(micro_precision, micro_recall)\\n\\n return macro_f1, micro_f1, micro_precision, micro_recall, label_f1\",\n \"def score(label_recall, label_precision, pred_recall, pred_precision):\\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\\n\\n return 0.4*f11 + 0.6*f12\",\n \"def f1_score(self):\\n self.overall_f1_score = f1_score(\\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\\n self.classes_f1_score = f1_score(\\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)\",\n \"def get_f1_scores(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\\\\n -> Union[np.ndarray, Tuple[np.ndarray, np.ndarray, np.ndarray]]:\\n confusion = get_confusion_matrix(labels_true, labels_pred)\\n n_labels = confusion.shape[0]\\n counts_correct = confusion.diagonal()\\n counts_true = confusion.dot(np.ones(n_labels))\\n counts_pred = confusion.T.dot(np.ones(n_labels))\\n mask = counts_true > 0\\n recalls = np.zeros(n_labels)\\n recalls[mask] = counts_correct[mask] / counts_true[mask]\\n precisions = np.zeros(n_labels)\\n mask = counts_pred > 0\\n precisions[mask] = counts_correct[mask] / counts_pred[mask]\\n f1_scores = np.zeros(n_labels)\\n mask = (counts_true > 0) & (counts_pred > 0)\\n f1_scores[mask] = 2 / (1 / precisions[mask] + 1 / recalls[mask])\\n if return_precision_recall:\\n return f1_scores, precisions, recalls\\n else:\\n return f1_scores\",\n \"def klue_re_micro_f1(preds, labels):\\n label_list = ['no_relation', 'org:top_members/employees', 'org:members',\\n 'org:product', 'per:title', 'org:alternate_names',\\n 'per:employee_of', 'org:place_of_headquarters', 'per:product',\\n 'org:number_of_employees/members', 'per:children',\\n 'per:place_of_residence', 'per:alternate_names',\\n 'per:other_family', 'per:colleagues', 'per:origin', 'per:siblings',\\n 'per:spouse', 'org:founded', 'org:political/religious_affiliation',\\n 'org:member_of', 'per:parents', 'org:dissolved',\\n 'per:schools_attended', 'per:date_of_death', 'per:date_of_birth',\\n 'per:place_of_birth', 'per:place_of_death', 'org:founded_by',\\n 'per:religion']\\n no_relation_label_idx = label_list.index(\\\"no_relation\\\")\\n label_indices = list(range(len(label_list)))\\n label_indices.remove(no_relation_label_idx)\\n return metrics.f1_score(labels, preds, average=\\\"micro\\\", labels=label_indices) * 100.0\",\n \"def f1_score(model_id, test_set_id, rubric_id):\\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\\n\\n for key in rubrication_result:\\n if rubrication_result[key] == answers[key]:\\n if rubrication_result[key] == 1:\\n result['true_positive'] += 1\\n else:\\n result['true_negative'] += 1\\n else:\\n if rubrication_result[key] == 1:\\n result['false_positive'] += 1\\n else:\\n result['false_negative'] += 1\\n if (result['true_positive'] + result['false_positive']) > 0:\\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\\n else:\\n result['precision'] = 0\\n if (result['true_positive'] + result['false_negative']) > 0:\\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\\n else:\\n result['recall'] = 0\\n if (result['precision'] + result['recall']) > 0:\\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\\n else:\\n result['f1'] = 0\\n return result\",\n \"def calf_f1(annotated_Y, predicted_Y):\\n\\n POSITIVE = ADR_MENTION_CLASS_LABEL\\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\\n\\n tp = 0\\n fp = 0\\n fn = 0\\n tn = 0\\n\\n total_actual_positives = 0\\n total_actual_negatives = 0\\n\\n for index, actual in enumerate(annotated_Y):\\n predicted = predicted_Y[index]\\n\\n if actual == POSITIVE:\\n total_actual_positives += 1\\n\\n if predicted == POSITIVE:\\n tp += 1\\n elif predicted == NEGATIVE:\\n fn += 1\\n\\n elif actual == NEGATIVE:\\n total_actual_negatives += 1\\n\\n if predicted == POSITIVE:\\n fp += 1\\n elif predicted == NEGATIVE:\\n tn += 1\\n\\n if (tp+fp) == 0:\\n precision = 0\\n else:\\n precision = tp/(tp+fp)\\n\\n if (tp+fn) == 0:\\n recall = 0\\n else:\\n recall = tp/(tp+fn)\\n\\n if (precision+recall) == 0:\\n f1 = 0\\n else:\\n f1 = 2*precision*recall/(precision+recall)\\n\\n # print(\\\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\\\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\\n # print(\\\"tp: {}, tn: {}, fp: {}, fn: {}\\\".format(tp, tn, fp, fn))\\n # print(\\\" Accuracy: {}\\\".format((tp+tn)/(len(test_Y))))\\n print(\\\" Precision: {}\\\".format(precision))\\n print(\\\" Recall: {}\\\".format(recall))\\n print(\\\" F1: {}\\\".format(f1))\",\n \"def f1_score(y_true, y_pred):\\n\\ty_true = tf.cast(y_true, \\\"float32\\\")\\n\\ty_pred = tf.cast(tf.round(y_pred), \\\"float32\\\") # implicit 0.5 threshold via tf.round\\n\\ty_correct = y_true * y_pred\\n\\n\\n\\tsum_true = tf.reduce_sum(y_true, axis=1)\\n\\tsum_pred = tf.reduce_sum(y_pred, axis=1)\\n\\tsum_correct = tf.reduce_sum(y_correct, axis=1)\\n\\n\\n\\tprecision = sum_correct / sum_pred\\n\\trecall = sum_correct / sum_true\\n\\tf_score = 2 * precision * recall / (precision + recall)\\n\\tf_score = tf.where(tf.is_nan(f_score), tf.zeros_like(f_score), f_score)\\n\\n\\n\\treturn tf.reduce_mean(f_score)\",\n \"def f1_score(self, y_true=None, y_pred=None, labels=None, average=\\\"macro\\\", decimal=None, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\\n\\n list_f1 = np.array([item[\\\"f1\\\"] for item in metrics.values()])\\n list_weights = np.array([item[\\\"n_true\\\"] for item in metrics.values()])\\n\\n if average == \\\"micro\\\":\\n tp_global = np.sum(np.diag(matrix))\\n fp_global = fn_global = np.sum(matrix) - tp_global\\n precision = tp_global / (tp_global + fp_global)\\n recall = tp_global / (tp_global + fn_global)\\n f1 = (2 * precision * recall) / (precision + recall)\\n elif average == \\\"macro\\\":\\n f1 = np.mean(list_f1)\\n elif average == \\\"weighted\\\":\\n f1 = np.dot(list_weights, list_f1) / np.sum(list_weights)\\n else:\\n f1 = dict([(label, np.round(item[\\\"f1\\\"], decimal)) for label, item in metrics.items()])\\n return f1 if type(f1) == dict else np.round(f1, decimal)\",\n \"def get_f1(self, predictions):\\n preds = []\\n ground_truth = []\\n for index in range(len(self.test_data)):\\n preds.append(predictions[index])\\n ground_truth.append(self.test_data[index][self.target_attribute])\\n f1 = metrics.f1_score(ground_truth,preds,labels=['win','loss','draw'],average='macro')\\n return f1\",\n \"def precision_recall_f1(prediction, ground_truth):\\n if not isinstance(prediction, list):\\n prediction_tokens = prediction.split()\\n else:\\n prediction_tokens = prediction\\n if not isinstance(ground_truth, list):\\n ground_truth_tokens = ground_truth.split()\\n else:\\n ground_truth_tokens = ground_truth\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0, 0, 0\\n p = 1.0 * num_same / len(prediction_tokens)\\n r = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * p * r) / (p + r)\\n return p, r, f1\",\n \"def F1_score(y_t, y_p, weights):\\n\\n P = Precision()\\n R = Recall() #label per label evaluation\\n F1_score_per_label = [] #store per label\\n P_per_label = []\\n R_per_label = []\\n F1_tot = 0 #weighted sum\\n\\n for i in range(8):\\n P.update_state( y_t[:,i], y_p[:,i] )\\n R.update_state( y_t[:,i], y_p[:,i] )\\n p = P.result().numpy()\\n r = R.result().numpy()\\n P.reset_states()\\n R.reset_states()\\n if p+r == 0:\\n f1 = 0\\n else:\\n f1 = 2*p*r/ (p+r)\\n F1_score_per_label.append(f1)\\n P_per_label.append(p)\\n R_per_label.append(r)\\n\\n F1_tot += f1*weights[i]\\n\\n return F1_score_per_label, P_per_label, R_per_label, F1_tot\",\n \"def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\\r\\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n\\r\\n if p + r > 0:\\r\\n return 2 * p * r / (p + r)\\r\\n else:\\r\\n return 0\",\n \"def f1_score(self):\",\n \"def f1_score(y_true, y_pred):\\n num = 2 * precision_score(y_true, y_pred) * recall_score(y_true, y_pred)\\n deno = (precision_score(y_true, y_pred) + recall_score(y_true, y_pred))\\n return num / deno\",\n \"def scores(self, y, y_pred):\\n\\n aucroc = 0.\\n precision = 0.\\n recall = 0.\\n f1 = 0.\\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n label_ratios = np.mean(y, axis=0)\\n\\n if len(y) > 1:\\n y_t = np.transpose(y)\\n col_keep = np.ones(len(y_t), dtype=bool)\\n for i, col_y in enumerate(y_t):\\n if 0 not in col_y or 1 not in col_y:\\n col_keep[i] = False\\n\\n if sum(col_keep) > 0:\\n if not col_keep.all():\\n y = np.transpose(y_t[col_keep])\\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\\n\\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\\n s = f1_score(y, self._round(y_pred), average=None)\\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\\n if sum(col_keep) > 1:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\\n else:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\\n elif self.verbose:\\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n elif len(y) == 1:\\n if self.verbose:\\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n result = {\\n 'aucroc': aucroc,\\n 'precision': precision,\\n 'recall': recall,\\n 'f1': f1,\\n 'aucroc_labs': aucroc_labs,\\n 'precision_labs': precision_labs,\\n 'recall_labs': recall_labs,\\n 'f1_labs': f1_labs,\\n 'label_ratios': label_ratios\\n }\\n\\n return result\",\n \"def get_f1_score(labels_true: np.ndarray, labels_pred: np.ndarray, return_precision_recall: bool = False) \\\\\\n -> Union[float, Tuple[float, float, float]]:\\n values = set(labels_true[labels_true >= 0]) | set(labels_pred[labels_pred >= 0])\\n if values != {0, 1}:\\n raise ValueError('Labels must be binary. '\\n 'Check get_f1_scores or get_average_f1_score for multi-label classification.')\\n if return_precision_recall:\\n f1_scores, precisions, recalls = get_f1_scores(labels_true, labels_pred, True)\\n return f1_scores[1], precisions[1], recalls[1]\\n else:\\n f1_scores = get_f1_scores(labels_true, labels_pred, False)\\n return f1_scores[1]\",\n \"def get_f1(self, predicted, gold):\\n correct_labeled = 0\\n correct_unlabeled = 0\\n num_predicted = 0\\n num_gold = 0\\n\\n for p, g in zip(predicted, gold):\\n if p != '_':\\n num_predicted += 1\\n if p == g:\\n correct_labeled += 1\\n correct_unlabeled += 1\\n elif g != '_':\\n correct_unlabeled += 1\\n \\n if g != '_':\\n num_gold += 1\\n \\n if num_predicted == 0 or num_gold == 0:\\n return 0, 0\\n\\n labeled_precision = correct_labeled / num_predicted\\n labeled_recall = correct_labeled / num_gold\\n labeled_f1 = (2 * labeled_precision * labeled_recall /\\n (labeled_precision + labeled_recall))\\n\\n unlabeled_precision = correct_unlabeled / num_predicted\\n unlabeled_recall = correct_unlabeled / num_gold\\n unlabeled_f1 = (2 * unlabeled_precision * unlabeled_recall /\\n (unlabeled_precision + unlabeled_recall))\\n\\n return labeled_f1, unlabeled_f1\",\n \"def F1_score(y, model):\\n\\tp = precision(y, model)\\n\\tr = recall(y, model)\\n\\tf = 2*((p*r)/(p+r))\\n\\treturn f\",\n \"def f1s_binary(y_i, predictions):\\n assert len(y_i) == len(predictions)\\n fp_1 = 0.0\\n tp_1 = 0.0\\n fn_1 = 0.0\\n tn_1 = 0.0\\n for y, y_pred in zip(y_i, predictions):\\n for y_w, y_pred_w in zip(y, y_pred):\\n if y_w == 0: # true class is 0\\n if y_pred_w == 0:\\n tp_1 += 1\\n else:\\n fn_1 += 1\\n else: # true class is 1\\n if y_pred_w == 0:\\n fp_1 += 1\\n else:\\n tn_1 += 1\\n tn_2 = tp_1\\n fp_2 = fn_1\\n fn_2 = fp_1\\n tp_2 = tn_1\\n precision_1 = tp_1 / (tp_1 + fp_1) if (tp_1 + fp_1) > 0 else 0\\n precision_2 = tp_2 / (tp_2 + fp_2) if (tp_2 + fp_2) > 0 else 0\\n recall_1 = tp_1 / (tp_1 + fn_1) if (tp_1 + fn_1) > 0 else 0\\n recall_2 = tp_2 / (tp_2 + fn_2) if (tp_2 + fn_2) > 0 else 0\\n f1_1 = 2 * (precision_1*recall_1) / (precision_1 + recall_1) if (precision_1 + recall_1) > 0 \\\\\\n else 0\\n f1_2 = 2 * (precision_2*recall_2) / (precision_2 + recall_2) if (precision_2 + recall_2) > 0 \\\\\\n else 0\\n return f1_1, f1_2\",\n \"def evaluate(gold, predictions):\\n # gold = {i[\\\"id\\\"]:i[\\\"label\\\"] for i in read(goldfile)}\\n # sys = {i[\\\"id\\\"]:i[\\\"prediction\\\"] for i in read(sysfile)}\\n\\n labels, preds = [], []\\n for idx in gold:\\n labels.append(gold[idx])\\n preds.append(predictions[idx])\\n\\n precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support(labels, preds, labels=[0, 1],\\n average=\\\"macro\\\")\\n print(\\\"F1-macro score for test data predictions are: %.4f\\\" % f1_macro)\\n return preds\",\n \"def computeFScores(self, targetLabels, actualLabels):\\r\\n if self.prMeasures is None:\\r\\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\\r\\n if self.prMeasures[0] == 0:\\r\\n return 0\\r\\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\\r\\n return self.f1score\",\n \"def run_evaluate_compound(self, data):\\n tp = 0\\n tn = 0\\n fp = 0\\n fn = 0\\n for words, labels, pos in minbatch_generator(data, self.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\\n if not type(labels_pred) == list:\\n labels_pred = labels_pred.tolist()\\n for i, label_actual in enumerate(labels):\\n # we have to now find all aspect terms. That is, merge consecutive B \\n # with I's until we get an O or B\\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\\n for a_term in a_terms_actual:\\n # say we have [1,2,3] as our a_term. we have to make sure that our \\n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\\n a_term_pred = []\\n for index in a_term:\\n if not label_actual[index] == labels_pred[i][index]:\\n fn += 1\\n break\\n else:\\n tp += 1\\n for index in non_a_terms_actual:\\n if label_actual[index] == labels_pred[i][index]:\\n tn += 1\\n else:\\n fp += 1\\n\\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\\n metrics = dict()\\n metrics[\\\"p_1\\\"] = precision\\n metrics[\\\"f_1\\\"] = fscore\\n metrics[\\\"r_1\\\"] = recall\\n return metrics\",\n \"def f1_score(guess, answer):\\n if guess is None or answer is None:\\n return 0\\n score = prec_recall_f1_score(normalize_answer(guess).split(), normalize_answer(answer).split())\\n\\n return score\",\n \"def rouge_l_fscore(predictions, labels):\\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\\n tf.float32)\\n return rouge_l_f_score, tf.constant(1.0)\",\n \"def f1_score(confusion):\\n sens = sensitivity(confusion)\\n prec = precision(confusion)\\n return 2 * sens * prec / (sens + prec)\",\n \"def score_sc1(self, prediction_file):\\n fh = TempFile()\\n gs1, _ = self.download_gs()\\n script = self.classpath + os.sep + \\\"DREAM_Olfaction_scoring_Q1.pl\\\"\\n cmd = \\\"perl %s %s %s %s\\\"\\n cmd = cmd % (script, prediction_file, fh.name, gs1)\\n shellcmd(cmd)\\n df = pd.read_csv(fh.name, sep='\\\\t', index_col=None).ix[0]\\n fh.delete()\\n return df\\n\\n\\n # score sub1 = (zint +zple +zdec)/3\\n # sigma_int = 0.0787\\n # sigma_ple = 0.176\\n # signa_dec = 0.0042\\n\\n # final is average of zscores\",\n \"def get_f1_score(y_true, y_pred):\\n cf_m = confusion_matrix(y_true, y_pred)\\n print(\\\"tn:\\\",cf_m[0,0])\\n print(\\\"fp:\\\",cf_m[0,1])\\n print(\\\"fn:\\\",cf_m[1,0])\\n print(\\\"tp:\\\",cf_m[1,1])\\n precision = cf_m[1,1] / (cf_m[1,1] + cf_m[0,1])\\n recall = cf_m[1,1] / (cf_m[1,1] + cf_m[1,0])\\n f1 = 2 * (precision * recall) / (precision + recall)\\n\\n\\n return precision, recall, f1\",\n \"def eval_metrics_for_seqtags(self, predicted_answers):\\n total_correct_in_all = 0\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids, include padding ids.\\n correct_label_indices = sample['correct_seq_labels']\\n # use extend to add all the labels in the seq, include the head padding and tail padding\\n label_true.extend(correct_label_indices)\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n label_pred.extend(sample['pred_seq_tags'])\\n\\n if total_correct_in_all != 0:\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\\n title='Confusion matrix when seq labeling, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\\n title='Normalized confusion matrix when seq labeling')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def binary_f1_score(preds, y):\\n rounded_predictions = torch.round(torch.sigmoid(preds))\\n\\n return f1_score(y.cpu().numpy(), rounded_predictions.cpu().numpy(), average='weighted')\",\n \"def score(self, predicted_y, actual_y):\\n\\n self.labels = [0, 1, 2, 3]\\n\\n # Dictionary to store count of each label in predicted labels list\\n self.total_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n # Dictionary to store count of each label in actual labels list\\n self.total_actual_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n # Dictionary to store count of correctly predicted labels\\n self.total_correct_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n for i in xrange(len(predicted_y)):\\n # Extract predicted and actual labels for ith record\\n predicted_label = predicted_y[i]\\n actual_label = actual_y[i]\\n\\n # Increment the count of corrected predicted label if predicted and actual labels are same\\n if predicted_label == actual_label:\\n self.total_correct_prediction_count[actual_label] += 1\\n\\n # Increment total counts\\n self.total_actual_count[actual_label] += 1\\n self.total_prediction_count[predicted_label] += 1\\n\\n # Compute f1 scores of each label and return their mean\\n return np.mean(self.__get_f1_scores__())\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def prediction_processing(predictions, labels, threshold, step_nb):\\n new_labels = []\\n new_predictions = []\\n number_sequences = step_nb//50\\n\\n for k in range(len(labels)//number_sequences):\\n total_prediction = 0\\n isLabelTrue = labels[number_sequences*k]\\n for i in range(number_sequences):\\n total_prediction += (1/predictions[number_sequences*k+i])\\n if not(isLabelTrue == (labels[number_sequences*k+i])):\\n logger.error('Problem.')\\n if total_prediction > threshold:\\n total_prediction = False\\n else:\\n total_prediction = True\\n new_labels.append(isLabelTrue)\\n new_predictions.append(total_prediction)\\n\\n recall_1 = recall_score(new_labels, new_predictions)\\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\\n precision_1 = precision_score(new_labels, new_predictions)\\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)\",\n \"def f1_score(precision, recall):\\n if precision + recall == 0:\\n return 0\\n return 2 * precision * recall / (precision + recall)\",\n \"def score(self, data):\\n\\n score_mappings = {\\n \\\"0\\\": np.log(self.class_zero_doc_count / self.total_docs),\\n \\\"1\\\": np.log(self.class_one_doc_count / self.total_docs)\\n }\\n\\n features = self.featurize(data)\\n\\n for f in features:\\n\\n if(f[0] in self.class_zero):\\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\\n else:\\n cond_prob_zero = 0\\n\\n if(f[0] in self.class_one):\\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\\n else:\\n cond_prob_one = 0\\n\\n score_mappings[\\\"0\\\"] += cond_prob_zero\\n score_mappings[\\\"1\\\"] += cond_prob_one\\n\\n score_mappings[\\\"0\\\"] = np.exp(score_mappings[\\\"0\\\"])\\n score_mappings[\\\"1\\\"] = np.exp(score_mappings[\\\"1\\\"])\\n\\n return score_mappings\",\n \"def f1_score(true, pred, n_classes=2, pos_label=1, average=None, weights=None):\\n\\n if n_classes == 2:\\n if np.sum(true * pred) == 0:\\n f1 = 0.0\\n else:\\n f1 = skl_f1_score(true, pred, average='binary', labels=range(n_classes), pos_label=pos_label, sample_weight=weights)\\n else:\\n if average is None:\\n f1 = skl_f1_score(true, pred, average='micro', labels=range(n_classes), pos_label=None, sample_weight=weights)\\n else:\\n f1 = skl_f1_score(true, pred, average=average, labels=range(n_classes), pos_label=None, sample_weight=weights)\\n return f1\",\n \"def evaluate(true_labels, predicted_labels):\\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \\n 2)\\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\\n average='weighted'), 2)\\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n \\n return accuracy, precision, recall, f1\",\n \"def f1_score(confusion):\\n p = precision(confusion)\\n r = sensitivity(confusion)\\n F1 = (2 * p * r) / (p + r)\\n return F1\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def scoring(estimator, features_test, labels_test):\\n pred = estimator.predict(features_test)\\n p = metrics.precision_score(labels_test, pred, average='micro')\\n r = metrics.recall_score(labels_test, pred, average='micro')\\n if p > 0.3 and r > 0.3:\\n return metrics.f1_score(labels_test, pred, average='macro')\\n return 0\",\n \"def _eval_classifier(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\\n try:\\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\\n except ValueError:\\n auc_baseline = \\\"NA\\\"\\n\\n precision_sample = precision_score(y_label_sample, y_pred_sample)\\n recall_sample = recall_score(y_label_sample, y_pred_sample)\\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\\n f1_sample = f1_score(y_label_sample, y_pred_sample)\\n try:\\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\\n except ValueError:\\n auc_sample = \\\"NA\\\"\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"Accuracy\\\": [acc_baseline, acc_sample],\\n \\\"Precision\\\": [precision_baseline, precision_sample],\\n \\\"Recall\\\": [recall_baseline, recall_sample],\\n \\\"F1\\\": [f1_baseline, f1_sample],\\n \\\"AUC\\\": [auc_baseline, auc_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def PredictMatch(yourName, tgtName, teamModels, db):\\n\\n teamTgtPipe, teamYourPipe = QueryTeamData(tgtName, yourName, db)\\n featureCoefTgt, probTgt = PredictOp(teamTgtPipe, teamYourPipe, tgtName, teamModels)\\n featureCoefYour, probYour = PredictOp(teamYourPipe, teamTgtPipe, yourName, teamModels)\\n odds = round(probYour / (probYour + probTgt), 2)\\n\\n # In featureCoefYour, you want INCREASE those with POSTIVE COEF, DECREASE those with NEGATIVE COEF\\n # In featureCoefTgt, you want to do the opposite\\n\\n # reverse both the sign of the coef, and '_op' in features so as to be the same with featureCoefYour\\n featureCoefTgt['coef'] = - featureCoefTgt['coef']\\n featureCoefTgt.features = [ii[:-3] if \\\"_op\\\" in ii else ii + '_op' for ii in featureCoefTgt.features]\\n\\n # Combine only the most important 10 features\\n # featureBoth = featureCoefTgt[11:].append(featureCoefYour[11:])\\n\\n # Combine only all the most important features\\n featureBoth = featureCoefTgt.append(featureCoefYour)\\n\\n # get action recommendations\\n # Somehow the pandas here uses a deprecated para cols, instaed of the new one subset\\n #featureBoth.drop_duplicates(subset = 'features', take_last = True, inplace = True)\\n featureBoth.drop_duplicates(cols = 'features', take_last = True, inplace = True)\\n actions, featureImprove = GetActions(featureBoth)\\n Imp = 0.1\\n oddsNew = ImprovedScore(tgtName, yourName, teamModels, featureImprove, teamTgtPipe, teamYourPipe, Imp)\\n\\n return odds, oddsNew, actions\",\n \"def f1_score_loss(predicted_probs: tf.Tensor, labels: tf.Tensor) -> tf.Tensor:\\n # Apply a sharpened sigmoid function to approximate the threshold\\n thresholded_predictions = predicted_probs - ONE_HALF\\n level_predictions = 1.0 / (1.0 + tf.exp(BETA * thresholded_predictions)) # [B, L]\\n # predictions = tf.reduce_prod(level_predictions, axis=-1, keepdims=True) # [B, 1]\\n predictions = tf.exp(tf.reduce_sum(tf.log(level_predictions), axis=-1, keepdims=True)) # [B, 1]\\n\\n # Compute the (approximate) F1 score\\n f1_score = 2 * tf.reduce_sum(predictions * labels) / (tf.reduce_sum(predictions) + tf.reduce_sum(labels))\\n return 1.0 - f1_score\",\n \"def accuracy(predictions, test_labels):\\n return f1_score(test_labels, predictions, average='micro') * 100\",\n \"def recall(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_neg = 0 #gold pos sys neg\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"1\\\" and predicted_labels[i] == \\\"0\\\"):\\n false_neg += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_neg))\",\n \"def score(self, sentence):\\n score = 0.0\\n V = len(self.f1) # vocabulary size\\n for token in sentence:\\n if token in self.f1: score += self.f1[token]\\n else: score -= math.log10(self.total + V)\\t\\t # OOV \\n return score\",\n \"def evaluate(self, predicted_df):\\n logging.info(\\\"Evaluating model: {}\\\".format(self.model_type))\\n y_true = predicted_df[\\\"user_label\\\"].as_matrix()\\n y_pred = predicted_df[\\\"label\\\"].as_matrix()\\n\\n scores_cols = [col for col in predicted_df.columns if col.startswith(\\\"scores_\\\")]\\n print(\\\"scores_cols: {}\\\".format(scores_cols))\\n\\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\\n print(\\\"predicted scores: {}\\\".format(y_pred_scores))\\n y_true_scores = []\\n for lab in predicted_df[\\\"user_label\\\"]:\\n trues = [0 for _ in range(len(scores_cols))]\\n if \\\"scores_\\\"+lab in scores_cols:\\n trues[scores_cols.index(\\\"scores_\\\"+lab)] = 1\\n y_true_scores.append(trues)\\n print(\\\"true scores: {}\\\".format(y_true_scores))\\n y_true_scores = np.array(y_true_scores)\\n\\n performance = {\\\"model\\\": self.model_type, \\\"description\\\": self.description}\\n if 'categorical_accuracy' in self.metrics:\\n logging.info(\\\"Calculating categorical accuracy for {}\\\".format(self))\\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\\n y_pred) # np.mean(y_pred == y_true)\\n if 'fmeasure' in self.metrics:\\n logging.info(\\\"Calculating fmeasure for {}\\\".format(self))\\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\\n if 'MRR' in self.metrics:\\n logging.info(\\\"Calculating MRR for {}\\\".format(self))\\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\\n logging.info(\\\"Calculated performance: {}\\\".format(performance))\\n print(performance)\\n return pd.DataFrame(performance, index=[0])\",\n \"def calculate_f1(fx, y):\\n pred_idxs = fx.max(1, keepdim=True)[1]\\n pred_names = [idx2target[i.item()] for i in pred_idxs]\\n original_names = [idx2target[i.item()] for i in y]\\n true_positive, false_positive, false_negative = 0, 0, 0\\n for p, o in zip(pred_names, original_names):\\n predicted_subtokens = p.split('|')\\n original_subtokens = o.split('|')\\n for subtok in predicted_subtokens:\\n if subtok in original_subtokens:\\n true_positive += 1\\n else:\\n false_positive += 1\\n for subtok in original_subtokens:\\n if not subtok in predicted_subtokens:\\n false_negative += 1\\n try:\\n precision = true_positive / (true_positive + false_positive)\\n recall = true_positive / (true_positive + false_negative)\\n f1 = 2 * precision * recall / (precision + recall)\\n except ZeroDivisionError:\\n precision, recall, f1 = 0, 0, 0\\n return precision, recall, f1\",\n \"def calculate_f1_score(predictions, actuals):\\n predictions = predictions > 0.5\\n # fbeta_score throws a confusing error if inputs are not numpy arrays\\n predictions, actuals, = np.array(predictions), np.array(actuals)\\n # We need to use average='samples' here, any other average method will generate bogus results\\n return fbeta_score(actuals, predictions, beta=1, average='samples')\",\n \"def calculate_score(result):\\n sample1=result['Sample1']\\n sample2=result['Sample2']\\n string1=paragraph_to_list(sample1)\\n string2=paragraph_to_list(sample2)\\n \\n return round( strings_similarity(string1, string2), 2)\\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\\n #return round(0.5*(method_difflab+method_dict), 2)\",\n \"def evaluate_nltk(self, X):\\n X_, y_ = separate_labels_from_features(X)\\n \\n y = []\\n n_sent_correct = 0\\n num_sent = len(y_)\\n \\n for i in range(num_sent):\\n sentence_correct = True\\n for j in range(len(y_[i])):\\n y.append(self.clf_nltk.classify(X_[i][j]))\\n if y_[i][j] != y[-1]:\\n sentence_correct = False\\n \\n if sentence_correct == True:\\n n_sent_correct += 1\\n \\n y_ = flatten(y_)\\n print(\\\"F1 score:\\\")\\n print(sklearn.metrics.precision_recall_fscore_support(y_, y, average='micro'))\\n print()\\n print(\\\"Accuracy:\\\")\\n print(sklearn.metrics.accuracy_score(y_, y))\\n print()\\n print(\\\"Sentence level accuracy:\\\")\\n print(n_sent_correct / num_sent)\\n print()\\n print(\\\"F1 score per class:\\\")\\n print(sklearn.metrics.precision_recall_fscore_support(y_, y))\\n print()\\n print(\\\"Confusion matrix:\\\")\\n cfm = sklearn.metrics.confusion_matrix(y_, y)\\n\\n plot_confusion_matrix(cfm, np.unique(y_))\\n \\n print(np.unique(y_))\\n print()\\n print(print(np.unique(y)))\",\n \"def compute(self) -> None:\\n \\n self.model.eval()\\n \\n with torch.no_grad():\\n for (input, target, _) in self.loader:\\n\\n # self.model = self.model.train(False) # TEST @lacoupe\\n output, _ = self.model(input)\\n \\n output = (output >= 0.5)\\n \\n for out, tar in zip(output, target):\\n \\n tar = bool(tar)\\n \\n if out and tar:\\n self.confusion['true_positive'] += 1\\n elif not out and not tar:\\n self.confusion['true_negative'] += 1\\n elif out and not tar:\\n self.confusion['false_positive'] += 1\\n elif not out and tar:\\n self.confusion['false_negative'] += 1\\n \\n self.accuracy = (self.confusion['true_positive'] + self.confusion['true_negative']) \\\\\\n / sum(list(self.confusion.values()))\\n \\n if (self.confusion['true_positive'] + self.confusion['false_positive']) == 0.:\\n self.precision = 0.\\n else:\\n self.precision = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_positive'])\\n \\n if (self.confusion['true_positive'] + self.confusion['false_negative']) == 0.:\\n self.recall = 0.\\n else:\\n self.recall = self.confusion['true_positive'] \\\\\\n / (self.confusion['true_positive'] + self.confusion['false_negative'])\\n \\n if (self.precision + self.recall) == 0.:\\n self.f1_score = 0.\\n else:\\n self.f1_score = 2 * self.precision * self.recall / (self.precision + self.recall)\",\n \"def get_best_f1_metrics(self,\\n verbose: bool = True) -> Tuple[int, int]:\\n f1_scores = list()\\n for i in self.search_space:\\n classes = self.convert_classes(threshold=i)\\n f1_scores.append(f1_score(classes, self.y_true))\\n best_f1_score, best_f1_threshold = self._get_best_metrics(\\n metric_type='f1_score',\\n scores=f1_scores,\\n greater_is_better=True,\\n verbose=verbose\\n )\\n return best_f1_score, best_f1_threshold\",\n \"def predict(self, x_val, y1_test=None, y2_test=None):\\n if y1_test is None and y2_test is None:\\n y1_test = np.ones(len(x_val))\\n y2_test = y1_test\\n score_model = False\\n else:\\n score_model = True\\n\\n self.stage_one.predict(x_val, y1_test)\\n if score_model:\\n stage_one_score = self.stage_one.score\\n\\n # This section will not generalize well beyond this specific dataset.\\n if score_model:\\n df = pd.DataFrame(data=[y1_test, self.stage_one.pred],\\n columns=['y1_test', 'stage_one.pred'])\\n df = pd.DataFrame(y1_test).rename(columns={'class_second': 'y1_test'})\\n df['stage_one.pred'] = self.stage_one.pred\\n df['tweets'] = x_val\\n df['y2_test'] = y2_test\\n\\n # x2_val = df['tweets'].loc[df['stage_one.pred'] == 0]\\n # y2_test_ = df['y2_test'].loc[df['stage_one.pred'] == 0]\\n x2_val = df['tweets'].loc[df['stage_one.pred'] == 1]\\n y2_test_ = df['y2_test'].loc[df['stage_one.pred'] == 1]\\n else:\\n # x2_val = x_val[self.stage_one.pred == 0]\\n x2_val = x_val[self.stage_one.pred == 1]\\n y2_test_ = np.ones(len(x2_val))\\n\\n self.stage_two.predict(x2_val, y2_test_)\\n if score_model:\\n stage_two_score = self.stage_two.score\\n return (stage_one_score, stage_two_score, stage_one_score*stage_two_score)\\n else:\\n # return tweets that contain hate speech\\n return x2_val[self.stage_two.pred == 0]\",\n \"def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\\n\\n\\t# set variables\\n\\trm1_vec = list()\\n\\tvocab = set()\\n\\tdoc_vecs = dict()\\n\\n\\t# create document feature vectors for each feedback doc\\n\\tfor doc_id in ids_and_scores.keys():\\n\\t\\t# convert current doc to bow format\\n\\t\\tbow = ix.doc2bow(corpus[doc_id])\\n\\t\\t# create document feature vector\\n\\t\\tdfv = create_feature_vector(ix, term_dict, bow)\\n\\t\\t# keep top 'fb_terms' from dfv\\n\\t\\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t\\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\\n\\t\\tvocab.update(dfv.keys())\\n\\t\\tdoc_vecs[doc_id] = dfv\\n\\n\\t# compute L1 norm for each document feature vector\\n\\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\\n\\n\\t# loop over terms in vocab and compute RM1\\n\\tfor term in vocab:\\n\\t\\tfb_weight = 0.0\\n\\t\\t# loop over document feature vectors \\n\\t\\tfor doc_id in doc_vecs.keys():\\n\\t\\t\\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\\n\\t\\t\\t\\t# sum the score of current term across different docs to fb_weight\\n\\t\\t\\t\\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\\n\\t\\t# assign term w/ weight to RM1 feature vector\\n\\t\\trm1_vec.append((term, fb_weight))\\n\\n\\t# keep top 'fb_terms' from rm1_vec\\n\\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t# scale rm1_vec to L1 norm\\n\\treturn scale_to_L1_norm(rm1_vec)\",\n \"def prec_recall_f1_score(pred_items, gold_items):\\n common = Counter(gold_items) & Counter(pred_items)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(pred_items)\\n recall = 1.0 * num_same / len(gold_items)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def f2_score(self, y_true=None, y_pred=None, labels=None, average=\\\"macro\\\", decimal=None, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\\n\\n list_f2 = np.array([item[\\\"f2\\\"] for item in metrics.values()])\\n list_weights = np.array([item[\\\"n_true\\\"] for item in metrics.values()])\\n\\n if average == \\\"micro\\\":\\n tp_global = np.sum(np.diag(matrix))\\n fp_global = fn_global = np.sum(matrix) - tp_global\\n precision = tp_global / (tp_global + fp_global)\\n recall = tp_global / (tp_global + fn_global)\\n f2 = (5 * precision * recall) / (4 * precision + recall)\\n elif average == \\\"macro\\\":\\n f2 = np.mean(list_f2)\\n elif average == \\\"weighted\\\":\\n f2 = np.dot(list_weights, list_f2) / np.sum(list_weights)\\n else:\\n f2 = dict([(label, np.round(item[\\\"f2\\\"], decimal)) for label, item in metrics.items()])\\n return f2 if type(f2) == dict else np.round(f2, decimal)\",\n \"def evaluate(ground_truth, prediction):\\n\\n def prfs_to_dict(prfs):\\n \\\"\\\"\\\"Returns a precision_recall_fscore_support() result as a dict.\\\"\\\"\\\"\\n return {\\\"precision\\\": prfs[0], \\\"recall\\\": prfs[1], \\\"fscore\\\": prfs[2]}\\n\\n results = {}\\n items_count = len(ground_truth)\\n\\n # accuracy\\n accuracy = accuracy_score(ground_truth, prediction)\\n results[\\\"accuracy\\\"] = accuracy\\n\\n # confusion matrix\\n categories = set(ground_truth) | set(prediction)\\n confusions = {\\n gold: {pred: 0 for pred in categories} for gold in categories\\n }\\n for g, p in zip(ground_truth, prediction):\\n confusions[g][p] += 1\\n results[\\\"confusions\\\"] = confusions\\n\\n # class wise precision, recall & f1\\n classwise = precision_recall_fscore_support(\\n ground_truth, prediction, average=None, warn_for=()\\n )\\n results[\\\"true_cat_dist\\\"] = list(classwise[-1])\\n results[\\\"classwise\\\"] = {\\n str(cl): prfs_to_dict(\\n [classwise[0][cl], classwise[1][cl], classwise[2][cl]]\\n )\\n for cl in categories\\n }\\n\\n # average precision, recall & f1\\n results[\\\"macro_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"macro\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n results[\\\"micro_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"micro\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n results[\\\"weigh_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"weighted\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n\\n # marginals\\n gold_category_distribution = {\\n g: sum([confusions[g][p] for p in categories]) for g in categories\\n }\\n pred_category_distribution = {\\n p: sum([confusions[g][p] for g in categories]) for p in categories\\n }\\n\\n # kappa\\n expected_agreement_fleiss = sum(\\n [\\n (\\n (gold_category_distribution[c] + pred_category_distribution[c])\\n / (2.0 * items_count)\\n )\\n ** 2\\n for c in categories\\n ]\\n )\\n expected_agreement_cohen = sum(\\n [\\n (float(gold_category_distribution[c]) / items_count)\\n * (float(pred_category_distribution[c]) / items_count)\\n for c in categories\\n ]\\n )\\n kappa_fleiss = (\\n 1.0\\n * (accuracy - expected_agreement_fleiss)\\n / (1 - expected_agreement_fleiss)\\n )\\n kappa_cohen = (\\n 1.0\\n * (accuracy - expected_agreement_cohen)\\n / (1 - expected_agreement_cohen)\\n )\\n results[\\\"k_fleiss\\\"] = {\\n \\\"k\\\": kappa_fleiss,\\n \\\"AE\\\": expected_agreement_fleiss,\\n \\\"AO\\\": accuracy,\\n }\\n results[\\\"k_cohen\\\"] = {\\n \\\"k\\\": kappa_cohen,\\n \\\"AE\\\": expected_agreement_cohen,\\n \\\"AO\\\": accuracy,\\n }\\n\\n return results\",\n \"def get_f1(self,common_len,RTSummary,SystemSummary):\\n recall = self.get_recall(common_len,RTSummary)\\n precision = self.get_precision(common_len,SystemSummary)\\n if precision<=0 or recall <=0:\\n return 0.0\\n else:\\n return ((2 * recall * precision)/(recall + precision))\",\n \"def _get_similarity_score(self, dict1, dict2):\\n try:\\n majorScoreDeterminer1 = ['primaryGenreId']\\n majorScoreDeterminer2 = ['genreIds']\\n Score = 0 # Base Score\\n for items in majorScoreDeterminer2:\\n\\n for item1 in self._get_app_param_info(dict1, resultCount=1, resultKey=items):\\n if item1 in self._get_app_param_info(dict2, resultCount=1, resultKey=items):\\n if Score == 0: # Add 50% base score for this category.\\n Score += 2 * .5\\n Score += 2 * .5 / len(self._get_app_param_info(dict1, resultCount=1, resultKey=items))\\n\\n for items in majorScoreDeterminer1:\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\\n self._get_app_param_info(dict1, resultCount=1, resultKey=items)):\\n Score += (3 / len(majorScoreDeterminer1))\\n\\n nameMatchScore = difflib.SequenceMatcher(None,\\n self._get_app_param_info(dict1, resultCount=1,\\n resultKey='trackName'),\\n self._get_app_param_info(dict2, resultCount=1,\\n resultKey='trackName')).ratio()\\n Score += nameMatchScore\\n\\n minorScoreDeterminer = ['isGameCenterEnabled', 'languageCodesISO2A', 'contentAdvisoryRating', 'artistId',\\n 'formattedPrice']\\n\\n for items in minorScoreDeterminer:\\n if items == \\\"formattedPrice\\\":\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \\\"Free\\\":\\n Score += (4 / (len(minorScoreDeterminer)))\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \\\"Free\\\":\\n continue\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \\\"Free\\\":\\n continue\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \\\"Free\\\":\\n Score += (4 / (len(minorScoreDeterminer)))\\n else:\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)):\\n Score += (4 / (len(minorScoreDeterminer)))\\n Score = round(Score, 1)\\n log_str = \\\"id\\\" + str(self._get_app_param_info(dict2, resultCount=1, resultKey='trackId')) + \\\" - \\\" + str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey='trackName')) + \\\"\\\\tScore: \\\" + str(Score)\\n except AssertionError as e:\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n except TypeError as e:\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n except:\\n e = sys.exc_info()[0]\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n else:\\n return log_str\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def _accuracy(label_file, pred_file,subword_option=None):\\n\\n with open(label_file, \\\"r\\\", encoding='utf-8') as label_fh:\\n with open(pred_file, \\\"r\\\", encoding='utf-8') as pred_fh:\\n count = 0.0\\n match = 0.0\\n for label in label_fh:\\n label = label.strip()\\n label = \\\" \\\".join(_clean(label,subword_option))\\n pred = pred_fh.readline().strip()\\n pred = \\\" \\\".join(_clean(pred,subword_option))\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def _prec_recall_f1_score(pred_items, gold_items):\\n common = Counter(gold_items) & Counter(pred_items)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0, 0, 0\\n precision = 1.0 * num_same / len(pred_items)\\n recall = 1.0 * num_same / len(gold_items)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return precision, recall, f1\",\n \"def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\\n best_f_score = tensor(0.0)\\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n for target in targets:\\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\\n if f_score > best_f_score:\\n best_f_score = f_score\\n best_matching_char_n_grams = matching_char_n_grams\\n best_matching_word_n_grams = matching_word_n_grams\\n best_target_char_n_grams = target_char_n_grams\\n best_target_word_n_grams = target_word_n_grams\\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams\",\n \"def get_r2_score(ground_truth, predicted):\\n residual = np.sum(np.square(np.subtract(ground_truth, predicted)))\\n print(residual)\\n total = np.sum(np.square(np.subtract(ground_truth, np.mean(ground_truth))))\\n print(total)\\n return np.subtract(1.0, np.divide(residual, (total + 0.00000000001)))\",\n \"def get_f1(self, y_true, y_pred):\\n precision = self.get_precision(y_true, y_pred)\\n recall = self.get_recall(y_true, y_pred)\\n f1 = 2*(precision*recall)/(precision + recall)\\n return f1\",\n \"def score(self, df: pd.DataFrame, label_column: str) -> float:\\n assert label_column not in self.feature_columns, 'Label column is in the feature list.'\\n assert label_column in df.columns, 'Label column is not in the dataframe.'\\n\\n rounded_preds = self.predict(df).round()\\n return f1_score(df[label_column].values, rounded_preds)\",\n \"def evaluate(model, eval_data, num_labels): \\n # Turn on the evaluation state to ignore dropouts\\n model.eval()\\n results = [predict(model, x) for x, y in eval_data]\\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\\n return f1_score, accuracy\",\n \"def calc_metrics(pred, labels):\\n pred_flat = np.argmax(pred, axis = 1).flatten()\\n labels_flat = labels.flatten()\\n \\n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\\n \\n # sklearn takes first parameter as the true label\\n precision = precision_score(labels_flat, pred_flat)\\n recall = recall_score(labels_flat, pred_flat)\\n \\n return flat_accuracy, precision, recall\",\n \"def validate(self, validate_data):\\n with open(validate_data, 'r') as validate_data:\\n true_positive = 0\\n true_negative = 0\\n false_positive = 0\\n false_negative = 0\\n result = {}\\n for type in self.label_type_map:\\n result[type] = []\\n while True:\\n tokens = validate_data.readline().split()\\n pos = validate_data.readline().split()\\n labels = validate_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Classify all named entities in a sentence 85\\n curr_results = self.viterbi(tokens)\\n for i in range(0, len(labels)):\\n if curr_results[i] != 'O':\\n if labels[i] == 'O':\\n false_positive += 1 # Not 'O', but should be 'O'\\n else:\\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\\n true_positive += 1 # Correct prediction\\n else:\\n if labels[i] == 'O':\\n true_negative += 1 # Correct prediction of 'O'\\n else:\\n false_negative += 1 # Predicted 'O', not 'O'\\n # Calculate precision - TP / (TP + FP)\\n precision = float(true_positive) / float(true_positive + false_positive)\\n # Calculate recall - TP / (TP + FN)\\n recall = float(true_positive) / float(true_positive + false_negative)\\n # Calculate F-Score - 2 * P * R / (P + R)\\n f_score = float(2*precision * recall) / float(precision + recall)\\n print \\\"Precision: \\\" + str(precision)\\n print \\\"Recall: \\\" + str(recall)\\n print \\\"F-score: \\\" + str(f_score)\",\n \"def recall1(y_test, predictions):\\n recall = 0.0\\n\\n for i in range(y_test.shape[0]):\\n intersection = 0.0\\n Yi = 0.0\\n for j in range(y_test.shape[1]):\\n Yi = Yi + int(y_test[i,j])\\n\\n if y_test[i,j] == 1 and int(predictions[i,j]) == 1:\\n intersection = intersection + 1\\n \\n if Yi != 0:\\n recall = recall + float(intersection/Yi) \\n \\n recall = recall/y_test.shape[0]\\n return recall\",\n \"def label_accuracy_score(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n # 一个batch里面可能有多个数据\\n # 通过迭代器将一个个数据进行计算\\n for lt, lp in zip(label_trues, label_preds):\\n # numpy.ndarray.flatten将numpy对象拉成1维\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n\\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\\n \\\"\\\"\\\"\\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\\n iu是召回率Recall，公式上面给出了\\n mean_iu就是对iu求了一个平均\\n freq是每一类被预测到的频率\\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\\n \\\"\\\"\\\"\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n # nanmean会自动忽略nan的元素求平均\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def score(self, x, y, verbose=False):\\n y_pred = self.forward(x).T\\n\\n y_p = np.argmax(y_pred, axis=-1)\\n y_t = np.argmax(y, axis=-1)\\n fpr, tpr, thresholds = roc_curve(y_t, y_p, pos_label=2)\\n\\n metricas = {\\n 'accuracy': accuracy_score(y_t, y_p),\\n 'f1':f1_score(y_t, y_p, average='macro'),\\n 'balanced accuracy': balanced_accuracy_score(y_t, y_p),\\n 'auc': auc(fpr, tpr)\\n }\\n\\n if verbose:\\n print('Accuracy', metricas['accuracy'])\\n print('F1-Macro', metricas['f1'])\\n print('Balanced accuracy', metricas['balanced accuracy'])\\n print('AUC', metricas['auc'])\\n\\n return metricas\",\n \"def evaluate(predictions, documents):\\n ###TODO\\n x = 0.0\\n y = 0 #true ham, classified spam\\n z = 0 #true spam, classified ham\\n \\n for i in range(0,len(predictions)):\\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\\n z += 1\\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\\n y += 1 \\n \\n x = (len(documents) - (y+z)) / len(documents) \\n return (x,y,z)\\n pass\",\n \"def evaluate(y_true, y_preds, labels=[0, 1, 2, 3, 4]):\\n p_scores = []\\n r_scroes = []\\n for label in labels:\\n p = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_preds == label).sum() + 0.001)\\n p_scores.append(p)\\n r = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_true == label).sum() + 0.001)\\n r_scroes.append(r)\\n p_scores = np.array(p_scores)\\n r_scroes = np.array(r_scroes)\\n f1 = 2 * (p_scores * r_scroes + 0.001) / (p_scores + r_scroes + 0.001)\\n\\n confmat = []\\n for label in labels:\\n conf = []\\n for label2 in labels:\\n conf.append(((y_preds == label) * (y_true == label2)).sum())\\n confmat.append(conf)\\n confmat = np.array(confmat)\\n\\n return p_scores, r_scroes, f1, confmat\",\n \"def _get_precision_recall_f1(preds_embeddings: Tensor, target_embeddings: Tensor, preds_idf_scale: Tensor, target_idf_scale: Tensor) ->Tuple[Tensor, Tensor, Tensor]:\\n cos_sim = torch.einsum('blpd, blrd -> blpr', preds_embeddings, target_embeddings)\\n precision = _get_scaled_precision_or_recall(cos_sim, 'precision', preds_idf_scale)\\n recall = _get_scaled_precision_or_recall(cos_sim, 'recall', target_idf_scale)\\n f1_score = 2 * precision * recall / (precision + recall)\\n f1_score = f1_score.masked_fill(torch.isnan(f1_score), 0.0)\\n return precision, recall, f1_score\",\n \"def evaluate(labels, predictions):\\n #labels and predictions\\n truePos = 0\\n trueNeg = 0\\n for data in range(len(labels)):\\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\\n truePos+=1\\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\\n trueNeg+=1\\n sensitivity = truePos/(len(labels) + 1)\\n specificity = trueNeg/(len(labels) + 1)\\n return (sensitivity, specificity)\\n \\n\\n #raise NotImplementedError\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n print('*'*20, '\\\\n')\\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\\\n')\\n print('*'*20)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def evaluate(self, sess, data_gen):\\n pred_labels = np.array([], dtype=np.intp)\\n labels = np.array([], dtype=np.intp)\\n for inputs, seq_length, batch_labels in data_gen:\\n feed_dict = self.create_feed_dict(inputs, seq_length, batch_labels,\\n self.config.dropout)\\n pred = sess.run(self.pred, feed_dict)\\n pred = softmax(pred, -1)\\n pred = binarize(pred[:, 1], self.threshold)\\n\\n pred_labels = np.concatenate((pred_labels, pred))\\n labels = np.concatenate((labels, batch_labels))\\n\\n score = f1_score(labels, pred_labels)\\n\\n return score, pred_labels\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def _score_to_decision(self, score):\",\n \"def scoring_function(self, model, y_true, y_predicted_probability):\",\n \"def do_score_prediction(self):\\n \\n import iread.myio as mio\\n from igui.score_canvas import ScoreCanvas\\n exp_name = 'JPS_act_12_exp_4_accv_half_fc_j2'\\n exp_name_base = 'ASM_act_12_exp_4'\\n exp_base_folder = '/opt/visal/tmp/for_sijin/Data/H36M/H36MExp'\\n exp_path = iu.fullfile(exp_base_folder, 'folder_%s' % exp_name, 'batches.meta')\\n meta_base_path = iu.fullfile(exp_base_folder, 'folder_%s' % exp_name_base, 'batches.meta')\\n meta = mio.unpickle(exp_path)\\n meta_base = mio.unpickle(meta_base_path)\\n images_path = meta_base['images_path']\\n \\n pred_pose = meta['feature_list'][0]\\n gt_pose = meta['random_feature_list'][0]\\n ntotal = gt_pose.shape[-1]\\n print 'gt_pose_shape',gt_pose.shape\\n print 'pred_pose_shape', pred_pose.shape\\n ref_frame = 7600 # This is the index in test range\\n ## ref_frame = 2600 # This is the index in test range\\n test_range = self.test_data_provider.feature_range\\n ref_idx = test_range[ref_frame]\\n \\n n_to_show = 1000\\n \\n idx_to_show = np.random.choice(ntotal, n_to_show - 1)\\n idx_to_show = [ref_idx] + idx_to_show.tolist() \\n idx_to_show = np.asarray(idx_to_show, dtype=np.int).flatten()\\n \\n ref_pose = pred_pose[...,ref_idx].reshape((-1,1),order='F') \\n pose_to_eval =gt_pose[...,idx_to_show]\\n output_feature_name = 'fc_2' # <------------------Parameter\\n output_layer_idx = self.get_layer_idx(output_feature_name)\\n\\n # do it once <------------- Maybe it can support multiple batch in the future\\n data_dim = self.model_state['layers'][output_layer_idx]['outputs']\\n print 'data_dim', data_dim\\n \\n cur_data = [np.require(np.tile(ref_pose, [1,n_to_show]), \\\\\\n dtype=np.single,requirements='C'), \\\\\\n np.require(pose_to_eval.reshape((-1,n_to_show),order='F'),\\\\\\n dtype=np.single,requirements='C'), \\\\\\n np.require(np.zeros((1,n_to_show),dtype=np.single), \\\\\\n requirements='C'),\\n np.require(np.zeros((n_to_show,data_dim),dtype=np.single), \\\\\\n requirements='C')]\\n residuals = cur_data[1][...,0].reshape((-1,1),order='F') - cur_data[1]\\n dp = self.test_data_provider\\n mpjpe = dutils.calc_mpjpe_from_residual(residuals, dp.num_joints)\\n\\n gt_score = dp.calc_score(mpjpe, dp.mpjpe_factor/dp.max_depth,\\\\\\n dp.mpjpe_offset/dp.max_depth).reshape((1,n_to_show)).flatten()\\n self.libmodel.startFeatureWriter(cur_data, output_layer_idx)\\n self.finish_batch()\\n score = cur_data[-1].T\\n print 'dim score', score.shape, 'dim gt_score', gt_score.shape\\n score = score.flatten()\\n # score = gt_score.flatten()\\n def my_sort_f(k):\\n if k == 0:\\n return 10000000\\n else:\\n return score[k]\\n sorted_idx = sorted(range(n_to_show), key=my_sort_f,reverse=True)\\n s_to_show = [idx_to_show[k] for k in sorted_idx]\\n sorted_score = np.asarray( [score[k] for k in sorted_idx])\\n \\n pose_to_plot = self.convert_relskel2rel(cur_data[1])\\n sorted_pose = pose_to_plot[...,sorted_idx]\\n class ScorePoseCanvas(ScoreCanvas):\\n def __init__(self,data_dic):\\n import iread.h36m_hmlpe as h36m\\n ScoreCanvas.__init__(self,data_dic)\\n self.pose_data = data_dic['pose_data']\\n self.limbs = h36m.part_idx\\n self.tmp = 0\\n def show_image(self,ax):\\n # ScoreCanvas.show_image(self,ax)\\n # return\\n import Image\\n idx =self.cur_data_idx\\n if idx == 0:\\n self.tmp = self.tmp + 1\\n if self.tmp == 1:\\n img = self.load_image(idx)\\n ax.imshow(np.asarray(img))\\n return\\n print 'Current data idx %d ' % self.cur_data_idx\\n # params = {'elev':-89, 'azim':-107}\\n # params = {'elev':-69, 'azim':-107}\\n params = {'elev':-81, 'azim':-91} # frontal view\\n fig = plt.figure(100)\\n from mpl_toolkits.mplot3d import Axes3D\\n import imgproc\\n # new_ax = self.fig.add_axes( rng_rel,projection='polar')\\n new_ax = fig.add_subplot(111,projection='3d')\\n imgproc.turn_off_axis(new_ax)\\n cur_pose = self.pose_data[...,idx].reshape((3,-1),order='F')\\n dutils.show_3d_skeleton(cur_pose.T,\\\\\\n self.limbs, params)\\n xmin,xmax = np.min(cur_pose[0]),np.max(cur_pose[0])\\n ymin,ymax = np.min(cur_pose[1]),np.max(cur_pose[1])\\n zmin,zmax = np.min(cur_pose[2]),np.max(cur_pose[2])\\n def extent(x,y,ratio):\\n x = x + (x-y) * ratio\\n y = y + (y-x) * ratio\\n return -0.4,0.4\\n r = 0.1\\n new_ax.set_xlim(extent(xmin,xmax,r))\\n new_ax.set_ylim(extent(ymin,ymax,r))\\n new_ax.set_ylim(extent(zmin,zmax,r))\\n tmp_folder = '/public/sijinli2/ibuffer/2014-CVPR2015/tmp/images'\\n save_path = iu.fullfile(tmp_folder, 'tmp_image.png')\\n plt.savefig(save_path)\\n img = Image.open(save_path)\\n plt.close(100)\\n img_arr = np.asarray(img)\\n s = np.int(img_arr.shape[0]/5.0)\\n e = np.int(img_arr.shape[0] - s)\\n s = 0\\n e = img_arr.shape[0]\\n img_arr = img_arr[s:e,:,:]\\n ax.imshow(np.asarray(img_arr))\\n # ax.plot([1,0,0],[0,1,0],[0,0,1])\\n\\n\\n sc = ScorePoseCanvas({'x': np.asarray(range(len(idx_to_show))), 'y':sorted_score,\\\\\\n 'images_path': [images_path[k] for k in s_to_show], \\\\\\n 'pose_data':sorted_pose})\\n sc.start()\\n print 'max score is ' , sorted_score.max()\\n gt_sort_idx = sorted(range(n_to_show), key=lambda k:gt_score[k], reverse=True)\\n sorted_gt_score = np.asarray([gt_score[k] for k in gt_sort_idx])\\n sorted_score_by_gt = [score[k] for k in gt_sort_idx]\\n pl.plot(np.asarray(range(n_to_show)), sorted_gt_score, 'r', label='gt_score')\\n pl.plot(np.asarray(range(n_to_show)), sorted_score_by_gt, 'g', label='pred_score')\",\n \"def PredictReviewScore(self, sentences, label=0):\\n AdjR = 0.0\\n # if text.startswith(\\\"For more photos and reviews do check out fourleggedfoodies\\\"):\\n # x = 1\\n adjAll = []\\n for sentence in sentences:\\n adjectives, dependencies = self.ExtractSentDetails(sentence)\\n adjAll.extend(adjectives)\\n allAdjectives = adjectives | Angel.GlobalAdjList\\n AdjS = 0.0\\n words = wordpunct_tokenize(sentence[\\\"Text\\\"])\\n if len(words) <= 3:\\n allAdjectives |= set([x.lower() for x in words])\\n for i in range(len(words)):\\n word = words[i].lower()\\n if word in {\\\"but\\\", \\\"if\\\"}:\\n AdjS = 0.0\\n elif word in allAdjectives and word in self.lexicon:\\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\\n AdjR += AdjS\\n AdjR *= self.PredictBase(adjAll)\\n finalScore = AdjR\\n if self.DumpRequested(finalScore, label):\\n self.DumpDetails(sentences, label)\\n return finalScore\",\n \"def eval_metrics_for_multiclass(self, predicted_answers):\\n total_correct_in_all = 0\\n total_pred_in_all = len(predicted_answers)\\n # initial a dict for total correct in topK counting.\\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\\n max_topK = max(self.topK_list)\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids\\n correct_label_indices = sample['correct_labels']\\n # current case, we only have a majority lable for the correct label\\n label_true.append(correct_label_indices[0])\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\\n top1_pred = sorted_probs_max_topK[0]\\n label_pred.append(top1_pred['label_index'])\\n\\n # for all topK predictions\\n for i in range(len(sorted_probs_max_topK)):\\n pred = sorted_probs_max_topK[i]\\n for topK in self.topK_list:\\n if i >= topK:\\n continue\\n else:\\n total_pred_in_topK[topK] += 1\\n if pred['label_index'] in correct_label_indices:\\n total_correct_in_topK[topK] += 1\\n\\n if total_correct_in_all != 0:\\n # recall@K\\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\\n # assign recall@K into metrics\\n for k, v in recall_at_K.items():\\n # Jie\\n # 1 means the greater the better.\\n # -1 means the smaller the better.\\n metrics['R@{}'.format(k)] = (1, v)\\n\\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\\n # here return all the p,r,f for each label, then we compute the micro average later.\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\\n title='Confusion matrix, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\\n title='Normalized confusion matrix')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71954495","0.71191156","0.6963033","0.69378823","0.6911759","0.6779604","0.6772857","0.6724274","0.67095697","0.6671175","0.6646141","0.6631684","0.660936","0.66015124","0.6600215","0.6514463","0.6501403","0.6496312","0.6494798","0.64848906","0.6475837","0.6473734","0.6473311","0.6443972","0.6438466","0.638338","0.6362805","0.6307725","0.62996686","0.6295592","0.6282512","0.6265438","0.6250778","0.62048703","0.6169679","0.61459213","0.61175114","0.6116844","0.6104615","0.6097745","0.6097548","0.6088628","0.6038251","0.6036917","0.6027642","0.601749","0.60133433","0.6004102","0.60032785","0.59914786","0.5967564","0.5951708","0.59470266","0.59470266","0.594046","0.5939344","0.59277993","0.592355","0.59002894","0.588747","0.58784825","0.5866899","0.58645767","0.5864241","0.5856446","0.5851617","0.5841421","0.58396363","0.58346575","0.58326507","0.58235604","0.58166987","0.5813993","0.5812329","0.58033156","0.5799394","0.57841986","0.5782227","0.5774059","0.57709056","0.5770639","0.5769611","0.57687443","0.576365","0.57516485","0.5749867","0.5745101","0.57366866","0.5736582","0.5734549","0.5732941","0.5725448","0.5721226","0.57072943","0.5705675","0.57043344","0.56976163","0.569551","0.5690861","0.5685226"],"string":"[\n \"0.71954495\",\n \"0.71191156\",\n \"0.6963033\",\n \"0.69378823\",\n \"0.6911759\",\n \"0.6779604\",\n \"0.6772857\",\n \"0.6724274\",\n \"0.67095697\",\n \"0.6671175\",\n \"0.6646141\",\n \"0.6631684\",\n \"0.660936\",\n \"0.66015124\",\n \"0.6600215\",\n \"0.6514463\",\n \"0.6501403\",\n \"0.6496312\",\n \"0.6494798\",\n \"0.64848906\",\n \"0.6475837\",\n \"0.6473734\",\n \"0.6473311\",\n \"0.6443972\",\n \"0.6438466\",\n \"0.638338\",\n \"0.6362805\",\n \"0.6307725\",\n \"0.62996686\",\n \"0.6295592\",\n \"0.6282512\",\n \"0.6265438\",\n \"0.6250778\",\n \"0.62048703\",\n \"0.6169679\",\n \"0.61459213\",\n \"0.61175114\",\n \"0.6116844\",\n \"0.6104615\",\n \"0.6097745\",\n \"0.6097548\",\n \"0.6088628\",\n \"0.6038251\",\n \"0.6036917\",\n \"0.6027642\",\n \"0.601749\",\n \"0.60133433\",\n \"0.6004102\",\n \"0.60032785\",\n \"0.59914786\",\n \"0.5967564\",\n \"0.5951708\",\n \"0.59470266\",\n \"0.59470266\",\n \"0.594046\",\n \"0.5939344\",\n \"0.59277993\",\n \"0.592355\",\n \"0.59002894\",\n \"0.588747\",\n \"0.58784825\",\n \"0.5866899\",\n \"0.58645767\",\n \"0.5864241\",\n \"0.5856446\",\n \"0.5851617\",\n \"0.5841421\",\n \"0.58396363\",\n \"0.58346575\",\n \"0.58326507\",\n \"0.58235604\",\n \"0.58166987\",\n \"0.5813993\",\n \"0.5812329\",\n \"0.58033156\",\n \"0.5799394\",\n \"0.57841986\",\n \"0.5782227\",\n \"0.5774059\",\n \"0.57709056\",\n \"0.5770639\",\n \"0.5769611\",\n \"0.57687443\",\n \"0.576365\",\n \"0.57516485\",\n \"0.5749867\",\n \"0.5745101\",\n \"0.57366866\",\n \"0.5736582\",\n \"0.5734549\",\n \"0.5732941\",\n \"0.5725448\",\n \"0.5721226\",\n \"0.57072943\",\n \"0.5705675\",\n \"0.57043344\",\n \"0.56976163\",\n \"0.569551\",\n \"0.5690861\",\n \"0.5685226\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59118205"},"document_rank":{"kind":"string","value":"58"}}},{"rowIdx":85170,"cells":{"query":{"kind":"string","value":"Computes ROUGEN f1 score of two text collections of sentences."},"document":{"kind":"string","value":"def rouge_n(eval_sentences, ref_sentences, n=2):\n f1_scores = []\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\n eval_ngrams = _get_ngrams(n, eval_sentence)\n ref_ngrams = _get_ngrams(n, ref_sentence)\n ref_count = len(ref_ngrams)\n eval_count = len(eval_ngrams)\n\n # Count the overlapping ngrams between evaluated and reference\n overlapping_ngrams = eval_ngrams.intersection(ref_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if eval_count == 0:\n precision = 0.0\n else:\n precision = float(overlapping_count) / eval_count\n if ref_count == 0:\n recall = 0.0\n else:\n recall = float(overlapping_count) / ref_count\n f1_scores.append(2.0 * ((precision * recall) / (precision + recall + 1e-8)))\n\n # return overlapping_count / reference_count\n return np.mean(f1_scores, dtype=np.float32)"},"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 wordSimilarityRatio(sent_1,sent_2):","def compare_word_selection(selection1,selection2):\n\n num_extra=0;\n num_total=0;\n total_score=0;\n for k in selection1.keys():\n num_total+=1;\n if k not in selection2:\n num_extra+=1;\n else:\n score=compare_sentences(selection1[k],selection2[k]);\n logging.info(\"Score: %f\" % score );\n total_score+=score;\n\n for k in selection2.keys():\n if k not in selection1:\n num_total+=1;\n num_extra+=1;\n\n if num_total==0:\n return 0;\n\n return float(total_score)/float(num_total)","def compare_sentences(s1,s2):\n\n total_score=0;\n num_total=0;\n for k in s1:\n num_total+=1\n if k in s2:\n if s1[k]==s2[k]:\n score = 1;\n else:\n score = 0;\n else:\n score = 0;\n total_score += score;\n \n for k in s2:\n if k not in s1:\n num_total+=1\n\n logging.info(\"Scored %f out of %d\" % (total_score, num_total));\n\n if num_total==0:\n return 1;\n return float(total_score)/float(num_total)","def get_score(self,sentence_1, sentence_2):\n\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)","def string_f1_score(prediction, ground_truth):\n prediction_tokens = normalize_answer(prediction).split()\n ground_truth_tokens = normalize_answer(ground_truth).split()\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def score(self, sentence):\n score = 0.0\n V = len(self.f1) # vocabulary size\n for token in sentence:\n if token in self.f1: score += self.f1[token]\n else: score -= math.log10(self.total + V)\t\t # OOV \n return score","def test_score_text1(self):\n\t\ttest = sentiment.LibraryRun(self.text3, self.lib)\n\t\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\n\t\tobj_ut, _ = test.score_text(matches)\n\t\tself.assertEqual(obj_ut, -1)","def _f1_score_(prediction, ground_truth):\n prediction_tokens = _normalize_answer(prediction).split()\n ground_truth_tokens = _normalize_answer(ground_truth).split()\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def match_score(seq1, seq2):\n\n seq1 = get_sequence_string(seq1)\n seq2 = get_sequence_string(seq2)\n score = align.localxx(seq1, seq2)[0][2]\n return score","def score():\n\n # Read files\n s1 = request.form.get(\"string1\")\n s2 = request.form.get(\"string2\")\n if not s1 or not s2:\n abort(400, \"missing strings\")\n\n # Score files\n matrix = distances(s1, s2)\n\n # Extract operations from table\n operations = []\n i, j = len(s1), len(s2)\n while True:\n _, operation = matrix[i][j]\n if not operation:\n break\n if operation == Operation.INSERTED:\n j -= 1\n elif operation == Operation.DELETED:\n i -= 1\n else:\n i -= 1\n j -= 1\n operations.append(operation)\n operations.reverse()\n\n # Maintain list of intermediate strings, operation, and descriptions\n transitions = [(s1, None, None)]\n i = 0\n\n # Apply each operation\n prev = s1\n for operation in operations:\n\n # Update string and description of operation\n if operation == Operation.INSERTED:\n s = (prev[:i], s2[i], prev[i:])\n description = f\"inserted '{s2[i]}'\"\n prev = prev[:i] + s2[i] + prev[i:]\n i += 1\n elif operation == Operation.DELETED:\n s = (prev[:i], prev[i], prev[i + 1:])\n description = f\"deleted '{prev[i]}'\"\n prev = prev[:i] + prev[i + 1:]\n elif prev[i] != s2[i]:\n s = (prev[:i], s2[i], prev[i + 1:])\n description = f\"substituted '{prev[i]}' with '{s2[i]}'\"\n prev = prev[:i] + s2[i] + prev[i + 1:]\n i += 1\n else:\n i += 1\n continue\n transitions.append((s, str(operation), description))\n transitions.append((s2, None, None))\n\n # Output comparison\n return render_template(\"score.html\", matrix=matrix, s1=s1, s2=s2, operations=transitions)","def f1_score(self):","def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\r\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\r\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\r\n\r\n if p + r > 0:\r\n return 2 * p * r / (p + r)\r\n else:\r\n return 0","def f1score(prediction,ytest):\n truepos = np.sum(ytest[prediction == 1])\n predpos = np.sum(prediction)\n actpos = np.sum(ytest)\n precision = truepos/predpos\n recall = truepos/actpos\n return 2*precision*recall/(precision + recall)","def test_score_text2(self):\n\t\t#import pdb; pdb.set_trace()\n\t\ttest = sentiment.LibraryRun(self.text3, self.lib)\n\t\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\n\t\tobj_ut, _ = test.score_text(matches, end_threshold=0.5)\n\t\tself.assertEqual(obj_ut, -1.25)","def difference(first, second, rf, rs, years=(1980, 2000),smooth=1, corpus='bok'):\n try:\n a_first = nb_ngram(first, years=years, smooth=smooth, corpus=corpus)\n a_second = nb_ngram(second, years=years, smooth=smooth, corpus=corpus)\n a = a_first.join(a_second) \n b_first = nb_ngram(rf, years=years, smooth=smooth, corpus=corpus)\n b_second = nb_ngram(rs, years=years, smooth=smooth, corpus=corpus)\n if rf == rs:\n b_second.columns = [rs + '2']\n b = b_first.join(b_second)\n s_a = a.mean()\n s_b = b.mean()\n f1 = s_a[a.columns[0]]/s_a[a.columns[1]]\n f2 = s_b[b.columns[0]]/s_b[b.columns[1]]\n res = f1/f2\n except:\n res = 'Mangler noen data - har bare for: ' + ', '.join([x for x in a.columns.append(b.columns)])\n return res","def get_raw_score(self, set1, set2):\n \n # input validations\n utils.sim_check_for_none(set1, set2)\n utils.sim_check_for_list_or_set_inputs(set1, set2)\n\n # if exact match return 1.0\n if utils.sim_check_for_exact_match(set1, set2):\n return 1.0\n\n # if one of the strings is empty return 0\n if utils.sim_check_for_empty(set1, set2):\n return 0\n\n if not isinstance(set1, set):\n set1 = set(set1)\n if not isinstance(set2, set):\n set2 = set(set2)\n\n return 2.0 * float(len(set1 & set2)) / float(len(set1) + len(set2))","def score_two(rect1, rect2):\n score = 0.0\n avg_width = (rect1[1][0] + rect2[1][0])/2\n avg_x = (rect1[0][0] + rect2[0][0])/2\n vector = np.array([rect2[0][0] - rect1[0][0], rect2[0][1] - rect1[0][1]])\n length = np.sqrt(np.dot(vector, vector))\n tilt_l = (14.5 - rect1[2])/15\n tilt_r = (14.5 + rect2[2])/15\n if length > 0:\n aim = (avg_x - mid_point)/mid_point\n ratio = 0.2 - avg_width / length\n sine = vector[1] / length\n cosine = vector[0] / length\n score += sine * sine\n score += (1 - cosine)\n score += ratio * ratio\n score += aim * aim\n score += tilt_l * tilt_l\n score += tilt_r * tilt_r\n return score","def f1_score(confusion):\n sens = sensitivity(confusion)\n prec = precision(confusion)\n return 2 * sens * prec / (sens + prec)","def sentence_similarity(self,sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n\n # Get the synsets for the tagged words\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n\n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n\n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n vals = [synset.path_similarity(ss) if synset.path_similarity(ss) is not None else 0 for ss in synsets2]\n best_score = max(vals,default=0)\n\n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n # Average the values\n if count == 0:\n return 0\n score /= count\n return score","def _compute_f1_score(predicted_answer: str, target_answer: str) ->Tensor:\n target_tokens = _get_tokens(target_answer)\n predicted_tokens = _get_tokens(predicted_answer)\n common = Counter(target_tokens) & Counter(predicted_tokens)\n num_same = tensor(sum(common.values()))\n if len(target_tokens) == 0 or len(predicted_tokens) == 0:\n return tensor(int(target_tokens == predicted_tokens))\n if num_same == 0:\n return tensor(0.0)\n precision = 1.0 * num_same / tensor(len(predicted_tokens))\n recall = 1.0 * num_same / tensor(len(target_tokens))\n f1 = 2 * precision * recall / (precision + recall)\n return f1","def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\"malaria\", confusion_matrix_title=\"\"):\n # demonstration of calculating metrics for a neural network model using sklearn\n if not binary_classifcation:\n # For multiclass classification.\n accuracy = accuracy_score(actual_labels, preds_labels)\n precision = precision_score(actual_labels, preds_labels, average=\"macro\")\n recall = recall_score(actual_labels, preds_labels, average=\"macro\")\n f1 = f1_score(actual_labels, preds_labels, average=\"macro\")\n print('Accuracy: %f' % accuracy)\n print('Precision: %f' % precision)\n print('Recall: %f' % recall)\n print('F1 score: %f' % f1)\n\n else:\n accuracy = accuracy_score(actual_labels, preds_labels)\n print('Accuracy: %f' % accuracy)\n # # precision tp / (tp + fp)\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Precision: %f' % precision)\n # recall: tp / (tp + fn)\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Recall: %f' % recall)\n # f1: 2 tp / (2 tp + fp + fn)\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\n print('F1 score: %f' % f1)\n # ROC AUC\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\n # print('ROC AUC: %f' % auc)\n\n # confusion matrix\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\n display_labels=list(np.unique(actual_labels)),\n cmap=plt.cm.Blues,\n normalize=None)\n disp.ax_.set_title(confusion_matrix_title)\n plt.show()\n matrix = confusion_matrix(actual_labels, preds_labels)\n print(matrix)\n # if plot_confusion_matrix:\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))","def score_scansions(self, scansion1, scansion2):\n p_1 = 1\n p_2 = 1\n word_scansions_1 = scansion1.scansion.lstrip(\" \").rstrip(\" \").split(\" \")\n word_scansions_2 = scansion2.scansion.lstrip(\" \").rstrip(\" \").split(\" \")\n for i, word in enumerate(self.words):\n p_word_1, _ = word.compare_scansions(word_scansions_1[i], word_scansions_2[i])\n p_1 *= p_word_1\n p_2 *= (1 - p_word_1)\n if p_1 > p_2:\n return scansion1, p_1/(p_1 + p_2)\n return scansion2, p_2 / (p_1 + p_2)","def get_identical_score(bin1,bin2=None):\n if bin2==None: bin2=[]\n tmpscore=0.0\n norm=0\n for ali1 in bin1:\n tmpscore+=get_subscore(ali1,ali1)\n norm+=1\n for ali2 in bin2:\n tmpscore+=get_subscore(ali2,ali2)\n norm+=1\n return tmpscore/norm","def f1_score(model_id, test_set_id, rubric_id):\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\n\n for key in rubrication_result:\n if rubrication_result[key] == answers[key]:\n if rubrication_result[key] == 1:\n result['true_positive'] += 1\n else:\n result['true_negative'] += 1\n else:\n if rubrication_result[key] == 1:\n result['false_positive'] += 1\n else:\n result['false_negative'] += 1\n if (result['true_positive'] + result['false_positive']) > 0:\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\n else:\n result['precision'] = 0\n if (result['true_positive'] + result['false_negative']) > 0:\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\n else:\n result['recall'] = 0\n if (result['precision'] + result['recall']) > 0:\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\n else:\n result['f1'] = 0\n return result","def _get_similarity_score(self, dict1, dict2):\n try:\n majorScoreDeterminer1 = ['primaryGenreId']\n majorScoreDeterminer2 = ['genreIds']\n Score = 0 # Base Score\n for items in majorScoreDeterminer2:\n\n for item1 in self._get_app_param_info(dict1, resultCount=1, resultKey=items):\n if item1 in self._get_app_param_info(dict2, resultCount=1, resultKey=items):\n if Score == 0: # Add 50% base score for this category.\n Score += 2 * .5\n Score += 2 * .5 / len(self._get_app_param_info(dict1, resultCount=1, resultKey=items))\n\n for items in majorScoreDeterminer1:\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\n self._get_app_param_info(dict1, resultCount=1, resultKey=items)):\n Score += (3 / len(majorScoreDeterminer1))\n\n nameMatchScore = difflib.SequenceMatcher(None,\n self._get_app_param_info(dict1, resultCount=1,\n resultKey='trackName'),\n self._get_app_param_info(dict2, resultCount=1,\n resultKey='trackName')).ratio()\n Score += nameMatchScore\n\n minorScoreDeterminer = ['isGameCenterEnabled', 'languageCodesISO2A', 'contentAdvisoryRating', 'artistId',\n 'formattedPrice']\n\n for items in minorScoreDeterminer:\n if items == \"formattedPrice\":\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \"Free\":\n Score += (4 / (len(minorScoreDeterminer)))\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \"Free\":\n continue\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \"Free\":\n continue\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \"Free\" and str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \"Free\":\n Score += (4 / (len(minorScoreDeterminer)))\n else:\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)):\n Score += (4 / (len(minorScoreDeterminer)))\n Score = round(Score, 1)\n log_str = \"id\" + str(self._get_app_param_info(dict2, resultCount=1, resultKey='trackId')) + \" - \" + str(\n self._get_app_param_info(dict2, resultCount=1, resultKey='trackName')) + \"\\tScore: \" + str(Score)\n except AssertionError as e:\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n except TypeError as e:\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n except:\n e = sys.exc_info()[0]\n print(\"Error: _get_similarity_score %s\" % e)\n sys.exit(\"Exit script with error code %s\" % e)\n else:\n return log_str","def calculate_score(result):\n sample1=result['Sample1']\n sample2=result['Sample2']\n string1=paragraph_to_list(sample1)\n string2=paragraph_to_list(sample2)\n \n return round( strings_similarity(string1, string2), 2)\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\n #return round(0.5*(method_difflab+method_dict), 2)","def f1_score(self):\n self.overall_f1_score = f1_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_f1_score = f1_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)","def text_proximity(str_1: str, str_2: str) -> float:\n tokens_1 = Counter(str_1.split(' '))\n tokens_2 = Counter(str_2.split(' '))\n return _normalized_scalar_product(tokens_1, tokens_2)","def sentence_similarity(self,wnsimilarity,sentence1, sentence2,icneed=False):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n \n # Get the synsets for the tagged words\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n \n score, count = 0.0, 0\n # For each word in the first sentence\n for synset in synsets1:\n \n # Get the similarity value of the most similar word in the other sentence\n score_list=[]\n if icneed == True :\n for ss in synsets2:\n try:\n temp=wnsimilarity(synset,ss,self.brown_ic)\n score_list.append(temp)\n except:\n continue\n \n else:\n for ss in synsets2:\n try:\n temp=wnsimilarity(synset,ss)\n score_list.append(temp)\n except:\n continue\n \n \n score_list = np.array(score_list, dtype=np.float64)\n score_list = np.nan_to_num(score_list)\n# print(score_list)\n if len(score_list)>0:\n best_score = np.nanmax(score_list)\n else:\n best_score=0.0\n# print(best_score)\n# print(type(best_score))\n \n # Check that the similarity could have been computed\n if best_score is not None:\n score =score + best_score\n# print(score)\n count = count+ 1\n \n \n# print(\"one sentence over\")\n # Average the values\n score /= count\n return score","def heuristic_2(a: str, b: str) -> float:\n # generate term-document matrices\n if get_intro(a) == \"\" or get_intro(b) == \"\":\n return 2\n else:\n corpus = [get_intro(a), get_intro(b)]\n vect = TfidfVectorizer()\n mat = vect.fit_transform(corpus)\n # return cosine similarity\n return abs(1 - cosine_similarity(mat[0:1], mat)[0][1]) * 2","def similarity(self, wSet1, wSet2, idf): \n if len(wSet1) == 0 or len(wSet2) == 0:\n return 0.0\n else:\n defaultIDF = idf['unknownToken']\n intersection = wSet1.intersection(wSet2)\n# intersection = self.synonymIntersection(wSet1, wSet2, idf)\n if len(intersection) == 0:\n return 0\n sum1 = 0\n sum2 = 0\n intersectionSum = 0\n for word in wSet1:\n sum1 += (idf.get(word, defaultIDF))**2\n for word in wSet2:\n sum2 += (idf.get(word, defaultIDF))**2\n for word in intersection:\n intersectionSum += (idf.get(word, defaultIDF))**2\n \n if sum1 == 0 or sum2 == 0:\n return 0.0\n else:\n return intersectionSum/(math.sqrt(sum1) * math.sqrt(sum2))","def ratio(n1,n2, explain=0, optimize=False):\n weight_normal_form = 5.0 #distance between soundexes of normal form\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\n weight_initials = 2 #distance between initials\n\n nf1 = n1.guess_normal_form()\n nf2 = n2.guess_normal_form()\n\n if not nf1 or not nf2:\n return 0.0\n elif nf1 == nf2:\n return 1.0\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\n \n #create a simkplified soundex set for this name\n #remove stopwords\n# nf1 = remove_stopwords( nf1)\n# nf2 = remove_stopwords( nf2)\n \n se1 = n1.get_normal_form_soundex()\n se2 = n2.get_normal_form_soundex()\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\n \n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\n g1 = to_ascii(g1)\n g2 = to_ascii(g2)\n if not optimize:\n #de soundexes van de achternaam worden meegewoen\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\n g1_soundex = n1.geslachtsnaam_soundex()\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\n g2_soundex = n2.geslachtsnaam_soundex()\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\n else:\n ratio_geslachtsnaam1 = 1 \n weight_geslachtsnaam1 = 0\n \n #n de afstand van de woorden in de achtenraam zelf\n ratio_geslachtsnaam2 = Similarity.average_distance(\n re.split('[ \\.\\,\\-]', g1.lower()),\n re.split('[ \\.\\,\\-]', g2.lower()),\n levenshtein_ratio)\n n1_initials = n1.initials()\n n1_initials_lower = n1_initials.lower()\n n2_initials = n2.initials()\n n2_initials_lower = n2_initials.lower()\n n1_contains_initials = n1.contains_initials()\n n2_contains_initials = n2.contains_initials()\n #count initials only if we have more than one\n #(or perhaps make this: if we know the first name)\n if len(n1_initials) == 1 or len(n2_initials) == 1:\n #initials count much less if there is only one\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\n# ratio_initials = .5\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n elif n1_contains_initials or n2_contains_initials:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n weight_initials = weight_initials_if_one_name_is_in_initials\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\n else:\n ratio_initials = 0.7\n \n if n1_contains_initials or n2_contains_initials:\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\n\n counter = (ratio_normal_form * weight_normal_form +\n ratio_normal_form_soundex * weight_normal_form_soundex +\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\n ratio_initials * weight_initials)\n numerator = (weight_normal_form + weight_normal_form_soundex +\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\n if numerator == 0:\n return 0.0\n final_ratio = counter/numerator\n\n if explain:\n s = '-' * 100 + '\\n'\n s += 'Naam1: %s [%s] [%s] %s\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\n s += 'Naam2: %s [%s] [%s] %s\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\n s += 'Similarity ratio: %s\\n' % final_ratio\n s += '--- REASONS' + '-' * 30 + '\\n'\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\n'\n s += format_s % ('\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\n s += '\\t' + '-' * 100 + '\\n'\n format_s = '\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\n'\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\n s += '\\tTOTAL (numerator) | %s (counter = %s)\\n' % (counter, numerator)\n \n return s\n return final_ratio","def sentence_similarity(sentence1, sentence2):\n sentence1 = sentence1.tags\n sentence2 = sentence2.tags\n \n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n \n for synset in synsets1:\n \n li=[synset.path_similarity(ss) for ss in synsets2]\n m=0\n for i in range(len(li)):\n if li[i] is not None and m<li[i]:\n m=li[i]\n if m != 0:\n score += m\n count += 1\n\n if count is 0:\n score = 0\n else:\n score /= count\n return score","def F1Score(labels, gold_file, wordnetCompression):\n\n gold_labels = []\n with open(gold_file, 'r') as file:\n for line in file:\n gold_labels.append(line.split()[1])\n\n flat_decoded_label_list = [item for sublist in labels for item in sublist]\n\n total = 0\n correct = 0\n if wordnetCompression:\n for i in range(len(gold_labels)):\n total += 1\n current_gold = gold_labels[i]\n pos = wn.lemma_from_key(current_gold).synset().pos()\n offset = wn.lemma_from_key(current_gold).synset().offset()\n wn_synset = \"wn:\" + str(offset).zfill( 8) + pos\n current_prediction = flat_decoded_label_list[i]\n #if len(current_prediction) > 1:\n # for elem in current_prediction:\n # if elem == current_gold:\n # correct += 1\n #else:\n if wn_synset == current_prediction:\n correct += 1\n else:\n for i in range(len(gold_labels)):\n if gold_labels[i] == flat_decoded_label_list[i]:\n correct += 1\n total += 1\n \n print(\"F1 SCORE: \", (correct/total)*100 )\n print(\"Total number of labels: \", total)\n print(\"Total correct: \", correct)\n print()","def compare(strokes1, strokes2):\n\n score = 0\n for stroke_i in strokes1:\n match = identify(strokes2, stroke_i)\n score += match\n\n # draw1 = concat(strokes1)\n # draw2 = concat(strokes2)\n # draw1_length,_ = draw1.euclidian_length()\n # draw2_length,_ = draw2.euclidian_length()\n\n # tot_length = draw1_length# + draw2_length\n\n return score","def calculate_score(s1, s2, l1, l2, startpoint):\n\n matched = \"\" # to hold string displaying alignments\n score = 0\n for i in range(l2):\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" # * indicates a match\n score = score + 1\n else:\n matched = matched + \"-\" # - indicates no match\n\n return score","def matching_score(self,set1, set2):\n set_set1=set(set1)\n set_set2=set(set2)\n '''print(\" set_set12\")\n print(set_set1)\n print(set_set2)'''\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))","def baseline_score(self,t0,t1):\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))","def simple_baseline_similarity(s1, s2):\n # Tokenize by sentences into words in lower case \n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\n\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\n \n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\n \n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\n\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\n\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\n\n return word_sim, lemm_sim","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\r\n return self.f1score","def _l1_similarity(self, sentence_one, sentence_two):\n with tf.name_scope(\"l1_similarity\"):\n # Take the L1 norm of the two vectors.\n # Shape: (batch_size, 2*rnn_hidden_size)\n l1_distance = tf.abs(sentence_one - sentence_two)\n\n # Take the sum for each sentence pair\n # Shape: (batch_size, 1)\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\n keep_dims=True)\n\n # Exponentiate the negative summed L1 distance to get the\n # positive-class probability.\n # Shape: (batch_size, 1)\n positive_class_probs = tf.exp(-summed_l1_distance)\n\n # Get the negative class probabilities by subtracting\n # the positive class probabilities from 1.\n # Shape: (batch_size, 1)\n negative_class_probs = 1 - positive_class_probs\n\n # Concatenate the positive and negative class probabilities\n # Shape: (batch_size, 2)\n class_probabilities = tf.concat([negative_class_probs,\n positive_class_probs], 1)\n\n # if class_probabilities has 0's, then taking the log of it\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\n # epsilon and renormalize by the sum of the vector.\n safe_class_probabilities = class_probabilities + 1e-08\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\n axis=1,\n keep_dims=True)\n return safe_class_probabilities","def _l1_similarity(self, sentence_one, sentence_two):\n with tf.name_scope(\"l1_similarity\"):\n # Take the L1 norm of the two vectors.\n # Shape: (batch_size, 2*rnn_hidden_size)\n l1_distance = tf.abs(sentence_one - sentence_two)\n\n # Take the sum for each sentence pair\n # Shape: (batch_size, 1)\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\n keep_dims=True)\n\n # Exponentiate the negative summed L1 distance to get the\n # positive-class probability.\n # Shape: (batch_size, 1)\n positive_class_probs = tf.exp(-summed_l1_distance)\n\n # Get the negative class probabilities by subtracting\n # the positive class probabilities from 1.\n # Shape: (batch_size, 1)\n negative_class_probs = 1 - positive_class_probs\n\n # Concatenate the positive and negative class probabilities\n # Shape: (batch_size, 2)\n class_probabilities = tf.concat([negative_class_probs,\n positive_class_probs], 1)\n\n # if class_probabilities has 0's, then taking the log of it\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\n # epsilon and renormalize by the sum of the vector.\n safe_class_probabilities = class_probabilities + 1e-08\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\n axis=1,\n keep_dims=True)\n return safe_class_probabilities","def compare_sentences(first, second):\n if not len(first) or not len(second):\n return 0\n return len(set(only_important(first)) & set(only_important(second))) / ((len(first) + len(second)) / 2.0)","def score_ngram(self, score_fn, w1, w2):\n n_all = self.N\n n_ii = self.ngram_fd[(w1, w2)] / (self.window_size - 1.0)\n if not n_ii:\n return\n n_ix = self.word_fd[w1]\n n_xi = self.word_fd[w2]\n return score_fn(n_ii, (n_ix, n_xi), n_all)","def sentence_similarity(sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n\n # Get the synsets for the tagged words\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n\n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n\n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n best_score = max([synset.path_similarity(ss) or 0 for ss in synsets2])\n\n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n if count == 0:\n return 0\n\n # Average the values\n score /= count\n return score","def calculate_f1_score(y_test, y_pred):\n print('# Running precision, recall and F1-score')\n print('# F1-Score:\\t\\t%.2f' % (f1_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Precision:\\t\\t%.2f' % (precision_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Recall:\\t\\t%.2f' % (recall_score(y_test, y_pred, average=\"macro\") * 100))","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2):\n #moves shorter sequence along longer, counting number of matches in\n #each position\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\"\n score = score + 1\n else:\n matched = matched + \"-\"\n\n # gives an output for each startpoint showing the number of matches where\n # * is a match and - is no match, position of the two sequences relative to\n # each other, and the number of matches for that startpoint.\n print(\".\" * startpoint + matched) \n print(\".\" * startpoint + s2)\n print(s1)\n print(score) \n print(\" \")\n\n return score","def compare_texts(text1, text2):\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))","def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n \"\"\"Get n-gram level f-score.\"\"\"\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\n return f_score","def get_f1(self,common_len,RTSummary,SystemSummary):\n recall = self.get_recall(common_len,RTSummary)\n precision = self.get_precision(common_len,SystemSummary)\n if precision<=0 or recall <=0:\n return 0.0\n else:\n return ((2 * recall * precision)/(recall + precision))","def wordNet_similarity(sentence1, sentence2):\r\n # Tokenize and tag\r\n \r\n # sentence1 = pos_tag(word_tokenize(sentence1))\r\n sentence1=st_tagger.tag(word_tokenize(sentence1))\r\n \r\n # sentence2 = pos_tag(word_tokenize(sentence2))\r\n sentence2=st_tagger.tag(word_tokenize(sentence2))\r\n\r\n \r\n # Get the synsets for the tagged words\r\n #################################################\r\n\r\n # synsets1=[]\r\n # synsets2=[]\r\n # for tagged_word in sentence1:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n # for tagged_word in sentence2:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # print(tagged_word)\r\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n\r\n # The code above is the elaboration of code below\r\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\r\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\r\n \r\n # Filter out the Nones in the synonym set\r\n synsets1 = [ss for ss in synsets1 if ss]\r\n synsets2 = [ss for ss in synsets2 if ss]\r\n \r\n score, count = 0.0, 0\r\n \r\n###########################################################################\r\n # for syn1 in synsets1:\r\n # arr_simi_score = []\r\n # print('=========================================')\r\n # print(syn1)\r\n # print('----------------')\r\n # for syn2 in synsets2:\r\n # print(syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n # print(simi_score)\r\n # if simi_score is not None:\r\n # arr_simi_score.append(simi_score)\r\n # print('----------------')\r\n # print(arr_simi_score)\r\n # if(len(arr_simi_score) > 0):\r\n # best = max(arr_simi_score)\r\n # print(best)\r\n # score += best\r\n # count += 1\r\n # # Average the values\r\n # print('score: ', score)\r\n # print('count: ', count)\r\n # score /= count\r\n\r\n###########################################################################\r\n\r\n for syn1 in synsets1:\r\n arr_simi_score = []\r\n # print('=========================================')\r\n print(\"Each word from Synonym se1\",syn1)\r\n # print('----------------')\r\n for syn2 in synsets2:\r\n print(\"Each word from Synonym se2\",syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n simi_score = syn1.wup_similarity(syn2)\r\n print(\"word to word path_similarity score\",simi_score)\r\n if simi_score is not None:\r\n arr_simi_score.append(simi_score)\r\n print('----------------')\r\n print(arr_simi_score)\r\n if(len(arr_simi_score) > 0):\r\n best = max(arr_simi_score)\r\n print(\"best score so far\", best)\r\n score += best\r\n count += 1\r\n # Average the values\r\n print('score: ', score)\r\n print('count: ', count)\r\n if count!=0:\r\n score /= count\r\n else:\r\n score=0.0\r\n return score","def word_order_similarity(self,sentence_1, sentence_2):\n\t words_1 = sentence_1.getList_of_words()\n\t words_2 = sentence_2.getList_of_words()\n\t joint_words = list(set(words_1).union(set(words_2)))\n\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\n\t r1 = self.word_order_vector(words_1, joint_words, windex)\n\t r2 = self.word_order_vector(words_2, joint_words, windex)\n\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))","def fuzzy_score_string(first_string, second_string):\n score = 0\n\n if len(first_string) < len(second_string):\n shorter, longer = (first_string, second_string)\n window_length = len(shorter)\n\n num_iterations = len(longer) - len(shorter) + 1\n\n for position in range(0, num_iterations):\n window = longer[position:position + window_length]\n l_ratio = Levenshtein.ratio(window, shorter) * 100\n\n if l_ratio > 60:\n result = statistics.mean(\n [100 - Levenshtein.distance(window, shorter) * 15, l_ratio, l_ratio])\n\n else:\n result = l_ratio\n\n if result > score:\n score = result\n\n else:\n l_ratio = Levenshtein.ratio(first_string, second_string) * 100\n score = statistics.mean(\n [100 - Levenshtein.distance(first_string, second_string) * 15, l_ratio, l_ratio])\n\n simple = fuzz.ratio(first_string, second_string)\n partial = fuzz.partial_ratio(first_string, second_string)\n sort = fuzz.token_sort_ratio(first_string, second_string)\n set_ratio = fuzz.token_set_ratio(first_string, second_string)\n\n score = max([score, simple, partial, sort, set_ratio])\n\n if score < 75:\n score = 0\n\n return score * 0.85","def get_subscore_pairwise(seqs1,seqs2, matrix=matrix, gap_s=gap_s, gap_e=gap_e):\n print type(seqs1)\n score=0\n terms=0\n for seq1 in seqs1:\n for seq2 in seqs2:\n score+=get_subscore(seq1, seq2, matrix, gap_s, gap_e)\n terms+=1.0\n\n return score/terms","def match(desc1,desc2):\n\t\n\tdesc1 = array([d/linalg.norm(d) for d in desc1])\n\tdesc2 = array([d/linalg.norm(d) for d in desc2])\n\t\n\tdist_ratio = 0.6\n\tdesc1_size = desc1.shape\n\t\n\tmatchscores = zeros((desc1_size[0],1))\n\tdesc2t = desc2.T #precompute matrix transpose\n\tfor i in range(desc1_size[0]):\n\t\tdotprods = dot(desc1[i,:],desc2t) #vector of dot products\n\t\tdotprods = 0.9999*dotprods\n\t\t#inverse cosine and sort, return index for features in second image\n\t\tindx = argsort(arccos(dotprods))\n\t\t\n\t\t#check if nearest neighbor has angle less than dist_ratio times 2nd\n#\t\tif arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n\t\tmatchscores[i] = int(indx[0])\n\t\n\treturn matchscores","def similar_text(word1, word2) -> float:\n\n return textdistance.overlap.similarity(word1, word2)","def _compute_score(self):\n\n sgml_path = str(self.sgml_file.name)\n text_path = sgml_path.replace('.sgm', '.txt')\n ref_path = 'testsets/wmt18.ende.ref.txt'\n\n from sacrebleu import process_to_text, corpus_bleu\n from pathlib import Path\n\n if not Path(text_path).exists():\n process_to_text(sgml_path, text_path)\n\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\n\n bleu = corpus_bleu(hyp_stream, [ref_stream])\n\n self.score = bleu.score\n self.save()","def calculate_flesch_score(text):\n\n # Use the given formula and call other functions to get the values\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\n text)\n\n return score","def get_relatedness(theme1,theme2):\r\n nAB=0\r\n nAB_plus=0\r\n for sentence_1 in theme1.sentences:\r\n for sentence_2 in theme2.sentences:\r\n if cmp(sentence_1[2],sentence_2[2])==0:\r\n nAB=nAB+1\r\n if sentence_1[3]==sentence_2[3]:\r\n nAB_plus=nAB_plus+1\r\n if nAB==0:\r\n return 0\r\n else:\r\n return float(nAB_plus)/float(nAB)","def score_function(word1, word2):\n if word2 == '':\n return len(word1)\n elif word1 == '':\n return len(word2)\n elif word1 == word2:\n return 0\n elif word1[0] == word2[0]:\n return 0 + score_function(word1[1:], word2[1:])\n else:\n add_char = 1 + score_function(word2[0] + word1[:], word2[:])\n sub_char = 1 + score_function(word1[1:], word2[1:])\n remove_char = 1 + score_function(word1[1:], word2[:])\n return min(add_char, sub_char, remove_char)\n # if word1 == word2: # Fill in the condition\n # # BEGIN Q6\n # return 0\n # # END Q6\n # elif word1[0] == word2[0]: # Feel free to remove or add additional cases\n # # BEGIN Q6\n # return score_function(word1[1:], word2[1:])\n # # END Q6\n # else:\n #\n # elif len(word1) > len(word2):\n # difference = len(word2) - len(word1)\n # word2 = word2[0:len(word1)]\n # return difference + score_function(word1, word2)\n # elif len(word1) == len(word2):\n # total = 0\n # for i in word1:\n # if word1[i] == word2[i]:\n # total += 1\n # return total\n # elif len(word1) < len(word2):\n # difference = len(word2) - len(word1)\n # word1 = word1 + word2[len(word1):]\n # return difference + score_function(word1, word2)\n # else:\n #\n # def add_char(word1, word2):\n # while len(word1) <= len(word2):\n # return swap_score(word1, word2)\n # return 0\n #\n # def remove_char(word1, word2):\n # while len(word1) >= len(word2):\n # if word1[0] != word2[0]:\n # return 1 + remove_char(word1[1:], word2[1:])\n # return 0\n #\n # def sub_char(word1, word2):\n # if len(word1) == len(word2):\n # if word1[0] == word2[0]:\n # return 0\n # else:\n # return 1 + sub_char(word1[1:], word2[1:])\n # return 0\n # # BEGIN Q6\n # return add_char(word1, word2) + remove_char(word1, word2) + sub_char(word1, word2)\n # # END Q6","def test_score_across_multiple_documents(self):\n\n \"\"\"\n Create the test data.\n \"\"\"\n tokenizer = Tokenizer(stem=False)\n posts = [\n \"Erdogan with threats to attack regime forces 'everywhere' in Syria\",\n \"Syria reacts to Erdogan's threats: Damascus says Erdogan 'disconnected from reality' after threats\",\n ]\n\n corpus = [ Document(post, tokenizer.tokenize(post)) for post in posts ]\n\n extractor = TokenExtractor(tokenizer=tokenizer)\n scorer = TFIDFScorer({ 'erdogan': 1, 'threats': 2 }, 10)\n candidates = extractor.extract(corpus)\n scores = scorer.score(candidates, normalize_scores=False)\n self.assertEqual(3 * math.log(10 / 1, 10), scores.get('erdogan'))\n self.assertEqual(3 * math.log(10 / 2, 10), scores.get('threats'))","def sentence_similarity_asym(sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n \n # Get the synsets for the tagged words\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\n if len(pathsim) == 0:\n #print sentence1, sentence2\n pathsim = [0]\n best_score = max(pathsim)\n \n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n if count == 0:\n return 0\n # Average the values\n score /= count\n return score","def f1_score(confusion):\n p = precision(confusion)\n r = sensitivity(confusion)\n F1 = (2 * p * r) / (p + r)\n return F1","def compute_readability(text):\n total_words = 0\n total_sentences = 0\n total_syllables = 0\n score = 0\n\n words = text.split()\n total_words = len(text.split()) \n total_sentences = count_sentences(text)\n total_syllables = count_syllables(words)\n \n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\n if score > 90.00:\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\n elif score <= 90.00 and score > 80.00:\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\n elif score <= 80.00 and score > 70.00:\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\n elif score <= 70.00 and score > 60.00:\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\n elif score <= 60.00 and score > 50.00:\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\n elif score <= 50.00 and score > 30.00:\n answer = 'Texto de nível Universitário, difícil de ler.'\n else:\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\n \n print('Pontuação Total:', score, answer)","def get_frame_element_score(self, fe1, fe2):\n name_match = fe1['name'] == fe2['name']\n score = self.get_text_score(fe1['spans'][0]['text'], fe2['spans'][0]['text'])\n if not name_match:\n score *= self.pen.factor_name_mismatch\n return score","def f1(predictions, gold):\n if len(gold) == 0:\n return 1. if len(predictions) == 0 else 0.\n if len(predictions) == 0:\n return 0.\n predictions_set = set(predictions)\n gold_set = set(gold)\n nom = 2 * len(predictions_set.intersection(gold_set))\n denom = len(predictions_set) + len(gold_set)\n return float(nom)/float(denom)","def match(desc1,desc2):\n desc1 = array([d/linalg.norm(d) for d in desc1])\n desc2 = array([d/linalg.norm(d) for d in desc2])\n dist_ratio = 0.6\n desc1_size = desc1.shape\n matchscores = zeros((desc1_size[0],1),'int')\n desc2t = desc2.T # precompute matrix transpose\n for i in range(desc1_size[0]):\n dotprods = dot(desc1[i, :], desc2t) # vector of dot products\n dotprods *= 0.9999\n # inverse cosine and sort, return index for features in second image\n indx = argsort(arccos(dotprods))\n # check if nearest neighbor has angle less than dist_ratio times 2nd\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n matchscores[i] = int(indx[0])\n return matchscores","def calculate_f1_score(predictions, actuals):\n predictions = predictions > 0.5\n # fbeta_score throws a confusing error if inputs are not numpy arrays\n predictions, actuals, = np.array(predictions), np.array(actuals)\n # We need to use average='samples' here, any other average method will generate bogus results\n return fbeta_score(actuals, predictions, beta=1, average='samples')","def classify(self, source1, source2):\n scores1 = self.similarity_scores(source1)\n scores2 = self.similarity_scores(source2)\n\n print(\"scores for\", source1.name, \":\", [round(number, 2) for number in scores1])\n print(\"scores for\", source2.name, \":\", [round(number, 2) for number in scores2])\n\n s1 = 0\n s2 = 0\n for x in range(len(scores1)):\n if scores1[x] >= scores2[x]:\n s1 += 1\n else:\n s2 += 1\n \n if s1 > s2:\n print(self.name, \"is more likely to have come from \", source1.name)\n print()\n else:\n print(self.name, \"is more likely to have come from \", source2.name)\n print()","def get_similarity_score(self, reviewer1: Any, reviewer2: Any) -> float:\n v1 = self._vertices[reviewer1]\n v2 = self._vertices[reviewer2]\n return v1.reviewer_similarity_score(v2)","def compute_similarity(self, text1, text2):\n\n text1_dist = self.predict(text1)[0]\n text2_dist = self.predict(text2)[0]\n return jensenshannon(text1_dist, text2_dist)","def match(desc1, desc2):\n desc1 = array([d/linalg.norm(d) for d in desc1])\n desc2 = array([d/linalg.norm(d) for d in desc2])\n\n dist_ratio = 0.6\n disc1_size = desc1.shape\n\n matchscores = zeros((desc1_size[0]), \"int\")\n desc2t = desc2.T\n for i in range(desc1_size[0]):\n dotprods = dot(desc1[i, :], desc2t)\n dotprods = 0.9999 * dotprods\n\n indx = argsort(arccos(dotprods))\n\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\n matchscores[i] = int(indx[0])\n\n return matchscores","def __call__(self, f1, f2):\n\n r = 0.0\n for f in f1:\n if f in f2:\n r += f1[f] * f2[f]\n\n return r","def score(self, sentence):\n # TODO your code here\n\n # initialize count with trained data\n unigram_count = self.count.copy()\n N = self.total\n\n # make a new key for UNK, add-one later\n for token in sentence:\n if token not in unigram_count:\n unigram_count[token] = 0\n\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\n score = 0.0 # P(<s>) = 1\n V = len(unigram_count) # the number of vocab including UNK\n for word in sentence:\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\n score += math.log(prob)\n\n return score","def f1_score_model(self, model, X, y):\n\n prediction = model.predict_classes(X)\n f1_macro = f1_score(y, prediction, average='macro')\n f1_micro = f1_score(y, prediction, average='macro')\n print(\"f1_macro: \", f1_score(y, prediction, average='macro'))\n print(\"f1_micro: \", f1_score(y, prediction, average=\"micro\"))\n print(\"f1_weighted: \", f1_score(y, prediction, average=\"weighted\"))\n return f1_macro, f1_micro","def f1_score(prediction, ground_truth):\n return precision_recall_f1(prediction, ground_truth)[2]","def score(self, text):\n logger.debug(\"score on an instance of len {0}\".format(len(text)))\n fv = self.instance2fv(text)\n fv /= np.sqrt((fv*fv).sum()) # normalize vector to len 1\n fdot = self.lprot.dot(fv) \n retval = dict(zip(self.langs, fdot))\n return retval","def score(stripe1, stripe2):\n scr = 0\n count = 0\n for p1, p2 in zip(stripe1, stripe2):\n r = abs(p1[0] - p2[0])\n g = abs(p1[1] - p2[1])\n b = abs(p1[2] - p2[2])\n scr += r + g + b\n return scr","def match_word_sorted(code1, code2):\n list1 = code1.split(\" \")\n list2 = code2.split(\" \")\n set1 = set(list1)\n set2 = set(list2)\n common_words = set1 & set2\n try:\n common_words.remove(\"\")\n except:\n pass\n\n words_to_index = {}\n for word in common_words:\n in1 = list1.index(word)\n in2 = list2.index(word)\n words_to_index[word] = (in1, in2)\n sorted1 = OrderedDict(sorted(words_to_index.items(), key=lambda t: t[1][0])).keys()\n sorted2 = OrderedDict(sorted(words_to_index.items(), key=lambda t: t[1][1])).keys()\n\n a = Sequence(sorted1)\n b = Sequence(sorted2)\n v = Vocabulary()\n a_encoded = v.encodeSequence(a)\n b_encoded = v.encodeSequence(b)\n scoring = SimpleScoring(MATCH_SCORE, MISMATCH_SCORE)\n aligner = GlobalSequenceAligner(scoring, GAP_SCORE)\n score, encoders = aligner.align(a_encoded, b_encoded, backtrace=True)\n max_score = 0\n for i, encoded in enumerate(encoders):\n alignment = v.decodeSequenceAlignment(encoded)\n if alignment.score > max_score:\n max_score = alignment.score\n return max_score","def score(self, sentence):\n\n\n # TODO your code here\n score = 0.0 \n prevWord = \"\"\n prevPrevWord = \"\"\n newSentence = []\n for word in sentence:\n newSentence += word.split()\n for currentWord in sentence:\n currentWord = currentWord.strip(STRIP_CHARS)\n currentWord = currentWord.lower()\n if prevWord != \"\":\n if prevPrevWord != \"\":\n trigram = (prevPrevWord, prevWord, currentWord)\n trigramCount = self.trigramCounts[trigram]\n if trigramCount > 0:\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\n # Subtraction by 1 removes the add one count from the laplace\n # smoothing\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\n score -= math.log(self.totalBigramCounts)\n else:\n count = self.unigramCounts[currentWord]\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\n score -= math.log(self.total)\n else:\n prevPrevWord = prevWord\n prevWord = currentWord\n else:\n prevWord = currentWord\n return -score","def calculate_f1(fx, y):\n pred_idxs = fx.max(1, keepdim=True)[1]\n pred_names = [idx2target[i.item()] for i in pred_idxs]\n original_names = [idx2target[i.item()] for i in y]\n true_positive, false_positive, false_negative = 0, 0, 0\n for p, o in zip(pred_names, original_names):\n predicted_subtokens = p.split('|')\n original_subtokens = o.split('|')\n for subtok in predicted_subtokens:\n if subtok in original_subtokens:\n true_positive += 1\n else:\n false_positive += 1\n for subtok in original_subtokens:\n if not subtok in predicted_subtokens:\n false_negative += 1\n try:\n precision = true_positive / (true_positive + false_positive)\n recall = true_positive / (true_positive + false_negative)\n f1 = 2 * precision * recall / (precision + recall)\n except ZeroDivisionError:\n precision, recall, f1 = 0, 0, 0\n return precision, recall, f1","def precision_recall_f1(prediction, ground_truth):\n if not isinstance(prediction, list):\n prediction_tokens = prediction.split()\n else:\n prediction_tokens = prediction\n if not isinstance(ground_truth, list):\n ground_truth_tokens = ground_truth.split()\n else:\n ground_truth_tokens = ground_truth\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0, 0, 0\n p = 1.0 * num_same / len(prediction_tokens)\n r = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * p * r) / (p + r)\n return p, r, f1","def matcher(features1, features2):\n #TODO: write a matching function\n #Performing the L2-Norm\n new_features1=[]\n new_features2=[]\n for itr in range(5):\n [rootOfSquare1,rootOfSquare2] = sumOfSquares(features1[itr],features2[itr])\n new_features1.append(np.array(features1[itr])/rootOfSquare1)\n new_features2.append(np.array(features2[itr])/rootOfSquare2)\n indices = []\n for itr in range(len(new_features1)):\n findMinDist=[]\n #findMaxCosineVal=[]\n for itr2 in range(len(new_features2)):\n f1 = new_features1[itr]\n f2 = new_features2[itr2]\n\n #For evaluating the cosine similarity\n # [rootOfSquare1,rootOfSquare2] = sumOfSquares(f1,f2)\n # numerator = np.array(f1)*np.array(f2)\n # numeratorSum = sum(numerator)\n # denominator = rootOfSquare1*rootOfSquare2\n # cosine = np.divide(numeratorSum,denominator)\n # findMaxCosineVal.append(cosine)\n\n #For evaluating the similarity based on euclidean distance\n Dist = np.array(f1) - np.array(f2)\n sum=0\n for i in Dist:\n sum=sum+math.pow(i,2)\n rootOfSum = math.sqrt(sum)\n findMinDist.append(rootOfSum)\n # print \"itr: \", itr, \" Matching scores: \", findMaxCosineVal\n # bestMatch = findMaxCosineVal.index(max(findMaxCosineVal))\n bestMatch = findMinDist.index(min(findMinDist))\n indices.append([itr,bestMatch])\n return indices","def calf_f1(annotated_Y, predicted_Y):\n\n POSITIVE = ADR_MENTION_CLASS_LABEL\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\n\n tp = 0\n fp = 0\n fn = 0\n tn = 0\n\n total_actual_positives = 0\n total_actual_negatives = 0\n\n for index, actual in enumerate(annotated_Y):\n predicted = predicted_Y[index]\n\n if actual == POSITIVE:\n total_actual_positives += 1\n\n if predicted == POSITIVE:\n tp += 1\n elif predicted == NEGATIVE:\n fn += 1\n\n elif actual == NEGATIVE:\n total_actual_negatives += 1\n\n if predicted == POSITIVE:\n fp += 1\n elif predicted == NEGATIVE:\n tn += 1\n\n if (tp+fp) == 0:\n precision = 0\n else:\n precision = tp/(tp+fp)\n\n if (tp+fn) == 0:\n recall = 0\n else:\n recall = tp/(tp+fn)\n\n if (precision+recall) == 0:\n f1 = 0\n else:\n f1 = 2*precision*recall/(precision+recall)\n\n # print(\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\n # print(\"tp: {}, tn: {}, fp: {}, fn: {}\".format(tp, tn, fp, fn))\n # print(\" Accuracy: {}\".format((tp+tn)/(len(test_Y))))\n print(\" Precision: {}\".format(precision))\n print(\" Recall: {}\".format(recall))\n print(\" F1: {}\".format(f1))","def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score","def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\n\n\t# set variables\n\trm1_vec = list()\n\tvocab = set()\n\tdoc_vecs = dict()\n\n\t# create document feature vectors for each feedback doc\n\tfor doc_id in ids_and_scores.keys():\n\t\t# convert current doc to bow format\n\t\tbow = ix.doc2bow(corpus[doc_id])\n\t\t# create document feature vector\n\t\tdfv = create_feature_vector(ix, term_dict, bow)\n\t\t# keep top 'fb_terms' from dfv\n\t\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\n\t\tvocab.update(dfv.keys())\n\t\tdoc_vecs[doc_id] = dfv\n\n\t# compute L1 norm for each document feature vector\n\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\n\n\t# loop over terms in vocab and compute RM1\n\tfor term in vocab:\n\t\tfb_weight = 0.0\n\t\t# loop over document feature vectors \n\t\tfor doc_id in doc_vecs.keys():\n\t\t\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\n\t\t\t\t# sum the score of current term across different docs to fb_weight\n\t\t\t\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\n\t\t# assign term w/ weight to RM1 feature vector\n\t\trm1_vec.append((term, fb_weight))\n\n\t# keep top 'fb_terms' from rm1_vec\n\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\n\t# scale rm1_vec to L1 norm\n\treturn scale_to_L1_norm(rm1_vec)","def classify(self, source1, source2):\n\n scores1 = self.similarity_scores(source1)\n scores2 = self.similarity_scores(source2)\n \n print('scores for ' + source1.name +':' + str(self.similarity_scores(source1)))\n print('scores for ' + source2.name +':' + str(self.similarity_scores(source2)))\n \n source1_score=0\n source2_score=0\n\n for i in range(len(scores1)):\n if scores1[i]> scores2[i]:\n source1_score+=1\n elif scores2[i]>scores1[i]:\n source2_score+=1\n \n if source1_score > source2_score:\n win=source1.name\n else:\n win=source2.name\n\n print(self.name + ' is more likely to have come from ' + win)","def qualify_words():\n config = get_config()\n\n all_feature_matrices = []\n all_opinion_matrices = []\n\n # first 5 parts are labeled, thus are useful\n all_feature_label_vectors = []\n all_opinion_label_vectors = []\n\n for fname in config.file_names:\n feature_X, feature_dims = load_feature_matrices(fname)\n opinion_X, opinion_dims = load_opinion_matrices(fname)\n feature_y = load_feature_labels(fname)\n opinion_y = load_opinion_labels(fname)\n\n # append to all collector\n all_feature_matrices.append(feature_X)\n all_feature_label_vectors.append(feature_y)\n all_opinion_matrices.append(opinion_X)\n all_opinion_label_vectors.append(opinion_y)\n # use first 5 for training\n # stack first 5\n feature_training_X = []\n feature_training_y = []\n opinion_training_X = []\n opinion_training_y = []\n for i in range(5):\n feature_training_X.append(all_feature_matrices[i])\n feature_training_y.append(all_feature_label_vectors[i])\n opinion_training_X.append(all_opinion_matrices[i])\n opinion_training_y.append(all_opinion_label_vectors[i])\n\n feature_training_X = np.hstack(feature_training_X)\n feature_training_y = np.hstack(feature_training_y)\n opinion_training_X = np.hstack(opinion_training_X)\n opinion_training_y = np.hstack(opinion_training_y)\n\n # using combination of rule and ranking score as features\n feature_model = MultinomialNB()\n opinion_model = MultinomialNB()\n\n # training\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\n\n # predicting on candidate aspects and opinions, extracted from amazon reviews\n for i in range(5, len(config.file_names)):\n fname = config.file_names[i]\n feature_pred = feature_model.predict_proba(\n np.transpose(all_feature_matrices[i]))[:,1]\n opinion_pred = opinion_model.predict_proba(\n np.transpose(all_opinion_matrices[i]))[:,1]\n # pickle the prediction results\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\n pickle.dump(feature_pred, f)\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\n pickle.dump(opinion_pred, f)","def word_overlap2(sentence_a, sentence_b):\n a_set = set(word for word in sentence_a) - config.stop_list\n b_set = set(word for word in sentence_b) - config.stop_list\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\n\n return score","def similarity_scores(self, other):\n results = []\n\n words_score=compare_dictionaries(other.words, self.words)\n wordl_score=compare_dictionaries(other.word_lengths, self.word_lengths)\n stems_score=compare_dictionaries(other.stems, self.stems)\n sentl_score=compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\n endings_score=compare_dictionaries(other.endings, self.endings)\n results+= [words_score]\n results+= [wordl_score]\n results+= [stems_score]\n results+= [sentl_score]\n results+= [endings_score]\n return results","def similarity_scores(self, other):\n word_score = compare_dictionaries(other.words, self.words)\n word_length_score = compare_dictionaries(other.word_lengths, self.words)\n stem_score = compare_dictionaries(other.stems, self.stems)\n sentence_length_score = compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\n common_word_score = compare_lists(other.common_word, self.common_word)\n\n return [word_score, word_length_score, stem_score, sentence_length_score, common_word_score]","def f1(gold_labels, predicted_labels):\n \n precision_value = float(precision(gold_labels, predicted_labels))\n recall_value = float(recall(gold_labels, predicted_labels))\n top = float(2 * precision_value * recall_value)\n bottom = precision_value + recall_value\n\n if(top == 0):\n return 0\n else:\n return float(top / bottom)","def f1_score(confusion):\n s = np.power(sensitivity(confusion), -1)\n p = np.power(precision(confusion), -1)\n return 2 / (s + p)","def test_find_phrase_matches1(self):\n\t\ttest = sentiment.LibraryRun(self.text1, self.lib)\n\t\tobj_ut = test.find_phrase_matches(self.tokens_generator1)[0]\n\t\tself.assertEqual(dict(obj_ut),\n\t\t\t{'not good': [[2, -1, 0]]})","def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\n\n y_pred = torch.ge(y_pred.float(), threshold).float()\n\n y_true = y_true.float()\n\n tp_l = (y_pred * y_true).sum(0).float()\n\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\n\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\n\n precision_label = tp_l.div(tp_l + fp_l + eps)\n\n recall_label = tp_l.div(tp_l + fn_l + eps)\n\n if macro:\n\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\n\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\n\n else: \n\n tp = tp_l.sum()\n\n fp = fp_l.sum()\n\n fn = fn_l.sum()\n\n precision = tp / (tp + fp + eps)\n\n recall = tp / (tp + fn + eps)\n\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\n\n return f1_micro.item(), precision.item(), recall.item()","def binary_f1_score(preds, y):\n rounded_predictions = torch.round(torch.sigmoid(preds))\n\n return f1_score(y.cpu().numpy(), rounded_predictions.cpu().numpy(), average='weighted')","def prec_recall_f1_score(pred_items, gold_items):\n common = Counter(gold_items) & Counter(pred_items)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(pred_items)\n recall = 1.0 * num_same / len(gold_items)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def compare_words(word1, word2):\n word1 = word1.lower()\n word2 = word2.lower()\n seg_scores = []\n if len(word1) >= len(word2):\n for i in range(0, len(word1) - len(word2) + 1):\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\n else:\n for i in range(0, len(word2) - len(word1) + 1):\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)","def f1_score(precision, recall):\n if precision + recall == 0:\n return 0\n return 2 * precision * recall / (precision + recall)","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2): \n if (i + startpoint) < (l1 + l2 - 1): \n if l2 - i > startpoint + 1:\n matched = matched + \".\" #dots before they start overlapping\n elif s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" #matched bases\n score = score + 1 #adds one to score\n else:\n matched = matched + \"-\" #not matched bases\n shift, end_shift = startpoint * \".\", (l2 + l1 - startpoint - 2) * \".\"\n # dots at end, but only up until end of dots tailing l1\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\n # this formula. the below check stops it from getting less than l2.\n if startpoint < l1 - 1:\n print(shift + matched + end_shift)\n else:\n print(shift + matched + (l2 - 1) * \".\")\n print(shift + s2 + end_shift)\n print(s1)\n print(str(score) + \"\\n\")\n return score, matched, shift, end_shift"],"string":"[\n \"def wordSimilarityRatio(sent_1,sent_2):\",\n \"def compare_word_selection(selection1,selection2):\\n\\n num_extra=0;\\n num_total=0;\\n total_score=0;\\n for k in selection1.keys():\\n num_total+=1;\\n if k not in selection2:\\n num_extra+=1;\\n else:\\n score=compare_sentences(selection1[k],selection2[k]);\\n logging.info(\\\"Score: %f\\\" % score );\\n total_score+=score;\\n\\n for k in selection2.keys():\\n if k not in selection1:\\n num_total+=1;\\n num_extra+=1;\\n\\n if num_total==0:\\n return 0;\\n\\n return float(total_score)/float(num_total)\",\n \"def compare_sentences(s1,s2):\\n\\n total_score=0;\\n num_total=0;\\n for k in s1:\\n num_total+=1\\n if k in s2:\\n if s1[k]==s2[k]:\\n score = 1;\\n else:\\n score = 0;\\n else:\\n score = 0;\\n total_score += score;\\n \\n for k in s2:\\n if k not in s1:\\n num_total+=1\\n\\n logging.info(\\\"Scored %f out of %d\\\" % (total_score, num_total));\\n\\n if num_total==0:\\n return 1;\\n return float(total_score)/float(num_total)\",\n \"def get_score(self,sentence_1, sentence_2):\\n\\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)\",\n \"def string_f1_score(prediction, ground_truth):\\n prediction_tokens = normalize_answer(prediction).split()\\n ground_truth_tokens = normalize_answer(ground_truth).split()\\n common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def score(self, sentence):\\n score = 0.0\\n V = len(self.f1) # vocabulary size\\n for token in sentence:\\n if token in self.f1: score += self.f1[token]\\n else: score -= math.log10(self.total + V)\\t\\t # OOV \\n return score\",\n \"def test_score_text1(self):\\n\\t\\ttest = sentiment.LibraryRun(self.text3, self.lib)\\n\\t\\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\\n\\t\\tobj_ut, _ = test.score_text(matches)\\n\\t\\tself.assertEqual(obj_ut, -1)\",\n \"def _f1_score_(prediction, ground_truth):\\n prediction_tokens = _normalize_answer(prediction).split()\\n ground_truth_tokens = _normalize_answer(ground_truth).split()\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def match_score(seq1, seq2):\\n\\n seq1 = get_sequence_string(seq1)\\n seq2 = get_sequence_string(seq2)\\n score = align.localxx(seq1, seq2)[0][2]\\n return score\",\n \"def score():\\n\\n # Read files\\n s1 = request.form.get(\\\"string1\\\")\\n s2 = request.form.get(\\\"string2\\\")\\n if not s1 or not s2:\\n abort(400, \\\"missing strings\\\")\\n\\n # Score files\\n matrix = distances(s1, s2)\\n\\n # Extract operations from table\\n operations = []\\n i, j = len(s1), len(s2)\\n while True:\\n _, operation = matrix[i][j]\\n if not operation:\\n break\\n if operation == Operation.INSERTED:\\n j -= 1\\n elif operation == Operation.DELETED:\\n i -= 1\\n else:\\n i -= 1\\n j -= 1\\n operations.append(operation)\\n operations.reverse()\\n\\n # Maintain list of intermediate strings, operation, and descriptions\\n transitions = [(s1, None, None)]\\n i = 0\\n\\n # Apply each operation\\n prev = s1\\n for operation in operations:\\n\\n # Update string and description of operation\\n if operation == Operation.INSERTED:\\n s = (prev[:i], s2[i], prev[i:])\\n description = f\\\"inserted '{s2[i]}'\\\"\\n prev = prev[:i] + s2[i] + prev[i:]\\n i += 1\\n elif operation == Operation.DELETED:\\n s = (prev[:i], prev[i], prev[i + 1:])\\n description = f\\\"deleted '{prev[i]}'\\\"\\n prev = prev[:i] + prev[i + 1:]\\n elif prev[i] != s2[i]:\\n s = (prev[:i], s2[i], prev[i + 1:])\\n description = f\\\"substituted '{prev[i]}' with '{s2[i]}'\\\"\\n prev = prev[:i] + s2[i] + prev[i + 1:]\\n i += 1\\n else:\\n i += 1\\n continue\\n transitions.append((s, str(operation), description))\\n transitions.append((s2, None, None))\\n\\n # Output comparison\\n return render_template(\\\"score.html\\\", matrix=matrix, s1=s1, s2=s2, operations=transitions)\",\n \"def f1_score(self):\",\n \"def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\\r\\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n\\r\\n if p + r > 0:\\r\\n return 2 * p * r / (p + r)\\r\\n else:\\r\\n return 0\",\n \"def f1score(prediction,ytest):\\n truepos = np.sum(ytest[prediction == 1])\\n predpos = np.sum(prediction)\\n actpos = np.sum(ytest)\\n precision = truepos/predpos\\n recall = truepos/actpos\\n return 2*precision*recall/(precision + recall)\",\n \"def test_score_text2(self):\\n\\t\\t#import pdb; pdb.set_trace()\\n\\t\\ttest = sentiment.LibraryRun(self.text3, self.lib)\\n\\t\\tmatches = test.find_phrase_matches(self.tokens_generator3)[0]\\n\\t\\tobj_ut, _ = test.score_text(matches, end_threshold=0.5)\\n\\t\\tself.assertEqual(obj_ut, -1.25)\",\n \"def difference(first, second, rf, rs, years=(1980, 2000),smooth=1, corpus='bok'):\\n try:\\n a_first = nb_ngram(first, years=years, smooth=smooth, corpus=corpus)\\n a_second = nb_ngram(second, years=years, smooth=smooth, corpus=corpus)\\n a = a_first.join(a_second) \\n b_first = nb_ngram(rf, years=years, smooth=smooth, corpus=corpus)\\n b_second = nb_ngram(rs, years=years, smooth=smooth, corpus=corpus)\\n if rf == rs:\\n b_second.columns = [rs + '2']\\n b = b_first.join(b_second)\\n s_a = a.mean()\\n s_b = b.mean()\\n f1 = s_a[a.columns[0]]/s_a[a.columns[1]]\\n f2 = s_b[b.columns[0]]/s_b[b.columns[1]]\\n res = f1/f2\\n except:\\n res = 'Mangler noen data - har bare for: ' + ', '.join([x for x in a.columns.append(b.columns)])\\n return res\",\n \"def get_raw_score(self, set1, set2):\\n \\n # input validations\\n utils.sim_check_for_none(set1, set2)\\n utils.sim_check_for_list_or_set_inputs(set1, set2)\\n\\n # if exact match return 1.0\\n if utils.sim_check_for_exact_match(set1, set2):\\n return 1.0\\n\\n # if one of the strings is empty return 0\\n if utils.sim_check_for_empty(set1, set2):\\n return 0\\n\\n if not isinstance(set1, set):\\n set1 = set(set1)\\n if not isinstance(set2, set):\\n set2 = set(set2)\\n\\n return 2.0 * float(len(set1 & set2)) / float(len(set1) + len(set2))\",\n \"def score_two(rect1, rect2):\\n score = 0.0\\n avg_width = (rect1[1][0] + rect2[1][0])/2\\n avg_x = (rect1[0][0] + rect2[0][0])/2\\n vector = np.array([rect2[0][0] - rect1[0][0], rect2[0][1] - rect1[0][1]])\\n length = np.sqrt(np.dot(vector, vector))\\n tilt_l = (14.5 - rect1[2])/15\\n tilt_r = (14.5 + rect2[2])/15\\n if length > 0:\\n aim = (avg_x - mid_point)/mid_point\\n ratio = 0.2 - avg_width / length\\n sine = vector[1] / length\\n cosine = vector[0] / length\\n score += sine * sine\\n score += (1 - cosine)\\n score += ratio * ratio\\n score += aim * aim\\n score += tilt_l * tilt_l\\n score += tilt_r * tilt_r\\n return score\",\n \"def f1_score(confusion):\\n sens = sensitivity(confusion)\\n prec = precision(confusion)\\n return 2 * sens * prec / (sens + prec)\",\n \"def sentence_similarity(self,sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n\\n # Get the synsets for the tagged words\\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n\\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n\\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n vals = [synset.path_similarity(ss) if synset.path_similarity(ss) is not None else 0 for ss in synsets2]\\n best_score = max(vals,default=0)\\n\\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n # Average the values\\n if count == 0:\\n return 0\\n score /= count\\n return score\",\n \"def _compute_f1_score(predicted_answer: str, target_answer: str) ->Tensor:\\n target_tokens = _get_tokens(target_answer)\\n predicted_tokens = _get_tokens(predicted_answer)\\n common = Counter(target_tokens) & Counter(predicted_tokens)\\n num_same = tensor(sum(common.values()))\\n if len(target_tokens) == 0 or len(predicted_tokens) == 0:\\n return tensor(int(target_tokens == predicted_tokens))\\n if num_same == 0:\\n return tensor(0.0)\\n precision = 1.0 * num_same / tensor(len(predicted_tokens))\\n recall = 1.0 * num_same / tensor(len(target_tokens))\\n f1 = 2 * precision * recall / (precision + recall)\\n return f1\",\n \"def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\\\"malaria\\\", confusion_matrix_title=\\\"\\\"):\\n # demonstration of calculating metrics for a neural network model using sklearn\\n if not binary_classifcation:\\n # For multiclass classification.\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n precision = precision_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n recall = recall_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n f1 = f1_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n print('Accuracy: %f' % accuracy)\\n print('Precision: %f' % precision)\\n print('Recall: %f' % recall)\\n print('F1 score: %f' % f1)\\n\\n else:\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n print('Accuracy: %f' % accuracy)\\n # # precision tp / (tp + fp)\\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Precision: %f' % precision)\\n # recall: tp / (tp + fn)\\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Recall: %f' % recall)\\n # f1: 2 tp / (2 tp + fp + fn)\\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('F1 score: %f' % f1)\\n # ROC AUC\\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\\n # print('ROC AUC: %f' % auc)\\n\\n # confusion matrix\\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\\n display_labels=list(np.unique(actual_labels)),\\n cmap=plt.cm.Blues,\\n normalize=None)\\n disp.ax_.set_title(confusion_matrix_title)\\n plt.show()\\n matrix = confusion_matrix(actual_labels, preds_labels)\\n print(matrix)\\n # if plot_confusion_matrix:\\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))\",\n \"def score_scansions(self, scansion1, scansion2):\\n p_1 = 1\\n p_2 = 1\\n word_scansions_1 = scansion1.scansion.lstrip(\\\" \\\").rstrip(\\\" \\\").split(\\\" \\\")\\n word_scansions_2 = scansion2.scansion.lstrip(\\\" \\\").rstrip(\\\" \\\").split(\\\" \\\")\\n for i, word in enumerate(self.words):\\n p_word_1, _ = word.compare_scansions(word_scansions_1[i], word_scansions_2[i])\\n p_1 *= p_word_1\\n p_2 *= (1 - p_word_1)\\n if p_1 > p_2:\\n return scansion1, p_1/(p_1 + p_2)\\n return scansion2, p_2 / (p_1 + p_2)\",\n \"def get_identical_score(bin1,bin2=None):\\n if bin2==None: bin2=[]\\n tmpscore=0.0\\n norm=0\\n for ali1 in bin1:\\n tmpscore+=get_subscore(ali1,ali1)\\n norm+=1\\n for ali2 in bin2:\\n tmpscore+=get_subscore(ali2,ali2)\\n norm+=1\\n return tmpscore/norm\",\n \"def f1_score(model_id, test_set_id, rubric_id):\\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\\n\\n for key in rubrication_result:\\n if rubrication_result[key] == answers[key]:\\n if rubrication_result[key] == 1:\\n result['true_positive'] += 1\\n else:\\n result['true_negative'] += 1\\n else:\\n if rubrication_result[key] == 1:\\n result['false_positive'] += 1\\n else:\\n result['false_negative'] += 1\\n if (result['true_positive'] + result['false_positive']) > 0:\\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\\n else:\\n result['precision'] = 0\\n if (result['true_positive'] + result['false_negative']) > 0:\\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\\n else:\\n result['recall'] = 0\\n if (result['precision'] + result['recall']) > 0:\\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\\n else:\\n result['f1'] = 0\\n return result\",\n \"def _get_similarity_score(self, dict1, dict2):\\n try:\\n majorScoreDeterminer1 = ['primaryGenreId']\\n majorScoreDeterminer2 = ['genreIds']\\n Score = 0 # Base Score\\n for items in majorScoreDeterminer2:\\n\\n for item1 in self._get_app_param_info(dict1, resultCount=1, resultKey=items):\\n if item1 in self._get_app_param_info(dict2, resultCount=1, resultKey=items):\\n if Score == 0: # Add 50% base score for this category.\\n Score += 2 * .5\\n Score += 2 * .5 / len(self._get_app_param_info(dict1, resultCount=1, resultKey=items))\\n\\n for items in majorScoreDeterminer1:\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) and str(\\n self._get_app_param_info(dict1, resultCount=1, resultKey=items)):\\n Score += (3 / len(majorScoreDeterminer1))\\n\\n nameMatchScore = difflib.SequenceMatcher(None,\\n self._get_app_param_info(dict1, resultCount=1,\\n resultKey='trackName'),\\n self._get_app_param_info(dict2, resultCount=1,\\n resultKey='trackName')).ratio()\\n Score += nameMatchScore\\n\\n minorScoreDeterminer = ['isGameCenterEnabled', 'languageCodesISO2A', 'contentAdvisoryRating', 'artistId',\\n 'formattedPrice']\\n\\n for items in minorScoreDeterminer:\\n if items == \\\"formattedPrice\\\":\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \\\"Free\\\":\\n Score += (4 / (len(minorScoreDeterminer)))\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) == \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \\\"Free\\\":\\n continue\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) == \\\"Free\\\":\\n continue\\n elif str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) != \\\"Free\\\" and str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)) != \\\"Free\\\":\\n Score += (4 / (len(minorScoreDeterminer)))\\n else:\\n if str(self._get_app_param_info(dict1, resultCount=1, resultKey=items)) in str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey=items)):\\n Score += (4 / (len(minorScoreDeterminer)))\\n Score = round(Score, 1)\\n log_str = \\\"id\\\" + str(self._get_app_param_info(dict2, resultCount=1, resultKey='trackId')) + \\\" - \\\" + str(\\n self._get_app_param_info(dict2, resultCount=1, resultKey='trackName')) + \\\"\\\\tScore: \\\" + str(Score)\\n except AssertionError as e:\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n except TypeError as e:\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n except:\\n e = sys.exc_info()[0]\\n print(\\\"Error: _get_similarity_score %s\\\" % e)\\n sys.exit(\\\"Exit script with error code %s\\\" % e)\\n else:\\n return log_str\",\n \"def calculate_score(result):\\n sample1=result['Sample1']\\n sample2=result['Sample2']\\n string1=paragraph_to_list(sample1)\\n string2=paragraph_to_list(sample2)\\n \\n return round( strings_similarity(string1, string2), 2)\\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\\n #return round(0.5*(method_difflab+method_dict), 2)\",\n \"def f1_score(self):\\n self.overall_f1_score = f1_score(\\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\\n self.classes_f1_score = f1_score(\\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)\",\n \"def text_proximity(str_1: str, str_2: str) -> float:\\n tokens_1 = Counter(str_1.split(' '))\\n tokens_2 = Counter(str_2.split(' '))\\n return _normalized_scalar_product(tokens_1, tokens_2)\",\n \"def sentence_similarity(self,wnsimilarity,sentence1, sentence2,icneed=False):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n \\n # Get the synsets for the tagged words\\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n \\n score, count = 0.0, 0\\n # For each word in the first sentence\\n for synset in synsets1:\\n \\n # Get the similarity value of the most similar word in the other sentence\\n score_list=[]\\n if icneed == True :\\n for ss in synsets2:\\n try:\\n temp=wnsimilarity(synset,ss,self.brown_ic)\\n score_list.append(temp)\\n except:\\n continue\\n \\n else:\\n for ss in synsets2:\\n try:\\n temp=wnsimilarity(synset,ss)\\n score_list.append(temp)\\n except:\\n continue\\n \\n \\n score_list = np.array(score_list, dtype=np.float64)\\n score_list = np.nan_to_num(score_list)\\n# print(score_list)\\n if len(score_list)>0:\\n best_score = np.nanmax(score_list)\\n else:\\n best_score=0.0\\n# print(best_score)\\n# print(type(best_score))\\n \\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score =score + best_score\\n# print(score)\\n count = count+ 1\\n \\n \\n# print(\\\"one sentence over\\\")\\n # Average the values\\n score /= count\\n return score\",\n \"def heuristic_2(a: str, b: str) -> float:\\n # generate term-document matrices\\n if get_intro(a) == \\\"\\\" or get_intro(b) == \\\"\\\":\\n return 2\\n else:\\n corpus = [get_intro(a), get_intro(b)]\\n vect = TfidfVectorizer()\\n mat = vect.fit_transform(corpus)\\n # return cosine similarity\\n return abs(1 - cosine_similarity(mat[0:1], mat)[0][1]) * 2\",\n \"def similarity(self, wSet1, wSet2, idf): \\n if len(wSet1) == 0 or len(wSet2) == 0:\\n return 0.0\\n else:\\n defaultIDF = idf['unknownToken']\\n intersection = wSet1.intersection(wSet2)\\n# intersection = self.synonymIntersection(wSet1, wSet2, idf)\\n if len(intersection) == 0:\\n return 0\\n sum1 = 0\\n sum2 = 0\\n intersectionSum = 0\\n for word in wSet1:\\n sum1 += (idf.get(word, defaultIDF))**2\\n for word in wSet2:\\n sum2 += (idf.get(word, defaultIDF))**2\\n for word in intersection:\\n intersectionSum += (idf.get(word, defaultIDF))**2\\n \\n if sum1 == 0 or sum2 == 0:\\n return 0.0\\n else:\\n return intersectionSum/(math.sqrt(sum1) * math.sqrt(sum2))\",\n \"def ratio(n1,n2, explain=0, optimize=False):\\n weight_normal_form = 5.0 #distance between soundexes of normal form\\n weight_normal_form_soundex = 8.0 #average distance between soundexes of normal form\\n weight_geslachtsnaam1 = 10.0 #distance between soundexes of geslachtsnamen\\n weight_geslachtsnaam2 = 10.0 #distance between geslachtsnaam\\n weight_initials = 2 #distance between initials\\n\\n nf1 = n1.guess_normal_form()\\n nf2 = n2.guess_normal_form()\\n\\n if not nf1 or not nf2:\\n return 0.0\\n elif nf1 == nf2:\\n return 1.0\\n ratio_normal_form = Similarity.average_distance(split(nf1), split(nf2))\\n \\n #create a simkplified soundex set for this name\\n #remove stopwords\\n# nf1 = remove_stopwords( nf1)\\n# nf2 = remove_stopwords( nf2)\\n \\n se1 = n1.get_normal_form_soundex()\\n se2 = n2.get_normal_form_soundex()\\n ratio_normal_form_soundex = Similarity.average_distance( se1, se2)\\n \\n #gelachtsnaam wordt op twee manieren met elkaar vergeleken\\n g1 = n1.geslachtsnaam() #or n1.get_volledige_naam()\\n g2 = n2.geslachtsnaam() #or n2.get_volledige_naam()\\n g1 = to_ascii(g1)\\n g2 = to_ascii(g2)\\n if not optimize:\\n #de soundexes van de achternaam worden meegewoen\\n #g1_soundex = n1.soundex_nl(g1, group=2, length=-1)\\n g1_soundex = n1.geslachtsnaam_soundex()\\n #g2_soundex = n2.soundex_nl(g2, group=2, length=-1)\\n g2_soundex = n2.geslachtsnaam_soundex()\\n ratio_geslachtsnaam1 = Similarity.average_distance(g1_soundex, g2_soundex)\\n else:\\n ratio_geslachtsnaam1 = 1 \\n weight_geslachtsnaam1 = 0\\n \\n #n de afstand van de woorden in de achtenraam zelf\\n ratio_geslachtsnaam2 = Similarity.average_distance(\\n re.split('[ \\\\.\\\\,\\\\-]', g1.lower()),\\n re.split('[ \\\\.\\\\,\\\\-]', g2.lower()),\\n levenshtein_ratio)\\n n1_initials = n1.initials()\\n n1_initials_lower = n1_initials.lower()\\n n2_initials = n2.initials()\\n n2_initials_lower = n2_initials.lower()\\n n1_contains_initials = n1.contains_initials()\\n n2_contains_initials = n2.contains_initials()\\n #count initials only if we have more than one\\n #(or perhaps make this: if we know the first name)\\n if len(n1_initials) == 1 or len(n2_initials) == 1:\\n #initials count much less if there is only one\\n weight_initials = weight_initials_if_one_name_consists_of_one_word_only\\n# ratio_initials = .5\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n elif n1_contains_initials or n2_contains_initials:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n weight_initials = weight_initials_if_one_name_is_in_initials\\n elif len(n1_initials) > 1 and len(n2_initials) > 1:\\n ratio_initials = levenshtein_ratio(n1_initials_lower, n2_initials_lower)\\n else:\\n ratio_initials = 0.7\\n \\n if n1_contains_initials or n2_contains_initials:\\n weight_normal_form = weight_normal_form_if_one_name_is_in_initials \\n weight_normal_form_soundex = weight_normal_form_soundex_if_one_name_is_in_initials\\n\\n counter = (ratio_normal_form * weight_normal_form +\\n ratio_normal_form_soundex * weight_normal_form_soundex +\\n ratio_geslachtsnaam1 * weight_geslachtsnaam1 +\\n ratio_geslachtsnaam2 * weight_geslachtsnaam2 +\\n ratio_initials * weight_initials)\\n numerator = (weight_normal_form + weight_normal_form_soundex +\\n weight_initials + weight_geslachtsnaam1 + weight_geslachtsnaam2)\\n if numerator == 0:\\n return 0.0\\n final_ratio = counter/numerator\\n\\n if explain:\\n s = '-' * 100 + '\\\\n'\\n s += 'Naam1: %s [%s] [%s] %s\\\\n' % (n1, n1_initials, n1.guess_normal_form(), se1)\\n s += 'Naam2: %s [%s] [%s] %s\\\\n' % (n2, n2_initials, n2.guess_normal_form(), se2)\\n s += 'Similarity ratio: %s\\\\n' % final_ratio\\n s += '--- REASONS' + '-' * 30 + '\\\\n'\\n format_s = '%-30s | %-10s | %-10s | %-10s | %-10s | %s-10s\\\\n'\\n s += format_s % ('\\\\t property', ' ratio', ' weight','relative_weight', ' r*w', 'r * relative_w')\\n s += '\\\\t' + '-' * 100 + '\\\\n'\\n format_s = '\\\\t%-30s | %-10f | %-10f | %-10f | %-10f | %-10f\\\\n'\\n s += format_s % (' normal_form', ratio_normal_form, weight_normal_form,weight_normal_form/counter, ratio_normal_form * weight_normal_form, ratio_normal_form * weight_normal_form/counter)\\n s += format_s % ('soundex van normal_form', ratio_normal_form_soundex, weight_normal_form_soundex,weight_normal_form_soundex/counter, ratio_normal_form_soundex* weight_normal_form_soundex, ratio_normal_form_soundex * weight_normal_form_soundex/counter)\\n s += format_s % ('soundex van geslachtsnaam1', ratio_geslachtsnaam1, weight_geslachtsnaam1,weight_geslachtsnaam1/counter, ratio_geslachtsnaam1 * weight_geslachtsnaam1, ratio_geslachtsnaam1 * weight_geslachtsnaam1/counter)\\n s += format_s % ('geslachtsnaam', ratio_geslachtsnaam2, weight_geslachtsnaam2,weight_geslachtsnaam2/counter, ratio_geslachtsnaam2 *weight_geslachtsnaam2 , ratio_geslachtsnaam2 * weight_geslachtsnaam2/counter)\\n s += format_s % ('initials', ratio_initials, weight_initials, weight_initials/counter, ratio_initials *weight_initials, ratio_initials * weight_initials/counter)\\n s += '\\\\tTOTAL (numerator) | %s (counter = %s)\\\\n' % (counter, numerator)\\n \\n return s\\n return final_ratio\",\n \"def sentence_similarity(sentence1, sentence2):\\n sentence1 = sentence1.tags\\n sentence2 = sentence2.tags\\n \\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n \\n for synset in synsets1:\\n \\n li=[synset.path_similarity(ss) for ss in synsets2]\\n m=0\\n for i in range(len(li)):\\n if li[i] is not None and m<li[i]:\\n m=li[i]\\n if m != 0:\\n score += m\\n count += 1\\n\\n if count is 0:\\n score = 0\\n else:\\n score /= count\\n return score\",\n \"def F1Score(labels, gold_file, wordnetCompression):\\n\\n gold_labels = []\\n with open(gold_file, 'r') as file:\\n for line in file:\\n gold_labels.append(line.split()[1])\\n\\n flat_decoded_label_list = [item for sublist in labels for item in sublist]\\n\\n total = 0\\n correct = 0\\n if wordnetCompression:\\n for i in range(len(gold_labels)):\\n total += 1\\n current_gold = gold_labels[i]\\n pos = wn.lemma_from_key(current_gold).synset().pos()\\n offset = wn.lemma_from_key(current_gold).synset().offset()\\n wn_synset = \\\"wn:\\\" + str(offset).zfill( 8) + pos\\n current_prediction = flat_decoded_label_list[i]\\n #if len(current_prediction) > 1:\\n # for elem in current_prediction:\\n # if elem == current_gold:\\n # correct += 1\\n #else:\\n if wn_synset == current_prediction:\\n correct += 1\\n else:\\n for i in range(len(gold_labels)):\\n if gold_labels[i] == flat_decoded_label_list[i]:\\n correct += 1\\n total += 1\\n \\n print(\\\"F1 SCORE: \\\", (correct/total)*100 )\\n print(\\\"Total number of labels: \\\", total)\\n print(\\\"Total correct: \\\", correct)\\n print()\",\n \"def compare(strokes1, strokes2):\\n\\n score = 0\\n for stroke_i in strokes1:\\n match = identify(strokes2, stroke_i)\\n score += match\\n\\n # draw1 = concat(strokes1)\\n # draw2 = concat(strokes2)\\n # draw1_length,_ = draw1.euclidian_length()\\n # draw2_length,_ = draw2.euclidian_length()\\n\\n # tot_length = draw1_length# + draw2_length\\n\\n return score\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n\\n matched = \\\"\\\" # to hold string displaying alignments\\n score = 0\\n for i in range(l2):\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" # * indicates a match\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\" # - indicates no match\\n\\n return score\",\n \"def matching_score(self,set1, set2):\\n set_set1=set(set1)\\n set_set2=set(set2)\\n '''print(\\\" set_set12\\\")\\n print(set_set1)\\n print(set_set2)'''\\n return len(set_set1.intersection(set_set2)) ** 2 / (float(len(set1)) * len(set2))\\n #return len(set_set1.intersection(set_set2)) / len(set_set1.union(set_set2))\",\n \"def baseline_score(self,t0,t1):\\n return len(set(t0) & set(t1))/len(set(t0).union(set(t1)))\",\n \"def simple_baseline_similarity(s1, s2):\\n # Tokenize by sentences into words in lower case \\n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\\n\\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\\n \\n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \\n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\\n \\n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\\n\\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\\n\\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\\n\\n return word_sim, lemm_sim\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def computeFScores(self, targetLabels, actualLabels):\\r\\n if self.prMeasures is None:\\r\\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\\r\\n if self.prMeasures[0] == 0:\\r\\n return 0\\r\\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\\r\\n return self.f1score\",\n \"def _l1_similarity(self, sentence_one, sentence_two):\\n with tf.name_scope(\\\"l1_similarity\\\"):\\n # Take the L1 norm of the two vectors.\\n # Shape: (batch_size, 2*rnn_hidden_size)\\n l1_distance = tf.abs(sentence_one - sentence_two)\\n\\n # Take the sum for each sentence pair\\n # Shape: (batch_size, 1)\\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\\n keep_dims=True)\\n\\n # Exponentiate the negative summed L1 distance to get the\\n # positive-class probability.\\n # Shape: (batch_size, 1)\\n positive_class_probs = tf.exp(-summed_l1_distance)\\n\\n # Get the negative class probabilities by subtracting\\n # the positive class probabilities from 1.\\n # Shape: (batch_size, 1)\\n negative_class_probs = 1 - positive_class_probs\\n\\n # Concatenate the positive and negative class probabilities\\n # Shape: (batch_size, 2)\\n class_probabilities = tf.concat([negative_class_probs,\\n positive_class_probs], 1)\\n\\n # if class_probabilities has 0's, then taking the log of it\\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\\n # epsilon and renormalize by the sum of the vector.\\n safe_class_probabilities = class_probabilities + 1e-08\\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\\n axis=1,\\n keep_dims=True)\\n return safe_class_probabilities\",\n \"def _l1_similarity(self, sentence_one, sentence_two):\\n with tf.name_scope(\\\"l1_similarity\\\"):\\n # Take the L1 norm of the two vectors.\\n # Shape: (batch_size, 2*rnn_hidden_size)\\n l1_distance = tf.abs(sentence_one - sentence_two)\\n\\n # Take the sum for each sentence pair\\n # Shape: (batch_size, 1)\\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\\n keep_dims=True)\\n\\n # Exponentiate the negative summed L1 distance to get the\\n # positive-class probability.\\n # Shape: (batch_size, 1)\\n positive_class_probs = tf.exp(-summed_l1_distance)\\n\\n # Get the negative class probabilities by subtracting\\n # the positive class probabilities from 1.\\n # Shape: (batch_size, 1)\\n negative_class_probs = 1 - positive_class_probs\\n\\n # Concatenate the positive and negative class probabilities\\n # Shape: (batch_size, 2)\\n class_probabilities = tf.concat([negative_class_probs,\\n positive_class_probs], 1)\\n\\n # if class_probabilities has 0's, then taking the log of it\\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\\n # epsilon and renormalize by the sum of the vector.\\n safe_class_probabilities = class_probabilities + 1e-08\\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\\n axis=1,\\n keep_dims=True)\\n return safe_class_probabilities\",\n \"def compare_sentences(first, second):\\n if not len(first) or not len(second):\\n return 0\\n return len(set(only_important(first)) & set(only_important(second))) / ((len(first) + len(second)) / 2.0)\",\n \"def score_ngram(self, score_fn, w1, w2):\\n n_all = self.N\\n n_ii = self.ngram_fd[(w1, w2)] / (self.window_size - 1.0)\\n if not n_ii:\\n return\\n n_ix = self.word_fd[w1]\\n n_xi = self.word_fd[w2]\\n return score_fn(n_ii, (n_ix, n_xi), n_all)\",\n \"def sentence_similarity(sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n\\n # Get the synsets for the tagged words\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n\\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n\\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n best_score = max([synset.path_similarity(ss) or 0 for ss in synsets2])\\n\\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n if count == 0:\\n return 0\\n\\n # Average the values\\n score /= count\\n return score\",\n \"def calculate_f1_score(y_test, y_pred):\\n print('# Running precision, recall and F1-score')\\n print('# F1-Score:\\\\t\\\\t%.2f' % (f1_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Precision:\\\\t\\\\t%.2f' % (precision_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Recall:\\\\t\\\\t%.2f' % (recall_score(y_test, y_pred, average=\\\"macro\\\") * 100))\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2):\\n #moves shorter sequence along longer, counting number of matches in\\n #each position\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\"\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\"\\n\\n # gives an output for each startpoint showing the number of matches where\\n # * is a match and - is no match, position of the two sequences relative to\\n # each other, and the number of matches for that startpoint.\\n print(\\\".\\\" * startpoint + matched) \\n print(\\\".\\\" * startpoint + s2)\\n print(s1)\\n print(score) \\n print(\\\" \\\")\\n\\n return score\",\n \"def compare_texts(text1, text2):\\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))\",\n \"def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n\\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n \\\"\\\"\\\"Get n-gram level f-score.\\\"\\\"\\\"\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\\n return f_score\",\n \"def get_f1(self,common_len,RTSummary,SystemSummary):\\n recall = self.get_recall(common_len,RTSummary)\\n precision = self.get_precision(common_len,SystemSummary)\\n if precision<=0 or recall <=0:\\n return 0.0\\n else:\\n return ((2 * recall * precision)/(recall + precision))\",\n \"def wordNet_similarity(sentence1, sentence2):\\r\\n # Tokenize and tag\\r\\n \\r\\n # sentence1 = pos_tag(word_tokenize(sentence1))\\r\\n sentence1=st_tagger.tag(word_tokenize(sentence1))\\r\\n \\r\\n # sentence2 = pos_tag(word_tokenize(sentence2))\\r\\n sentence2=st_tagger.tag(word_tokenize(sentence2))\\r\\n\\r\\n \\r\\n # Get the synsets for the tagged words\\r\\n #################################################\\r\\n\\r\\n # synsets1=[]\\r\\n # synsets2=[]\\r\\n # for tagged_word in sentence1:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n # for tagged_word in sentence2:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # print(tagged_word)\\r\\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n\\r\\n # The code above is the elaboration of code below\\r\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\r\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\r\\n \\r\\n # Filter out the Nones in the synonym set\\r\\n synsets1 = [ss for ss in synsets1 if ss]\\r\\n synsets2 = [ss for ss in synsets2 if ss]\\r\\n \\r\\n score, count = 0.0, 0\\r\\n \\r\\n###########################################################################\\r\\n # for syn1 in synsets1:\\r\\n # arr_simi_score = []\\r\\n # print('=========================================')\\r\\n # print(syn1)\\r\\n # print('----------------')\\r\\n # for syn2 in synsets2:\\r\\n # print(syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n # print(simi_score)\\r\\n # if simi_score is not None:\\r\\n # arr_simi_score.append(simi_score)\\r\\n # print('----------------')\\r\\n # print(arr_simi_score)\\r\\n # if(len(arr_simi_score) > 0):\\r\\n # best = max(arr_simi_score)\\r\\n # print(best)\\r\\n # score += best\\r\\n # count += 1\\r\\n # # Average the values\\r\\n # print('score: ', score)\\r\\n # print('count: ', count)\\r\\n # score /= count\\r\\n\\r\\n###########################################################################\\r\\n\\r\\n for syn1 in synsets1:\\r\\n arr_simi_score = []\\r\\n # print('=========================================')\\r\\n print(\\\"Each word from Synonym se1\\\",syn1)\\r\\n # print('----------------')\\r\\n for syn2 in synsets2:\\r\\n print(\\\"Each word from Synonym se2\\\",syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n simi_score = syn1.wup_similarity(syn2)\\r\\n print(\\\"word to word path_similarity score\\\",simi_score)\\r\\n if simi_score is not None:\\r\\n arr_simi_score.append(simi_score)\\r\\n print('----------------')\\r\\n print(arr_simi_score)\\r\\n if(len(arr_simi_score) > 0):\\r\\n best = max(arr_simi_score)\\r\\n print(\\\"best score so far\\\", best)\\r\\n score += best\\r\\n count += 1\\r\\n # Average the values\\r\\n print('score: ', score)\\r\\n print('count: ', count)\\r\\n if count!=0:\\r\\n score /= count\\r\\n else:\\r\\n score=0.0\\r\\n return score\",\n \"def word_order_similarity(self,sentence_1, sentence_2):\\n\\t words_1 = sentence_1.getList_of_words()\\n\\t words_2 = sentence_2.getList_of_words()\\n\\t joint_words = list(set(words_1).union(set(words_2)))\\n\\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\\n\\t r1 = self.word_order_vector(words_1, joint_words, windex)\\n\\t r2 = self.word_order_vector(words_2, joint_words, windex)\\n\\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))\",\n \"def fuzzy_score_string(first_string, second_string):\\n score = 0\\n\\n if len(first_string) < len(second_string):\\n shorter, longer = (first_string, second_string)\\n window_length = len(shorter)\\n\\n num_iterations = len(longer) - len(shorter) + 1\\n\\n for position in range(0, num_iterations):\\n window = longer[position:position + window_length]\\n l_ratio = Levenshtein.ratio(window, shorter) * 100\\n\\n if l_ratio > 60:\\n result = statistics.mean(\\n [100 - Levenshtein.distance(window, shorter) * 15, l_ratio, l_ratio])\\n\\n else:\\n result = l_ratio\\n\\n if result > score:\\n score = result\\n\\n else:\\n l_ratio = Levenshtein.ratio(first_string, second_string) * 100\\n score = statistics.mean(\\n [100 - Levenshtein.distance(first_string, second_string) * 15, l_ratio, l_ratio])\\n\\n simple = fuzz.ratio(first_string, second_string)\\n partial = fuzz.partial_ratio(first_string, second_string)\\n sort = fuzz.token_sort_ratio(first_string, second_string)\\n set_ratio = fuzz.token_set_ratio(first_string, second_string)\\n\\n score = max([score, simple, partial, sort, set_ratio])\\n\\n if score < 75:\\n score = 0\\n\\n return score * 0.85\",\n \"def get_subscore_pairwise(seqs1,seqs2, matrix=matrix, gap_s=gap_s, gap_e=gap_e):\\n print type(seqs1)\\n score=0\\n terms=0\\n for seq1 in seqs1:\\n for seq2 in seqs2:\\n score+=get_subscore(seq1, seq2, matrix, gap_s, gap_e)\\n terms+=1.0\\n\\n return score/terms\",\n \"def match(desc1,desc2):\\n\\t\\n\\tdesc1 = array([d/linalg.norm(d) for d in desc1])\\n\\tdesc2 = array([d/linalg.norm(d) for d in desc2])\\n\\t\\n\\tdist_ratio = 0.6\\n\\tdesc1_size = desc1.shape\\n\\t\\n\\tmatchscores = zeros((desc1_size[0],1))\\n\\tdesc2t = desc2.T #precompute matrix transpose\\n\\tfor i in range(desc1_size[0]):\\n\\t\\tdotprods = dot(desc1[i,:],desc2t) #vector of dot products\\n\\t\\tdotprods = 0.9999*dotprods\\n\\t\\t#inverse cosine and sort, return index for features in second image\\n\\t\\tindx = argsort(arccos(dotprods))\\n\\t\\t\\n\\t\\t#check if nearest neighbor has angle less than dist_ratio times 2nd\\n#\\t\\tif arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n\\t\\tmatchscores[i] = int(indx[0])\\n\\t\\n\\treturn matchscores\",\n \"def similar_text(word1, word2) -> float:\\n\\n return textdistance.overlap.similarity(word1, word2)\",\n \"def _compute_score(self):\\n\\n sgml_path = str(self.sgml_file.name)\\n text_path = sgml_path.replace('.sgm', '.txt')\\n ref_path = 'testsets/wmt18.ende.ref.txt'\\n\\n from sacrebleu import process_to_text, corpus_bleu\\n from pathlib import Path\\n\\n if not Path(text_path).exists():\\n process_to_text(sgml_path, text_path)\\n\\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\\n\\n bleu = corpus_bleu(hyp_stream, [ref_stream])\\n\\n self.score = bleu.score\\n self.save()\",\n \"def calculate_flesch_score(text):\\n\\n # Use the given formula and call other functions to get the values\\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\\n text)\\n\\n return score\",\n \"def get_relatedness(theme1,theme2):\\r\\n nAB=0\\r\\n nAB_plus=0\\r\\n for sentence_1 in theme1.sentences:\\r\\n for sentence_2 in theme2.sentences:\\r\\n if cmp(sentence_1[2],sentence_2[2])==0:\\r\\n nAB=nAB+1\\r\\n if sentence_1[3]==sentence_2[3]:\\r\\n nAB_plus=nAB_plus+1\\r\\n if nAB==0:\\r\\n return 0\\r\\n else:\\r\\n return float(nAB_plus)/float(nAB)\",\n \"def score_function(word1, word2):\\n if word2 == '':\\n return len(word1)\\n elif word1 == '':\\n return len(word2)\\n elif word1 == word2:\\n return 0\\n elif word1[0] == word2[0]:\\n return 0 + score_function(word1[1:], word2[1:])\\n else:\\n add_char = 1 + score_function(word2[0] + word1[:], word2[:])\\n sub_char = 1 + score_function(word1[1:], word2[1:])\\n remove_char = 1 + score_function(word1[1:], word2[:])\\n return min(add_char, sub_char, remove_char)\\n # if word1 == word2: # Fill in the condition\\n # # BEGIN Q6\\n # return 0\\n # # END Q6\\n # elif word1[0] == word2[0]: # Feel free to remove or add additional cases\\n # # BEGIN Q6\\n # return score_function(word1[1:], word2[1:])\\n # # END Q6\\n # else:\\n #\\n # elif len(word1) > len(word2):\\n # difference = len(word2) - len(word1)\\n # word2 = word2[0:len(word1)]\\n # return difference + score_function(word1, word2)\\n # elif len(word1) == len(word2):\\n # total = 0\\n # for i in word1:\\n # if word1[i] == word2[i]:\\n # total += 1\\n # return total\\n # elif len(word1) < len(word2):\\n # difference = len(word2) - len(word1)\\n # word1 = word1 + word2[len(word1):]\\n # return difference + score_function(word1, word2)\\n # else:\\n #\\n # def add_char(word1, word2):\\n # while len(word1) <= len(word2):\\n # return swap_score(word1, word2)\\n # return 0\\n #\\n # def remove_char(word1, word2):\\n # while len(word1) >= len(word2):\\n # if word1[0] != word2[0]:\\n # return 1 + remove_char(word1[1:], word2[1:])\\n # return 0\\n #\\n # def sub_char(word1, word2):\\n # if len(word1) == len(word2):\\n # if word1[0] == word2[0]:\\n # return 0\\n # else:\\n # return 1 + sub_char(word1[1:], word2[1:])\\n # return 0\\n # # BEGIN Q6\\n # return add_char(word1, word2) + remove_char(word1, word2) + sub_char(word1, word2)\\n # # END Q6\",\n \"def test_score_across_multiple_documents(self):\\n\\n \\\"\\\"\\\"\\n Create the test data.\\n \\\"\\\"\\\"\\n tokenizer = Tokenizer(stem=False)\\n posts = [\\n \\\"Erdogan with threats to attack regime forces 'everywhere' in Syria\\\",\\n \\\"Syria reacts to Erdogan's threats: Damascus says Erdogan 'disconnected from reality' after threats\\\",\\n ]\\n\\n corpus = [ Document(post, tokenizer.tokenize(post)) for post in posts ]\\n\\n extractor = TokenExtractor(tokenizer=tokenizer)\\n scorer = TFIDFScorer({ 'erdogan': 1, 'threats': 2 }, 10)\\n candidates = extractor.extract(corpus)\\n scores = scorer.score(candidates, normalize_scores=False)\\n self.assertEqual(3 * math.log(10 / 1, 10), scores.get('erdogan'))\\n self.assertEqual(3 * math.log(10 / 2, 10), scores.get('threats'))\",\n \"def sentence_similarity_asym(sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n \\n # Get the synsets for the tagged words\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\\n if len(pathsim) == 0:\\n #print sentence1, sentence2\\n pathsim = [0]\\n best_score = max(pathsim)\\n \\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n if count == 0:\\n return 0\\n # Average the values\\n score /= count\\n return score\",\n \"def f1_score(confusion):\\n p = precision(confusion)\\n r = sensitivity(confusion)\\n F1 = (2 * p * r) / (p + r)\\n return F1\",\n \"def compute_readability(text):\\n total_words = 0\\n total_sentences = 0\\n total_syllables = 0\\n score = 0\\n\\n words = text.split()\\n total_words = len(text.split()) \\n total_sentences = count_sentences(text)\\n total_syllables = count_syllables(words)\\n \\n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\\n if score > 90.00:\\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\\n elif score <= 90.00 and score > 80.00:\\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\\n elif score <= 80.00 and score > 70.00:\\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\\n elif score <= 70.00 and score > 60.00:\\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\\n elif score <= 60.00 and score > 50.00:\\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\\n elif score <= 50.00 and score > 30.00:\\n answer = 'Texto de nível Universitário, difícil de ler.'\\n else:\\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\\n \\n print('Pontuação Total:', score, answer)\",\n \"def get_frame_element_score(self, fe1, fe2):\\n name_match = fe1['name'] == fe2['name']\\n score = self.get_text_score(fe1['spans'][0]['text'], fe2['spans'][0]['text'])\\n if not name_match:\\n score *= self.pen.factor_name_mismatch\\n return score\",\n \"def f1(predictions, gold):\\n if len(gold) == 0:\\n return 1. if len(predictions) == 0 else 0.\\n if len(predictions) == 0:\\n return 0.\\n predictions_set = set(predictions)\\n gold_set = set(gold)\\n nom = 2 * len(predictions_set.intersection(gold_set))\\n denom = len(predictions_set) + len(gold_set)\\n return float(nom)/float(denom)\",\n \"def match(desc1,desc2):\\n desc1 = array([d/linalg.norm(d) for d in desc1])\\n desc2 = array([d/linalg.norm(d) for d in desc2])\\n dist_ratio = 0.6\\n desc1_size = desc1.shape\\n matchscores = zeros((desc1_size[0],1),'int')\\n desc2t = desc2.T # precompute matrix transpose\\n for i in range(desc1_size[0]):\\n dotprods = dot(desc1[i, :], desc2t) # vector of dot products\\n dotprods *= 0.9999\\n # inverse cosine and sort, return index for features in second image\\n indx = argsort(arccos(dotprods))\\n # check if nearest neighbor has angle less than dist_ratio times 2nd\\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n matchscores[i] = int(indx[0])\\n return matchscores\",\n \"def calculate_f1_score(predictions, actuals):\\n predictions = predictions > 0.5\\n # fbeta_score throws a confusing error if inputs are not numpy arrays\\n predictions, actuals, = np.array(predictions), np.array(actuals)\\n # We need to use average='samples' here, any other average method will generate bogus results\\n return fbeta_score(actuals, predictions, beta=1, average='samples')\",\n \"def classify(self, source1, source2):\\n scores1 = self.similarity_scores(source1)\\n scores2 = self.similarity_scores(source2)\\n\\n print(\\\"scores for\\\", source1.name, \\\":\\\", [round(number, 2) for number in scores1])\\n print(\\\"scores for\\\", source2.name, \\\":\\\", [round(number, 2) for number in scores2])\\n\\n s1 = 0\\n s2 = 0\\n for x in range(len(scores1)):\\n if scores1[x] >= scores2[x]:\\n s1 += 1\\n else:\\n s2 += 1\\n \\n if s1 > s2:\\n print(self.name, \\\"is more likely to have come from \\\", source1.name)\\n print()\\n else:\\n print(self.name, \\\"is more likely to have come from \\\", source2.name)\\n print()\",\n \"def get_similarity_score(self, reviewer1: Any, reviewer2: Any) -> float:\\n v1 = self._vertices[reviewer1]\\n v2 = self._vertices[reviewer2]\\n return v1.reviewer_similarity_score(v2)\",\n \"def compute_similarity(self, text1, text2):\\n\\n text1_dist = self.predict(text1)[0]\\n text2_dist = self.predict(text2)[0]\\n return jensenshannon(text1_dist, text2_dist)\",\n \"def match(desc1, desc2):\\n desc1 = array([d/linalg.norm(d) for d in desc1])\\n desc2 = array([d/linalg.norm(d) for d in desc2])\\n\\n dist_ratio = 0.6\\n disc1_size = desc1.shape\\n\\n matchscores = zeros((desc1_size[0]), \\\"int\\\")\\n desc2t = desc2.T\\n for i in range(desc1_size[0]):\\n dotprods = dot(desc1[i, :], desc2t)\\n dotprods = 0.9999 * dotprods\\n\\n indx = argsort(arccos(dotprods))\\n\\n if arccos(dotprods)[indx[0]] < dist_ratio * arccos(dotprods)[indx[1]]:\\n matchscores[i] = int(indx[0])\\n\\n return matchscores\",\n \"def __call__(self, f1, f2):\\n\\n r = 0.0\\n for f in f1:\\n if f in f2:\\n r += f1[f] * f2[f]\\n\\n return r\",\n \"def score(self, sentence):\\n # TODO your code here\\n\\n # initialize count with trained data\\n unigram_count = self.count.copy()\\n N = self.total\\n\\n # make a new key for UNK, add-one later\\n for token in sentence:\\n if token not in unigram_count:\\n unigram_count[token] = 0\\n\\n # calcutate lopP(<s>) + logP(w1) + logP(w2) + ...\\n score = 0.0 # P(<s>) = 1\\n V = len(unigram_count) # the number of vocab including UNK\\n for word in sentence:\\n prob = float((unigram_count[word] + 1) / (N + V)) # c(w) + 1 / N + V\\n score += math.log(prob)\\n\\n return score\",\n \"def f1_score_model(self, model, X, y):\\n\\n prediction = model.predict_classes(X)\\n f1_macro = f1_score(y, prediction, average='macro')\\n f1_micro = f1_score(y, prediction, average='macro')\\n print(\\\"f1_macro: \\\", f1_score(y, prediction, average='macro'))\\n print(\\\"f1_micro: \\\", f1_score(y, prediction, average=\\\"micro\\\"))\\n print(\\\"f1_weighted: \\\", f1_score(y, prediction, average=\\\"weighted\\\"))\\n return f1_macro, f1_micro\",\n \"def f1_score(prediction, ground_truth):\\n return precision_recall_f1(prediction, ground_truth)[2]\",\n \"def score(self, text):\\n logger.debug(\\\"score on an instance of len {0}\\\".format(len(text)))\\n fv = self.instance2fv(text)\\n fv /= np.sqrt((fv*fv).sum()) # normalize vector to len 1\\n fdot = self.lprot.dot(fv) \\n retval = dict(zip(self.langs, fdot))\\n return retval\",\n \"def score(stripe1, stripe2):\\n scr = 0\\n count = 0\\n for p1, p2 in zip(stripe1, stripe2):\\n r = abs(p1[0] - p2[0])\\n g = abs(p1[1] - p2[1])\\n b = abs(p1[2] - p2[2])\\n scr += r + g + b\\n return scr\",\n \"def match_word_sorted(code1, code2):\\n list1 = code1.split(\\\" \\\")\\n list2 = code2.split(\\\" \\\")\\n set1 = set(list1)\\n set2 = set(list2)\\n common_words = set1 & set2\\n try:\\n common_words.remove(\\\"\\\")\\n except:\\n pass\\n\\n words_to_index = {}\\n for word in common_words:\\n in1 = list1.index(word)\\n in2 = list2.index(word)\\n words_to_index[word] = (in1, in2)\\n sorted1 = OrderedDict(sorted(words_to_index.items(), key=lambda t: t[1][0])).keys()\\n sorted2 = OrderedDict(sorted(words_to_index.items(), key=lambda t: t[1][1])).keys()\\n\\n a = Sequence(sorted1)\\n b = Sequence(sorted2)\\n v = Vocabulary()\\n a_encoded = v.encodeSequence(a)\\n b_encoded = v.encodeSequence(b)\\n scoring = SimpleScoring(MATCH_SCORE, MISMATCH_SCORE)\\n aligner = GlobalSequenceAligner(scoring, GAP_SCORE)\\n score, encoders = aligner.align(a_encoded, b_encoded, backtrace=True)\\n max_score = 0\\n for i, encoded in enumerate(encoders):\\n alignment = v.decodeSequenceAlignment(encoded)\\n if alignment.score > max_score:\\n max_score = alignment.score\\n return max_score\",\n \"def score(self, sentence):\\n\\n\\n # TODO your code here\\n score = 0.0 \\n prevWord = \\\"\\\"\\n prevPrevWord = \\\"\\\"\\n newSentence = []\\n for word in sentence:\\n newSentence += word.split()\\n for currentWord in sentence:\\n currentWord = currentWord.strip(STRIP_CHARS)\\n currentWord = currentWord.lower()\\n if prevWord != \\\"\\\":\\n if prevPrevWord != \\\"\\\":\\n trigram = (prevPrevWord, prevWord, currentWord)\\n trigramCount = self.trigramCounts[trigram]\\n if trigramCount > 0:\\n score += math.log(max(self.trigramCounts[trigram] - DISCOUNT, 0)*len(self.trigramCounts) + DISCOUNT*self.followingCounts[(prevPrevWord, prevWord)]*self.continuationCounts[currentWord])\\n # Subtraction by 1 removes the add one count from the laplace\\n # smoothing\\n score -= math.log((self.bigramCounts[(prevPrevWord, prevWord)]) * len(self.trigramCounts))\\n elif self.bigramCounts[(prevWord, currentWord)] > 0:\\n score += math.log(self.bigramCounts[(prevWord, currentWord)]*BI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.totalBigramCounts)\\n else:\\n count = self.unigramCounts[currentWord]\\n score += math.log(count * UNI_BACKOFF_COEFFICIENT)\\n score -= math.log(self.total)\\n else:\\n prevPrevWord = prevWord\\n prevWord = currentWord\\n else:\\n prevWord = currentWord\\n return -score\",\n \"def calculate_f1(fx, y):\\n pred_idxs = fx.max(1, keepdim=True)[1]\\n pred_names = [idx2target[i.item()] for i in pred_idxs]\\n original_names = [idx2target[i.item()] for i in y]\\n true_positive, false_positive, false_negative = 0, 0, 0\\n for p, o in zip(pred_names, original_names):\\n predicted_subtokens = p.split('|')\\n original_subtokens = o.split('|')\\n for subtok in predicted_subtokens:\\n if subtok in original_subtokens:\\n true_positive += 1\\n else:\\n false_positive += 1\\n for subtok in original_subtokens:\\n if not subtok in predicted_subtokens:\\n false_negative += 1\\n try:\\n precision = true_positive / (true_positive + false_positive)\\n recall = true_positive / (true_positive + false_negative)\\n f1 = 2 * precision * recall / (precision + recall)\\n except ZeroDivisionError:\\n precision, recall, f1 = 0, 0, 0\\n return precision, recall, f1\",\n \"def precision_recall_f1(prediction, ground_truth):\\n if not isinstance(prediction, list):\\n prediction_tokens = prediction.split()\\n else:\\n prediction_tokens = prediction\\n if not isinstance(ground_truth, list):\\n ground_truth_tokens = ground_truth.split()\\n else:\\n ground_truth_tokens = ground_truth\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0, 0, 0\\n p = 1.0 * num_same / len(prediction_tokens)\\n r = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * p * r) / (p + r)\\n return p, r, f1\",\n \"def matcher(features1, features2):\\n #TODO: write a matching function\\n #Performing the L2-Norm\\n new_features1=[]\\n new_features2=[]\\n for itr in range(5):\\n [rootOfSquare1,rootOfSquare2] = sumOfSquares(features1[itr],features2[itr])\\n new_features1.append(np.array(features1[itr])/rootOfSquare1)\\n new_features2.append(np.array(features2[itr])/rootOfSquare2)\\n indices = []\\n for itr in range(len(new_features1)):\\n findMinDist=[]\\n #findMaxCosineVal=[]\\n for itr2 in range(len(new_features2)):\\n f1 = new_features1[itr]\\n f2 = new_features2[itr2]\\n\\n #For evaluating the cosine similarity\\n # [rootOfSquare1,rootOfSquare2] = sumOfSquares(f1,f2)\\n # numerator = np.array(f1)*np.array(f2)\\n # numeratorSum = sum(numerator)\\n # denominator = rootOfSquare1*rootOfSquare2\\n # cosine = np.divide(numeratorSum,denominator)\\n # findMaxCosineVal.append(cosine)\\n\\n #For evaluating the similarity based on euclidean distance\\n Dist = np.array(f1) - np.array(f2)\\n sum=0\\n for i in Dist:\\n sum=sum+math.pow(i,2)\\n rootOfSum = math.sqrt(sum)\\n findMinDist.append(rootOfSum)\\n # print \\\"itr: \\\", itr, \\\" Matching scores: \\\", findMaxCosineVal\\n # bestMatch = findMaxCosineVal.index(max(findMaxCosineVal))\\n bestMatch = findMinDist.index(min(findMinDist))\\n indices.append([itr,bestMatch])\\n return indices\",\n \"def calf_f1(annotated_Y, predicted_Y):\\n\\n POSITIVE = ADR_MENTION_CLASS_LABEL\\n NEGATIVE = NON_ADR_MENTION_CLASS_LABEL\\n\\n tp = 0\\n fp = 0\\n fn = 0\\n tn = 0\\n\\n total_actual_positives = 0\\n total_actual_negatives = 0\\n\\n for index, actual in enumerate(annotated_Y):\\n predicted = predicted_Y[index]\\n\\n if actual == POSITIVE:\\n total_actual_positives += 1\\n\\n if predicted == POSITIVE:\\n tp += 1\\n elif predicted == NEGATIVE:\\n fn += 1\\n\\n elif actual == NEGATIVE:\\n total_actual_negatives += 1\\n\\n if predicted == POSITIVE:\\n fp += 1\\n elif predicted == NEGATIVE:\\n tn += 1\\n\\n if (tp+fp) == 0:\\n precision = 0\\n else:\\n precision = tp/(tp+fp)\\n\\n if (tp+fn) == 0:\\n recall = 0\\n else:\\n recall = tp/(tp+fn)\\n\\n if (precision+recall) == 0:\\n f1 = 0\\n else:\\n f1 = 2*precision*recall/(precision+recall)\\n\\n # print(\\\"Total labels: {}, total actual positives: {}, total_actual_negatives: {}\\\".format(len(predicted_Y), total_actual_positives, total_actual_negatives))\\n # print(\\\"tp: {}, tn: {}, fp: {}, fn: {}\\\".format(tp, tn, fp, fn))\\n # print(\\\" Accuracy: {}\\\".format((tp+tn)/(len(test_Y))))\\n print(\\\" Precision: {}\\\".format(precision))\\n print(\\\" Recall: {}\\\".format(recall))\\n print(\\\" F1: {}\\\".format(f1))\",\n \"def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\",\n \"def neural_relevance_model(ix, term_dict, ids_and_scores, corpus, fb_terms):\\n\\n\\t# set variables\\n\\trm1_vec = list()\\n\\tvocab = set()\\n\\tdoc_vecs = dict()\\n\\n\\t# create document feature vectors for each feedback doc\\n\\tfor doc_id in ids_and_scores.keys():\\n\\t\\t# convert current doc to bow format\\n\\t\\tbow = ix.doc2bow(corpus[doc_id])\\n\\t\\t# create document feature vector\\n\\t\\tdfv = create_feature_vector(ix, term_dict, bow)\\n\\t\\t# keep top 'fb_terms' from dfv\\n\\t\\tdfv = defaultdict(int, sorted(dfv, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t\\t# update vocab with top 'fb_terms' terms contained within feedback docs and store document feature vectors\\n\\t\\tvocab.update(dfv.keys())\\n\\t\\tdoc_vecs[doc_id] = dfv\\n\\n\\t# compute L1 norm for each document feature vector\\n\\tnorms = {doc_id: sum(dfv.values()) for doc_id, dfv in doc_vecs.items()}\\n\\n\\t# loop over terms in vocab and compute RM1\\n\\tfor term in vocab:\\n\\t\\tfb_weight = 0.0\\n\\t\\t# loop over document feature vectors \\n\\t\\tfor doc_id in doc_vecs.keys():\\n\\t\\t\\tif norms[doc_id] > 0.001: # avoids zero-length feedback docs which cause division by zero when computing term weights\\n\\t\\t\\t\\t# sum the score of current term across different docs to fb_weight\\n\\t\\t\\t\\tfb_weight += (doc_vecs[doc_id][term] / norms[doc_id]) * ids_and_scores[doc_id] # ids_and_scores[doc_id] is the score obtained for current doc w/ the original query\\n\\t\\t# assign term w/ weight to RM1 feature vector\\n\\t\\trm1_vec.append((term, fb_weight))\\n\\n\\t# keep top 'fb_terms' from rm1_vec\\n\\trm1_vec = defaultdict(float, sorted(rm1_vec, key=lambda x: (-x[1], x[0]))[:fb_terms]) # -x[1] represents descending order\\n\\t# scale rm1_vec to L1 norm\\n\\treturn scale_to_L1_norm(rm1_vec)\",\n \"def classify(self, source1, source2):\\n\\n scores1 = self.similarity_scores(source1)\\n scores2 = self.similarity_scores(source2)\\n \\n print('scores for ' + source1.name +':' + str(self.similarity_scores(source1)))\\n print('scores for ' + source2.name +':' + str(self.similarity_scores(source2)))\\n \\n source1_score=0\\n source2_score=0\\n\\n for i in range(len(scores1)):\\n if scores1[i]> scores2[i]:\\n source1_score+=1\\n elif scores2[i]>scores1[i]:\\n source2_score+=1\\n \\n if source1_score > source2_score:\\n win=source1.name\\n else:\\n win=source2.name\\n\\n print(self.name + ' is more likely to have come from ' + win)\",\n \"def qualify_words():\\n config = get_config()\\n\\n all_feature_matrices = []\\n all_opinion_matrices = []\\n\\n # first 5 parts are labeled, thus are useful\\n all_feature_label_vectors = []\\n all_opinion_label_vectors = []\\n\\n for fname in config.file_names:\\n feature_X, feature_dims = load_feature_matrices(fname)\\n opinion_X, opinion_dims = load_opinion_matrices(fname)\\n feature_y = load_feature_labels(fname)\\n opinion_y = load_opinion_labels(fname)\\n\\n # append to all collector\\n all_feature_matrices.append(feature_X)\\n all_feature_label_vectors.append(feature_y)\\n all_opinion_matrices.append(opinion_X)\\n all_opinion_label_vectors.append(opinion_y)\\n # use first 5 for training\\n # stack first 5\\n feature_training_X = []\\n feature_training_y = []\\n opinion_training_X = []\\n opinion_training_y = []\\n for i in range(5):\\n feature_training_X.append(all_feature_matrices[i])\\n feature_training_y.append(all_feature_label_vectors[i])\\n opinion_training_X.append(all_opinion_matrices[i])\\n opinion_training_y.append(all_opinion_label_vectors[i])\\n\\n feature_training_X = np.hstack(feature_training_X)\\n feature_training_y = np.hstack(feature_training_y)\\n opinion_training_X = np.hstack(opinion_training_X)\\n opinion_training_y = np.hstack(opinion_training_y)\\n\\n # using combination of rule and ranking score as features\\n feature_model = MultinomialNB()\\n opinion_model = MultinomialNB()\\n\\n # training\\n feature_model.fit(np.transpose(feature_training_X), feature_training_y.ravel())\\n opinion_model.fit(np.transpose(opinion_training_X), opinion_training_y.ravel())\\n\\n # predicting on candidate aspects and opinions, extracted from amazon reviews\\n for i in range(5, len(config.file_names)):\\n fname = config.file_names[i]\\n feature_pred = feature_model.predict_proba(\\n np.transpose(all_feature_matrices[i]))[:,1]\\n opinion_pred = opinion_model.predict_proba(\\n np.transpose(all_opinion_matrices[i]))[:,1]\\n # pickle the prediction results\\n with open('../results/' + fname + '_feature_pred_score.pickle', 'wb') as f:\\n pickle.dump(feature_pred, f)\\n with open('../results/' + fname + '_opinion_pred_score.pickle', 'wb') as f:\\n pickle.dump(opinion_pred, f)\",\n \"def word_overlap2(sentence_a, sentence_b):\\n a_set = set(word for word in sentence_a) - config.stop_list\\n b_set = set(word for word in sentence_b) - config.stop_list\\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\\n\\n return score\",\n \"def similarity_scores(self, other):\\n results = []\\n\\n words_score=compare_dictionaries(other.words, self.words)\\n wordl_score=compare_dictionaries(other.word_lengths, self.word_lengths)\\n stems_score=compare_dictionaries(other.stems, self.stems)\\n sentl_score=compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\\n endings_score=compare_dictionaries(other.endings, self.endings)\\n results+= [words_score]\\n results+= [wordl_score]\\n results+= [stems_score]\\n results+= [sentl_score]\\n results+= [endings_score]\\n return results\",\n \"def similarity_scores(self, other):\\n word_score = compare_dictionaries(other.words, self.words)\\n word_length_score = compare_dictionaries(other.word_lengths, self.words)\\n stem_score = compare_dictionaries(other.stems, self.stems)\\n sentence_length_score = compare_dictionaries(other.sentence_lengths, self.sentence_lengths)\\n common_word_score = compare_lists(other.common_word, self.common_word)\\n\\n return [word_score, word_length_score, stem_score, sentence_length_score, common_word_score]\",\n \"def f1(gold_labels, predicted_labels):\\n \\n precision_value = float(precision(gold_labels, predicted_labels))\\n recall_value = float(recall(gold_labels, predicted_labels))\\n top = float(2 * precision_value * recall_value)\\n bottom = precision_value + recall_value\\n\\n if(top == 0):\\n return 0\\n else:\\n return float(top / bottom)\",\n \"def f1_score(confusion):\\n s = np.power(sensitivity(confusion), -1)\\n p = np.power(precision(confusion), -1)\\n return 2 / (s + p)\",\n \"def test_find_phrase_matches1(self):\\n\\t\\ttest = sentiment.LibraryRun(self.text1, self.lib)\\n\\t\\tobj_ut = test.find_phrase_matches(self.tokens_generator1)[0]\\n\\t\\tself.assertEqual(dict(obj_ut),\\n\\t\\t\\t{'not good': [[2, -1, 0]]})\",\n \"def f1_score(y_true, y_pred, threshold, macro = False, eps = 1e-9):\\n\\n y_pred = torch.ge(y_pred.float(), threshold).float()\\n\\n y_true = y_true.float()\\n\\n tp_l = (y_pred * y_true).sum(0).float()\\n\\n fp_l = (y_pred * (1 - y_true)).sum(0).float()\\n\\n fn_l = ((1 - y_pred) * y_true).sum(0).float()\\n\\n precision_label = tp_l.div(tp_l + fp_l + eps)\\n\\n recall_label = tp_l.div(tp_l + fn_l + eps)\\n\\n if macro:\\n\\n f1_macro = torch.mean((precision_label * recall_label).div(precision_label + recall_label + eps) * 2)\\n\\n return f1_macro.item(), torch.mean(precision_label).item(), torch.mean(recall_label).item()\\n\\n else: \\n\\n tp = tp_l.sum()\\n\\n fp = fp_l.sum()\\n\\n fn = fn_l.sum()\\n\\n precision = tp / (tp + fp + eps)\\n\\n recall = tp / (tp + fn + eps)\\n\\n f1_micro = (precision * recall).div(precision + recall + eps) * 2\\n\\n return f1_micro.item(), precision.item(), recall.item()\",\n \"def binary_f1_score(preds, y):\\n rounded_predictions = torch.round(torch.sigmoid(preds))\\n\\n return f1_score(y.cpu().numpy(), rounded_predictions.cpu().numpy(), average='weighted')\",\n \"def prec_recall_f1_score(pred_items, gold_items):\\n common = Counter(gold_items) & Counter(pred_items)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(pred_items)\\n recall = 1.0 * num_same / len(gold_items)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def compare_words(word1, word2):\\n word1 = word1.lower()\\n word2 = word2.lower()\\n seg_scores = []\\n if len(word1) >= len(word2):\\n for i in range(0, len(word1) - len(word2) + 1):\\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\\n else:\\n for i in range(0, len(word2) - len(word1) + 1):\\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)\",\n \"def f1_score(precision, recall):\\n if precision + recall == 0:\\n return 0\\n return 2 * precision * recall / (precision + recall)\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2): \\n if (i + startpoint) < (l1 + l2 - 1): \\n if l2 - i > startpoint + 1:\\n matched = matched + \\\".\\\" #dots before they start overlapping\\n elif s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" #matched bases\\n score = score + 1 #adds one to score\\n else:\\n matched = matched + \\\"-\\\" #not matched bases\\n shift, end_shift = startpoint * \\\".\\\", (l2 + l1 - startpoint - 2) * \\\".\\\"\\n # dots at end, but only up until end of dots tailing l1\\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\\n # this formula. the below check stops it from getting less than l2.\\n if startpoint < l1 - 1:\\n print(shift + matched + end_shift)\\n else:\\n print(shift + matched + (l2 - 1) * \\\".\\\")\\n print(shift + s2 + end_shift)\\n print(s1)\\n print(str(score) + \\\"\\\\n\\\")\\n return score, matched, shift, end_shift\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6674491","0.66676176","0.66379195","0.66306865","0.65985924","0.65764666","0.63913876","0.6372906","0.63459545","0.6281768","0.6273304","0.62707555","0.62299347","0.6229132","0.6220144","0.6207237","0.6142732","0.61302173","0.6130169","0.6127994","0.61096865","0.6084136","0.60831654","0.6081698","0.6063249","0.60567236","0.60522145","0.60437626","0.6031068","0.60260016","0.5996972","0.5988405","0.59784126","0.5958649","0.59510684","0.5941975","0.5939048","0.5926002","0.58944106","0.5880797","0.58783364","0.586711","0.586711","0.5860621","0.5852034","0.5851578","0.5846779","0.58451647","0.58432084","0.5806078","0.5802634","0.57967556","0.57953733","0.5794621","0.579283","0.57892495","0.5788028","0.578414","0.5783851","0.578123","0.5779424","0.5775867","0.57544315","0.57539207","0.5750696","0.5747756","0.5738864","0.5735395","0.5718908","0.5714871","0.57072014","0.5703812","0.57014716","0.5701377","0.569961","0.5697665","0.5691933","0.5689038","0.56887734","0.5673421","0.5672502","0.56630695","0.5659559","0.5658926","0.56496364","0.5647913","0.5635917","0.5635583","0.5633575","0.56331605","0.562854","0.5626742","0.56156695","0.5603435","0.55995315","0.55977094","0.5595315","0.559104","0.5590086","0.55842173","0.5582495"],"string":"[\n \"0.6674491\",\n \"0.66676176\",\n \"0.66379195\",\n \"0.66306865\",\n \"0.65985924\",\n \"0.65764666\",\n \"0.63913876\",\n \"0.6372906\",\n \"0.63459545\",\n \"0.6281768\",\n \"0.6273304\",\n \"0.62707555\",\n \"0.62299347\",\n \"0.6229132\",\n \"0.6220144\",\n \"0.6207237\",\n \"0.6142732\",\n \"0.61302173\",\n \"0.6130169\",\n \"0.6127994\",\n \"0.61096865\",\n \"0.6084136\",\n \"0.60831654\",\n \"0.6081698\",\n \"0.6063249\",\n \"0.60567236\",\n \"0.60522145\",\n \"0.60437626\",\n \"0.6031068\",\n \"0.60260016\",\n \"0.5996972\",\n \"0.5988405\",\n \"0.59784126\",\n \"0.5958649\",\n \"0.59510684\",\n \"0.5941975\",\n \"0.5939048\",\n \"0.5926002\",\n \"0.58944106\",\n \"0.5880797\",\n \"0.58783364\",\n \"0.586711\",\n \"0.586711\",\n \"0.5860621\",\n \"0.5852034\",\n \"0.5851578\",\n \"0.5846779\",\n \"0.58451647\",\n \"0.58432084\",\n \"0.5806078\",\n \"0.5802634\",\n \"0.57967556\",\n \"0.57953733\",\n \"0.5794621\",\n \"0.579283\",\n \"0.57892495\",\n \"0.5788028\",\n \"0.578414\",\n \"0.5783851\",\n \"0.578123\",\n \"0.5779424\",\n \"0.5775867\",\n \"0.57544315\",\n \"0.57539207\",\n \"0.5750696\",\n \"0.5747756\",\n \"0.5738864\",\n \"0.5735395\",\n \"0.5718908\",\n \"0.5714871\",\n \"0.57072014\",\n \"0.5703812\",\n \"0.57014716\",\n \"0.5701377\",\n \"0.569961\",\n \"0.5697665\",\n \"0.5691933\",\n \"0.5689038\",\n \"0.56887734\",\n \"0.5673421\",\n \"0.5672502\",\n \"0.56630695\",\n \"0.5659559\",\n \"0.5658926\",\n \"0.56496364\",\n \"0.5647913\",\n \"0.5635917\",\n \"0.5635583\",\n \"0.5633575\",\n \"0.56331605\",\n \"0.562854\",\n \"0.5626742\",\n \"0.56156695\",\n \"0.5603435\",\n \"0.55995315\",\n \"0.55977094\",\n \"0.5595315\",\n \"0.559104\",\n \"0.5590086\",\n \"0.55842173\",\n \"0.5582495\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85171,"cells":{"query":{"kind":"string","value":"ROUGE scores computation between labels and predictions. This is an approximate ROUGE scoring method since we do not glue word pieces or decode the ids and tokenize the output."},"document":{"kind":"string","value":"def rouge_l_fscore(predictions, labels):\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\n tf.float32)\n return rouge_l_f_score, tf.constant(1.0)"},"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 score(self, target_tokens, prediction_tokens):\n result = {}\n\n for rouge_type in self.rouge_types:\n if rouge_type == \"rougeL\":\n # Rouge from longest common subsequences.\n scores = _score_lcs(target_tokens, prediction_tokens)\n elif re.match(r\"rouge[0-9]$\", rouge_type):\n # Rouge from n-grams.\n n = int(rouge_type[5:])\n if n <= 0:\n raise ValueError(\"rougen requires positive n: %s\" % rouge_type)\n target_ngrams = _create_ngrams(target_tokens, n)\n prediction_ngrams = _create_ngrams(prediction_tokens, n)\n scores = _score_ngrams(target_ngrams, prediction_ngrams)\n else:\n raise ValueError(\"Invalid rouge type: %s\" % rouge_type)\n result[rouge_type] = scores\n\n return result","def _detection_scores(inputs, gt_boxes, gt_labels, model):\n model = check_model('model', model, BlackModel)\n boxes_and_confi, pred_labels = model.predict(*inputs)\n det_scores = []\n correct_labels_num = []\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\n iou_thres = 0.5\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\n gt_box_num = gt_box.shape[0]\n score = 0\n box_num = boxes.shape[0]\n correct_label_flag = np.zeros(gt_label.shape)\n for i in range(box_num):\n pred_box = boxes[i]\n max_iou_confi = 0\n for j in range(gt_box_num):\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\n correct_label_flag[j] = 1\n score += max_iou_confi\n det_scores.append(score)\n correct_labels_num.append(np.sum(correct_label_flag))\n return np.array(det_scores), np.array(correct_labels_num)","def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12","def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\n pred_len = sum(map(len, pred))\n target_len = sum(map(len, target))\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\n ngrams: Counter = Counter()\n for sentence in sentences:\n ngrams.update(sentence)\n return ngrams\n pred_tokens_count = _get_token_counts(pred)\n target_tokens_count = _get_token_counts(target)\n hits = 0\n for tgt in target:\n lcs = _union_lcs(pred, tgt)\n for token in lcs:\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\n hits += 1\n pred_tokens_count[token] -= 1\n target_tokens_count[token] -= 1\n return _compute_metrics(hits, pred_len, target_len)","def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\n pred_len, target_len = len(pred), len(target)\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n lcs: int = _lcs(pred, target)\n return _compute_metrics(lcs, pred_len, target_len)","def eval_metrics_for_seqtags(self, predicted_answers):\n total_correct_in_all = 0\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids, include padding ids.\n correct_label_indices = sample['correct_seq_labels']\n # use extend to add all the labels in the seq, include the head padding and tail padding\n label_true.extend(correct_label_indices)\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n label_pred.extend(sample['pred_seq_tags'])\n\n if total_correct_in_all != 0:\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\n title='Confusion matrix when seq labeling, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\n title='Normalized confusion matrix when seq labeling')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def scores(self, y, y_pred):\n\n aucroc = 0.\n precision = 0.\n recall = 0.\n f1 = 0.\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\n label_ratios = np.mean(y, axis=0)\n\n if len(y) > 1:\n y_t = np.transpose(y)\n col_keep = np.ones(len(y_t), dtype=bool)\n for i, col_y in enumerate(y_t):\n if 0 not in col_y or 1 not in col_y:\n col_keep[i] = False\n\n if sum(col_keep) > 0:\n if not col_keep.all():\n y = np.transpose(y_t[col_keep])\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\n\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\n s = f1_score(y, self._round(y_pred), average=None)\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\n if sum(col_keep) > 1:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\n else:\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\n elif self.verbose:\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n elif len(y) == 1:\n if self.verbose:\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\n precision_labs = precision_score(y, self._round(y_pred), average=None)\n\n result = {\n 'aucroc': aucroc,\n 'precision': precision,\n 'recall': recall,\n 'f1': f1,\n 'aucroc_labs': aucroc_labs,\n 'precision_labs': precision_labs,\n 'recall_labs': recall_labs,\n 'f1_labs': f1_labs,\n 'label_ratios': label_ratios\n }\n\n return result","def prediction_processing(predictions, labels, threshold, step_nb):\n new_labels = []\n new_predictions = []\n number_sequences = step_nb//50\n\n for k in range(len(labels)//number_sequences):\n total_prediction = 0\n isLabelTrue = labels[number_sequences*k]\n for i in range(number_sequences):\n total_prediction += (1/predictions[number_sequences*k+i])\n if not(isLabelTrue == (labels[number_sequences*k+i])):\n logger.error('Problem.')\n if total_prediction > threshold:\n total_prediction = False\n else:\n total_prediction = True\n new_labels.append(isLabelTrue)\n new_predictions.append(total_prediction)\n\n recall_1 = recall_score(new_labels, new_predictions)\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\n precision_1 = precision_score(new_labels, new_predictions)\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)","def evaluate(prediction_folder, label_folder, verbose=False):\n prediction_tasks = next(os.walk(prediction_folder))[1]\n label_tasks = next(os.walk(label_folder))[1]\n # prediction_tasks = label_tasks = ['mlqa', 'tydiqa', 'xquad']\n\n detailed_scores = {}\n for task, langs in TASK2LANGS.items():\n if task in prediction_tasks and task in label_tasks:\n suffix = \"json\" if task in GROUP2TASK[\"qa\"] else \"tsv\"\n # collect scores over all languages\n score = defaultdict(dict)\n for lg in langs:\n prediction_file = os.path.join(prediction_folder, task, f\"test-{lg}.{suffix}\")\n label_file = os.path.join(label_folder, task, f\"test-{lg}.{suffix}\")\n score_lg = evaluate_one_task(prediction_file, label_file, task, language=lg)\n for metric in score_lg:\n score[metric][lg] = score_lg[metric]\n # average over all languages\n avg_score = {}\n for m in score:\n avg_score[f'avg_{m}'] = sum(score[m].values()) / len(score[m])\n score.update(avg_score)\n if task in GROUP2TASK[\"qa\"]:\n score['avg_metric'] = (score['avg_exact_match'] + score['avg_f1']) / 2\n elif 'avg_f1' in score:\n score['avg_metric'] = score['avg_f1']\n elif 'avg_accuracy' in score:\n score['avg_metric'] = score['avg_accuracy']\n detailed_scores[task] = score\n if verbose:\n avg_result = ', '.join(['{}={:.1f}'.format(k, v) for k, v in score.items() if k.startswith('avg')])\n print('- Evaluate {}:\\t{}'.format(task, avg_result))\n\n # Display logic:\n overall_scores = {}\n all_tasks = set(TASK2LANGS.keys())\n available_tasks = set(detailed_scores.keys())\n\n # If scores of all tasks are available, show the overall score in the main table\n if all_tasks == available_tasks:\n overall_scores['all_task'] = sum(detailed_scores[task]['avg_metric'] for task in all_tasks) / len(all_tasks)\n\n # If scores of all tasks in a sub group are available, show the score in the sub table\n for group, group_tasks in GROUP2TASK.items():\n if len(set(group_tasks) - available_tasks) == 0:\n overall_scores[group] = sum(detailed_scores[task]['avg_metric'] for task in group_tasks) / len(group_tasks)\n\n return overall_scores, detailed_scores","def compute_score(predictions, references, vocab=None, beam_size=4):\n assert np.rank(predictions) == 3\n assert predictions.shape[0] == references.shape[0]\n batch_size = predictions.shape[0]\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\n hypotheses_list = []\n references_list = []\n\n for index in range(batch_size):\n # All predictions in beam search are used for validation scores.\n for b_index in range(beam_size):\n h = predictions[index][b_index]\n try:\n eos_index = h.index(input_utils.EOS)\n except ValueError:\n eos_index = len(h)\n hypotheses_list.append(h[:eos_index])\n\n ref = references[index][0].decode().split('|')\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\n references_list.append(ref_list)\n\n all_scores = collections.defaultdict(list)\n for hypothesis, references in zip(hypotheses_list, references_list):\n if vocab is not None and len(vocab):\n # Skip PADDING, UNK, EOS, START (0-3).\n hypothesis = [\n vocab[word_id].numpy().decode()\n for word_id in hypothesis\n if word_id > 3\n ]\n\n h_str = ' '.join(str(e) for e in hypothesis)\n r_str = [' '.join(str(e) for e in ref) for ref in references]\n\n print('hypothesis: ', str(h_str))\n print('references: ', str(r_str))\n print('\\n')\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\n for key, score in scores.items():\n all_scores[key].append(score)\n score_names = [\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\n ]\n\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]","def evaluate(predictions, documents):\n ###TODO\n x = 0.0\n y = 0 #true ham, classified spam\n z = 0 #true spam, classified ham\n \n for i in range(0,len(predictions)):\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\n z += 1\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\n y += 1 \n \n x = (len(documents) - (y+z)) / len(documents) \n return (x,y,z)\n pass","def PredictReviewScore(self, sentences, label=0):\n AdjR = 0.0\n # if text.startswith(\"For more photos and reviews do check out fourleggedfoodies\"):\n # x = 1\n adjAll = []\n for sentence in sentences:\n adjectives, dependencies = self.ExtractSentDetails(sentence)\n adjAll.extend(adjectives)\n allAdjectives = adjectives | Angel.GlobalAdjList\n AdjS = 0.0\n words = wordpunct_tokenize(sentence[\"Text\"])\n if len(words) <= 3:\n allAdjectives |= set([x.lower() for x in words])\n for i in range(len(words)):\n word = words[i].lower()\n if word in {\"but\", \"if\"}:\n AdjS = 0.0\n elif word in allAdjectives and word in self.lexicon:\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\n AdjR += AdjS\n AdjR *= self.PredictBase(adjAll)\n finalScore = AdjR\n if self.DumpRequested(finalScore, label):\n self.DumpDetails(sentences, label)\n return finalScore","def score(self, predictions):\n return 0.","def run_evaluate_compound(self, data):\n tp = 0\n tn = 0\n fp = 0\n fn = 0\n for words, labels, pos in minbatch_generator(data, self.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\n if not type(labels_pred) == list:\n labels_pred = labels_pred.tolist()\n for i, label_actual in enumerate(labels):\n # we have to now find all aspect terms. That is, merge consecutive B \n # with I's until we get an O or B\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\n for a_term in a_terms_actual:\n # say we have [1,2,3] as our a_term. we have to make sure that our \n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\n a_term_pred = []\n for index in a_term:\n if not label_actual[index] == labels_pred[i][index]:\n fn += 1\n break\n else:\n tp += 1\n for index in non_a_terms_actual:\n if label_actual[index] == labels_pred[i][index]:\n tn += 1\n else:\n fp += 1\n\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\n metrics = dict()\n metrics[\"p_1\"] = precision\n metrics[\"f_1\"] = fscore\n metrics[\"r_1\"] = recall\n return metrics","def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n ngram_counter_clip = preds_counter & target_counter\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n return preds_len, target_len","def score(self, phrases):\n pred = self.predict(phrases)\n return accuracy_score(preprocessor.getLabels(phrases), pred)","def evaluate(groundtruth, prediction, tiou_threshold=0.5):\n\n video_num = len(groundtruth)\n print('Computing grounding accuracy over {} videos...'.format(video_num))\n acc, acc_sub, acc_obj = 0.0, 0.0, 0.0\n\n gt_rnum = 0\n for qid, relation_gt in groundtruth.items():\n\n if qid not in prediction:\n continue\n relation_pred = prediction[qid]\n if len(relation_pred) == 0:\n continue\n\n video_acc, video_acc_sub, video_acc_obj, relation_num = eval_ground_scores(relation_gt, relation_pred, tiou_threshold)\n\n acc += video_acc\n acc_sub += video_acc_sub\n acc_obj += video_acc_obj\n gt_rnum += relation_num\n\n\n acc /= video_num\n acc_sub /= video_num\n acc_obj /= video_num\n\n print(\"Acc_S\\t Acc_O\\t Acc_R\")\n\n print('{:.2f}\\t {:.2f}\\t {:.2f}'.format(acc_sub*100, acc_obj*100, acc*100))","def compute_scores(self):\n if self.num_classes == 2:\n score_1 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold=0.5,\n )[1]\n\n score_2 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold_ratio=0.5,\n )[1]\n\n score_3 = self.competition_metric(\n impact_threshold=0.5,\n )[1]\n else:\n score_1 = self.detection_metric(threshold=0.1)\n score_2 = self.detection_metric(threshold=0.25)\n score_3 = self.detection_metric(threshold=0.5)\n\n return score_1, score_2, score_3","def labels_to_scores(labels):\n device = sp.get_device(labels)\n xp = device.xp\n with device:\n num_classes = labels.max() + 1\n scores = xp.zeros([len(labels), num_classes], dtype=np.float32)\n scores[xp.arange(len(labels)), labels] = 1\n\n return scores","def evaluate(labels, predictions):\n pos = 0\n neg = 0\n true_pos_rate = 0\n true_neg_rate = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n pos += 1\n else:\n neg += 1\n if predictions[i] == labels[i]:\n if predictions[i] == 1:\n true_pos_rate += 1\n else:\n true_neg_rate += 1\n \n sensitivity = true_pos_rate / pos\n specificity = true_neg_rate / neg\n\n return (sensitivity, specificity)","def evaluate(ground_truth, prediction):\n\n def prfs_to_dict(prfs):\n \"\"\"Returns a precision_recall_fscore_support() result as a dict.\"\"\"\n return {\"precision\": prfs[0], \"recall\": prfs[1], \"fscore\": prfs[2]}\n\n results = {}\n items_count = len(ground_truth)\n\n # accuracy\n accuracy = accuracy_score(ground_truth, prediction)\n results[\"accuracy\"] = accuracy\n\n # confusion matrix\n categories = set(ground_truth) | set(prediction)\n confusions = {\n gold: {pred: 0 for pred in categories} for gold in categories\n }\n for g, p in zip(ground_truth, prediction):\n confusions[g][p] += 1\n results[\"confusions\"] = confusions\n\n # class wise precision, recall & f1\n classwise = precision_recall_fscore_support(\n ground_truth, prediction, average=None, warn_for=()\n )\n results[\"true_cat_dist\"] = list(classwise[-1])\n results[\"classwise\"] = {\n str(cl): prfs_to_dict(\n [classwise[0][cl], classwise[1][cl], classwise[2][cl]]\n )\n for cl in categories\n }\n\n # average precision, recall & f1\n results[\"macro_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"macro\",\n pos_label=None,\n warn_for=(),\n )\n )\n results[\"micro_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"micro\",\n pos_label=None,\n warn_for=(),\n )\n )\n results[\"weigh_avg\"] = prfs_to_dict(\n precision_recall_fscore_support(\n ground_truth,\n prediction,\n average=\"weighted\",\n pos_label=None,\n warn_for=(),\n )\n )\n\n # marginals\n gold_category_distribution = {\n g: sum([confusions[g][p] for p in categories]) for g in categories\n }\n pred_category_distribution = {\n p: sum([confusions[g][p] for g in categories]) for p in categories\n }\n\n # kappa\n expected_agreement_fleiss = sum(\n [\n (\n (gold_category_distribution[c] + pred_category_distribution[c])\n / (2.0 * items_count)\n )\n ** 2\n for c in categories\n ]\n )\n expected_agreement_cohen = sum(\n [\n (float(gold_category_distribution[c]) / items_count)\n * (float(pred_category_distribution[c]) / items_count)\n for c in categories\n ]\n )\n kappa_fleiss = (\n 1.0\n * (accuracy - expected_agreement_fleiss)\n / (1 - expected_agreement_fleiss)\n )\n kappa_cohen = (\n 1.0\n * (accuracy - expected_agreement_cohen)\n / (1 - expected_agreement_cohen)\n )\n results[\"k_fleiss\"] = {\n \"k\": kappa_fleiss,\n \"AE\": expected_agreement_fleiss,\n \"AO\": accuracy,\n }\n results[\"k_cohen\"] = {\n \"k\": kappa_cohen,\n \"AE\": expected_agreement_cohen,\n \"AO\": accuracy,\n }\n\n return results","def score(self, X_test: List[str], y_test: List[str]) -> int:\n predictions_count = 0\n right_predictions_count = 0\n\n for i in range(len(X_test)):\n label = self.predict(X_test[i].split())\n predictions_count += 1\n right_predictions_count += 1 if label == y_test[i] else 0\n\n return right_predictions_count / predictions_count","def ocr_metrics(predicts, ground_truth):\n\n if len(predicts) == 0 or len(ground_truth) == 0:\n return (1, 1, 1)\n\n cer, wer, ser = [], [], []\n\n for (pd, gt) in zip(predicts, ground_truth):\n pd_cer, gt_cer = list(pd), list(gt)\n dist = editdistance.eval(pd_cer, gt_cer)\n cer.append(dist / (max(len(pd_cer), len(gt_cer))))\n\n pd_wer, gt_wer = pd.split('|'), gt.split('|')\n dist = editdistance.eval(pd_wer, gt_wer)\n wer.append(dist / (max(len(pd_wer), len(gt_wer))))\n\n # pd_ser, gt_ser = [pd], [gt]\n # dist = editdistance.eval(pd_ser, gt_ser)\n # ser.append(dist / (max(len(pd_ser), len(gt_ser))))\n\n metrics = [wer, cer]#, ser]\n metrics = np.mean(metrics, axis=1)\n\n return metrics","def eval_metrics_for_multiclass(self, predicted_answers):\n total_correct_in_all = 0\n total_pred_in_all = len(predicted_answers)\n # initial a dict for total correct in topK counting.\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\n max_topK = max(self.topK_list)\n label_pred = []\n label_true = []\n label_weights = []\n digits = 3\n metrics = {}\n\n for e_id, sample in predicted_answers.iteritems():\n # get all correct ids\n correct_label_indices = sample['correct_labels']\n # current case, we only have a majority lable for the correct label\n label_true.append(correct_label_indices[0])\n # counting all correct for each sample\n total_correct_in_all += len(correct_label_indices)\n # select topK\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\n top1_pred = sorted_probs_max_topK[0]\n label_pred.append(top1_pred['label_index'])\n\n # for all topK predictions\n for i in range(len(sorted_probs_max_topK)):\n pred = sorted_probs_max_topK[i]\n for topK in self.topK_list:\n if i >= topK:\n continue\n else:\n total_pred_in_topK[topK] += 1\n if pred['label_index'] in correct_label_indices:\n total_correct_in_topK[topK] += 1\n\n if total_correct_in_all != 0:\n # recall@K\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\n # assign recall@K into metrics\n for k, v in recall_at_K.items():\n # Jie\n # 1 means the greater the better.\n # -1 means the smaller the better.\n metrics['R@{}'.format(k)] = (1, v)\n\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\n # here return all the p,r,f for each label, then we compute the micro average later.\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\n total_s = np.sum(s)\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\n target_names = self.classes\n name_width = max(len(cn) for cn in target_names)\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\n\n headers = [\"precision\", \"recall\", \"f1-score\", \"support\"]\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\n report = head_fmt.format(u'', *headers, width=width)\n report += u'\\n\\n'\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\n'\n rows = zip(target_names, p, r, f1, s)\n for row in rows:\n label_weights.append(row[4])\n report += row_fmt.format(*row, width=width, digits=digits)\n metrics['P_{}'.format(row[0])] = (1, row[1])\n metrics['R_{}'.format(row[0])] = (1, row[2])\n metrics['F1_{}'.format(row[0])] = (1, row[3])\n report += u'\\n'\n\n # compute macro averages\n p_macro = np.average(p, weights = None)\n r_macro = np.average(r, weights = None)\n f1_macro = np.average(f1, weights = None)\n metrics['P_{}'.format(\"macro\")] = (1, p_macro)\n metrics['R_{}'.format(\"macro\")] = (1, r_macro)\n metrics['F1_{}'.format(\"macro\")] = (1, f1_macro)\n report += row_fmt.format(last_lines_heading[0],\n p_macro,\n r_macro,\n f1_macro,\n total_s,\n width=width, digits=digits)\n\n # compute weighted macro average\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\n p_weighted_average = np.average(p, weights = label_weights)\n r_weighted_average = np.average(r, weights = label_weights)\n f1_weighted_average = np.average(f1, weights = label_weights)\n metrics['P_{}'.format(\"weighted_macro\")] = (1, p_weighted_average)\n metrics['R_{}'.format(\"weighted_macro\")] = (1, r_weighted_average)\n metrics['F1_{}'.format(\"weighted_macro\")] = (1, f1_weighted_average)\n report += row_fmt.format(last_lines_heading[1],\n p_weighted_average,\n r_weighted_average,\n f1_weighted_average,\n total_s,\n width=width, digits=digits)\n # micro average\n metrics['P_{}'.format(\"micro\")] = (1, p_micro)\n metrics['R_{}'.format(\"micro\")] = (1, r_micro)\n metrics['F1_{}'.format(\"micro\")] = (1, f1_micro)\n report += row_fmt.format(last_lines_heading[2],\n p_micro,\n r_micro,\n f1_micro,\n total_s,\n width=width, digits=digits)\n\n self.logger.info(\"P,R,F1 report as follows:\\n {}\".format(report))\n # only plot it at dev and test time, not during training.\n if self.gen_confusing_matrix:\n\n self.logger.info(\"Generate confusing matrix photo.\")\n # Compute confusion matrix\n conf_matrix = confusion_matrix(label_true, label_pred)\n np.set_printoptions(precision=2)\n\n # Plot non-normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\n title='Confusion matrix, without normalization')\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\n plt.savefig(wo_norm_fig_path)\n\n # Plot normalized confusion matrix\n plt.figure()\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\n title='Normalized confusion matrix')\n\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\n plt.savefig(norm_fig_path)\n\n else:\n self.logger.warn('invalid total_correct_in_all')\n\n return metrics","def evaluate(self, predicted_df):\n logging.info(\"Evaluating model: {}\".format(self.model_type))\n y_true = predicted_df[\"user_label\"].as_matrix()\n y_pred = predicted_df[\"label\"].as_matrix()\n\n scores_cols = [col for col in predicted_df.columns if col.startswith(\"scores_\")]\n print(\"scores_cols: {}\".format(scores_cols))\n\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\n print(\"predicted scores: {}\".format(y_pred_scores))\n y_true_scores = []\n for lab in predicted_df[\"user_label\"]:\n trues = [0 for _ in range(len(scores_cols))]\n if \"scores_\"+lab in scores_cols:\n trues[scores_cols.index(\"scores_\"+lab)] = 1\n y_true_scores.append(trues)\n print(\"true scores: {}\".format(y_true_scores))\n y_true_scores = np.array(y_true_scores)\n\n performance = {\"model\": self.model_type, \"description\": self.description}\n if 'categorical_accuracy' in self.metrics:\n logging.info(\"Calculating categorical accuracy for {}\".format(self))\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\n y_pred) # np.mean(y_pred == y_true)\n if 'fmeasure' in self.metrics:\n logging.info(\"Calculating fmeasure for {}\".format(self))\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\n if 'MRR' in self.metrics:\n logging.info(\"Calculating MRR for {}\".format(self))\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\n logging.info(\"Calculated performance: {}\".format(performance))\n print(performance)\n return pd.DataFrame(performance, index=[0])","def _compute_scores(y_pred, y_true):\n auc = accuracy_score(y_true = y_true, y_pred = y_pred)\n pre = precision_score(y_true, y_pred, average = \"macro\")\n rec = recall_score(y_true, y_pred, average = \"macro\")\n f1 = f1_score(y_true, y_pred, average = \"macro\")\n\n return pd.Series(data = [auc, pre, rec, f1], index = ['acc', 'pre', 'rec', 'f1'])","def evaluate(labels, predictions):\n #labels and predictions\n truePos = 0\n trueNeg = 0\n for data in range(len(labels)):\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\n truePos+=1\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\n trueNeg+=1\n sensitivity = truePos/(len(labels) + 1)\n specificity = trueNeg/(len(labels) + 1)\n return (sensitivity, specificity)\n \n\n #raise NotImplementedError","def evaluate(labels, predictions):\n actual_positive = 0\n actual_negative = 0\n predicted_positive = 0\n predicted_negative = 0\n for i, j in zip(labels, predictions):\n if i == 1:\n actual_positive += i\n predicted_positive += j\n else:\n actual_negative += 1\n if j == 0:\n predicted_negative += 1\n return predicted_positive/actual_positive, predicted_negative/actual_negative","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def _compute_scores(self, triples):\n # compute scores as sum(s * p * o)\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\n return scores","def classify(self, documents):\n predictions = []\n for doc in documents:\n\n score_sod = math.log(self.priorSOD)\n score_pop = math.log(self.priorPOP)\n for term in doc.tokens:\n if term in self.cond_prob_sod.keys():\n score_sod += math.log(self.cond_prob_sod[term])\n if term in self.cond_prob_pop.keys():\n score_pop += math.log(self.cond_prob_pop[term])\n if(score_pop >= score_sod): #defaults to ham if score = even \n predictions.append('pop')\n else:\n predictions.append('sod')\n \n return predictions \n pass","def calc_metrics(pred, labels):\n pred_flat = np.argmax(pred, axis = 1).flatten()\n labels_flat = labels.flatten()\n \n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\n \n # sklearn takes first parameter as the true label\n precision = precision_score(labels_flat, pred_flat)\n recall = recall_score(labels_flat, pred_flat)\n \n return flat_accuracy, precision, recall","def evaluate(predictions, ids, label_identifiers):\n\n labels = []\n #For every prediction\n for i in range(len(predictions)):\n sentence_predictions = predictions[i]\n id_sequence = ids[i]\n sequence_labels = []\n counter = 0\n #For every predicted token\n for j in range(len(id_sequence)):\n word_prediction = sentence_predictions[j]\n id = id_sequence[j]\n #Take only the lemmas that have to be disambiguated\n if not id == '0':\n #Extract the identifiers of the sensekeys associated to the lemma\n indexes = label_identifiers[i][counter]\n new_predictions = []\n #Check if the identifier is a number \n for elem in indexes:\n try:\n index = int(elem)\n new_predictions.append(predictions[i][j][index])\n except ValueError:\n #If is not, MFS was applied\n new_predictions.append(elem)\n #Do the argmax on the extracted prediction indexes\n argmax = np.argmax(new_predictions)\n label = label_identifiers[i][counter][argmax]\n sequence_labels.append(label)\n counter += 1\n labels.append(sequence_labels)\n\n return labels","def _rouge_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], rouge_keys_values: List[Union[int, str]], accumulate: str, stemmer: Optional[Any]=None, normalizer: Callable[[str], str]=None, tokenizer: Callable[[str], Sequence[str]]=None) ->Dict[Union[int, str], List[Dict[str, Tensor]]]:\n results: Dict[Union[int, str], List[Dict[str, Tensor]]] = {rouge_key: [] for rouge_key in rouge_keys_values}\n for pred_raw, target_raw in zip(preds, target):\n result_inner: Dict[Union[int, str], Dict[str, Tensor]] = {rouge_key: {} for rouge_key in rouge_keys_values}\n result_avg: Dict[Union[int, str], List[Dict[str, Tensor]]] = {rouge_key: [] for rouge_key in rouge_keys_values}\n list_results = []\n pred = _normalize_and_tokenize_text(pred_raw, stemmer, normalizer, tokenizer)\n if 'Lsum' in rouge_keys_values:\n pred_lsum = [_normalize_and_tokenize_text(pred_sentence, stemmer, normalizer, tokenizer) for pred_sentence in _split_sentence(pred_raw)]\n for target_raw_inner in target_raw:\n tgt = _normalize_and_tokenize_text(target_raw_inner, stemmer, normalizer, tokenizer)\n if 'Lsum' in rouge_keys_values:\n target_lsum = [_normalize_and_tokenize_text(tgt_sentence, stemmer, normalizer, tokenizer) for tgt_sentence in _split_sentence(target_raw_inner)]\n for rouge_key in rouge_keys_values:\n if isinstance(rouge_key, int):\n score = _rouge_n_score(pred, tgt, rouge_key)\n elif rouge_key == 'L':\n score = _rouge_l_score(pred, tgt)\n elif rouge_key == 'Lsum':\n score = _rouge_lsum_score(pred_lsum, target_lsum)\n result_inner[rouge_key] = score\n result_avg[rouge_key].append(score)\n list_results.append(result_inner.copy())\n if accumulate == 'best':\n key_curr = rouge_keys_values[0]\n all_fmeasure = torch.tensor([v[key_curr]['fmeasure'] for v in list_results])\n highest_idx = int(torch.argmax(all_fmeasure).item())\n for rouge_key in rouge_keys_values:\n results[rouge_key].append(list_results[highest_idx][rouge_key])\n elif accumulate == 'avg':\n new_result_avg: Dict[Union[int, str], Dict[str, Tensor]] = {rouge_key: {} for rouge_key in rouge_keys_values}\n for rouge_key, metrics in result_avg.items():\n _dict_metric_score_batch: Dict[str, List[Tensor]] = {}\n for metric in metrics:\n for _type, value in metric.items():\n if _type not in _dict_metric_score_batch:\n _dict_metric_score_batch[_type] = []\n _dict_metric_score_batch[_type].append(value)\n new_result_avg[rouge_key] = {_type: torch.tensor(_dict_metric_score_batch[_type]).mean() for _type in _dict_metric_score_batch}\n for rouge_key in rouge_keys_values:\n results[rouge_key].append(new_result_avg[rouge_key])\n return results","def score(self, data):\n\n score_mappings = {\n \"0\": np.log(self.class_zero_doc_count / self.total_docs),\n \"1\": np.log(self.class_one_doc_count / self.total_docs)\n }\n\n features = self.featurize(data)\n\n for f in features:\n\n if(f[0] in self.class_zero):\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\n else:\n cond_prob_zero = 0\n\n if(f[0] in self.class_one):\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\n elif(f[0] in self.vocab):\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\n else:\n cond_prob_one = 0\n\n score_mappings[\"0\"] += cond_prob_zero\n score_mappings[\"1\"] += cond_prob_one\n\n score_mappings[\"0\"] = np.exp(score_mappings[\"0\"])\n score_mappings[\"1\"] = np.exp(score_mappings[\"1\"])\n\n return score_mappings","def evaluate(labels, predictions):\n\n truePositiveCounter = 0\n trueNegativeCounter = 0\n truePositiveCorrect = 0\n trueNegativeCorrect = 0\n \n sensitivity = 0\n specificity = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n truePositiveCounter += 1\n if(labels[i] == predictions[i]):\n truePositiveCorrect += 1\n elif labels[i] == 0:\n trueNegativeCounter += 1\n if(labels[i] == predictions[i]):\n trueNegativeCorrect += 1\n\n sensitivity = truePositiveCorrect / truePositiveCounter\n specificity = trueNegativeCorrect / trueNegativeCounter\n\n return sensitivity, specificity","def evaluate(gold, predictions):\n # gold = {i[\"id\"]:i[\"label\"] for i in read(goldfile)}\n # sys = {i[\"id\"]:i[\"prediction\"] for i in read(sysfile)}\n\n labels, preds = [], []\n for idx in gold:\n labels.append(gold[idx])\n preds.append(predictions[idx])\n\n precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support(labels, preds, labels=[0, 1],\n average=\"macro\")\n print(\"F1-macro score for test data predictions are: %.4f\" % f1_macro)\n return preds","def recall(gold_labels, predicted_labels):\n \n true_pos = 0 #gold pos sys pos\n false_neg = 0 #gold pos sys neg\n\n for i in range(0, len(gold_labels)):\n if(gold_labels[i] == predicted_labels[i] == \"1\"):\n true_pos += 1\n elif(gold_labels[i] == \"1\" and predicted_labels[i] == \"0\"):\n false_neg += 1\n\n if(true_pos == 0):\n return 0\n else:\n return float(true_pos / (true_pos + false_neg))","def evaluate(y_true, y_preds, labels=[0, 1, 2, 3, 4]):\n p_scores = []\n r_scroes = []\n for label in labels:\n p = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_preds == label).sum() + 0.001)\n p_scores.append(p)\n r = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_true == label).sum() + 0.001)\n r_scroes.append(r)\n p_scores = np.array(p_scores)\n r_scroes = np.array(r_scroes)\n f1 = 2 * (p_scores * r_scroes + 0.001) / (p_scores + r_scroes + 0.001)\n\n confmat = []\n for label in labels:\n conf = []\n for label2 in labels:\n conf.append(((y_preds == label) * (y_true == label2)).sum())\n confmat.append(conf)\n confmat = np.array(confmat)\n\n return p_scores, r_scroes, f1, confmat","def cal_err(label_scores, predicted_scores, top_k_int=1, use_predicted_order=False):\n \n if not use_predicted_order:\n max_label_score = tf.reduce_max(label_scores)\n sorted_labels, predicted_order, sorted_predictions = _get_ranking_orders(\n label_scores, predicted_scores, top_k_int=top_k_int)\n else:\n indices = tf.range(top_k_int)\n predicted_order = tf.gather(predicted_scores, indices)\n max_label_score = tf.reduce_max(label_scores)\n\n predicted_relevance = _get_relevance_scores(predicted_order)\n predicted_relevance_ratio = predicted_relevance / (2**max_label_score)\n _ratio = 1- predicted_relevance_ratio\n prob_stepdown = tf.cumprod(_ratio, exclusive=True)\n cur_rank = tf.range(top_k_int) + 1\n cur_rank = tf.cast(cur_rank, dtype=tf.float32)\n cur_rank = tf.reshape(cur_rank, [-1, 1])\n products = tf.multiply(predicted_relevance_ratio, prob_stepdown)\n products = tf.cast(products, dtype=tf.float32)\n errs = tf.divide(products, cur_rank)\n err = tf.reduce_sum(errs)\n return err","def evaluate(labels, predictions):\n\n true_positives = 0\n label_positives = 0\n\n true_negatives = 0\n label_negatives = 0\n\n for i in range(len(predictions)):\n if labels[i] == predictions[i] == 1:\n true_positives += 1\n if labels[i] == 1:\n label_positives += 1\n\n if labels[i] == predictions[i] == 0:\n true_negatives += 1\n if labels[i] == 0:\n label_negatives += 1\n\n return true_positives / label_positives, true_negatives / label_negatives\n\n # raise NotImplementedError","def score(self, test_data):\n\n\t\tins, outs = self._split_inputs_outputs(test_data)\n\n\t\t# One hot encode the input/labels\n\t\tencoder = LabelEncoder()\n\t\tencoder.fit(outs)\n\t\tenc_labels = encoder.transform(outs)\n\t\tenc_labels = np_utils.to_categorical(enc_labels)\n\n\t\t_, score = self.model.evaluate(ins, enc_labels, verbose=2)\n\n\t\treturn score","def evaluate(labels, predictions):\n correct_positive = 0\n correct_negative = 0\n total_positive = 0\n total_negative = 0\n\n for i in range(len(labels)):\n if labels[i] == 1:\n total_positive += 1\n if predictions[i] == 1:\n correct_positive += 1\n else:\n total_negative += 1\n if predictions[i] == 0:\n correct_negative += 1\n\n sensitivity = correct_positive / total_positive\n specificity = correct_negative / total_negative\n\n return sensitivity, specificity","def evaluate(model, df_result, label='test'):\n\n y_true = df_result['RUL']\n y_hat = df_result['y_hat']\n df_result['breakdown'].replace(0, False, inplace=True) # rsf only takes true or false\n df_result['breakdown'].replace(1, True, inplace=True) # rsf only takes true or false\n\n mse = mean_squared_error(y_true, y_hat)\n rmse = np.sqrt(mse)\n variance = r2_score(y_true, y_hat)\n\n # the concordance index (CI) is interested on the order of the predictions, not the predictions themselves\n # CI can only be measured between individual samples where a censoring or failure event occurred\n # https://medium.com/analytics-vidhya/concordance-index-72298c11eac7#:~:text=The%20concordance%20index%20or%20c,this%20definition%20mean%20in%20practice\n df_result_grouped = df_result.groupby('unit num').last()\n breakdown = df_result_grouped['breakdown']\n y_true = df_result_grouped['RUL']\n y_hat = df_result_grouped['y_hat']\n ci_sk = ci_scikit(breakdown, y_true, y_hat)[0]\n score = nasaScore(y_true, y_hat) # score should be based on the last instance\n # print(f'Number of concordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[1]}')\n # print(f'Number of discordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[2]}')\n # print(f'Number of pairs having tied estimated risks (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[3]}')\n # print(f'Number of comparable pairs sharing the same time (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[4]}')\n print('{} set RMSE:{:.2f}, Score:{:.2f}, CI(scikit):{:.4f}, R2:{:.2f}'.format(label, rmse, score, ci_sk, variance))\n result = [model, label, rmse, score, ci_sk, variance]\n return result","def score(self, X, y):\n predictions = self.predict(X)\n total_values = len(y)\n accuracy = 0\n if 'classification' == self.label_type:\n correct_values = np.where(predictions == y)\n accuracy = correct_values[0].size / total_values\n elif 'regression' == self.label_type:\n sse = (y - predictions) ** 2\n sse_summed = np.sum(sse)\n accuracy = sse_summed / total_values\n\n return accuracy","def _eval_classifier(self):\n\n y_pred_baseline = self.df_baseline[self.score_column]\n y_pred_sample = self.df_sample[self.score_column]\n\n y_label_baseline = self.df_baseline[self.label_column]\n y_label_sample = self.df_sample[self.label_column]\n\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\n try:\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\n except ValueError:\n auc_baseline = \"NA\"\n\n precision_sample = precision_score(y_label_sample, y_pred_sample)\n recall_sample = recall_score(y_label_sample, y_pred_sample)\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\n f1_sample = f1_score(y_label_sample, y_pred_sample)\n try:\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\n except ValueError:\n auc_sample = \"NA\"\n\n metrics_df = pd.DataFrame(\n {\n \"Accuracy\": [acc_baseline, acc_sample],\n \"Precision\": [precision_baseline, precision_sample],\n \"Recall\": [recall_baseline, recall_sample],\n \"F1\": [f1_baseline, f1_sample],\n \"AUC\": [auc_baseline, auc_sample],\n },\n index=[\"baseline\", \"sample\"],\n )\n\n self.performance_comparison = metrics_df","def label_accuracy_score(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n # 一个batch里面可能有多个数据\n # 通过迭代器将一个个数据进行计算\n for lt, lp in zip(label_trues, label_preds):\n # numpy.ndarray.flatten将numpy对象拉成1维\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\n \"\"\"\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\n iu是召回率Recall，公式上面给出了\n mean_iu就是对iu求了一个平均\n freq是每一类被预测到的频率\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\n \"\"\"\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n # nanmean会自动忽略nan的元素求平均\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n return acc, acc_cls, mean_iu, fwavacc","def scoring(estimator, features_test, labels_test):\n pred = estimator.predict(features_test)\n p = metrics.precision_score(labels_test, pred, average='micro')\n r = metrics.recall_score(labels_test, pred, average='micro')\n if p > 0.3 and r > 0.3:\n return metrics.f1_score(labels_test, pred, average='macro')\n return 0","def eval(self, test_docs, test_labels):\n assert len(test_docs)==len(test_labels)\n preds = [] # predicted labels\n for doc,y_gold in zip(test_docs,test_labels):\n y_pred = self.predict(doc)\n preds.append(y_pred)\n ev = Eval(test_labels, preds)\n return ev.accuracy()","def score_pred(Y_lab, Y_prob, threshold):\n Y_thresh = Y_prob >= threshold\n\n precision = []\n recall = []\n fbeta_score = []\n support = []\n voe = []\n acc = []\n\n Y_lab = Y_lab.reshape(-1)\n Y_thresh = Y_thresh.reshape(-1)\n\n # Compute precision/recall scores\n scores = precision_recall_fscore_support(y_true=Y_lab, y_pred=Y_thresh)\n precision.append(scores[0][1])\n recall.append(scores[1][1])\n fbeta_score.append(scores[2][1])\n support.append(scores[3][1]/(scores[3][0] + scores[3][1])) # percent of volume occupied by tumor\n voe.append(jaccard_similarity_score(y_true=Y_lab, y_pred=Y_thresh))\n acc.append(accuracy_score(y_true=Y_lab, y_pred=Y_thresh, normalize=True))\n\n return precision, recall, fbeta_score, support, voe, acc","def ranked_accuracy(predictions, labels):\n rank1 = 0\n rank5 = 0\n\n for (pred, lbl) in zip(predictions, labels):\n pred = np.argsort(pred)[::-1]\n\n if lbl in pred[:5]:\n rank5+=1\n\n if lbl == pred[0]:\n rank1+=1\n\n rank1 /= float(len(labels))\n rank5 /= float(len(labels))\n\n return (rank1, rank5)","def _rouge_n_score(pred: Sequence[str], target: Sequence[str], n_gram: int) ->Dict[str, Tensor]:\n\n def _create_ngrams(tokens: Sequence[str], n: int) ->Counter:\n ngrams: Counter = Counter()\n for ngram in (tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)):\n ngrams[ngram] += 1\n return ngrams\n pred_ngrams, target_ngrams = _create_ngrams(pred, n_gram), _create_ngrams(target, n_gram)\n pred_len, target_len = sum(pred_ngrams.values()), sum(target_ngrams.values())\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n hits = sum(min(pred_ngrams[w], target_ngrams[w]) for w in set(pred_ngrams))\n return _compute_metrics(hits, max(pred_len, 1), max(target_len, 1))","def evaluate(model, eval_data, num_labels): \n # Turn on the evaluation state to ignore dropouts\n model.eval()\n results = [predict(model, x) for x, y in eval_data]\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\n return f1_score, accuracy","def _bleu_score_update(\n preds: Sequence[str],\n target: Sequence[Sequence[str]],\n numerator: Tensor,\n denominator: Tensor,\n preds_len: Tensor,\n target_len: Tensor,\n n_gram: int = 4,\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\n) -> Tuple[Tensor, Tensor]:\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\n\n for pred, targets in zip(preds_, target_):\n preds_len += len(pred)\n target_len_list = [len(tgt) for tgt in targets]\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\n preds_counter: Counter = _count_ngram(pred, n_gram)\n target_counter: Counter = Counter()\n\n for tgt in targets:\n target_counter |= _count_ngram(tgt, n_gram)\n\n ngram_counter_clip = preds_counter & target_counter\n\n for counter_clip in ngram_counter_clip:\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\n\n for counter in preds_counter:\n denominator[len(counter) - 1] += preds_counter[counter]\n\n return preds_len, target_len","def _compute_relex_metrics(self,\n batch_predicted_relations,\n batch_doc_raw_relations):\n\n # Evaluation is done on document level.\n for doc_predictions, doc_relations in zip(batch_predicted_relations,\n batch_doc_raw_relations):\n # TODO Change Metrics interface, feed raw sets\n # TODO Decode sentence_predictions as dict, not list of triples\n\n predicted_labels = []\n true_labels = []\n\n keys = set(doc_predictions.keys()) | set(doc_relations.keys())\n for key in keys:\n predicted_labels.append(doc_predictions.get(key, ''))\n true_labels.append(doc_relations.get(key, ''))\n\n self._relex_precision_recall_fscore(predicted_labels, true_labels)","def evaluate_overall(predictions):\n print(\"\\nAccuracy for the the models combined (full prediction):\\n\")\n\n perfect_predictions = [0, 0, 0]\n exact_code_match = [0, 0, 0]\n exact_code_match_ignore_spaces = [0, 0, 0]\n correct_syntax = [0, 0, 0]\n total_predictions = [0, 0, 0]\n num_failed_predictions = 0\n \n for prediction in predictions:\n # Perfect Prediction\n if prediction[\"correct_data\"][\"correct_location\"] == prediction[\"predicted_location\"]:\n # Correct type\n if prediction[\"correct_data\"][\"correct_type\"] == prediction[\"predicted_type\"]:\n # Correct token\n if prediction[\"predicted_type\"] == \"insert\" or prediction[\"predicted_type\"] == \"modify\":\n if \"correct_token\" in prediction[\"correct_data\"] and prediction[\"correct_data\"][\"correct_token\"] == \\\n prediction[\"predicted_token\"]:\n perfect_predictions[FixType[prediction[\"predicted_type\"]].value] = perfect_predictions[FixType[\n prediction[\"predicted_type\"]].value] + 1\n else:\n perfect_predictions[FixType[prediction[\"predicted_type\"]].value] = perfect_predictions[FixType[\n prediction[\"predicted_type\"]].value] + 1\n \n # Exact Code Match\n if prediction[\"predicted_code\"] == prediction[\"correct_data\"][\"correct_code\"]:\n exact_code_match[FixType[prediction[\"predicted_type\"]].value] = exact_code_match[FixType[\n prediction[\"predicted_type\"]].value] + 1\n \n # Exact Code Match (Ignore Spaces)\n if prediction[\"predicted_code\"].replace(\" \", \"\") == prediction[\"correct_data\"][\"correct_code\"].replace(\" \", \"\"):\n exact_code_match_ignore_spaces[FixType[prediction[\"predicted_type\"]].value] = exact_code_match_ignore_spaces[FixType[\n prediction[\"predicted_type\"]].value] + 1\n \n # Correct Syntax Fix\n try:\n cst.parse_module(prediction[\"predicted_code\"])\n correct_syntax[FixType[prediction[\"predicted_type\"]].value] = correct_syntax[FixType[\n prediction[\"predicted_type\"]].value] + 1\n except Exception as e:\n logging.warning(f\"{e.__class__.__name__} occurred: {e}\")\n # Happens if parsing fails\n pass\n \n total_predictions[FixType[prediction[\"predicted_type\"]].value] = total_predictions[FixType[\n prediction[\"predicted_type\"]].value] + 1\n \n # Perfect Prediction\n for i in range(3):\n if total_predictions[i] == 0: # If the type was never predicted\n accuracy = 0\n else:\n accuracy = perfect_predictions[i] / total_predictions[i]\n print(f\"Perfect Prediction for class {FixType(i).name}: {accuracy * 100} %\")\n\n accuracy = sum(perfect_predictions) / (len(predictions) - num_failed_predictions)\n print(f\"Perfect Prediction accuracy overall is {accuracy * 100} %\")\n \n # Exact Code Match\n for i in range(3):\n if total_predictions[i] == 0: # If the type was never predicted\n accuracy = 0\n else:\n accuracy = exact_code_match[i] / total_predictions[i]\n print(f\"Exact Code Match for class {FixType(i).name}: {accuracy * 100} %\")\n\n accuracy = sum(exact_code_match) / (len(predictions) - num_failed_predictions)\n print(f\"Exact Code Match accuracy overall is {accuracy * 100} %\")\n \n # Exact Code Match (Ignore Spaces)\n for i in range(3):\n if total_predictions[i] == 0: # If the type was never predicted\n accuracy = 0\n else:\n accuracy = exact_code_match_ignore_spaces[i] / total_predictions[i]\n print(f\"Exact Code Match (Ignore Spaces) for class {FixType(i).name}: {accuracy * 100} %\")\n\n accuracy = sum(exact_code_match_ignore_spaces) / (len(predictions) - num_failed_predictions)\n print(f\"Exact Code Match (Ignore Spaces) accuracy overall is {accuracy * 100} %\")\n \n # Correct Syntax Fixes\n for i in range(3):\n if total_predictions[i] == 0: # If the type was never predicted\n accuracy = 0\n else:\n accuracy = correct_syntax[i] / total_predictions[i]\n print(f\"Correct Syntax Fixes for class {FixType(i).name}: {accuracy * 100} %\")\n\n accuracy = sum(correct_syntax) / (len(predictions) - num_failed_predictions)\n print(f\"Correct Syntax Fixes accuracy overall is {accuracy * 100} %\")","def _score(metric,\n estimations,\n annotations,\n loudnessesBelow,\n loudnessesAbove):\n\n def accuracy():\n return np.equal(estimations, annotations).mean()\n \n def falsePositiveRate():\n return np.logical_and(\n estimations, np.logical_not(annotations)).mean()\n\n def falseNegativeRate():\n return np.logical_and(\n np.logical_not(estimations), annotations).mean()\n\n def weightedAccuracy():\n # accuracy with greater weight on rarer label\n \n numClassifications = len(annotations)\n numPositives = np.sum(annotations)\n numNegatives = numClassifications - numPositives\n\n if numPositives > 0 and numNegatives > 0:\n scoreVector = np.full(numClassifications, 0.5 / numPositives) \\\n * annotations \\\n + np.full(numClassifications, 0.5 / numNegatives) \\\n * np.logical_not(annotations)\n return np.sum(np.equal(estimations, annotations) * scoreVector)\n \n return accuracy()\n \n if metric == \"accuracy\":\n return accuracy()\n if metric == \"falsePositiveRate\":\n return 1 - falsePositiveRate()\n if metric == \"falseNegativeRate\":\n return 1 - falseNegativeRate()\n if metric == \"weightedAccuracy\":\n return weightedAccuracy()\n raise RuntimeError(\"Unknown measure: {}\".format(metric))","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n print('*'*20, '\\n')\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\n')\n print('*'*20)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def validate(self, validate_data):\n with open(validate_data, 'r') as validate_data:\n true_positive = 0\n true_negative = 0\n false_positive = 0\n false_negative = 0\n result = {}\n for type in self.label_type_map:\n result[type] = []\n while True:\n tokens = validate_data.readline().split()\n pos = validate_data.readline().split()\n labels = validate_data.readline().split()\n if not tokens or not pos or not labels:\n break\n # Classify all named entities in a sentence 85\n curr_results = self.viterbi(tokens)\n for i in range(0, len(labels)):\n if curr_results[i] != 'O':\n if labels[i] == 'O':\n false_positive += 1 # Not 'O', but should be 'O'\n else:\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\n true_positive += 1 # Correct prediction\n else:\n if labels[i] == 'O':\n true_negative += 1 # Correct prediction of 'O'\n else:\n false_negative += 1 # Predicted 'O', not 'O'\n # Calculate precision - TP / (TP + FP)\n precision = float(true_positive) / float(true_positive + false_positive)\n # Calculate recall - TP / (TP + FN)\n recall = float(true_positive) / float(true_positive + false_negative)\n # Calculate F-Score - 2 * P * R / (P + R)\n f_score = float(2*precision * recall) / float(precision + recall)\n print \"Precision: \" + str(precision)\n print \"Recall: \" + str(recall)\n print \"F-score: \" + str(f_score)","def computeErrorRate(test_set, words_likely_tags):\n # initiate vars\n known_words = {} # those two dictionaries are optional, just for debuging\n unknown_words = {} # those two dictionaries are optional, just for debuging\n correct_predictions = 0\n total_predictions = 0\n correct_unknown_predictions = 0\n total_unknown_predictions = 0\n\n for i in range(len(test_set)): # iterate sentences\n test_sent = test_set[i]\n for j in range(len(test_sent)): # iterate words in sent\n w = test_sent[j][WORD]\n t = test_sent[j][TAG]\n\n # known words\n if w in words_likely_tags:\n if w in known_words:\n known_words[w][COUNTER_SHOWS] += 1\n if t == words_likely_tags[w]: # same tag\n known_words[w][COUNTER_EQUAL] += 1\n correct_predictions += 1\n else:\n if t == words_likely_tags[w]: # same tag\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_predictions += 1\n else:\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_predictions += 1\n # unknown words\n else: # w not in words_likely_tags, treat w as unknown_word\n if w in unknown_words:\n unknown_words[w][COUNTER_SHOWS] += 1\n if t == UNKNOWN_TAG:\n # same tag as our model predicts for unknown words\n unknown_words[w][COUNTER_EQUAL] += 1\n correct_unknown_predictions += 1\n else:\n if t == UNKNOWN_TAG: # same tag\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\n correct_unknown_predictions += 1\n else:\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\n\n total_unknown_predictions += 1\n\n # print('correct_predictions......... = ', correct_predictions)\n # print('total_predictions........... = ', total_predictions)\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\n # print('total_unknown_predictions... = ', total_unknown_predictions)\n err_rate_known = 1 - correct_predictions/total_predictions\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\n # total_err = err_rate_known + err_rate_unknown\n tot_pred = total_predictions + total_unknown_predictions\n corr_pred = correct_predictions + correct_unknown_predictions\n total_err = 1 - corr_pred/tot_pred\n\n return err_rate_known, err_rate_unknown, total_err","def segmentation_scores(label_trues, label_preds, n_class):\n hist = np.zeros((n_class, n_class))\n for lt, lp in zip(label_trues, label_preds):\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n mean_iu = np.nanmean(iu)\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n\n return {'overall_acc': acc,\n 'mean_acc': acc_cls,\n 'freq_w_acc': fwavacc,\n 'mean_iou': mean_iu}","def scoring_function(self, model, y_true, y_predicted_probability):","def evaluate_rouge_match(ref_data, pred_data, align=\"rouge\"):\n\n scorer = RougeScorer([\"rougeL\"])\n agg = scoring.BootstrapAggregator(confidence_interval=0.95)\n sample_evaluated = 0\n\n for tid in tqdm(pred_data):\n cur_sys = pred_data[tid][\"pred\"]\n if not tid in ref_data: continue\n cur_ref_lst = [x[\"tgt_words\"] for x in ref_data[tid]]\n if len(cur_ref_lst) > 0:\n if align == \"rouge\":\n best_rouge_scrs = __rouge_pairs(cur_sys, cur_ref_lst, scorer)\n agg.add_scores(best_rouge_scrs)\n else:\n best_paired_ref, _ = utils.pair_ref_sys_by_coverage(cur_sys, cur_ref_lst)\n agg.add_scores(scorer.score(best_paired_ref, cur_sys))\n sample_evaluated += 1\n\n print(sample_evaluated)\n result = agg.aggregate()\n for rouge_type in result:\n print(rouge_type)\n print(result[rouge_type].mid)\n\n print(agg.aggregate())\n return","def score_calc(self, annotations, predictions):\n\n mean_probabilities_of_classes = np.expand_dims(np.mean(predictions, axis=0), axis=0)\n KL_d = predictions * (np.log(predictions + self.eps) - np.log(mean_probabilities_of_classes + self.eps))\n KL_D = KL_d.sum(axis=1)\n\n score = np.exp(np.mean(KL_D))\n return score","def _score_ngrams(target_ngrams, prediction_ngrams):\n\n intersection_ngrams_count = 0\n for ngram in six.iterkeys(target_ngrams):\n intersection_ngrams_count += min(target_ngrams[ngram],\n prediction_ngrams[ngram])\n target_ngrams_count = sum(target_ngrams.values())\n prediction_ngrams_count = sum(prediction_ngrams.values())\n\n precision = intersection_ngrams_count / max(prediction_ngrams_count, 1)\n recall = intersection_ngrams_count / max(target_ngrams_count, 1)\n fmeasure = scoring.fmeasure(precision, recall)\n\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)","def evaluate(predicted, labels):\n \n assert len(predicted) == len(labels), \"Different number of predictions and labels.\"\n \n total = len(predicted)\n movie_correct = 0\n location_correct = 0\n \n center_frame_dist = [] \n overlaps = []\n \n for pred, label in zip(predicted, labels):\n \n dist = 0\n \n if pred[0] == label[0]: # Check if movie is correct\n movie_correct += 1\n \n dist = abs(pred[1] - ((label[1]+label[2])/2)) \n center_frame_dist.append(dist)\n \n correct = False\n if label[1] <= pred[1] <= label[2]:\n correct = True\n location_correct += 1\n\n \n# print(\"Label: ({:s}, {:d}, {:d}), predicted: ({:s}, {:d}), location correct: {!s:}, start_frame_dist: {:d}, overlap: {:d}\".format(\n# *label,\n# *pred,\n# correct,\n# dist\n# ))\n \n # Return (# movies correct, # correct location, # total movies) and (avg start frame distance, std)\n return (movie_correct, location_correct, total), (np.mean(center_frame_dist), np.std(center_frame_dist))","def evaluate(labels, predictions):\n\n # Positive and positive identified count\n pos = 0\n posid = 0\n\n # Negative and positive identified count\n neg = 0\n negid = 0\n\n for label, pred in zip(labels, predictions):\n if label == 1:\n pos += 1\n if pred == 1:\n posid += 1\n elif label == 0:\n neg += 1\n if pred == 0:\n negid += 1\n else:\n raise ValueError\n\n # `sensitivity` should be a floating-point value from 0 to 1\n # representing the \"true positive rate\": the proportion of\n # actual positive labels that were accurately identified.\n sens = float(posid / pos)\n\n # `specificity` should be a floating-point value from 0 to 1\n # representing the \"true negative rate\": the proportion of\n # actual negative labels that were accurately identified.\n spec = float(negid / neg)\n\n return (sens, spec)","def evaluate(y_test, pred_labels):\n \n # Converts one-hot code to a label (the index of 1)\n y_test_labels = np.argmax(y_test, axis=1)\n \n # Compare test labels to predicted labels\n score = accuracy_score(y_test_labels, pred_labels)\n \n return y_test_labels, score","def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\n \"missing keys: {}\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\n scores = {}\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\n for i, bleu_score in enumerate(bleu_scores):\n scores['Bleu-%d' % (i + 1)] = bleu_score\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\n scores['Rouge-L'] = rouge_score\n return scores","def get_accuracy(self, gold, predicted):\n # Exercise 3: calculate accuracy\n i = 0\n j = 0\n for labels in gold:\n if labels == predicted[i]:\n j +=1\n i +=1\n return j / i * 100","def calculate_score(result):\n sample1=result['Sample1']\n sample2=result['Sample2']\n string1=paragraph_to_list(sample1)\n string2=paragraph_to_list(sample2)\n \n return round( strings_similarity(string1, string2), 2)\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\n #return round(0.5*(method_difflab+method_dict), 2)","def score(self, y_true, y_pred):\r\n pass","def f1_score(model_id, test_set_id, rubric_id):\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\n\n for key in rubrication_result:\n if rubrication_result[key] == answers[key]:\n if rubrication_result[key] == 1:\n result['true_positive'] += 1\n else:\n result['true_negative'] += 1\n else:\n if rubrication_result[key] == 1:\n result['false_positive'] += 1\n else:\n result['false_negative'] += 1\n if (result['true_positive'] + result['false_positive']) > 0:\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\n else:\n result['precision'] = 0\n if (result['true_positive'] + result['false_negative']) > 0:\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\n else:\n result['recall'] = 0\n if (result['precision'] + result['recall']) > 0:\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\n else:\n result['f1'] = 0\n return result","def rouge_score(references, generated):\r\n score = rouge(generated, references)\r\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\r\n '''\r\n \"rouge_1/f_score\": rouge_1_f,\r\n \"rouge_1/r_score\": rouge_1_r,\r\n \"rouge_1/p_score\": rouge_1_p,\r\n \"rouge_2/f_score\": rouge_2_f,\r\n \"rouge_2/r_score\": rouge_2_r,\r\n \"rouge_2/p_score\": rouge_2_p,\r\n \"rouge_l/f_score\": rouge_l_f,\r\n \"rouge_l/r_score\": rouge_l_r,\r\n \"rouge_l/p_score\": rouge_l_p,\r\n '''\r\n return rouge_s","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def classify(texts: List[str], params: Any) -> List[str]:\n\n alpha = 1\n token_probs_pos = params[\"token_probs_pos\"]\n token_probs_neg = params[\"token_probs_neg\"]\n all_words = params[\"all_words\"]\n M = len(all_words)\n cnt_pos_docs = params[\"cnt_pos_docs\"]\n cnt_neg_docs = params[\"cnt_neg_docs\"]\n\n sum_len_neg = params[\"sum_len_neg\"]\n sum_len_pos = params[\"sum_len_pos\"]\n pos_dict = params[\"pos_dict\"]\n neg_dict = params[\"neg_dict\"]\n\n\n test_texts = preprocessing(texts)\n test_tokenized_texts = text_to_tokens(test_texts)\n \n res = []\n log_pos_probablity = 0\n log_neg_probablity = 0\n i = 0\n for text in test_tokenized_texts:\n if (i % 5000 == 0):\n print(\"Classified\", i, \"texts\")\n i += 1\n log_pos_probablity = log(cnt_pos_docs)\n log_neg_probablity = log(cnt_neg_docs)\n for token in text:\n if (token_probs_pos[token] == 0):\n token_probs_pos[token] = alpha / (alpha * M + sum_len_pos)\n else:\n log_pos_probablity += log(token_probs_pos[token])\n if (token_probs_neg[token] == 0):\n token_probs_neg[token] = alpha / (alpha * M + sum_len_neg)\n else:\n log_neg_probablity += log(token_probs_neg[token])\n if (log_neg_probablity > log_pos_probablity):\n res.append(\"neg\")\n #for token in text:\n # all_words.add(token)\n # M = len(all_words)\n # neg_dict[token] += text[token]\n # sum_len_neg += text[token]\n # token_probs_neg[token] = (alpha + neg_dict[token]) / (alpha * M + sum_len_neg)\n\n else:\n res.append(\"pos\")\n #for token in text:\n # all_words.add(token)\n # M = len(all_words)\n # pos_dict[token] += text[token]\n # sum_len_pos += text[token]\n # token_probs_pos[token] = (alpha + pos_dict[token]) / (alpha * M + sum_len_pos)\n\n\n \n print('Predicted labels counts:')\n print(count_labels(res))\n return res","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def score_one(self, test_data):\n\n\t\ttest_in, test_labels = self._split_inputs_outputs(test_data)\n\t\tcorrect = 0\n\t\ttotal = 0\n\n\t\tfor i, test_input in enumerate(test_in):\n\t\t\tprediction = self.model.predict(test_input.reshape(1,-1))\n\t\t\tif prediction[0] == test_labels[i]:\n\t\t\t\tcorrect+=1\n\t\t\ttotal+=1\n\t\treturn float(correct)/total","def eval(self):\n target_truth_labels = self.get_target_labels()\n for key in self.id_uncertainty_measures.keys():\n # deep copy needed as we mutate confidence values later on\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\n copy.deepcopy(self.ood_uncertainty_measures[key])),\n axis=0)\n # negation needed for confidence, as confidence is indicator of label=0 samples\n # i.e for correct classified samples.\n # But we need scores for label=1 samples i.e misclassified samples\n # to be higher, so we negate.\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\n decision_fn_value *= -1.0\n\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\n\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\n f.write('AUPR using ' + key._value_ + \": \" +\n str(np.round(aupr * 100.0, 1)) + '\\n')\n f.write('AUROC using ' + key._value_ + \": \" +\n str(np.round(auroc * 100.0, 1)) + '\\n')","def evaluate(\n args,\n generator,\n model,\n iou_threshold=0.5,\n score_threshold=0.05,\n max_detections=100,\n save_path=None\n):\n # gather all detections and annotations\n all_detections = _get_detections(args, generator, model, score_threshold=score_threshold, max_detections=max_detections, save_path=save_path)\n all_annotations = _get_annotations(generator)\n # print('all detections:', all_detections)\n # print('all all_annotations:', all_annotations)\n average_precisions = {}\n\n # all_detections = pickle.load(open('all_detections.pkl', 'rb'))\n # all_annotations = pickle.load(open('all_annotations.pkl', 'rb'))\n # pickle.dump(all_detections, open('all_detections.pkl', 'wb'))\n # pickle.dump(all_annotations, open('all_annotations.pkl', 'wb'))\n\n # process detections and annotations\n # print('###########')\n # print(generator.num_classes())\n\n for label in range(generator.num_classes()):\n if not generator.has_label(label):\n print('generator has not label')\n continue\n\n false_positives = np.zeros((0,))\n true_positives = np.zeros((0,))\n false_negatives = np.zeros((0,))\n scores = np.zeros((0,))\n num_annotations = 0.0\n\n for i in range(generator.size()):\n detections = all_detections[i][label]\n annotations = all_annotations[i][label]\n num_annotations += annotations.shape[0]\n detected_annotations = []\n\n for d in detections:\n scores = np.append(scores, d[4])\n\n if annotations.shape[0] == 0:\n # print('NO bbox annos')\n # print(d)\n false_positives = np.append(false_positives, 0)\n true_positives = np.append(true_positives, 0)\n false_negatives = np.append(false_negatives, 1)\n continue\n\n overlaps = compute_overlap(np.expand_dims(d, axis=0), annotations)\n assigned_annotation = np.argmax(overlaps, axis=1)\n max_overlap = overlaps[0, assigned_annotation]\n\n if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations:\n false_positives = np.append(false_positives, 0)\n true_positives = np.append(true_positives, 1)\n detected_annotations.append(assigned_annotation)\n else:\n false_positives = np.append(false_positives, 1)\n true_positives = np.append(true_positives, 0)\n\n # no annotations -> AP for this class is 0 (is this correct?)\n if num_annotations == 0:\n average_precisions[label] = 0, 0\n continue\n\n # print(num_annotations)\n # print(all_detections[0][label].shape)\n # print(all_detections[0][label])\n TP = sum(true_positives)\n FP = sum(false_positives)\n FN = sum(false_negatives)\n # sort by score\n indices = np.argsort(-scores)\n false_positives = false_positives[indices]\n true_positives = true_positives[indices]\n\n # compute false positives and true positives\n false_positives = np.cumsum(false_positives)\n true_positives = np.cumsum(true_positives)\n\n # compute recall and precision\n recall = true_positives / num_annotations\n precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps)\n\n\n print('TP:', TP)\n print('FP:', FP)\n print('FN:', FN)\n print('Recall:', TP / (TP + FN))\n print('Precision:', TP / (TP + FP))\n\n # compute average precision\n average_precision = _compute_ap(recall, precision)\n average_precisions[label] = average_precision, num_annotations\n\n return average_precisions","def evaluate(true_labels, predicted_labels):\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \n 2)\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \n average='weighted'), 2)\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\n average='weighted'), 2)\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \n average='weighted'), 2)\n \n return accuracy, precision, recall, f1","def calc_instance_segmentation_voc_prec_rec(\r\n pred_masks, pred_labels, pred_scores,\r\n gt_masks, gt_labels, iou_thresh):\r\n\r\n pred_masks = iter(pred_masks)\r\n pred_labels = iter(pred_labels)\r\n pred_scores = iter(pred_scores)\r\n gt_masks = iter(gt_masks)\r\n gt_labels = iter(gt_labels)\r\n\r\n n_pos = defaultdict(int)\r\n score = defaultdict(list)\r\n match = defaultdict(list)\r\n\r\n for pred_mask, pred_label, pred_score, gt_mask, gt_label in \\\r\n six.moves.zip(\r\n pred_masks, pred_labels, pred_scores,\r\n gt_masks, gt_labels):\r\n\r\n for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):\r\n pred_keep_l = pred_label == l\r\n pred_mask_l = pred_mask[pred_keep_l]\r\n pred_score_l = pred_score[pred_keep_l]\r\n # sort by score\r\n order = pred_score_l.argsort()[::-1]\r\n pred_mask_l = pred_mask_l[order]\r\n pred_score_l = pred_score_l[order]\r\n\r\n gt_keep_l = gt_label == l\r\n gt_mask_l = gt_mask[gt_keep_l]\r\n\r\n n_pos[l] += gt_keep_l.sum()\r\n score[l].extend(pred_score_l)\r\n\r\n if len(pred_mask_l) == 0:\r\n continue\r\n if len(gt_mask_l) == 0:\r\n match[l].extend((0,) * pred_mask_l.shape[0])\r\n continue\r\n\r\n iou = mask_iou(pred_mask_l, gt_mask_l)\r\n gt_index = iou.argmax(axis=1)\r\n # set -1 if there is no matching ground truth\r\n gt_index[iou.max(axis=1) < iou_thresh] = -1\r\n del iou\r\n\r\n selec = np.zeros(gt_mask_l.shape[0], dtype=bool)\r\n for gt_idx in gt_index:\r\n if gt_idx >= 0:\r\n if not selec[gt_idx]:\r\n match[l].append(1)\r\n else:\r\n match[l].append(0)\r\n selec[gt_idx] = True\r\n else:\r\n match[l].append(0)\r\n\r\n for iter_ in (pred_masks, pred_labels, pred_scores, gt_masks, gt_labels):\r\n if next(iter_, None) is not None:\r\n raise ValueError('Length of input iterables need to be same.')\r\n\r\n n_fg_class = max(n_pos.keys()) + 1\r\n prec = [None] * n_fg_class\r\n rec = [None] * n_fg_class\r\n\r\n for l in n_pos.keys():\r\n score_l = np.array(score[l])\r\n match_l = np.array(\r\n match[l], dtype=np.int8)\r\n\r\n order = score_l.argsort()[::-1]\r\n match_l = match_l[order]\r\n\r\n tp = np.cumsum(match_l == 1)\r\n fp = np.cumsum(match_l == 0)\r\n\r\n # If an element of fp + tp is 0,\r\n # the corresponding element of prec[l] is nan.\r\n prec[l] = tp / (fp + tp)\r\n # If n_pos[l] is 0, rec[l] is None.\r\n if n_pos[l] > 0:\r\n rec[l] = tp / n_pos[l]\r\n\r\n return prec, rec","def _compute_relevance_map(self, labels):\n\n ds_labels = np.zeros(self.ds_size)\n ds_relevance_map = 0\n for i in np.unique(labels):\n if i != 0:\n # 2.1- Compute the coarse label image\n y, x, z = np.where(labels == i)\n ds_labels[np.int32(y * self.full_to_ds_ratio[0]),\n np.int32(x * self.full_to_ds_ratio[1]), z] = i\n # 2.2- Compute the energy map\n M = np.ones_like(ds_labels)\n M[ds_labels == i] = 0\n distance_map = distance_transform_edt(M)\n ds_relevance_map += distance_map\n\n # 2.3- Normalize the energy map and compute the ROI\n ds_relevance_map = ds_relevance_map / ds_relevance_map.max()\n return ds_labels, ds_relevance_map","def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\n rank10_acc = 0\n rank5_acc = 0\n rank1_acc = 0\n avg_acc = 0\n vote_res = 0\n\n l2 = []\n for anchor in range(0, len(X_anchor)):\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\n vote = defaultdict(int)\n # Accuracy\n correct = 0\n for i in res[:10]:\n vote[y_gal[i]] += 1\n\n max_key = max(vote, key=vote.get)\n if max_key == y_anchor[anchor]:\n vote_res += 1\n \n\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1 \n\n avg_acc += correct/len(res)\n\n # Mean Average Precision\n l1 = []\n for recomm in res[:10]:\n if y_gal[recomm] == y_anchor[anchor]:\n correct += 1\n l1.append(1)\n else:\n l1.append(0)\n l2.append(l1) \n\n # Rank10 Accuracy\n for each_val in res[:10]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank10_acc += 1\n break\n \n # Rank5 Accuracy\n for each_val in res[:5]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank5_acc += 1\n break\n\n # Rank1 Accuracy\n for each_val in res[:1]:\n if y_gal[each_val] == y_anchor[anchor]:\n rank1_acc += 1\n break\n\n print(\"Avg acc is :: {avg_acc}\".format(avg_acc = avg_acc/len(X_anchor)))\n print(\"Rank 10 acc is :: {rank10_acc}\".format(rank10_acc = rank10_acc/len(X_anchor)))\n print(\"Rank 5 acc is :: {rank5_acc}\".format(rank5_acc = rank5_acc/len(X_anchor)))\n print(\"Rank 1 acc is :: {rank1_acc}\".format(rank1_acc = rank1_acc/len(X_anchor)))\n print(\"Mean Avg Precision is :: {mAP}\".format(mAP=mean_average_precision(l2)))\n print(\"Vote res :: \", vote_res/len(X_anchor))\n\n return rank1_acc/len(X_anchor), mean_average_precision(l2)","def score_prediction(y_true, y_pred):\n return [round(metrics.accuracy_score(y_true, y_pred)*100, 2),\n round(metrics.precision_score(y_true, y_pred)*100, 2),\n round(metrics.recall_score(y_true, y_pred)*100, 2),\n round(metrics.f1_score(y_true, y_pred)*100, 2)]","def score(self, predicted_y, actual_y):\n\n self.labels = [0, 1, 2, 3]\n\n # Dictionary to store count of each label in predicted labels list\n self.total_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n # Dictionary to store count of each label in actual labels list\n self.total_actual_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n # Dictionary to store count of correctly predicted labels\n self.total_correct_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\n\n for i in xrange(len(predicted_y)):\n # Extract predicted and actual labels for ith record\n predicted_label = predicted_y[i]\n actual_label = actual_y[i]\n\n # Increment the count of corrected predicted label if predicted and actual labels are same\n if predicted_label == actual_label:\n self.total_correct_prediction_count[actual_label] += 1\n\n # Increment total counts\n self.total_actual_count[actual_label] += 1\n self.total_prediction_count[predicted_label] += 1\n\n # Compute f1 scores of each label and return their mean\n return np.mean(self.__get_f1_scores__())","def _score_for_model(meta):\n mean_acc = list()\n pipes = meta[\"pipeline\"]\n acc = meta[\"accuracy\"]\n if \"tagger\" in pipes:\n mean_acc.append(acc[\"tags_acc\"])\n if \"morphologizer\" in pipes:\n mean_acc.append((acc[\"morphs_acc\"] + acc[\"pos_acc\"]) / 2)\n if \"parser\" in pipes:\n mean_acc.append((acc[\"uas\"] + acc[\"las\"]) / 2)\n if \"ner\" in pipes:\n mean_acc.append((acc[\"ents_p\"] + acc[\"ents_r\"] + acc[\"ents_f\"]) / 3)\n if \"textcat\" in pipes:\n mean_acc.append(acc[\"textcat_score\"])\n if \"senter\" in pipes:\n mean_acc.append((acc[\"sent_p\"] + acc[\"sent_r\"] + acc[\"sent_f\"]) / 3)\n return sum(mean_acc) / len(mean_acc)","def calc_scores(y_true, y_pred, mltype, metrics=None):\n scores = OrderedDict()\n\n if mltype == 'cls': \n scores['auroc'] = sklearn.metrics.roc_auc_score(y_true, y_pred)\n scores['f1_score'] = sklearn.metrics.f1_score(y_true, y_pred, average='micro')\n scores['acc_blnc'] = sklearn.metrics.balanced_accuracy_score(y_true, y_pred)\n\n elif mltype == 'reg':\n scores['r2'] = sklearn.metrics.r2_score(y_true=y_true, y_pred=y_pred)\n scores['mean_absolute_error'] = sklearn.metrics.mean_absolute_error(y_true=y_true, y_pred=y_pred)\n scores['median_absolute_error'] = sklearn.metrics.median_absolute_error(y_true=y_true, y_pred=y_pred)\n scores['mean_squared_error'] = sklearn.metrics.mean_squared_error(y_true=y_true, y_pred=y_pred)\n scores['auroc_reg'] = reg_auroc(y_true=y_true, y_pred=y_pred)\n\n # # https://scikit-learn.org/stable/modules/model_evaluation.html\n # for metric_name, metric in metrics.items():\n # if isinstance(metric, str):\n # scorer = sklearn.metrics.get_scorer(metric_name) # get a scorer from string\n # scores[metric_name] = scorer(ydata, pred)\n # else:\n # scores[metric_name] = scorer(ydata, pred)\n\n return scores","def evaluate(ner_model, examples):\n # The Scorer computes and stores evaluation scores\n scorer = Scorer()\n for text, annotations in examples:\n # Process the text to get entities predicted\n document = ner_model.make_doc(text)\n correct_annotations = GoldParse(document, entities=annotations['entities'])\n predicted_annotations = ner_model(text)\n # Update the evaluation scores from the document\n scorer.score(predicted_annotations, correct_annotations)\n return scorer.scores","def sentence_accuracy(references, predictions):\n count = 0.0\n match = 0.0\n for label, pred in zip(references, predictions):\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\n results: Dict[str, Tensor] = {}\n if sentence_results == {}:\n return results\n for rouge_key, scores in sentence_results.items():\n results[rouge_key] = torch.tensor(scores).mean()\n return results","def compute_precision(gold_dict, src_word2ind, trg_word2ind, src_words, trg_words, scores, args, BATCH_SIZE=20, verbose = False):\n oov = set()\n correct = 0\n n,m = scores.shape # The actual size of mapping computed, might be smaller that total size of dict\n\n precisions = {}\n if verbose:\n print('@{:2} {:10} {:30} {:30}'.format('k', 'Src','Predicted','Gold'))\n print_row = '{:2} {:10} {:30} {:30} {}'\n\n for k in [1,5,10]:\n correct = 0\n for src_idx,tgt_idx in gold_dict.items():\n if src_idx > n or np.all([e>m for e in tgt_idx]):#Src word not in mapping\n oov.add(src_idx)\n continue\n else:\n knn = np.argpartition(scores[src_idx,:], -k)[-k:] # argpartition returns top k not in order\n knn_sort = knn[np.argsort(-scores[src_idx,knn])] # With - to get descending order\n if set(knn_sort).intersection(tgt_idx):\n correct +=1\n correct_string = ' '\n else:\n correct_string = 'X'\n if verbose:\n src_str = src_words[src_idx]\n pred_str = ','.join([trg_words[k] for k in knn_sort])\n gold_str = ','.join([trg_words[k] for k in tgt_idx])\n print(print_row.format(k,src_str,pred_str,gold_str,correct_string))\n\n\n coverage = len(gold_dict.keys()) / (len(gold_dict.keys()) + len(oov))\n if verbose:\n print('Coverage: {:7.2%} Precision @{:2}:{:7.2%}'.format(coverage, k, correct / len(gold_dict)))\n precisions[k] = correct / len(gold_dict)\n return precisions","def evaluate(labels, predictions):\n positive_count = 0\n positive = 0\n negative_count = 0\n negative = 0\n for i in range(len(labels)):\n if labels[i] == 1:\n positive_count+=1\n if predictions[i] == 1:\n positive +=1\n else:\n negative_count+=1\n if predictions[i] == 0:\n negative +=1\n\n sensitivity = positive / positive_count\n specificity = negative / negative_count\n\n return (sensitivity, specificity)","def _accuracy(label_file, pred_file,subword_option=None):\n\n with open(label_file, \"r\", encoding='utf-8') as label_fh:\n with open(pred_file, \"r\", encoding='utf-8') as pred_fh:\n count = 0.0\n match = 0.0\n for label in label_fh:\n label = label.strip()\n label = \" \".join(_clean(label,subword_option))\n pred = pred_fh.readline().strip()\n pred = \" \".join(_clean(pred,subword_option))\n if label == pred:\n match += 1\n count += 1\n return 100 * match / count","def evaluate(session, model, char_data, tag_data, dict_data, len_data, eval_op, batch_size, verbose=False):\n correct_labels = 0\n total_labels = 0\n\n xArray, yArray, dArray, lArray = reader.iterator(char_data, tag_data, dict_data, len_data, batch_size)\n yp_wordnum = 0\n yt_wordnum = 0\n cor_num = 0\n for x, y, d, l in zip(xArray, yArray, dArray, lArray):\n fetches = [model.loss, model.logits, model.trans]\n feed_dict = {}\n feed_dict[model.input_data] = x\n feed_dict[model.targets] = y\n feed_dict[model.dicts] = d\n feed_dict[model.seq_len] = l\n loss, logits, trans = session.run(fetches, feed_dict)\n\n for logits_, y_, l_ in zip(logits, y, l):\n logits_ = logits_[:l_]\n y_ = y_[:l_]\n viterbi_sequence, _ = tf.contrib.crf.viterbi_decode(logits_, trans)\n\n yp_wordnum += viterbi_sequence.count(2) + viterbi_sequence.count(3)\n yt_wordnum += (y_ == 2).sum() + (y_ == 3).sum()\n correct_labels += np.sum(np.equal(viterbi_sequence, y_))\n total_labels += l_\n\n start = 0\n for i in range(len(y_)):\n if (y_[i] == 2 or y_[i] == 3):\n flag = True\n for j in range(start, i + 1):\n if y_[j] != viterbi_sequence[j]:\n flag = False\n if flag == True:\n cor_num += 1\n start = i + 1\n P = cor_num / float(yp_wordnum)\n R = cor_num / float(yt_wordnum)\n F = 2 * P * R / (P + R)\n accuracy = 100.0 * correct_labels / float(total_labels)\n return accuracy, P, R, F","def genuines_and_impostors(self, scores, labels):\r\n print('Computing genuine scores and impostor scores')\r\n scores_dimension, genuine_dimension, impostor_dimension = self._define_dimensions(scores, labels)\r\n genuine_score = np.zeros(shape=(genuine_dimension, 1))\r\n impostor_score = np.zeros(shape=(impostor_dimension, 1))\r\n indg = 0\r\n indi = 0\r\n for i in range(scores_dimension):\r\n for j in range(i):\r\n if labels[i] == labels[j]:\r\n genuine_score[indg, 0] = scores[i, j];\r\n indg = indg + 1;\r\n else:\r\n impostor_score[indi, 0] = scores[i, j];\r\n indi = indi + 1;\r\n gen_unique = np.unique(genuine_score)\r\n imp_unique = np.unique(impostor_score)\r\n print('Defining the thresholds')\r\n thresholds = np.concatenate(([0], gen_unique, imp_unique, [1]))\r\n thresholds = np.unique(thresholds)\r\n if np.max(np.shape(thresholds)) > 100:\r\n thresholds = self._compute_thresholds(0.01)\r\n return genuine_score, impostor_score, thresholds","def scoring(self):\n pass","def run_evaluate(self, test):\n accs = []\n correct_preds, total_correct, total_preds = 0., 0., 0.\n for words, labels in minibatches(test, self.config.batch_size):\n labels_pred, sequence_lengths = self.predict_batch(words)\n\n for lab, lab_pred, length in zip(labels, labels_pred,\n sequence_lengths):\n lab = lab[:length]\n lab_pred = lab_pred[:length]\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\n\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\n lab_pred_chunks = set(get_chunks(lab_pred,\n self.config.vocab_tags))\n\n correct_preds += len(lab_chunks & lab_pred_chunks)\n total_preds += len(lab_pred_chunks)\n total_correct += len(lab_chunks)\n\n p = correct_preds / total_preds if correct_preds > 0 else 0\n r = correct_preds / total_correct if correct_preds > 0 else 0\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\n acc = np.mean(accs)\n\n return {\"acc\": 100*acc, \"f1\": 100*f1}","def partial_match_score(\n truth: List[Rationale], pred: List[Rationale], thresholds: List[float]\n) -> List[PartialMatchScore]:\n\n ann_to_rat = _keyed_rationale_from_list(truth)\n pred_to_rat = _keyed_rationale_from_list(pred)\n\n num_classifications = {k: len(v) for k, v in pred_to_rat.items()}\n num_truth = {k: len(v) for k, v in ann_to_rat.items()}\n ious: Dict[str, Dict[str, float]] = defaultdict(dict)\n for k in set(ann_to_rat.keys()) | set(pred_to_rat.keys()):\n for p in pred_to_rat.get(k, []):\n best_iou = 0.0\n for t in ann_to_rat.get(k, []):\n num = len(\n set(range(p.start_token, p.end_token))\n & set(range(t.start_token, t.end_token))\n )\n denom = len(\n set(range(p.start_token, p.end_token))\n | set(range(t.start_token, t.end_token))\n )\n iou = 0 if denom == 0 else num / denom\n if iou > best_iou:\n best_iou = iou\n ious[k][p] = best_iou\n\n scores: List[PartialMatchScore] = []\n for threshold in thresholds:\n threshold_tps: Dict[str, float] = {}\n for k, vs in ious.items():\n threshold_tps[k] = sum(int(x >= threshold) for x in vs.values())\n micro_r = (\n sum(threshold_tps.values()) / sum(num_truth.values())\n if sum(num_truth.values()) > 0\n else 0\n )\n micro_p = (\n sum(threshold_tps.values()) / sum(num_classifications.values())\n if sum(num_classifications.values()) > 0\n else 0\n )\n micro_f1 = _f1(micro_r, micro_p)\n macro_rs = list(\n threshold_tps.get(k, 0.0) / n if n > 0 else 0 for k, n in num_truth.items()\n )\n macro_ps = list(\n threshold_tps.get(k, 0.0) / n if n > 0 else 0\n for k, n in num_classifications.items()\n )\n macro_r = sum(macro_rs) / len(macro_rs) if len(macro_rs) > 0 else 0\n macro_p = sum(macro_ps) / len(macro_ps) if len(macro_ps) > 0 else 0\n macro_f1 = _f1(macro_r, macro_p)\n\n scores.append(\n PartialMatchScore(\n threshold=threshold,\n micro=InstanceScore(p=micro_p, r=micro_r, f1=micro_f1),\n macro=InstanceScore(p=macro_p, r=macro_r, f1=macro_f1),\n )\n )\n\n return scores","def compute_precision(model:nn.Module, l_dataset, l_label_vocab, int_to_label, opts, pre):\n\n all_predictions = list()\n reconstructed_predictions = list()\n all_labels = list()\n \n read_labels = list()\n read_predictions = list()\n\n pos = None\n pred = None\n\n inp, prs = pre.list_l_sentences, pre.list_l_unpacked_predicates\n original_predicates = pre.list_l_original_predicates\n labels_as_dict = pre.labels_dict\n dev_d = pre.list_l_labels\n\n model.eval()\n\n duplicates = [(len(x) - x.count(\"_\")) for x in original_predicates]\n\n pred_idx = [[i for i, v in enumerate(x) if v!=\"_\"] for x in original_predicates]\n\n # Loop over dataset (dataloader)\n for batch in l_dataset:\n\n inputs = batch[\"inputs\"].to(opts[\"device\"])\n if opts[\"use_binary_pred\"] == True:\n pred = batch[\"preds\"].type(torch.FloatTensor).to(opts[\"device\"])\n else:\n pred = batch[\"preds\"].to(opts[\"device\"])\n labels = batch[\"labels\"].to(opts[\"device\"])\n mask = batch[\"mask\"].to(opts[\"device\"], dtype=torch.uint8)\n \n # If model uses POS embeddings include batch of encoded POS tags\n if opts[\"use_pos_embeddings\"] == True:\n pos = batch[\"pos\"].to(opts[\"device\"])\n\n # Get original length of every sentence in the batch\n # subtract 4 if we are using BERT (as we will remove the 4 special tokens in BERT)\n if opts[\"use_bert\"] == False:\n original_len = np.asarray([len(x[x.nonzero(as_tuple=True)].tolist()) for x in inputs]) \n elif opts[\"use_bert\"] == True:\n unmodified_original_len = [len(x[x.nonzero(as_tuple=True)].tolist()) for x in inputs]\n original_len = np.asarray([b - 4 for b in unmodified_original_len])\n\n labels = labels.view(-1)\n valid_indices = labels != 0\n \n # Forward pass through network\n predictions = model(inputs, mask, pred, pos)\n predictions = torch.argmax(predictions, -1).view(-1)\n valid_predictions = predictions[valid_indices]\n\n # Map predictions from ints to words\n mapper = lambda x: int_to_label[x]\n mapped_predictions = list(map(mapper, valid_predictions.tolist()))\n all_predictions.extend(mapped_predictions)\n\n # Recontruct predictions from one big list that has predictions for entire batch\n # into a list of lists where every list has predictions for a sentence\n reconst = [] \n var = 0\n for c_idx in range(len(original_len)):\n reconst.append(mapped_predictions[var:var+original_len[c_idx]])\n var += original_len[c_idx]\n\n reconstructed_predictions.extend(reconst)\n\n valid_labels = labels[valid_indices]\n all_labels.extend(valid_labels.tolist())\n \n read_labels.append(valid_labels.tolist())\n\n # Get index of a few labels and access the POS of those indeces\n select_labels_idx = [i for i, v in enumerate(all_labels) if v==4 or v==6 or v==10 or v==12 or v==16 or v==18]\n all_pos = [y for x in pre.list_l_pos for y in x]\n \n pos_that_are_agent = [all_pos[ag_ix] for ag_ix in select_labels_idx]\n labels_that_are_agent = [int_to_label[all_labels[ag_ix]] for ag_ix in select_labels_idx]\n \n # Create a datafram of POS Tags and the labels associated with them\n df = pd.DataFrame(list(zip(pos_that_are_agent, labels_that_are_agent)), columns=[\"POS Tag\", \"Label\"])\n \n # Plot the POS Tags of the Labels we selected in \"select_labels_idx\"\n df=df.groupby(['POS Tag','Label']).size()\n df=df.unstack()\n df.plot(kind='bar')\n plt.xticks(rotation=0)\n plt.show()\n\n # Convert predictions from a list of lists into a dictionary:\n # sentence index: { roles: { index of predicate: [ labels of predicate ] } }\n all_predictions_dict = {}\n c = 0\n for idx, elem in enumerate(duplicates):\n all_predictions_dict.update({idx: {\"roles\": {}}})\n if elem == 0:\n c += 1\n else: \n for h in range(elem):\n None if not pred_idx[idx] else all_predictions_dict[idx][\"roles\"].update({pred_idx[idx][h]:reconstructed_predictions[c]})\n c += 1\n\n # Compute precision, recall, F-score\n arg_ident = evaluate_argument_identification(labels_as_dict, all_predictions_dict)\n arg_class = evaluate_argument_classification(labels_as_dict, all_predictions_dict)\n\n # Write the ground truth label and prediction of every sentence to file\n # for debugging purposes\n eval_file = \"{}/Prediction_vs_GroundTruth.txt\".format(opts[\"save_model_path\"])\n s_op_file = open(eval_file, \"w\", encoding=\"utf8\")\n\n for true_label, prediction, sentence, pr in zip(dev_d, reconstructed_predictions, inp, prs):\n \n s_op_file.write(\"sen:\")\n for token in sentence:\n s_op_file.write(token + \" \")\n s_op_file.write(\"\\n\")\n\n s_op_file.write(\"prd:\")\n for th in pr:\n s_op_file.write(th + \" \")\n s_op_file.write(\"\\n\")\n\n s_op_file.write(\"org:\")\n for word in true_label:\n s_op_file.write(str(word) + \" \")\n s_op_file.write(\"\\n\")\n\n s_op_file.write(\"pre:\")\n for p in prediction:\n s_op_file.write(str(p) + \" \")\n s_op_file.write(\"\\n\")\n s_op_file.write(\"\\n\")\n assert len(true_label) == len(prediction)\n \n # Write the Precision, Recall and F1-score the model acheived to file \n s_op_file.write(\"\\n\\nIdentification\")\n s_op_file.write(\"\\n\\tPrecision: {}\\n\\tRcall: {}\\n\\tF-1 score: {}\\n\\n\".format(arg_ident[\"precision\"], arg_ident[\"recall\"], arg_ident[\"f1\"]))\n\n\n s_op_file.write(\"\\nClassification\")\n s_op_file.write(\"\\n\\tPrecision: {}\\n\\tRcall: {}\\n\\tF-1 score: {}\\n\\n\".format(arg_class[\"precision\"], arg_class[\"recall\"], arg_class[\"f1\"]))\n\n return arg_ident, arg_class"],"string":"[\n \"def score(self, target_tokens, prediction_tokens):\\n result = {}\\n\\n for rouge_type in self.rouge_types:\\n if rouge_type == \\\"rougeL\\\":\\n # Rouge from longest common subsequences.\\n scores = _score_lcs(target_tokens, prediction_tokens)\\n elif re.match(r\\\"rouge[0-9]$\\\", rouge_type):\\n # Rouge from n-grams.\\n n = int(rouge_type[5:])\\n if n <= 0:\\n raise ValueError(\\\"rougen requires positive n: %s\\\" % rouge_type)\\n target_ngrams = _create_ngrams(target_tokens, n)\\n prediction_ngrams = _create_ngrams(prediction_tokens, n)\\n scores = _score_ngrams(target_ngrams, prediction_ngrams)\\n else:\\n raise ValueError(\\\"Invalid rouge type: %s\\\" % rouge_type)\\n result[rouge_type] = scores\\n\\n return result\",\n \"def _detection_scores(inputs, gt_boxes, gt_labels, model):\\n model = check_model('model', model, BlackModel)\\n boxes_and_confi, pred_labels = model.predict(*inputs)\\n det_scores = []\\n correct_labels_num = []\\n # repeat gt_boxes and gt_labels for all particles cloned from the same sample in PSOAttack/GeneticAttack\\n if gt_boxes.shape[0] == 1 and boxes_and_confi.shape[0] > 1:\\n gt_boxes = np.repeat(gt_boxes, boxes_and_confi.shape[0], axis=0)\\n gt_labels = np.repeat(gt_labels, boxes_and_confi.shape[0], axis=0)\\n iou_thres = 0.5\\n for boxes, labels, gt_box, gt_label in zip(boxes_and_confi, pred_labels, gt_boxes, gt_labels):\\n gt_box_num = gt_box.shape[0]\\n score = 0\\n box_num = boxes.shape[0]\\n correct_label_flag = np.zeros(gt_label.shape)\\n for i in range(box_num):\\n pred_box = boxes[i]\\n max_iou_confi = 0\\n for j in range(gt_box_num):\\n iou = calculate_iou(pred_box[:4], gt_box[j][:4])\\n if labels[i] == gt_label[j] and iou > iou_thres and correct_label_flag[j] == 0:\\n max_iou_confi = max(max_iou_confi, pred_box[-1] + iou)\\n correct_label_flag[j] = 1\\n score += max_iou_confi\\n det_scores.append(score)\\n correct_labels_num.append(np.sum(correct_label_flag))\\n return np.array(det_scores), np.array(correct_labels_num)\",\n \"def score(label_recall, label_precision, pred_recall, pred_precision):\\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\\n\\n return 0.4*f11 + 0.6*f12\",\n \"def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\\n pred_len = sum(map(len, pred))\\n target_len = sum(map(len, target))\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n\\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\\n ngrams: Counter = Counter()\\n for sentence in sentences:\\n ngrams.update(sentence)\\n return ngrams\\n pred_tokens_count = _get_token_counts(pred)\\n target_tokens_count = _get_token_counts(target)\\n hits = 0\\n for tgt in target:\\n lcs = _union_lcs(pred, tgt)\\n for token in lcs:\\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\\n hits += 1\\n pred_tokens_count[token] -= 1\\n target_tokens_count[token] -= 1\\n return _compute_metrics(hits, pred_len, target_len)\",\n \"def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\\n pred_len, target_len = len(pred), len(target)\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n lcs: int = _lcs(pred, target)\\n return _compute_metrics(lcs, pred_len, target_len)\",\n \"def eval_metrics_for_seqtags(self, predicted_answers):\\n total_correct_in_all = 0\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids, include padding ids.\\n correct_label_indices = sample['correct_seq_labels']\\n # use extend to add all the labels in the seq, include the head padding and tail padding\\n label_true.extend(correct_label_indices)\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n label_pred.extend(sample['pred_seq_tags'])\\n\\n if total_correct_in_all != 0:\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes,\\n title='Confusion matrix when seq labeling, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, normalize=True,\\n title='Normalized confusion matrix when seq labeling')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def scores(self, y, y_pred):\\n\\n aucroc = 0.\\n precision = 0.\\n recall = 0.\\n f1 = 0.\\n aucroc_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n precision_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n recall_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n f1_labs = np.zeros(self.datas[self.train_idx].n_labels)\\n label_ratios = np.mean(y, axis=0)\\n\\n if len(y) > 1:\\n y_t = np.transpose(y)\\n col_keep = np.ones(len(y_t), dtype=bool)\\n for i, col_y in enumerate(y_t):\\n if 0 not in col_y or 1 not in col_y:\\n col_keep[i] = False\\n\\n if sum(col_keep) > 0:\\n if not col_keep.all():\\n y = np.transpose(y_t[col_keep])\\n y_pred = np.transpose(np.transpose(y_pred)[col_keep])\\n\\n f1 = f1_score(y, self._round(y_pred), average=self.metrics_avg)\\n s = f1_score(y, self._round(y_pred), average=None)\\n f1_labs[col_keep] = s if sum(col_keep) > 1 else s[1]\\n aucroc = roc_auc_score(y, y_pred, average=self.metrics_avg)\\n aucroc_labs[col_keep] = roc_auc_score(y, y_pred, average=None)\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n recall = recall_score(y, self._round(y_pred), average=self.metrics_avg)\\n if sum(col_keep) > 1:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred), average=None)\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred), average=None)\\n else:\\n precision_labs[col_keep] = precision_score(y, self._round(y_pred))\\n recall_labs[col_keep] = recall_score(y, self._round(y_pred))\\n elif self.verbose:\\n print('*Cannot compute other metrics because no label in Truth has alternatives, only precision*')\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n elif len(y) == 1:\\n if self.verbose:\\n print('*Cannot compute other metrics with %d samples, only precision*' % len(y))\\n precision = precision_score(y, self._round(y_pred), average=self.metrics_avg)\\n precision_labs = precision_score(y, self._round(y_pred), average=None)\\n\\n result = {\\n 'aucroc': aucroc,\\n 'precision': precision,\\n 'recall': recall,\\n 'f1': f1,\\n 'aucroc_labs': aucroc_labs,\\n 'precision_labs': precision_labs,\\n 'recall_labs': recall_labs,\\n 'f1_labs': f1_labs,\\n 'label_ratios': label_ratios\\n }\\n\\n return result\",\n \"def prediction_processing(predictions, labels, threshold, step_nb):\\n new_labels = []\\n new_predictions = []\\n number_sequences = step_nb//50\\n\\n for k in range(len(labels)//number_sequences):\\n total_prediction = 0\\n isLabelTrue = labels[number_sequences*k]\\n for i in range(number_sequences):\\n total_prediction += (1/predictions[number_sequences*k+i])\\n if not(isLabelTrue == (labels[number_sequences*k+i])):\\n logger.error('Problem.')\\n if total_prediction > threshold:\\n total_prediction = False\\n else:\\n total_prediction = True\\n new_labels.append(isLabelTrue)\\n new_predictions.append(total_prediction)\\n\\n recall_1 = recall_score(new_labels, new_predictions)\\n recall_0 = recall_score(new_labels, new_predictions, pos_label=0)\\n precision_1 = precision_score(new_labels, new_predictions)\\n precision_0 = precision_score(new_labels, new_predictions, pos_label=0)\\n return((recall_1, recall_0, precision_1, precision_0), new_predictions, new_labels)\",\n \"def evaluate(prediction_folder, label_folder, verbose=False):\\n prediction_tasks = next(os.walk(prediction_folder))[1]\\n label_tasks = next(os.walk(label_folder))[1]\\n # prediction_tasks = label_tasks = ['mlqa', 'tydiqa', 'xquad']\\n\\n detailed_scores = {}\\n for task, langs in TASK2LANGS.items():\\n if task in prediction_tasks and task in label_tasks:\\n suffix = \\\"json\\\" if task in GROUP2TASK[\\\"qa\\\"] else \\\"tsv\\\"\\n # collect scores over all languages\\n score = defaultdict(dict)\\n for lg in langs:\\n prediction_file = os.path.join(prediction_folder, task, f\\\"test-{lg}.{suffix}\\\")\\n label_file = os.path.join(label_folder, task, f\\\"test-{lg}.{suffix}\\\")\\n score_lg = evaluate_one_task(prediction_file, label_file, task, language=lg)\\n for metric in score_lg:\\n score[metric][lg] = score_lg[metric]\\n # average over all languages\\n avg_score = {}\\n for m in score:\\n avg_score[f'avg_{m}'] = sum(score[m].values()) / len(score[m])\\n score.update(avg_score)\\n if task in GROUP2TASK[\\\"qa\\\"]:\\n score['avg_metric'] = (score['avg_exact_match'] + score['avg_f1']) / 2\\n elif 'avg_f1' in score:\\n score['avg_metric'] = score['avg_f1']\\n elif 'avg_accuracy' in score:\\n score['avg_metric'] = score['avg_accuracy']\\n detailed_scores[task] = score\\n if verbose:\\n avg_result = ', '.join(['{}={:.1f}'.format(k, v) for k, v in score.items() if k.startswith('avg')])\\n print('- Evaluate {}:\\\\t{}'.format(task, avg_result))\\n\\n # Display logic:\\n overall_scores = {}\\n all_tasks = set(TASK2LANGS.keys())\\n available_tasks = set(detailed_scores.keys())\\n\\n # If scores of all tasks are available, show the overall score in the main table\\n if all_tasks == available_tasks:\\n overall_scores['all_task'] = sum(detailed_scores[task]['avg_metric'] for task in all_tasks) / len(all_tasks)\\n\\n # If scores of all tasks in a sub group are available, show the score in the sub table\\n for group, group_tasks in GROUP2TASK.items():\\n if len(set(group_tasks) - available_tasks) == 0:\\n overall_scores[group] = sum(detailed_scores[task]['avg_metric'] for task in group_tasks) / len(group_tasks)\\n\\n return overall_scores, detailed_scores\",\n \"def compute_score(predictions, references, vocab=None, beam_size=4):\\n assert np.rank(predictions) == 3\\n assert predictions.shape[0] == references.shape[0]\\n batch_size = predictions.shape[0]\\n predictions = tf.make_ndarray(tf.make_tensor_proto(predictions)).tolist()\\n references = tf.make_ndarray(tf.make_tensor_proto(references)).tolist()\\n hypotheses_list = []\\n references_list = []\\n\\n for index in range(batch_size):\\n # All predictions in beam search are used for validation scores.\\n for b_index in range(beam_size):\\n h = predictions[index][b_index]\\n try:\\n eos_index = h.index(input_utils.EOS)\\n except ValueError:\\n eos_index = len(h)\\n hypotheses_list.append(h[:eos_index])\\n\\n ref = references[index][0].decode().split('|')\\n ref_list = [r.strip().split(' ') for r in ref if r.strip()]\\n references_list.append(ref_list)\\n\\n all_scores = collections.defaultdict(list)\\n for hypothesis, references in zip(hypotheses_list, references_list):\\n if vocab is not None and len(vocab):\\n # Skip PADDING, UNK, EOS, START (0-3).\\n hypothesis = [\\n vocab[word_id].numpy().decode()\\n for word_id in hypothesis\\n if word_id > 3\\n ]\\n\\n h_str = ' '.join(str(e) for e in hypothesis)\\n r_str = [' '.join(str(e) for e in ref) for ref in references]\\n\\n print('hypothesis: ', str(h_str))\\n print('references: ', str(r_str))\\n print('\\\\n')\\n scores = screen2words_eval.coco_evaluate(r_str, h_str)\\n for key, score in scores.items():\\n all_scores[key].append(score)\\n score_names = [\\n 'BLEU-1', 'BLEU-2', 'BLEU-3', 'BLEU-4', 'ROUGE-1-f1-mean',\\n 'ROUGE-1-f1-min', 'ROUGE-1-f1-max', 'ROUGE-2-f1-mean', 'ROUGE-2-f1-min',\\n 'ROUGE-2-f1-max', 'ROUGE-L-f1-mean', 'ROUGE-L-f1-min', 'ROUGE-L-f1-max'\\n ]\\n\\n return [np.array(all_scores[name], dtype=np.float32) for name in score_names]\",\n \"def evaluate(predictions, documents):\\n ###TODO\\n x = 0.0\\n y = 0 #true ham, classified spam\\n z = 0 #true spam, classified ham\\n \\n for i in range(0,len(predictions)):\\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\\n z += 1\\n if(documents[i].label == 'sod' and predictions[i] == 'pop'):\\n y += 1 \\n \\n x = (len(documents) - (y+z)) / len(documents) \\n return (x,y,z)\\n pass\",\n \"def PredictReviewScore(self, sentences, label=0):\\n AdjR = 0.0\\n # if text.startswith(\\\"For more photos and reviews do check out fourleggedfoodies\\\"):\\n # x = 1\\n adjAll = []\\n for sentence in sentences:\\n adjectives, dependencies = self.ExtractSentDetails(sentence)\\n adjAll.extend(adjectives)\\n allAdjectives = adjectives | Angel.GlobalAdjList\\n AdjS = 0.0\\n words = wordpunct_tokenize(sentence[\\\"Text\\\"])\\n if len(words) <= 3:\\n allAdjectives |= set([x.lower() for x in words])\\n for i in range(len(words)):\\n word = words[i].lower()\\n if word in {\\\"but\\\", \\\"if\\\"}:\\n AdjS = 0.0\\n elif word in allAdjectives and word in self.lexicon:\\n AdjS += float(self.lexicon[word]) * self.PredictMultiplier(word, dependencies[word], words, i)\\n AdjR += AdjS\\n AdjR *= self.PredictBase(adjAll)\\n finalScore = AdjR\\n if self.DumpRequested(finalScore, label):\\n self.DumpDetails(sentences, label)\\n return finalScore\",\n \"def score(self, predictions):\\n return 0.\",\n \"def run_evaluate_compound(self, data):\\n tp = 0\\n tn = 0\\n fp = 0\\n fn = 0\\n for words, labels, pos in minbatch_generator(data, self.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words, pos)\\n if not type(labels_pred) == list:\\n labels_pred = labels_pred.tolist()\\n for i, label_actual in enumerate(labels):\\n # we have to now find all aspect terms. That is, merge consecutive B \\n # with I's until we get an O or B\\n a_terms_actual, non_a_terms_actual = get_aspect_chunks(label_actual)\\n for a_term in a_terms_actual:\\n # say we have [1,2,3] as our a_term. we have to make sure that our \\n # prediction should have tags B, I, I in 1, 2 and 3 indices respectively\\n a_term_pred = []\\n for index in a_term:\\n if not label_actual[index] == labels_pred[i][index]:\\n fn += 1\\n break\\n else:\\n tp += 1\\n for index in non_a_terms_actual:\\n if label_actual[index] == labels_pred[i][index]:\\n tn += 1\\n else:\\n fp += 1\\n\\n precision = 0 if tp+fp == 0 else tp/(tp+fp)\\n recall = 0 if tp+fn == 0 else tp/(tp+fn)\\n fscore = 0 if precision+recall == 0 else (2*recall*precision)/(recall+precision)\\n metrics = dict()\\n metrics[\\\"p_1\\\"] = precision\\n metrics[\\\"f_1\\\"] = fscore\\n metrics[\\\"r_1\\\"] = recall\\n return metrics\",\n \"def _bleu_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], numerator: Tensor, denominator: Tensor, preds_len: Tensor, target_len: Tensor, n_gram: int=4, tokenizer: Callable[[str], Sequence[str]]=_tokenize_fn) ->Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[(tokenizer(line) if line else []) for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [(tokenizer(line) if line else []) for line in preds]\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n ngram_counter_clip = preds_counter & target_counter\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n return preds_len, target_len\",\n \"def score(self, phrases):\\n pred = self.predict(phrases)\\n return accuracy_score(preprocessor.getLabels(phrases), pred)\",\n \"def evaluate(groundtruth, prediction, tiou_threshold=0.5):\\n\\n video_num = len(groundtruth)\\n print('Computing grounding accuracy over {} videos...'.format(video_num))\\n acc, acc_sub, acc_obj = 0.0, 0.0, 0.0\\n\\n gt_rnum = 0\\n for qid, relation_gt in groundtruth.items():\\n\\n if qid not in prediction:\\n continue\\n relation_pred = prediction[qid]\\n if len(relation_pred) == 0:\\n continue\\n\\n video_acc, video_acc_sub, video_acc_obj, relation_num = eval_ground_scores(relation_gt, relation_pred, tiou_threshold)\\n\\n acc += video_acc\\n acc_sub += video_acc_sub\\n acc_obj += video_acc_obj\\n gt_rnum += relation_num\\n\\n\\n acc /= video_num\\n acc_sub /= video_num\\n acc_obj /= video_num\\n\\n print(\\\"Acc_S\\\\t Acc_O\\\\t Acc_R\\\")\\n\\n print('{:.2f}\\\\t {:.2f}\\\\t {:.2f}'.format(acc_sub*100, acc_obj*100, acc*100))\",\n \"def compute_scores(self):\\n if self.num_classes == 2:\\n score_1 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold=0.5,\\n )[1]\\n\\n score_2 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold_ratio=0.5,\\n )[1]\\n\\n score_3 = self.competition_metric(\\n impact_threshold=0.5,\\n )[1]\\n else:\\n score_1 = self.detection_metric(threshold=0.1)\\n score_2 = self.detection_metric(threshold=0.25)\\n score_3 = self.detection_metric(threshold=0.5)\\n\\n return score_1, score_2, score_3\",\n \"def labels_to_scores(labels):\\n device = sp.get_device(labels)\\n xp = device.xp\\n with device:\\n num_classes = labels.max() + 1\\n scores = xp.zeros([len(labels), num_classes], dtype=np.float32)\\n scores[xp.arange(len(labels)), labels] = 1\\n\\n return scores\",\n \"def evaluate(labels, predictions):\\n pos = 0\\n neg = 0\\n true_pos_rate = 0\\n true_neg_rate = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n pos += 1\\n else:\\n neg += 1\\n if predictions[i] == labels[i]:\\n if predictions[i] == 1:\\n true_pos_rate += 1\\n else:\\n true_neg_rate += 1\\n \\n sensitivity = true_pos_rate / pos\\n specificity = true_neg_rate / neg\\n\\n return (sensitivity, specificity)\",\n \"def evaluate(ground_truth, prediction):\\n\\n def prfs_to_dict(prfs):\\n \\\"\\\"\\\"Returns a precision_recall_fscore_support() result as a dict.\\\"\\\"\\\"\\n return {\\\"precision\\\": prfs[0], \\\"recall\\\": prfs[1], \\\"fscore\\\": prfs[2]}\\n\\n results = {}\\n items_count = len(ground_truth)\\n\\n # accuracy\\n accuracy = accuracy_score(ground_truth, prediction)\\n results[\\\"accuracy\\\"] = accuracy\\n\\n # confusion matrix\\n categories = set(ground_truth) | set(prediction)\\n confusions = {\\n gold: {pred: 0 for pred in categories} for gold in categories\\n }\\n for g, p in zip(ground_truth, prediction):\\n confusions[g][p] += 1\\n results[\\\"confusions\\\"] = confusions\\n\\n # class wise precision, recall & f1\\n classwise = precision_recall_fscore_support(\\n ground_truth, prediction, average=None, warn_for=()\\n )\\n results[\\\"true_cat_dist\\\"] = list(classwise[-1])\\n results[\\\"classwise\\\"] = {\\n str(cl): prfs_to_dict(\\n [classwise[0][cl], classwise[1][cl], classwise[2][cl]]\\n )\\n for cl in categories\\n }\\n\\n # average precision, recall & f1\\n results[\\\"macro_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"macro\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n results[\\\"micro_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"micro\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n results[\\\"weigh_avg\\\"] = prfs_to_dict(\\n precision_recall_fscore_support(\\n ground_truth,\\n prediction,\\n average=\\\"weighted\\\",\\n pos_label=None,\\n warn_for=(),\\n )\\n )\\n\\n # marginals\\n gold_category_distribution = {\\n g: sum([confusions[g][p] for p in categories]) for g in categories\\n }\\n pred_category_distribution = {\\n p: sum([confusions[g][p] for g in categories]) for p in categories\\n }\\n\\n # kappa\\n expected_agreement_fleiss = sum(\\n [\\n (\\n (gold_category_distribution[c] + pred_category_distribution[c])\\n / (2.0 * items_count)\\n )\\n ** 2\\n for c in categories\\n ]\\n )\\n expected_agreement_cohen = sum(\\n [\\n (float(gold_category_distribution[c]) / items_count)\\n * (float(pred_category_distribution[c]) / items_count)\\n for c in categories\\n ]\\n )\\n kappa_fleiss = (\\n 1.0\\n * (accuracy - expected_agreement_fleiss)\\n / (1 - expected_agreement_fleiss)\\n )\\n kappa_cohen = (\\n 1.0\\n * (accuracy - expected_agreement_cohen)\\n / (1 - expected_agreement_cohen)\\n )\\n results[\\\"k_fleiss\\\"] = {\\n \\\"k\\\": kappa_fleiss,\\n \\\"AE\\\": expected_agreement_fleiss,\\n \\\"AO\\\": accuracy,\\n }\\n results[\\\"k_cohen\\\"] = {\\n \\\"k\\\": kappa_cohen,\\n \\\"AE\\\": expected_agreement_cohen,\\n \\\"AO\\\": accuracy,\\n }\\n\\n return results\",\n \"def score(self, X_test: List[str], y_test: List[str]) -> int:\\n predictions_count = 0\\n right_predictions_count = 0\\n\\n for i in range(len(X_test)):\\n label = self.predict(X_test[i].split())\\n predictions_count += 1\\n right_predictions_count += 1 if label == y_test[i] else 0\\n\\n return right_predictions_count / predictions_count\",\n \"def ocr_metrics(predicts, ground_truth):\\n\\n if len(predicts) == 0 or len(ground_truth) == 0:\\n return (1, 1, 1)\\n\\n cer, wer, ser = [], [], []\\n\\n for (pd, gt) in zip(predicts, ground_truth):\\n pd_cer, gt_cer = list(pd), list(gt)\\n dist = editdistance.eval(pd_cer, gt_cer)\\n cer.append(dist / (max(len(pd_cer), len(gt_cer))))\\n\\n pd_wer, gt_wer = pd.split('|'), gt.split('|')\\n dist = editdistance.eval(pd_wer, gt_wer)\\n wer.append(dist / (max(len(pd_wer), len(gt_wer))))\\n\\n # pd_ser, gt_ser = [pd], [gt]\\n # dist = editdistance.eval(pd_ser, gt_ser)\\n # ser.append(dist / (max(len(pd_ser), len(gt_ser))))\\n\\n metrics = [wer, cer]#, ser]\\n metrics = np.mean(metrics, axis=1)\\n\\n return metrics\",\n \"def eval_metrics_for_multiclass(self, predicted_answers):\\n total_correct_in_all = 0\\n total_pred_in_all = len(predicted_answers)\\n # initial a dict for total correct in topK counting.\\n total_correct_in_topK = dict([(i, 0) for i in self.topK_list])\\n total_pred_in_topK = dict([(i, 0) for i in self.topK_list])\\n max_topK = max(self.topK_list)\\n label_pred = []\\n label_true = []\\n label_weights = []\\n digits = 3\\n metrics = {}\\n\\n for e_id, sample in predicted_answers.iteritems():\\n # get all correct ids\\n correct_label_indices = sample['correct_labels']\\n # current case, we only have a majority lable for the correct label\\n label_true.append(correct_label_indices[0])\\n # counting all correct for each sample\\n total_correct_in_all += len(correct_label_indices)\\n # select topK\\n sorted_probs_max_topK = sorted(sample['pred_probs'], reverse=True, key=lambda x: x['prob'])[:max_topK]\\n top1_pred = sorted_probs_max_topK[0]\\n label_pred.append(top1_pred['label_index'])\\n\\n # for all topK predictions\\n for i in range(len(sorted_probs_max_topK)):\\n pred = sorted_probs_max_topK[i]\\n for topK in self.topK_list:\\n if i >= topK:\\n continue\\n else:\\n total_pred_in_topK[topK] += 1\\n if pred['label_index'] in correct_label_indices:\\n total_correct_in_topK[topK] += 1\\n\\n if total_correct_in_all != 0:\\n # recall@K\\n recall_at_K = dict([(k, total_correct_in_topK[k] / (total_correct_in_all * 1.0)) for k in self.topK_list])\\n # assign recall@K into metrics\\n for k, v in recall_at_K.items():\\n # Jie\\n # 1 means the greater the better.\\n # -1 means the smaller the better.\\n metrics['R@{}'.format(k)] = (1, v)\\n\\n self.logger.info('total_correct_in_all = {}, correct_in_topK = {}, recall@K = {}'.format(total_correct_in_all, sorted(total_correct_in_topK.items()), sorted(recall_at_K.items())))\\n # here return all the p,r,f for each label, then we compute the micro average later.\\n p, r, f1, s = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average=None)\\n total_s = np.sum(s)\\n p_micro, r_micro, f1_micro, _ = precision_recall_fscore_support(label_true, label_pred, beta=1.0, labels=range(self.num_classes), average='micro')\\n last_lines_heading = ['macro / total', 'weighted_mac / total', 'micro / total']\\n target_names = self.classes\\n name_width = max(len(cn) for cn in target_names)\\n width = max(name_width, max([len(x) for x in last_lines_heading]), digits)\\n\\n headers = [\\\"precision\\\", \\\"recall\\\", \\\"f1-score\\\", \\\"support\\\"]\\n head_fmt = u'{:>{width}s} ' + u' {:>9}' * len(headers)\\n report = head_fmt.format(u'', *headers, width=width)\\n report += u'\\\\n\\\\n'\\n row_fmt = u'{:>{width}s} ' + u' {:>9.{digits}f}' * 3 + u' {:>9}\\\\n'\\n rows = zip(target_names, p, r, f1, s)\\n for row in rows:\\n label_weights.append(row[4])\\n report += row_fmt.format(*row, width=width, digits=digits)\\n metrics['P_{}'.format(row[0])] = (1, row[1])\\n metrics['R_{}'.format(row[0])] = (1, row[2])\\n metrics['F1_{}'.format(row[0])] = (1, row[3])\\n report += u'\\\\n'\\n\\n # compute macro averages\\n p_macro = np.average(p, weights = None)\\n r_macro = np.average(r, weights = None)\\n f1_macro = np.average(f1, weights = None)\\n metrics['P_{}'.format(\\\"macro\\\")] = (1, p_macro)\\n metrics['R_{}'.format(\\\"macro\\\")] = (1, r_macro)\\n metrics['F1_{}'.format(\\\"macro\\\")] = (1, f1_macro)\\n report += row_fmt.format(last_lines_heading[0],\\n p_macro,\\n r_macro,\\n f1_macro,\\n total_s,\\n width=width, digits=digits)\\n\\n # compute weighted macro average\\n label_weights = map(lambda x : x/(total_s * 1.0), label_weights)\\n p_weighted_average = np.average(p, weights = label_weights)\\n r_weighted_average = np.average(r, weights = label_weights)\\n f1_weighted_average = np.average(f1, weights = label_weights)\\n metrics['P_{}'.format(\\\"weighted_macro\\\")] = (1, p_weighted_average)\\n metrics['R_{}'.format(\\\"weighted_macro\\\")] = (1, r_weighted_average)\\n metrics['F1_{}'.format(\\\"weighted_macro\\\")] = (1, f1_weighted_average)\\n report += row_fmt.format(last_lines_heading[1],\\n p_weighted_average,\\n r_weighted_average,\\n f1_weighted_average,\\n total_s,\\n width=width, digits=digits)\\n # micro average\\n metrics['P_{}'.format(\\\"micro\\\")] = (1, p_micro)\\n metrics['R_{}'.format(\\\"micro\\\")] = (1, r_micro)\\n metrics['F1_{}'.format(\\\"micro\\\")] = (1, f1_micro)\\n report += row_fmt.format(last_lines_heading[2],\\n p_micro,\\n r_micro,\\n f1_micro,\\n total_s,\\n width=width, digits=digits)\\n\\n self.logger.info(\\\"P,R,F1 report as follows:\\\\n {}\\\".format(report))\\n # only plot it at dev and test time, not during training.\\n if self.gen_confusing_matrix:\\n\\n self.logger.info(\\\"Generate confusing matrix photo.\\\")\\n # Compute confusion matrix\\n conf_matrix = confusion_matrix(label_true, label_pred)\\n np.set_printoptions(precision=2)\\n\\n # Plot non-normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d',\\n title='Confusion matrix, without normalization')\\n wo_norm_fig_path = os.path.join(self.result_dir, '{}_wo_norm.png'.format(self.result_prefix))\\n plt.savefig(wo_norm_fig_path)\\n\\n # Plot normalized confusion matrix\\n plt.figure()\\n self.plot_confusion_matrix(conf_matrix, classes=self.brief_classes, ori_fmt='d', normalize=True,\\n title='Normalized confusion matrix')\\n\\n norm_fig_path = os.path.join(self.result_dir, '{}_w_norm.png'.format(self.result_prefix))\\n plt.savefig(norm_fig_path)\\n\\n else:\\n self.logger.warn('invalid total_correct_in_all')\\n\\n return metrics\",\n \"def evaluate(self, predicted_df):\\n logging.info(\\\"Evaluating model: {}\\\".format(self.model_type))\\n y_true = predicted_df[\\\"user_label\\\"].as_matrix()\\n y_pred = predicted_df[\\\"label\\\"].as_matrix()\\n\\n scores_cols = [col for col in predicted_df.columns if col.startswith(\\\"scores_\\\")]\\n print(\\\"scores_cols: {}\\\".format(scores_cols))\\n\\n y_pred_scores = predicted_df[scores_cols].copy().fillna(value=0).as_matrix()\\n print(\\\"predicted scores: {}\\\".format(y_pred_scores))\\n y_true_scores = []\\n for lab in predicted_df[\\\"user_label\\\"]:\\n trues = [0 for _ in range(len(scores_cols))]\\n if \\\"scores_\\\"+lab in scores_cols:\\n trues[scores_cols.index(\\\"scores_\\\"+lab)] = 1\\n y_true_scores.append(trues)\\n print(\\\"true scores: {}\\\".format(y_true_scores))\\n y_true_scores = np.array(y_true_scores)\\n\\n performance = {\\\"model\\\": self.model_type, \\\"description\\\": self.description}\\n if 'categorical_accuracy' in self.metrics:\\n logging.info(\\\"Calculating categorical accuracy for {}\\\".format(self))\\n performance['categorical_accuracy'] = sklearn.metrics.accuracy_score(y_true,\\n y_pred) # np.mean(y_pred == y_true)\\n if 'fmeasure' in self.metrics:\\n logging.info(\\\"Calculating fmeasure for {}\\\".format(self))\\n performance['fmeasure'] = sklearn.metrics.f1_score(y_true, y_pred, average=self.metrics_average)\\n if 'MRR' in self.metrics:\\n logging.info(\\\"Calculating MRR for {}\\\".format(self))\\n performance['MRR'] = sklearn.metrics.label_ranking_average_precision_score(y_true_scores, y_pred_scores)\\n logging.info(\\\"Calculated performance: {}\\\".format(performance))\\n print(performance)\\n return pd.DataFrame(performance, index=[0])\",\n \"def _compute_scores(y_pred, y_true):\\n auc = accuracy_score(y_true = y_true, y_pred = y_pred)\\n pre = precision_score(y_true, y_pred, average = \\\"macro\\\")\\n rec = recall_score(y_true, y_pred, average = \\\"macro\\\")\\n f1 = f1_score(y_true, y_pred, average = \\\"macro\\\")\\n\\n return pd.Series(data = [auc, pre, rec, f1], index = ['acc', 'pre', 'rec', 'f1'])\",\n \"def evaluate(labels, predictions):\\n #labels and predictions\\n truePos = 0\\n trueNeg = 0\\n for data in range(len(labels)):\\n if((predictions[data] == 1) and (predictions[data] == labels[data])):\\n truePos+=1\\n elif((predictions[data] == 0) and (predictions[data] == labels[data])):\\n trueNeg+=1\\n sensitivity = truePos/(len(labels) + 1)\\n specificity = trueNeg/(len(labels) + 1)\\n return (sensitivity, specificity)\\n \\n\\n #raise NotImplementedError\",\n \"def evaluate(labels, predictions):\\n actual_positive = 0\\n actual_negative = 0\\n predicted_positive = 0\\n predicted_negative = 0\\n for i, j in zip(labels, predictions):\\n if i == 1:\\n actual_positive += i\\n predicted_positive += j\\n else:\\n actual_negative += 1\\n if j == 0:\\n predicted_negative += 1\\n return predicted_positive/actual_positive, predicted_negative/actual_negative\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def _compute_scores(self, triples):\\n # compute scores as sum(s * p * o)\\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\\n return scores\",\n \"def classify(self, documents):\\n predictions = []\\n for doc in documents:\\n\\n score_sod = math.log(self.priorSOD)\\n score_pop = math.log(self.priorPOP)\\n for term in doc.tokens:\\n if term in self.cond_prob_sod.keys():\\n score_sod += math.log(self.cond_prob_sod[term])\\n if term in self.cond_prob_pop.keys():\\n score_pop += math.log(self.cond_prob_pop[term])\\n if(score_pop >= score_sod): #defaults to ham if score = even \\n predictions.append('pop')\\n else:\\n predictions.append('sod')\\n \\n return predictions \\n pass\",\n \"def calc_metrics(pred, labels):\\n pred_flat = np.argmax(pred, axis = 1).flatten()\\n labels_flat = labels.flatten()\\n \\n flat_accuracy = np.sum(pred_flat == labels_flat) / len(labels_flat)\\n \\n # sklearn takes first parameter as the true label\\n precision = precision_score(labels_flat, pred_flat)\\n recall = recall_score(labels_flat, pred_flat)\\n \\n return flat_accuracy, precision, recall\",\n \"def evaluate(predictions, ids, label_identifiers):\\n\\n labels = []\\n #For every prediction\\n for i in range(len(predictions)):\\n sentence_predictions = predictions[i]\\n id_sequence = ids[i]\\n sequence_labels = []\\n counter = 0\\n #For every predicted token\\n for j in range(len(id_sequence)):\\n word_prediction = sentence_predictions[j]\\n id = id_sequence[j]\\n #Take only the lemmas that have to be disambiguated\\n if not id == '0':\\n #Extract the identifiers of the sensekeys associated to the lemma\\n indexes = label_identifiers[i][counter]\\n new_predictions = []\\n #Check if the identifier is a number \\n for elem in indexes:\\n try:\\n index = int(elem)\\n new_predictions.append(predictions[i][j][index])\\n except ValueError:\\n #If is not, MFS was applied\\n new_predictions.append(elem)\\n #Do the argmax on the extracted prediction indexes\\n argmax = np.argmax(new_predictions)\\n label = label_identifiers[i][counter][argmax]\\n sequence_labels.append(label)\\n counter += 1\\n labels.append(sequence_labels)\\n\\n return labels\",\n \"def _rouge_score_update(preds: Sequence[str], target: Sequence[Sequence[str]], rouge_keys_values: List[Union[int, str]], accumulate: str, stemmer: Optional[Any]=None, normalizer: Callable[[str], str]=None, tokenizer: Callable[[str], Sequence[str]]=None) ->Dict[Union[int, str], List[Dict[str, Tensor]]]:\\n results: Dict[Union[int, str], List[Dict[str, Tensor]]] = {rouge_key: [] for rouge_key in rouge_keys_values}\\n for pred_raw, target_raw in zip(preds, target):\\n result_inner: Dict[Union[int, str], Dict[str, Tensor]] = {rouge_key: {} for rouge_key in rouge_keys_values}\\n result_avg: Dict[Union[int, str], List[Dict[str, Tensor]]] = {rouge_key: [] for rouge_key in rouge_keys_values}\\n list_results = []\\n pred = _normalize_and_tokenize_text(pred_raw, stemmer, normalizer, tokenizer)\\n if 'Lsum' in rouge_keys_values:\\n pred_lsum = [_normalize_and_tokenize_text(pred_sentence, stemmer, normalizer, tokenizer) for pred_sentence in _split_sentence(pred_raw)]\\n for target_raw_inner in target_raw:\\n tgt = _normalize_and_tokenize_text(target_raw_inner, stemmer, normalizer, tokenizer)\\n if 'Lsum' in rouge_keys_values:\\n target_lsum = [_normalize_and_tokenize_text(tgt_sentence, stemmer, normalizer, tokenizer) for tgt_sentence in _split_sentence(target_raw_inner)]\\n for rouge_key in rouge_keys_values:\\n if isinstance(rouge_key, int):\\n score = _rouge_n_score(pred, tgt, rouge_key)\\n elif rouge_key == 'L':\\n score = _rouge_l_score(pred, tgt)\\n elif rouge_key == 'Lsum':\\n score = _rouge_lsum_score(pred_lsum, target_lsum)\\n result_inner[rouge_key] = score\\n result_avg[rouge_key].append(score)\\n list_results.append(result_inner.copy())\\n if accumulate == 'best':\\n key_curr = rouge_keys_values[0]\\n all_fmeasure = torch.tensor([v[key_curr]['fmeasure'] for v in list_results])\\n highest_idx = int(torch.argmax(all_fmeasure).item())\\n for rouge_key in rouge_keys_values:\\n results[rouge_key].append(list_results[highest_idx][rouge_key])\\n elif accumulate == 'avg':\\n new_result_avg: Dict[Union[int, str], Dict[str, Tensor]] = {rouge_key: {} for rouge_key in rouge_keys_values}\\n for rouge_key, metrics in result_avg.items():\\n _dict_metric_score_batch: Dict[str, List[Tensor]] = {}\\n for metric in metrics:\\n for _type, value in metric.items():\\n if _type not in _dict_metric_score_batch:\\n _dict_metric_score_batch[_type] = []\\n _dict_metric_score_batch[_type].append(value)\\n new_result_avg[rouge_key] = {_type: torch.tensor(_dict_metric_score_batch[_type]).mean() for _type in _dict_metric_score_batch}\\n for rouge_key in rouge_keys_values:\\n results[rouge_key].append(new_result_avg[rouge_key])\\n return results\",\n \"def score(self, data):\\n\\n score_mappings = {\\n \\\"0\\\": np.log(self.class_zero_doc_count / self.total_docs),\\n \\\"1\\\": np.log(self.class_one_doc_count / self.total_docs)\\n }\\n\\n features = self.featurize(data)\\n\\n for f in features:\\n\\n if(f[0] in self.class_zero):\\n cond_prob_zero = np.log((self.class_zero[f[0]] + 1) / (self.class_zero_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_zero = np.log(1 / (self.class_zero_feature_count + len(self.vocab)))\\n else:\\n cond_prob_zero = 0\\n\\n if(f[0] in self.class_one):\\n cond_prob_one = np.log((self.class_one[f[0]] + 1) / (self.class_one_feature_count + len(self.vocab)))\\n elif(f[0] in self.vocab):\\n cond_prob_one = np.log(1 / (self.class_one_feature_count + len(self.vocab)))\\n else:\\n cond_prob_one = 0\\n\\n score_mappings[\\\"0\\\"] += cond_prob_zero\\n score_mappings[\\\"1\\\"] += cond_prob_one\\n\\n score_mappings[\\\"0\\\"] = np.exp(score_mappings[\\\"0\\\"])\\n score_mappings[\\\"1\\\"] = np.exp(score_mappings[\\\"1\\\"])\\n\\n return score_mappings\",\n \"def evaluate(labels, predictions):\\n\\n truePositiveCounter = 0\\n trueNegativeCounter = 0\\n truePositiveCorrect = 0\\n trueNegativeCorrect = 0\\n \\n sensitivity = 0\\n specificity = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n truePositiveCounter += 1\\n if(labels[i] == predictions[i]):\\n truePositiveCorrect += 1\\n elif labels[i] == 0:\\n trueNegativeCounter += 1\\n if(labels[i] == predictions[i]):\\n trueNegativeCorrect += 1\\n\\n sensitivity = truePositiveCorrect / truePositiveCounter\\n specificity = trueNegativeCorrect / trueNegativeCounter\\n\\n return sensitivity, specificity\",\n \"def evaluate(gold, predictions):\\n # gold = {i[\\\"id\\\"]:i[\\\"label\\\"] for i in read(goldfile)}\\n # sys = {i[\\\"id\\\"]:i[\\\"prediction\\\"] for i in read(sysfile)}\\n\\n labels, preds = [], []\\n for idx in gold:\\n labels.append(gold[idx])\\n preds.append(predictions[idx])\\n\\n precision_macro, recall_macro, f1_macro, _ = precision_recall_fscore_support(labels, preds, labels=[0, 1],\\n average=\\\"macro\\\")\\n print(\\\"F1-macro score for test data predictions are: %.4f\\\" % f1_macro)\\n return preds\",\n \"def recall(gold_labels, predicted_labels):\\n \\n true_pos = 0 #gold pos sys pos\\n false_neg = 0 #gold pos sys neg\\n\\n for i in range(0, len(gold_labels)):\\n if(gold_labels[i] == predicted_labels[i] == \\\"1\\\"):\\n true_pos += 1\\n elif(gold_labels[i] == \\\"1\\\" and predicted_labels[i] == \\\"0\\\"):\\n false_neg += 1\\n\\n if(true_pos == 0):\\n return 0\\n else:\\n return float(true_pos / (true_pos + false_neg))\",\n \"def evaluate(y_true, y_preds, labels=[0, 1, 2, 3, 4]):\\n p_scores = []\\n r_scroes = []\\n for label in labels:\\n p = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_preds == label).sum() + 0.001)\\n p_scores.append(p)\\n r = (((y_true == label) * (y_preds == label)).sum()+0.001) / ((y_true == label).sum() + 0.001)\\n r_scroes.append(r)\\n p_scores = np.array(p_scores)\\n r_scroes = np.array(r_scroes)\\n f1 = 2 * (p_scores * r_scroes + 0.001) / (p_scores + r_scroes + 0.001)\\n\\n confmat = []\\n for label in labels:\\n conf = []\\n for label2 in labels:\\n conf.append(((y_preds == label) * (y_true == label2)).sum())\\n confmat.append(conf)\\n confmat = np.array(confmat)\\n\\n return p_scores, r_scroes, f1, confmat\",\n \"def cal_err(label_scores, predicted_scores, top_k_int=1, use_predicted_order=False):\\n \\n if not use_predicted_order:\\n max_label_score = tf.reduce_max(label_scores)\\n sorted_labels, predicted_order, sorted_predictions = _get_ranking_orders(\\n label_scores, predicted_scores, top_k_int=top_k_int)\\n else:\\n indices = tf.range(top_k_int)\\n predicted_order = tf.gather(predicted_scores, indices)\\n max_label_score = tf.reduce_max(label_scores)\\n\\n predicted_relevance = _get_relevance_scores(predicted_order)\\n predicted_relevance_ratio = predicted_relevance / (2**max_label_score)\\n _ratio = 1- predicted_relevance_ratio\\n prob_stepdown = tf.cumprod(_ratio, exclusive=True)\\n cur_rank = tf.range(top_k_int) + 1\\n cur_rank = tf.cast(cur_rank, dtype=tf.float32)\\n cur_rank = tf.reshape(cur_rank, [-1, 1])\\n products = tf.multiply(predicted_relevance_ratio, prob_stepdown)\\n products = tf.cast(products, dtype=tf.float32)\\n errs = tf.divide(products, cur_rank)\\n err = tf.reduce_sum(errs)\\n return err\",\n \"def evaluate(labels, predictions):\\n\\n true_positives = 0\\n label_positives = 0\\n\\n true_negatives = 0\\n label_negatives = 0\\n\\n for i in range(len(predictions)):\\n if labels[i] == predictions[i] == 1:\\n true_positives += 1\\n if labels[i] == 1:\\n label_positives += 1\\n\\n if labels[i] == predictions[i] == 0:\\n true_negatives += 1\\n if labels[i] == 0:\\n label_negatives += 1\\n\\n return true_positives / label_positives, true_negatives / label_negatives\\n\\n # raise NotImplementedError\",\n \"def score(self, test_data):\\n\\n\\t\\tins, outs = self._split_inputs_outputs(test_data)\\n\\n\\t\\t# One hot encode the input/labels\\n\\t\\tencoder = LabelEncoder()\\n\\t\\tencoder.fit(outs)\\n\\t\\tenc_labels = encoder.transform(outs)\\n\\t\\tenc_labels = np_utils.to_categorical(enc_labels)\\n\\n\\t\\t_, score = self.model.evaluate(ins, enc_labels, verbose=2)\\n\\n\\t\\treturn score\",\n \"def evaluate(labels, predictions):\\n correct_positive = 0\\n correct_negative = 0\\n total_positive = 0\\n total_negative = 0\\n\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n total_positive += 1\\n if predictions[i] == 1:\\n correct_positive += 1\\n else:\\n total_negative += 1\\n if predictions[i] == 0:\\n correct_negative += 1\\n\\n sensitivity = correct_positive / total_positive\\n specificity = correct_negative / total_negative\\n\\n return sensitivity, specificity\",\n \"def evaluate(model, df_result, label='test'):\\n\\n y_true = df_result['RUL']\\n y_hat = df_result['y_hat']\\n df_result['breakdown'].replace(0, False, inplace=True) # rsf only takes true or false\\n df_result['breakdown'].replace(1, True, inplace=True) # rsf only takes true or false\\n\\n mse = mean_squared_error(y_true, y_hat)\\n rmse = np.sqrt(mse)\\n variance = r2_score(y_true, y_hat)\\n\\n # the concordance index (CI) is interested on the order of the predictions, not the predictions themselves\\n # CI can only be measured between individual samples where a censoring or failure event occurred\\n # https://medium.com/analytics-vidhya/concordance-index-72298c11eac7#:~:text=The%20concordance%20index%20or%20c,this%20definition%20mean%20in%20practice\\n df_result_grouped = df_result.groupby('unit num').last()\\n breakdown = df_result_grouped['breakdown']\\n y_true = df_result_grouped['RUL']\\n y_hat = df_result_grouped['y_hat']\\n ci_sk = ci_scikit(breakdown, y_true, y_hat)[0]\\n score = nasaScore(y_true, y_hat) # score should be based on the last instance\\n # print(f'Number of concordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[1]}')\\n # print(f'Number of discordant pairs (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[2]}')\\n # print(f'Number of pairs having tied estimated risks (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[3]}')\\n # print(f'Number of comparable pairs sharing the same time (scikit-survival): {ci_scikit(breakdown, y_true, y_hat)[4]}')\\n print('{} set RMSE:{:.2f}, Score:{:.2f}, CI(scikit):{:.4f}, R2:{:.2f}'.format(label, rmse, score, ci_sk, variance))\\n result = [model, label, rmse, score, ci_sk, variance]\\n return result\",\n \"def score(self, X, y):\\n predictions = self.predict(X)\\n total_values = len(y)\\n accuracy = 0\\n if 'classification' == self.label_type:\\n correct_values = np.where(predictions == y)\\n accuracy = correct_values[0].size / total_values\\n elif 'regression' == self.label_type:\\n sse = (y - predictions) ** 2\\n sse_summed = np.sum(sse)\\n accuracy = sse_summed / total_values\\n\\n return accuracy\",\n \"def _eval_classifier(self):\\n\\n y_pred_baseline = self.df_baseline[self.score_column]\\n y_pred_sample = self.df_sample[self.score_column]\\n\\n y_label_baseline = self.df_baseline[self.label_column]\\n y_label_sample = self.df_sample[self.label_column]\\n\\n precision_baseline = precision_score(y_label_baseline, y_pred_baseline)\\n recall_baseline = recall_score(y_label_baseline, y_pred_baseline)\\n acc_baseline = accuracy_score(y_label_baseline, y_pred_baseline)\\n f1_baseline = f1_score(y_label_baseline, y_pred_baseline)\\n try:\\n auc_baseline = roc_auc_score(y_label_baseline, y_pred_baseline)\\n except ValueError:\\n auc_baseline = \\\"NA\\\"\\n\\n precision_sample = precision_score(y_label_sample, y_pred_sample)\\n recall_sample = recall_score(y_label_sample, y_pred_sample)\\n acc_sample = accuracy_score(y_label_sample, y_pred_sample)\\n f1_sample = f1_score(y_label_sample, y_pred_sample)\\n try:\\n auc_sample = roc_auc_score(y_label_sample, y_pred_sample)\\n except ValueError:\\n auc_sample = \\\"NA\\\"\\n\\n metrics_df = pd.DataFrame(\\n {\\n \\\"Accuracy\\\": [acc_baseline, acc_sample],\\n \\\"Precision\\\": [precision_baseline, precision_sample],\\n \\\"Recall\\\": [recall_baseline, recall_sample],\\n \\\"F1\\\": [f1_baseline, f1_sample],\\n \\\"AUC\\\": [auc_baseline, auc_sample],\\n },\\n index=[\\\"baseline\\\", \\\"sample\\\"],\\n )\\n\\n self.performance_comparison = metrics_df\",\n \"def label_accuracy_score(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n # 一个batch里面可能有多个数据\\n # 通过迭代器将一个个数据进行计算\\n for lt, lp in zip(label_trues, label_preds):\\n # numpy.ndarray.flatten将numpy对象拉成1维\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n\\n # np.diag(a)假如a是一个二维矩阵，那么会输出矩阵的对角线元素\\n # np.sum()可以计算出所有元素的和。如果axis=1，则表示按行相加\\n \\\"\\\"\\\"\\n acc是准确率 = 预测正确的像素点个数/总的像素点个数\\n acc_cls是预测的每一类别的准确率(比如第0行是预测的类别为0的准确率)，然后求平均\\n iu是召回率Recall，公式上面给出了\\n mean_iu就是对iu求了一个平均\\n freq是每一类被预测到的频率\\n fwavacc是频率乘以召回率，我也不知道这个指标代表什么\\n \\\"\\\"\\\"\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n # nanmean会自动忽略nan的元素求平均\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n return acc, acc_cls, mean_iu, fwavacc\",\n \"def scoring(estimator, features_test, labels_test):\\n pred = estimator.predict(features_test)\\n p = metrics.precision_score(labels_test, pred, average='micro')\\n r = metrics.recall_score(labels_test, pred, average='micro')\\n if p > 0.3 and r > 0.3:\\n return metrics.f1_score(labels_test, pred, average='macro')\\n return 0\",\n \"def eval(self, test_docs, test_labels):\\n assert len(test_docs)==len(test_labels)\\n preds = [] # predicted labels\\n for doc,y_gold in zip(test_docs,test_labels):\\n y_pred = self.predict(doc)\\n preds.append(y_pred)\\n ev = Eval(test_labels, preds)\\n return ev.accuracy()\",\n \"def score_pred(Y_lab, Y_prob, threshold):\\n Y_thresh = Y_prob >= threshold\\n\\n precision = []\\n recall = []\\n fbeta_score = []\\n support = []\\n voe = []\\n acc = []\\n\\n Y_lab = Y_lab.reshape(-1)\\n Y_thresh = Y_thresh.reshape(-1)\\n\\n # Compute precision/recall scores\\n scores = precision_recall_fscore_support(y_true=Y_lab, y_pred=Y_thresh)\\n precision.append(scores[0][1])\\n recall.append(scores[1][1])\\n fbeta_score.append(scores[2][1])\\n support.append(scores[3][1]/(scores[3][0] + scores[3][1])) # percent of volume occupied by tumor\\n voe.append(jaccard_similarity_score(y_true=Y_lab, y_pred=Y_thresh))\\n acc.append(accuracy_score(y_true=Y_lab, y_pred=Y_thresh, normalize=True))\\n\\n return precision, recall, fbeta_score, support, voe, acc\",\n \"def ranked_accuracy(predictions, labels):\\n rank1 = 0\\n rank5 = 0\\n\\n for (pred, lbl) in zip(predictions, labels):\\n pred = np.argsort(pred)[::-1]\\n\\n if lbl in pred[:5]:\\n rank5+=1\\n\\n if lbl == pred[0]:\\n rank1+=1\\n\\n rank1 /= float(len(labels))\\n rank5 /= float(len(labels))\\n\\n return (rank1, rank5)\",\n \"def _rouge_n_score(pred: Sequence[str], target: Sequence[str], n_gram: int) ->Dict[str, Tensor]:\\n\\n def _create_ngrams(tokens: Sequence[str], n: int) ->Counter:\\n ngrams: Counter = Counter()\\n for ngram in (tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1)):\\n ngrams[ngram] += 1\\n return ngrams\\n pred_ngrams, target_ngrams = _create_ngrams(pred, n_gram), _create_ngrams(target, n_gram)\\n pred_len, target_len = sum(pred_ngrams.values()), sum(target_ngrams.values())\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n hits = sum(min(pred_ngrams[w], target_ngrams[w]) for w in set(pred_ngrams))\\n return _compute_metrics(hits, max(pred_len, 1), max(target_len, 1))\",\n \"def evaluate(model, eval_data, num_labels): \\n # Turn on the evaluation state to ignore dropouts\\n model.eval()\\n results = [predict(model, x) for x, y in eval_data]\\n f1_score, accuracy = get_metrics(np.array([y for x, y in eval_data]), results, num_labels)\\n return f1_score, accuracy\",\n \"def _bleu_score_update(\\n preds: Sequence[str],\\n target: Sequence[Sequence[str]],\\n numerator: Tensor,\\n denominator: Tensor,\\n preds_len: Tensor,\\n target_len: Tensor,\\n n_gram: int = 4,\\n tokenizer: Callable[[str], Sequence[str]] = _tokenize_fn,\\n) -> Tuple[Tensor, Tensor]:\\n target_: Sequence[Sequence[Sequence[str]]] = [[tokenizer(line) if line else [] for line in t] for t in target]\\n preds_: Sequence[Sequence[str]] = [tokenizer(line) if line else [] for line in preds]\\n\\n for pred, targets in zip(preds_, target_):\\n preds_len += len(pred)\\n target_len_list = [len(tgt) for tgt in targets]\\n target_len_diff = [abs(len(pred) - x) for x in target_len_list]\\n target_len += target_len_list[target_len_diff.index(min(target_len_diff))]\\n preds_counter: Counter = _count_ngram(pred, n_gram)\\n target_counter: Counter = Counter()\\n\\n for tgt in targets:\\n target_counter |= _count_ngram(tgt, n_gram)\\n\\n ngram_counter_clip = preds_counter & target_counter\\n\\n for counter_clip in ngram_counter_clip:\\n numerator[len(counter_clip) - 1] += ngram_counter_clip[counter_clip]\\n\\n for counter in preds_counter:\\n denominator[len(counter) - 1] += preds_counter[counter]\\n\\n return preds_len, target_len\",\n \"def _compute_relex_metrics(self,\\n batch_predicted_relations,\\n batch_doc_raw_relations):\\n\\n # Evaluation is done on document level.\\n for doc_predictions, doc_relations in zip(batch_predicted_relations,\\n batch_doc_raw_relations):\\n # TODO Change Metrics interface, feed raw sets\\n # TODO Decode sentence_predictions as dict, not list of triples\\n\\n predicted_labels = []\\n true_labels = []\\n\\n keys = set(doc_predictions.keys()) | set(doc_relations.keys())\\n for key in keys:\\n predicted_labels.append(doc_predictions.get(key, ''))\\n true_labels.append(doc_relations.get(key, ''))\\n\\n self._relex_precision_recall_fscore(predicted_labels, true_labels)\",\n \"def evaluate_overall(predictions):\\n print(\\\"\\\\nAccuracy for the the models combined (full prediction):\\\\n\\\")\\n\\n perfect_predictions = [0, 0, 0]\\n exact_code_match = [0, 0, 0]\\n exact_code_match_ignore_spaces = [0, 0, 0]\\n correct_syntax = [0, 0, 0]\\n total_predictions = [0, 0, 0]\\n num_failed_predictions = 0\\n \\n for prediction in predictions:\\n # Perfect Prediction\\n if prediction[\\\"correct_data\\\"][\\\"correct_location\\\"] == prediction[\\\"predicted_location\\\"]:\\n # Correct type\\n if prediction[\\\"correct_data\\\"][\\\"correct_type\\\"] == prediction[\\\"predicted_type\\\"]:\\n # Correct token\\n if prediction[\\\"predicted_type\\\"] == \\\"insert\\\" or prediction[\\\"predicted_type\\\"] == \\\"modify\\\":\\n if \\\"correct_token\\\" in prediction[\\\"correct_data\\\"] and prediction[\\\"correct_data\\\"][\\\"correct_token\\\"] == \\\\\\n prediction[\\\"predicted_token\\\"]:\\n perfect_predictions[FixType[prediction[\\\"predicted_type\\\"]].value] = perfect_predictions[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n else:\\n perfect_predictions[FixType[prediction[\\\"predicted_type\\\"]].value] = perfect_predictions[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n \\n # Exact Code Match\\n if prediction[\\\"predicted_code\\\"] == prediction[\\\"correct_data\\\"][\\\"correct_code\\\"]:\\n exact_code_match[FixType[prediction[\\\"predicted_type\\\"]].value] = exact_code_match[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n \\n # Exact Code Match (Ignore Spaces)\\n if prediction[\\\"predicted_code\\\"].replace(\\\" \\\", \\\"\\\") == prediction[\\\"correct_data\\\"][\\\"correct_code\\\"].replace(\\\" \\\", \\\"\\\"):\\n exact_code_match_ignore_spaces[FixType[prediction[\\\"predicted_type\\\"]].value] = exact_code_match_ignore_spaces[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n \\n # Correct Syntax Fix\\n try:\\n cst.parse_module(prediction[\\\"predicted_code\\\"])\\n correct_syntax[FixType[prediction[\\\"predicted_type\\\"]].value] = correct_syntax[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n except Exception as e:\\n logging.warning(f\\\"{e.__class__.__name__} occurred: {e}\\\")\\n # Happens if parsing fails\\n pass\\n \\n total_predictions[FixType[prediction[\\\"predicted_type\\\"]].value] = total_predictions[FixType[\\n prediction[\\\"predicted_type\\\"]].value] + 1\\n \\n # Perfect Prediction\\n for i in range(3):\\n if total_predictions[i] == 0: # If the type was never predicted\\n accuracy = 0\\n else:\\n accuracy = perfect_predictions[i] / total_predictions[i]\\n print(f\\\"Perfect Prediction for class {FixType(i).name}: {accuracy * 100} %\\\")\\n\\n accuracy = sum(perfect_predictions) / (len(predictions) - num_failed_predictions)\\n print(f\\\"Perfect Prediction accuracy overall is {accuracy * 100} %\\\")\\n \\n # Exact Code Match\\n for i in range(3):\\n if total_predictions[i] == 0: # If the type was never predicted\\n accuracy = 0\\n else:\\n accuracy = exact_code_match[i] / total_predictions[i]\\n print(f\\\"Exact Code Match for class {FixType(i).name}: {accuracy * 100} %\\\")\\n\\n accuracy = sum(exact_code_match) / (len(predictions) - num_failed_predictions)\\n print(f\\\"Exact Code Match accuracy overall is {accuracy * 100} %\\\")\\n \\n # Exact Code Match (Ignore Spaces)\\n for i in range(3):\\n if total_predictions[i] == 0: # If the type was never predicted\\n accuracy = 0\\n else:\\n accuracy = exact_code_match_ignore_spaces[i] / total_predictions[i]\\n print(f\\\"Exact Code Match (Ignore Spaces) for class {FixType(i).name}: {accuracy * 100} %\\\")\\n\\n accuracy = sum(exact_code_match_ignore_spaces) / (len(predictions) - num_failed_predictions)\\n print(f\\\"Exact Code Match (Ignore Spaces) accuracy overall is {accuracy * 100} %\\\")\\n \\n # Correct Syntax Fixes\\n for i in range(3):\\n if total_predictions[i] == 0: # If the type was never predicted\\n accuracy = 0\\n else:\\n accuracy = correct_syntax[i] / total_predictions[i]\\n print(f\\\"Correct Syntax Fixes for class {FixType(i).name}: {accuracy * 100} %\\\")\\n\\n accuracy = sum(correct_syntax) / (len(predictions) - num_failed_predictions)\\n print(f\\\"Correct Syntax Fixes accuracy overall is {accuracy * 100} %\\\")\",\n \"def _score(metric,\\n estimations,\\n annotations,\\n loudnessesBelow,\\n loudnessesAbove):\\n\\n def accuracy():\\n return np.equal(estimations, annotations).mean()\\n \\n def falsePositiveRate():\\n return np.logical_and(\\n estimations, np.logical_not(annotations)).mean()\\n\\n def falseNegativeRate():\\n return np.logical_and(\\n np.logical_not(estimations), annotations).mean()\\n\\n def weightedAccuracy():\\n # accuracy with greater weight on rarer label\\n \\n numClassifications = len(annotations)\\n numPositives = np.sum(annotations)\\n numNegatives = numClassifications - numPositives\\n\\n if numPositives > 0 and numNegatives > 0:\\n scoreVector = np.full(numClassifications, 0.5 / numPositives) \\\\\\n * annotations \\\\\\n + np.full(numClassifications, 0.5 / numNegatives) \\\\\\n * np.logical_not(annotations)\\n return np.sum(np.equal(estimations, annotations) * scoreVector)\\n \\n return accuracy()\\n \\n if metric == \\\"accuracy\\\":\\n return accuracy()\\n if metric == \\\"falsePositiveRate\\\":\\n return 1 - falsePositiveRate()\\n if metric == \\\"falseNegativeRate\\\":\\n return 1 - falseNegativeRate()\\n if metric == \\\"weightedAccuracy\\\":\\n return weightedAccuracy()\\n raise RuntimeError(\\\"Unknown measure: {}\\\".format(metric))\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n print('*'*20, '\\\\n')\\n print('precision:', p, 'recall:', r, 'f1:', f1, '\\\\n')\\n print('*'*20)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def validate(self, validate_data):\\n with open(validate_data, 'r') as validate_data:\\n true_positive = 0\\n true_negative = 0\\n false_positive = 0\\n false_negative = 0\\n result = {}\\n for type in self.label_type_map:\\n result[type] = []\\n while True:\\n tokens = validate_data.readline().split()\\n pos = validate_data.readline().split()\\n labels = validate_data.readline().split()\\n if not tokens or not pos or not labels:\\n break\\n # Classify all named entities in a sentence 85\\n curr_results = self.viterbi(tokens)\\n for i in range(0, len(labels)):\\n if curr_results[i] != 'O':\\n if labels[i] == 'O':\\n false_positive += 1 # Not 'O', but should be 'O'\\n else:\\n if self.label_type_map[labels[i]] == self.label_type_map[curr_results[i]]:\\n true_positive += 1 # Correct prediction\\n else:\\n if labels[i] == 'O':\\n true_negative += 1 # Correct prediction of 'O'\\n else:\\n false_negative += 1 # Predicted 'O', not 'O'\\n # Calculate precision - TP / (TP + FP)\\n precision = float(true_positive) / float(true_positive + false_positive)\\n # Calculate recall - TP / (TP + FN)\\n recall = float(true_positive) / float(true_positive + false_negative)\\n # Calculate F-Score - 2 * P * R / (P + R)\\n f_score = float(2*precision * recall) / float(precision + recall)\\n print \\\"Precision: \\\" + str(precision)\\n print \\\"Recall: \\\" + str(recall)\\n print \\\"F-score: \\\" + str(f_score)\",\n \"def computeErrorRate(test_set, words_likely_tags):\\n # initiate vars\\n known_words = {} # those two dictionaries are optional, just for debuging\\n unknown_words = {} # those two dictionaries are optional, just for debuging\\n correct_predictions = 0\\n total_predictions = 0\\n correct_unknown_predictions = 0\\n total_unknown_predictions = 0\\n\\n for i in range(len(test_set)): # iterate sentences\\n test_sent = test_set[i]\\n for j in range(len(test_sent)): # iterate words in sent\\n w = test_sent[j][WORD]\\n t = test_sent[j][TAG]\\n\\n # known words\\n if w in words_likely_tags:\\n if w in known_words:\\n known_words[w][COUNTER_SHOWS] += 1\\n if t == words_likely_tags[w]: # same tag\\n known_words[w][COUNTER_EQUAL] += 1\\n correct_predictions += 1\\n else:\\n if t == words_likely_tags[w]: # same tag\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_predictions += 1\\n else:\\n known_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_predictions += 1\\n # unknown words\\n else: # w not in words_likely_tags, treat w as unknown_word\\n if w in unknown_words:\\n unknown_words[w][COUNTER_SHOWS] += 1\\n if t == UNKNOWN_TAG:\\n # same tag as our model predicts for unknown words\\n unknown_words[w][COUNTER_EQUAL] += 1\\n correct_unknown_predictions += 1\\n else:\\n if t == UNKNOWN_TAG: # same tag\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 1}\\n correct_unknown_predictions += 1\\n else:\\n unknown_words[w] = {COUNTER_SHOWS: 1, COUNTER_EQUAL: 0}\\n\\n total_unknown_predictions += 1\\n\\n # print('correct_predictions......... = ', correct_predictions)\\n # print('total_predictions........... = ', total_predictions)\\n # print('correct_unknown_predictions. = ', correct_unknown_predictions)\\n # print('total_unknown_predictions... = ', total_unknown_predictions)\\n err_rate_known = 1 - correct_predictions/total_predictions\\n err_rate_unknown = 1 - correct_unknown_predictions/total_unknown_predictions\\n # total_err = err_rate_known + err_rate_unknown\\n tot_pred = total_predictions + total_unknown_predictions\\n corr_pred = correct_predictions + correct_unknown_predictions\\n total_err = 1 - corr_pred/tot_pred\\n\\n return err_rate_known, err_rate_unknown, total_err\",\n \"def segmentation_scores(label_trues, label_preds, n_class):\\n hist = np.zeros((n_class, n_class))\\n for lt, lp in zip(label_trues, label_preds):\\n hist += _fast_hist(lt.flatten(), lp.flatten(), n_class)\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n mean_iu = np.nanmean(iu)\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n\\n return {'overall_acc': acc,\\n 'mean_acc': acc_cls,\\n 'freq_w_acc': fwavacc,\\n 'mean_iou': mean_iu}\",\n \"def scoring_function(self, model, y_true, y_predicted_probability):\",\n \"def evaluate_rouge_match(ref_data, pred_data, align=\\\"rouge\\\"):\\n\\n scorer = RougeScorer([\\\"rougeL\\\"])\\n agg = scoring.BootstrapAggregator(confidence_interval=0.95)\\n sample_evaluated = 0\\n\\n for tid in tqdm(pred_data):\\n cur_sys = pred_data[tid][\\\"pred\\\"]\\n if not tid in ref_data: continue\\n cur_ref_lst = [x[\\\"tgt_words\\\"] for x in ref_data[tid]]\\n if len(cur_ref_lst) > 0:\\n if align == \\\"rouge\\\":\\n best_rouge_scrs = __rouge_pairs(cur_sys, cur_ref_lst, scorer)\\n agg.add_scores(best_rouge_scrs)\\n else:\\n best_paired_ref, _ = utils.pair_ref_sys_by_coverage(cur_sys, cur_ref_lst)\\n agg.add_scores(scorer.score(best_paired_ref, cur_sys))\\n sample_evaluated += 1\\n\\n print(sample_evaluated)\\n result = agg.aggregate()\\n for rouge_type in result:\\n print(rouge_type)\\n print(result[rouge_type].mid)\\n\\n print(agg.aggregate())\\n return\",\n \"def score_calc(self, annotations, predictions):\\n\\n mean_probabilities_of_classes = np.expand_dims(np.mean(predictions, axis=0), axis=0)\\n KL_d = predictions * (np.log(predictions + self.eps) - np.log(mean_probabilities_of_classes + self.eps))\\n KL_D = KL_d.sum(axis=1)\\n\\n score = np.exp(np.mean(KL_D))\\n return score\",\n \"def _score_ngrams(target_ngrams, prediction_ngrams):\\n\\n intersection_ngrams_count = 0\\n for ngram in six.iterkeys(target_ngrams):\\n intersection_ngrams_count += min(target_ngrams[ngram],\\n prediction_ngrams[ngram])\\n target_ngrams_count = sum(target_ngrams.values())\\n prediction_ngrams_count = sum(prediction_ngrams.values())\\n\\n precision = intersection_ngrams_count / max(prediction_ngrams_count, 1)\\n recall = intersection_ngrams_count / max(target_ngrams_count, 1)\\n fmeasure = scoring.fmeasure(precision, recall)\\n\\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)\",\n \"def evaluate(predicted, labels):\\n \\n assert len(predicted) == len(labels), \\\"Different number of predictions and labels.\\\"\\n \\n total = len(predicted)\\n movie_correct = 0\\n location_correct = 0\\n \\n center_frame_dist = [] \\n overlaps = []\\n \\n for pred, label in zip(predicted, labels):\\n \\n dist = 0\\n \\n if pred[0] == label[0]: # Check if movie is correct\\n movie_correct += 1\\n \\n dist = abs(pred[1] - ((label[1]+label[2])/2)) \\n center_frame_dist.append(dist)\\n \\n correct = False\\n if label[1] <= pred[1] <= label[2]:\\n correct = True\\n location_correct += 1\\n\\n \\n# print(\\\"Label: ({:s}, {:d}, {:d}), predicted: ({:s}, {:d}), location correct: {!s:}, start_frame_dist: {:d}, overlap: {:d}\\\".format(\\n# *label,\\n# *pred,\\n# correct,\\n# dist\\n# ))\\n \\n # Return (# movies correct, # correct location, # total movies) and (avg start frame distance, std)\\n return (movie_correct, location_correct, total), (np.mean(center_frame_dist), np.std(center_frame_dist))\",\n \"def evaluate(labels, predictions):\\n\\n # Positive and positive identified count\\n pos = 0\\n posid = 0\\n\\n # Negative and positive identified count\\n neg = 0\\n negid = 0\\n\\n for label, pred in zip(labels, predictions):\\n if label == 1:\\n pos += 1\\n if pred == 1:\\n posid += 1\\n elif label == 0:\\n neg += 1\\n if pred == 0:\\n negid += 1\\n else:\\n raise ValueError\\n\\n # `sensitivity` should be a floating-point value from 0 to 1\\n # representing the \\\"true positive rate\\\": the proportion of\\n # actual positive labels that were accurately identified.\\n sens = float(posid / pos)\\n\\n # `specificity` should be a floating-point value from 0 to 1\\n # representing the \\\"true negative rate\\\": the proportion of\\n # actual negative labels that were accurately identified.\\n spec = float(negid / neg)\\n\\n return (sens, spec)\",\n \"def evaluate(y_test, pred_labels):\\n \\n # Converts one-hot code to a label (the index of 1)\\n y_test_labels = np.argmax(y_test, axis=1)\\n \\n # Compare test labels to predicted labels\\n score = accuracy_score(y_test_labels, pred_labels)\\n \\n return y_test_labels, score\",\n \"def compute_bleu_rouge(pred_dict, ref_dict, bleu_order=4):\\n assert set(pred_dict.keys()) == set(ref_dict.keys()), \\\\\\n \\\"missing keys: {}\\\".format(set(ref_dict.keys()) - set(pred_dict.keys()))\\n scores = {}\\n bleu_scores, _ = Bleu(bleu_order).compute_score(ref_dict, pred_dict)\\n for i, bleu_score in enumerate(bleu_scores):\\n scores['Bleu-%d' % (i + 1)] = bleu_score\\n rouge_score, _ = Rouge().compute_score(ref_dict, pred_dict)\\n scores['Rouge-L'] = rouge_score\\n return scores\",\n \"def get_accuracy(self, gold, predicted):\\n # Exercise 3: calculate accuracy\\n i = 0\\n j = 0\\n for labels in gold:\\n if labels == predicted[i]:\\n j +=1\\n i +=1\\n return j / i * 100\",\n \"def calculate_score(result):\\n sample1=result['Sample1']\\n sample2=result['Sample2']\\n string1=paragraph_to_list(sample1)\\n string2=paragraph_to_list(sample2)\\n \\n return round( strings_similarity(string1, string2), 2)\\n #method_dict=strings_count_compare(string1, string2)/ max(len(string1), len(string2))\\n #return round(0.5*(method_difflab+method_dict), 2)\",\n \"def score(self, y_true, y_pred):\\r\\n pass\",\n \"def f1_score(model_id, test_set_id, rubric_id):\\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\\n\\n for key in rubrication_result:\\n if rubrication_result[key] == answers[key]:\\n if rubrication_result[key] == 1:\\n result['true_positive'] += 1\\n else:\\n result['true_negative'] += 1\\n else:\\n if rubrication_result[key] == 1:\\n result['false_positive'] += 1\\n else:\\n result['false_negative'] += 1\\n if (result['true_positive'] + result['false_positive']) > 0:\\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\\n else:\\n result['precision'] = 0\\n if (result['true_positive'] + result['false_negative']) > 0:\\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\\n else:\\n result['recall'] = 0\\n if (result['precision'] + result['recall']) > 0:\\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\\n else:\\n result['f1'] = 0\\n return result\",\n \"def rouge_score(references, generated):\\r\\n score = rouge(generated, references)\\r\\n rouge_s = {k: (v * 100) for (k, v) in score.items()}\\r\\n '''\\r\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\r\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\r\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\r\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\r\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\r\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\r\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\r\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\r\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\r\\n '''\\r\\n return rouge_s\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def classify(texts: List[str], params: Any) -> List[str]:\\n\\n alpha = 1\\n token_probs_pos = params[\\\"token_probs_pos\\\"]\\n token_probs_neg = params[\\\"token_probs_neg\\\"]\\n all_words = params[\\\"all_words\\\"]\\n M = len(all_words)\\n cnt_pos_docs = params[\\\"cnt_pos_docs\\\"]\\n cnt_neg_docs = params[\\\"cnt_neg_docs\\\"]\\n\\n sum_len_neg = params[\\\"sum_len_neg\\\"]\\n sum_len_pos = params[\\\"sum_len_pos\\\"]\\n pos_dict = params[\\\"pos_dict\\\"]\\n neg_dict = params[\\\"neg_dict\\\"]\\n\\n\\n test_texts = preprocessing(texts)\\n test_tokenized_texts = text_to_tokens(test_texts)\\n \\n res = []\\n log_pos_probablity = 0\\n log_neg_probablity = 0\\n i = 0\\n for text in test_tokenized_texts:\\n if (i % 5000 == 0):\\n print(\\\"Classified\\\", i, \\\"texts\\\")\\n i += 1\\n log_pos_probablity = log(cnt_pos_docs)\\n log_neg_probablity = log(cnt_neg_docs)\\n for token in text:\\n if (token_probs_pos[token] == 0):\\n token_probs_pos[token] = alpha / (alpha * M + sum_len_pos)\\n else:\\n log_pos_probablity += log(token_probs_pos[token])\\n if (token_probs_neg[token] == 0):\\n token_probs_neg[token] = alpha / (alpha * M + sum_len_neg)\\n else:\\n log_neg_probablity += log(token_probs_neg[token])\\n if (log_neg_probablity > log_pos_probablity):\\n res.append(\\\"neg\\\")\\n #for token in text:\\n # all_words.add(token)\\n # M = len(all_words)\\n # neg_dict[token] += text[token]\\n # sum_len_neg += text[token]\\n # token_probs_neg[token] = (alpha + neg_dict[token]) / (alpha * M + sum_len_neg)\\n\\n else:\\n res.append(\\\"pos\\\")\\n #for token in text:\\n # all_words.add(token)\\n # M = len(all_words)\\n # pos_dict[token] += text[token]\\n # sum_len_pos += text[token]\\n # token_probs_pos[token] = (alpha + pos_dict[token]) / (alpha * M + sum_len_pos)\\n\\n\\n \\n print('Predicted labels counts:')\\n print(count_labels(res))\\n return res\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def score_one(self, test_data):\\n\\n\\t\\ttest_in, test_labels = self._split_inputs_outputs(test_data)\\n\\t\\tcorrect = 0\\n\\t\\ttotal = 0\\n\\n\\t\\tfor i, test_input in enumerate(test_in):\\n\\t\\t\\tprediction = self.model.predict(test_input.reshape(1,-1))\\n\\t\\t\\tif prediction[0] == test_labels[i]:\\n\\t\\t\\t\\tcorrect+=1\\n\\t\\t\\ttotal+=1\\n\\t\\treturn float(correct)/total\",\n \"def eval(self):\\n target_truth_labels = self.get_target_labels()\\n for key in self.id_uncertainty_measures.keys():\\n # deep copy needed as we mutate confidence values later on\\n decision_fn_value = np.concatenate((copy.deepcopy(self.id_uncertainty_measures[key]),\\n copy.deepcopy(self.ood_uncertainty_measures[key])),\\n axis=0)\\n # negation needed for confidence, as confidence is indicator of label=0 samples\\n # i.e for correct classified samples.\\n # But we need scores for label=1 samples i.e misclassified samples\\n # to be higher, so we negate.\\n if key == UncertaintyMeasuresEnum.CONFIDENCE or key == UncertaintyMeasuresEnum.PRECISION:\\n decision_fn_value *= -1.0\\n\\n aupr, auroc = ClassifierPredictionEvaluator.compute_pr_roc_curves(\\n decision_fn_value, target_truth_labels, self.result_dir, key._value_)\\n\\n with open(os.path.join(self.result_dir, 'results.txt'), 'a') as f:\\n f.write('AUPR using ' + key._value_ + \\\": \\\" +\\n str(np.round(aupr * 100.0, 1)) + '\\\\n')\\n f.write('AUROC using ' + key._value_ + \\\": \\\" +\\n str(np.round(auroc * 100.0, 1)) + '\\\\n')\",\n \"def evaluate(\\n args,\\n generator,\\n model,\\n iou_threshold=0.5,\\n score_threshold=0.05,\\n max_detections=100,\\n save_path=None\\n):\\n # gather all detections and annotations\\n all_detections = _get_detections(args, generator, model, score_threshold=score_threshold, max_detections=max_detections, save_path=save_path)\\n all_annotations = _get_annotations(generator)\\n # print('all detections:', all_detections)\\n # print('all all_annotations:', all_annotations)\\n average_precisions = {}\\n\\n # all_detections = pickle.load(open('all_detections.pkl', 'rb'))\\n # all_annotations = pickle.load(open('all_annotations.pkl', 'rb'))\\n # pickle.dump(all_detections, open('all_detections.pkl', 'wb'))\\n # pickle.dump(all_annotations, open('all_annotations.pkl', 'wb'))\\n\\n # process detections and annotations\\n # print('###########')\\n # print(generator.num_classes())\\n\\n for label in range(generator.num_classes()):\\n if not generator.has_label(label):\\n print('generator has not label')\\n continue\\n\\n false_positives = np.zeros((0,))\\n true_positives = np.zeros((0,))\\n false_negatives = np.zeros((0,))\\n scores = np.zeros((0,))\\n num_annotations = 0.0\\n\\n for i in range(generator.size()):\\n detections = all_detections[i][label]\\n annotations = all_annotations[i][label]\\n num_annotations += annotations.shape[0]\\n detected_annotations = []\\n\\n for d in detections:\\n scores = np.append(scores, d[4])\\n\\n if annotations.shape[0] == 0:\\n # print('NO bbox annos')\\n # print(d)\\n false_positives = np.append(false_positives, 0)\\n true_positives = np.append(true_positives, 0)\\n false_negatives = np.append(false_negatives, 1)\\n continue\\n\\n overlaps = compute_overlap(np.expand_dims(d, axis=0), annotations)\\n assigned_annotation = np.argmax(overlaps, axis=1)\\n max_overlap = overlaps[0, assigned_annotation]\\n\\n if max_overlap >= iou_threshold and assigned_annotation not in detected_annotations:\\n false_positives = np.append(false_positives, 0)\\n true_positives = np.append(true_positives, 1)\\n detected_annotations.append(assigned_annotation)\\n else:\\n false_positives = np.append(false_positives, 1)\\n true_positives = np.append(true_positives, 0)\\n\\n # no annotations -> AP for this class is 0 (is this correct?)\\n if num_annotations == 0:\\n average_precisions[label] = 0, 0\\n continue\\n\\n # print(num_annotations)\\n # print(all_detections[0][label].shape)\\n # print(all_detections[0][label])\\n TP = sum(true_positives)\\n FP = sum(false_positives)\\n FN = sum(false_negatives)\\n # sort by score\\n indices = np.argsort(-scores)\\n false_positives = false_positives[indices]\\n true_positives = true_positives[indices]\\n\\n # compute false positives and true positives\\n false_positives = np.cumsum(false_positives)\\n true_positives = np.cumsum(true_positives)\\n\\n # compute recall and precision\\n recall = true_positives / num_annotations\\n precision = true_positives / np.maximum(true_positives + false_positives, np.finfo(np.float64).eps)\\n\\n\\n print('TP:', TP)\\n print('FP:', FP)\\n print('FN:', FN)\\n print('Recall:', TP / (TP + FN))\\n print('Precision:', TP / (TP + FP))\\n\\n # compute average precision\\n average_precision = _compute_ap(recall, precision)\\n average_precisions[label] = average_precision, num_annotations\\n\\n return average_precisions\",\n \"def evaluate(true_labels, predicted_labels):\\n accuracy = np.round(metrics.accuracy_score(true_labels, predicted_labels), \\n 2)\\n precision = np.round(metrics.precision_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n recall = np.round(metrics.recall_score(true_labels, predicted_labels,\\n average='weighted'), 2)\\n f1 = np.round(metrics.f1_score(true_labels, predicted_labels, \\n average='weighted'), 2)\\n \\n return accuracy, precision, recall, f1\",\n \"def calc_instance_segmentation_voc_prec_rec(\\r\\n pred_masks, pred_labels, pred_scores,\\r\\n gt_masks, gt_labels, iou_thresh):\\r\\n\\r\\n pred_masks = iter(pred_masks)\\r\\n pred_labels = iter(pred_labels)\\r\\n pred_scores = iter(pred_scores)\\r\\n gt_masks = iter(gt_masks)\\r\\n gt_labels = iter(gt_labels)\\r\\n\\r\\n n_pos = defaultdict(int)\\r\\n score = defaultdict(list)\\r\\n match = defaultdict(list)\\r\\n\\r\\n for pred_mask, pred_label, pred_score, gt_mask, gt_label in \\\\\\r\\n six.moves.zip(\\r\\n pred_masks, pred_labels, pred_scores,\\r\\n gt_masks, gt_labels):\\r\\n\\r\\n for l in np.unique(np.concatenate((pred_label, gt_label)).astype(int)):\\r\\n pred_keep_l = pred_label == l\\r\\n pred_mask_l = pred_mask[pred_keep_l]\\r\\n pred_score_l = pred_score[pred_keep_l]\\r\\n # sort by score\\r\\n order = pred_score_l.argsort()[::-1]\\r\\n pred_mask_l = pred_mask_l[order]\\r\\n pred_score_l = pred_score_l[order]\\r\\n\\r\\n gt_keep_l = gt_label == l\\r\\n gt_mask_l = gt_mask[gt_keep_l]\\r\\n\\r\\n n_pos[l] += gt_keep_l.sum()\\r\\n score[l].extend(pred_score_l)\\r\\n\\r\\n if len(pred_mask_l) == 0:\\r\\n continue\\r\\n if len(gt_mask_l) == 0:\\r\\n match[l].extend((0,) * pred_mask_l.shape[0])\\r\\n continue\\r\\n\\r\\n iou = mask_iou(pred_mask_l, gt_mask_l)\\r\\n gt_index = iou.argmax(axis=1)\\r\\n # set -1 if there is no matching ground truth\\r\\n gt_index[iou.max(axis=1) < iou_thresh] = -1\\r\\n del iou\\r\\n\\r\\n selec = np.zeros(gt_mask_l.shape[0], dtype=bool)\\r\\n for gt_idx in gt_index:\\r\\n if gt_idx >= 0:\\r\\n if not selec[gt_idx]:\\r\\n match[l].append(1)\\r\\n else:\\r\\n match[l].append(0)\\r\\n selec[gt_idx] = True\\r\\n else:\\r\\n match[l].append(0)\\r\\n\\r\\n for iter_ in (pred_masks, pred_labels, pred_scores, gt_masks, gt_labels):\\r\\n if next(iter_, None) is not None:\\r\\n raise ValueError('Length of input iterables need to be same.')\\r\\n\\r\\n n_fg_class = max(n_pos.keys()) + 1\\r\\n prec = [None] * n_fg_class\\r\\n rec = [None] * n_fg_class\\r\\n\\r\\n for l in n_pos.keys():\\r\\n score_l = np.array(score[l])\\r\\n match_l = np.array(\\r\\n match[l], dtype=np.int8)\\r\\n\\r\\n order = score_l.argsort()[::-1]\\r\\n match_l = match_l[order]\\r\\n\\r\\n tp = np.cumsum(match_l == 1)\\r\\n fp = np.cumsum(match_l == 0)\\r\\n\\r\\n # If an element of fp + tp is 0,\\r\\n # the corresponding element of prec[l] is nan.\\r\\n prec[l] = tp / (fp + tp)\\r\\n # If n_pos[l] is 0, rec[l] is None.\\r\\n if n_pos[l] > 0:\\r\\n rec[l] = tp / n_pos[l]\\r\\n\\r\\n return prec, rec\",\n \"def _compute_relevance_map(self, labels):\\n\\n ds_labels = np.zeros(self.ds_size)\\n ds_relevance_map = 0\\n for i in np.unique(labels):\\n if i != 0:\\n # 2.1- Compute the coarse label image\\n y, x, z = np.where(labels == i)\\n ds_labels[np.int32(y * self.full_to_ds_ratio[0]),\\n np.int32(x * self.full_to_ds_ratio[1]), z] = i\\n # 2.2- Compute the energy map\\n M = np.ones_like(ds_labels)\\n M[ds_labels == i] = 0\\n distance_map = distance_transform_edt(M)\\n ds_relevance_map += distance_map\\n\\n # 2.3- Normalize the energy map and compute the ROI\\n ds_relevance_map = ds_relevance_map / ds_relevance_map.max()\\n return ds_labels, ds_relevance_map\",\n \"def get_metrics(cfg, model, X_anchor, y_anchor, X_gal, y_gal, annoy_index, vec_dim):\\n rank10_acc = 0\\n rank5_acc = 0\\n rank1_acc = 0\\n avg_acc = 0\\n vote_res = 0\\n\\n l2 = []\\n for anchor in range(0, len(X_anchor)):\\n res = get_result(get_image_features(cfg, model, X_anchor[anchor]), annoy_index)\\n vote = defaultdict(int)\\n # Accuracy\\n correct = 0\\n for i in res[:10]:\\n vote[y_gal[i]] += 1\\n\\n max_key = max(vote, key=vote.get)\\n if max_key == y_anchor[anchor]:\\n vote_res += 1\\n \\n\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1 \\n\\n avg_acc += correct/len(res)\\n\\n # Mean Average Precision\\n l1 = []\\n for recomm in res[:10]:\\n if y_gal[recomm] == y_anchor[anchor]:\\n correct += 1\\n l1.append(1)\\n else:\\n l1.append(0)\\n l2.append(l1) \\n\\n # Rank10 Accuracy\\n for each_val in res[:10]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank10_acc += 1\\n break\\n \\n # Rank5 Accuracy\\n for each_val in res[:5]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank5_acc += 1\\n break\\n\\n # Rank1 Accuracy\\n for each_val in res[:1]:\\n if y_gal[each_val] == y_anchor[anchor]:\\n rank1_acc += 1\\n break\\n\\n print(\\\"Avg acc is :: {avg_acc}\\\".format(avg_acc = avg_acc/len(X_anchor)))\\n print(\\\"Rank 10 acc is :: {rank10_acc}\\\".format(rank10_acc = rank10_acc/len(X_anchor)))\\n print(\\\"Rank 5 acc is :: {rank5_acc}\\\".format(rank5_acc = rank5_acc/len(X_anchor)))\\n print(\\\"Rank 1 acc is :: {rank1_acc}\\\".format(rank1_acc = rank1_acc/len(X_anchor)))\\n print(\\\"Mean Avg Precision is :: {mAP}\\\".format(mAP=mean_average_precision(l2)))\\n print(\\\"Vote res :: \\\", vote_res/len(X_anchor))\\n\\n return rank1_acc/len(X_anchor), mean_average_precision(l2)\",\n \"def score_prediction(y_true, y_pred):\\n return [round(metrics.accuracy_score(y_true, y_pred)*100, 2),\\n round(metrics.precision_score(y_true, y_pred)*100, 2),\\n round(metrics.recall_score(y_true, y_pred)*100, 2),\\n round(metrics.f1_score(y_true, y_pred)*100, 2)]\",\n \"def score(self, predicted_y, actual_y):\\n\\n self.labels = [0, 1, 2, 3]\\n\\n # Dictionary to store count of each label in predicted labels list\\n self.total_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n # Dictionary to store count of each label in actual labels list\\n self.total_actual_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n # Dictionary to store count of correctly predicted labels\\n self.total_correct_prediction_count = {0: 0, 1: 0, 2: 0, 3: 0}\\n\\n for i in xrange(len(predicted_y)):\\n # Extract predicted and actual labels for ith record\\n predicted_label = predicted_y[i]\\n actual_label = actual_y[i]\\n\\n # Increment the count of corrected predicted label if predicted and actual labels are same\\n if predicted_label == actual_label:\\n self.total_correct_prediction_count[actual_label] += 1\\n\\n # Increment total counts\\n self.total_actual_count[actual_label] += 1\\n self.total_prediction_count[predicted_label] += 1\\n\\n # Compute f1 scores of each label and return their mean\\n return np.mean(self.__get_f1_scores__())\",\n \"def _score_for_model(meta):\\n mean_acc = list()\\n pipes = meta[\\\"pipeline\\\"]\\n acc = meta[\\\"accuracy\\\"]\\n if \\\"tagger\\\" in pipes:\\n mean_acc.append(acc[\\\"tags_acc\\\"])\\n if \\\"morphologizer\\\" in pipes:\\n mean_acc.append((acc[\\\"morphs_acc\\\"] + acc[\\\"pos_acc\\\"]) / 2)\\n if \\\"parser\\\" in pipes:\\n mean_acc.append((acc[\\\"uas\\\"] + acc[\\\"las\\\"]) / 2)\\n if \\\"ner\\\" in pipes:\\n mean_acc.append((acc[\\\"ents_p\\\"] + acc[\\\"ents_r\\\"] + acc[\\\"ents_f\\\"]) / 3)\\n if \\\"textcat\\\" in pipes:\\n mean_acc.append(acc[\\\"textcat_score\\\"])\\n if \\\"senter\\\" in pipes:\\n mean_acc.append((acc[\\\"sent_p\\\"] + acc[\\\"sent_r\\\"] + acc[\\\"sent_f\\\"]) / 3)\\n return sum(mean_acc) / len(mean_acc)\",\n \"def calc_scores(y_true, y_pred, mltype, metrics=None):\\n scores = OrderedDict()\\n\\n if mltype == 'cls': \\n scores['auroc'] = sklearn.metrics.roc_auc_score(y_true, y_pred)\\n scores['f1_score'] = sklearn.metrics.f1_score(y_true, y_pred, average='micro')\\n scores['acc_blnc'] = sklearn.metrics.balanced_accuracy_score(y_true, y_pred)\\n\\n elif mltype == 'reg':\\n scores['r2'] = sklearn.metrics.r2_score(y_true=y_true, y_pred=y_pred)\\n scores['mean_absolute_error'] = sklearn.metrics.mean_absolute_error(y_true=y_true, y_pred=y_pred)\\n scores['median_absolute_error'] = sklearn.metrics.median_absolute_error(y_true=y_true, y_pred=y_pred)\\n scores['mean_squared_error'] = sklearn.metrics.mean_squared_error(y_true=y_true, y_pred=y_pred)\\n scores['auroc_reg'] = reg_auroc(y_true=y_true, y_pred=y_pred)\\n\\n # # https://scikit-learn.org/stable/modules/model_evaluation.html\\n # for metric_name, metric in metrics.items():\\n # if isinstance(metric, str):\\n # scorer = sklearn.metrics.get_scorer(metric_name) # get a scorer from string\\n # scores[metric_name] = scorer(ydata, pred)\\n # else:\\n # scores[metric_name] = scorer(ydata, pred)\\n\\n return scores\",\n \"def evaluate(ner_model, examples):\\n # The Scorer computes and stores evaluation scores\\n scorer = Scorer()\\n for text, annotations in examples:\\n # Process the text to get entities predicted\\n document = ner_model.make_doc(text)\\n correct_annotations = GoldParse(document, entities=annotations['entities'])\\n predicted_annotations = ner_model(text)\\n # Update the evaluation scores from the document\\n scorer.score(predicted_annotations, correct_annotations)\\n return scorer.scores\",\n \"def sentence_accuracy(references, predictions):\\n count = 0.0\\n match = 0.0\\n for label, pred in zip(references, predictions):\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def _rouge_score_compute(sentence_results: Dict[str, List[Tensor]]) ->Dict[str, Tensor]:\\n results: Dict[str, Tensor] = {}\\n if sentence_results == {}:\\n return results\\n for rouge_key, scores in sentence_results.items():\\n results[rouge_key] = torch.tensor(scores).mean()\\n return results\",\n \"def compute_precision(gold_dict, src_word2ind, trg_word2ind, src_words, trg_words, scores, args, BATCH_SIZE=20, verbose = False):\\n oov = set()\\n correct = 0\\n n,m = scores.shape # The actual size of mapping computed, might be smaller that total size of dict\\n\\n precisions = {}\\n if verbose:\\n print('@{:2} {:10} {:30} {:30}'.format('k', 'Src','Predicted','Gold'))\\n print_row = '{:2} {:10} {:30} {:30} {}'\\n\\n for k in [1,5,10]:\\n correct = 0\\n for src_idx,tgt_idx in gold_dict.items():\\n if src_idx > n or np.all([e>m for e in tgt_idx]):#Src word not in mapping\\n oov.add(src_idx)\\n continue\\n else:\\n knn = np.argpartition(scores[src_idx,:], -k)[-k:] # argpartition returns top k not in order\\n knn_sort = knn[np.argsort(-scores[src_idx,knn])] # With - to get descending order\\n if set(knn_sort).intersection(tgt_idx):\\n correct +=1\\n correct_string = ' '\\n else:\\n correct_string = 'X'\\n if verbose:\\n src_str = src_words[src_idx]\\n pred_str = ','.join([trg_words[k] for k in knn_sort])\\n gold_str = ','.join([trg_words[k] for k in tgt_idx])\\n print(print_row.format(k,src_str,pred_str,gold_str,correct_string))\\n\\n\\n coverage = len(gold_dict.keys()) / (len(gold_dict.keys()) + len(oov))\\n if verbose:\\n print('Coverage: {:7.2%} Precision @{:2}:{:7.2%}'.format(coverage, k, correct / len(gold_dict)))\\n precisions[k] = correct / len(gold_dict)\\n return precisions\",\n \"def evaluate(labels, predictions):\\n positive_count = 0\\n positive = 0\\n negative_count = 0\\n negative = 0\\n for i in range(len(labels)):\\n if labels[i] == 1:\\n positive_count+=1\\n if predictions[i] == 1:\\n positive +=1\\n else:\\n negative_count+=1\\n if predictions[i] == 0:\\n negative +=1\\n\\n sensitivity = positive / positive_count\\n specificity = negative / negative_count\\n\\n return (sensitivity, specificity)\",\n \"def _accuracy(label_file, pred_file,subword_option=None):\\n\\n with open(label_file, \\\"r\\\", encoding='utf-8') as label_fh:\\n with open(pred_file, \\\"r\\\", encoding='utf-8') as pred_fh:\\n count = 0.0\\n match = 0.0\\n for label in label_fh:\\n label = label.strip()\\n label = \\\" \\\".join(_clean(label,subword_option))\\n pred = pred_fh.readline().strip()\\n pred = \\\" \\\".join(_clean(pred,subword_option))\\n if label == pred:\\n match += 1\\n count += 1\\n return 100 * match / count\",\n \"def evaluate(session, model, char_data, tag_data, dict_data, len_data, eval_op, batch_size, verbose=False):\\n correct_labels = 0\\n total_labels = 0\\n\\n xArray, yArray, dArray, lArray = reader.iterator(char_data, tag_data, dict_data, len_data, batch_size)\\n yp_wordnum = 0\\n yt_wordnum = 0\\n cor_num = 0\\n for x, y, d, l in zip(xArray, yArray, dArray, lArray):\\n fetches = [model.loss, model.logits, model.trans]\\n feed_dict = {}\\n feed_dict[model.input_data] = x\\n feed_dict[model.targets] = y\\n feed_dict[model.dicts] = d\\n feed_dict[model.seq_len] = l\\n loss, logits, trans = session.run(fetches, feed_dict)\\n\\n for logits_, y_, l_ in zip(logits, y, l):\\n logits_ = logits_[:l_]\\n y_ = y_[:l_]\\n viterbi_sequence, _ = tf.contrib.crf.viterbi_decode(logits_, trans)\\n\\n yp_wordnum += viterbi_sequence.count(2) + viterbi_sequence.count(3)\\n yt_wordnum += (y_ == 2).sum() + (y_ == 3).sum()\\n correct_labels += np.sum(np.equal(viterbi_sequence, y_))\\n total_labels += l_\\n\\n start = 0\\n for i in range(len(y_)):\\n if (y_[i] == 2 or y_[i] == 3):\\n flag = True\\n for j in range(start, i + 1):\\n if y_[j] != viterbi_sequence[j]:\\n flag = False\\n if flag == True:\\n cor_num += 1\\n start = i + 1\\n P = cor_num / float(yp_wordnum)\\n R = cor_num / float(yt_wordnum)\\n F = 2 * P * R / (P + R)\\n accuracy = 100.0 * correct_labels / float(total_labels)\\n return accuracy, P, R, F\",\n \"def genuines_and_impostors(self, scores, labels):\\r\\n print('Computing genuine scores and impostor scores')\\r\\n scores_dimension, genuine_dimension, impostor_dimension = self._define_dimensions(scores, labels)\\r\\n genuine_score = np.zeros(shape=(genuine_dimension, 1))\\r\\n impostor_score = np.zeros(shape=(impostor_dimension, 1))\\r\\n indg = 0\\r\\n indi = 0\\r\\n for i in range(scores_dimension):\\r\\n for j in range(i):\\r\\n if labels[i] == labels[j]:\\r\\n genuine_score[indg, 0] = scores[i, j];\\r\\n indg = indg + 1;\\r\\n else:\\r\\n impostor_score[indi, 0] = scores[i, j];\\r\\n indi = indi + 1;\\r\\n gen_unique = np.unique(genuine_score)\\r\\n imp_unique = np.unique(impostor_score)\\r\\n print('Defining the thresholds')\\r\\n thresholds = np.concatenate(([0], gen_unique, imp_unique, [1]))\\r\\n thresholds = np.unique(thresholds)\\r\\n if np.max(np.shape(thresholds)) > 100:\\r\\n thresholds = self._compute_thresholds(0.01)\\r\\n return genuine_score, impostor_score, thresholds\",\n \"def scoring(self):\\n pass\",\n \"def run_evaluate(self, test):\\n accs = []\\n correct_preds, total_correct, total_preds = 0., 0., 0.\\n for words, labels in minibatches(test, self.config.batch_size):\\n labels_pred, sequence_lengths = self.predict_batch(words)\\n\\n for lab, lab_pred, length in zip(labels, labels_pred,\\n sequence_lengths):\\n lab = lab[:length]\\n lab_pred = lab_pred[:length]\\n accs += [a==b for (a, b) in zip(lab, lab_pred)]\\n\\n lab_chunks = set(get_chunks(lab, self.config.vocab_tags))\\n lab_pred_chunks = set(get_chunks(lab_pred,\\n self.config.vocab_tags))\\n\\n correct_preds += len(lab_chunks & lab_pred_chunks)\\n total_preds += len(lab_pred_chunks)\\n total_correct += len(lab_chunks)\\n\\n p = correct_preds / total_preds if correct_preds > 0 else 0\\n r = correct_preds / total_correct if correct_preds > 0 else 0\\n f1 = 2 * p * r / (p + r) if correct_preds > 0 else 0\\n acc = np.mean(accs)\\n\\n return {\\\"acc\\\": 100*acc, \\\"f1\\\": 100*f1}\",\n \"def partial_match_score(\\n truth: List[Rationale], pred: List[Rationale], thresholds: List[float]\\n) -> List[PartialMatchScore]:\\n\\n ann_to_rat = _keyed_rationale_from_list(truth)\\n pred_to_rat = _keyed_rationale_from_list(pred)\\n\\n num_classifications = {k: len(v) for k, v in pred_to_rat.items()}\\n num_truth = {k: len(v) for k, v in ann_to_rat.items()}\\n ious: Dict[str, Dict[str, float]] = defaultdict(dict)\\n for k in set(ann_to_rat.keys()) | set(pred_to_rat.keys()):\\n for p in pred_to_rat.get(k, []):\\n best_iou = 0.0\\n for t in ann_to_rat.get(k, []):\\n num = len(\\n set(range(p.start_token, p.end_token))\\n & set(range(t.start_token, t.end_token))\\n )\\n denom = len(\\n set(range(p.start_token, p.end_token))\\n | set(range(t.start_token, t.end_token))\\n )\\n iou = 0 if denom == 0 else num / denom\\n if iou > best_iou:\\n best_iou = iou\\n ious[k][p] = best_iou\\n\\n scores: List[PartialMatchScore] = []\\n for threshold in thresholds:\\n threshold_tps: Dict[str, float] = {}\\n for k, vs in ious.items():\\n threshold_tps[k] = sum(int(x >= threshold) for x in vs.values())\\n micro_r = (\\n sum(threshold_tps.values()) / sum(num_truth.values())\\n if sum(num_truth.values()) > 0\\n else 0\\n )\\n micro_p = (\\n sum(threshold_tps.values()) / sum(num_classifications.values())\\n if sum(num_classifications.values()) > 0\\n else 0\\n )\\n micro_f1 = _f1(micro_r, micro_p)\\n macro_rs = list(\\n threshold_tps.get(k, 0.0) / n if n > 0 else 0 for k, n in num_truth.items()\\n )\\n macro_ps = list(\\n threshold_tps.get(k, 0.0) / n if n > 0 else 0\\n for k, n in num_classifications.items()\\n )\\n macro_r = sum(macro_rs) / len(macro_rs) if len(macro_rs) > 0 else 0\\n macro_p = sum(macro_ps) / len(macro_ps) if len(macro_ps) > 0 else 0\\n macro_f1 = _f1(macro_r, macro_p)\\n\\n scores.append(\\n PartialMatchScore(\\n threshold=threshold,\\n micro=InstanceScore(p=micro_p, r=micro_r, f1=micro_f1),\\n macro=InstanceScore(p=macro_p, r=macro_r, f1=macro_f1),\\n )\\n )\\n\\n return scores\",\n \"def compute_precision(model:nn.Module, l_dataset, l_label_vocab, int_to_label, opts, pre):\\n\\n all_predictions = list()\\n reconstructed_predictions = list()\\n all_labels = list()\\n \\n read_labels = list()\\n read_predictions = list()\\n\\n pos = None\\n pred = None\\n\\n inp, prs = pre.list_l_sentences, pre.list_l_unpacked_predicates\\n original_predicates = pre.list_l_original_predicates\\n labels_as_dict = pre.labels_dict\\n dev_d = pre.list_l_labels\\n\\n model.eval()\\n\\n duplicates = [(len(x) - x.count(\\\"_\\\")) for x in original_predicates]\\n\\n pred_idx = [[i for i, v in enumerate(x) if v!=\\\"_\\\"] for x in original_predicates]\\n\\n # Loop over dataset (dataloader)\\n for batch in l_dataset:\\n\\n inputs = batch[\\\"inputs\\\"].to(opts[\\\"device\\\"])\\n if opts[\\\"use_binary_pred\\\"] == True:\\n pred = batch[\\\"preds\\\"].type(torch.FloatTensor).to(opts[\\\"device\\\"])\\n else:\\n pred = batch[\\\"preds\\\"].to(opts[\\\"device\\\"])\\n labels = batch[\\\"labels\\\"].to(opts[\\\"device\\\"])\\n mask = batch[\\\"mask\\\"].to(opts[\\\"device\\\"], dtype=torch.uint8)\\n \\n # If model uses POS embeddings include batch of encoded POS tags\\n if opts[\\\"use_pos_embeddings\\\"] == True:\\n pos = batch[\\\"pos\\\"].to(opts[\\\"device\\\"])\\n\\n # Get original length of every sentence in the batch\\n # subtract 4 if we are using BERT (as we will remove the 4 special tokens in BERT)\\n if opts[\\\"use_bert\\\"] == False:\\n original_len = np.asarray([len(x[x.nonzero(as_tuple=True)].tolist()) for x in inputs]) \\n elif opts[\\\"use_bert\\\"] == True:\\n unmodified_original_len = [len(x[x.nonzero(as_tuple=True)].tolist()) for x in inputs]\\n original_len = np.asarray([b - 4 for b in unmodified_original_len])\\n\\n labels = labels.view(-1)\\n valid_indices = labels != 0\\n \\n # Forward pass through network\\n predictions = model(inputs, mask, pred, pos)\\n predictions = torch.argmax(predictions, -1).view(-1)\\n valid_predictions = predictions[valid_indices]\\n\\n # Map predictions from ints to words\\n mapper = lambda x: int_to_label[x]\\n mapped_predictions = list(map(mapper, valid_predictions.tolist()))\\n all_predictions.extend(mapped_predictions)\\n\\n # Recontruct predictions from one big list that has predictions for entire batch\\n # into a list of lists where every list has predictions for a sentence\\n reconst = [] \\n var = 0\\n for c_idx in range(len(original_len)):\\n reconst.append(mapped_predictions[var:var+original_len[c_idx]])\\n var += original_len[c_idx]\\n\\n reconstructed_predictions.extend(reconst)\\n\\n valid_labels = labels[valid_indices]\\n all_labels.extend(valid_labels.tolist())\\n \\n read_labels.append(valid_labels.tolist())\\n\\n # Get index of a few labels and access the POS of those indeces\\n select_labels_idx = [i for i, v in enumerate(all_labels) if v==4 or v==6 or v==10 or v==12 or v==16 or v==18]\\n all_pos = [y for x in pre.list_l_pos for y in x]\\n \\n pos_that_are_agent = [all_pos[ag_ix] for ag_ix in select_labels_idx]\\n labels_that_are_agent = [int_to_label[all_labels[ag_ix]] for ag_ix in select_labels_idx]\\n \\n # Create a datafram of POS Tags and the labels associated with them\\n df = pd.DataFrame(list(zip(pos_that_are_agent, labels_that_are_agent)), columns=[\\\"POS Tag\\\", \\\"Label\\\"])\\n \\n # Plot the POS Tags of the Labels we selected in \\\"select_labels_idx\\\"\\n df=df.groupby(['POS Tag','Label']).size()\\n df=df.unstack()\\n df.plot(kind='bar')\\n plt.xticks(rotation=0)\\n plt.show()\\n\\n # Convert predictions from a list of lists into a dictionary:\\n # sentence index: { roles: { index of predicate: [ labels of predicate ] } }\\n all_predictions_dict = {}\\n c = 0\\n for idx, elem in enumerate(duplicates):\\n all_predictions_dict.update({idx: {\\\"roles\\\": {}}})\\n if elem == 0:\\n c += 1\\n else: \\n for h in range(elem):\\n None if not pred_idx[idx] else all_predictions_dict[idx][\\\"roles\\\"].update({pred_idx[idx][h]:reconstructed_predictions[c]})\\n c += 1\\n\\n # Compute precision, recall, F-score\\n arg_ident = evaluate_argument_identification(labels_as_dict, all_predictions_dict)\\n arg_class = evaluate_argument_classification(labels_as_dict, all_predictions_dict)\\n\\n # Write the ground truth label and prediction of every sentence to file\\n # for debugging purposes\\n eval_file = \\\"{}/Prediction_vs_GroundTruth.txt\\\".format(opts[\\\"save_model_path\\\"])\\n s_op_file = open(eval_file, \\\"w\\\", encoding=\\\"utf8\\\")\\n\\n for true_label, prediction, sentence, pr in zip(dev_d, reconstructed_predictions, inp, prs):\\n \\n s_op_file.write(\\\"sen:\\\")\\n for token in sentence:\\n s_op_file.write(token + \\\" \\\")\\n s_op_file.write(\\\"\\\\n\\\")\\n\\n s_op_file.write(\\\"prd:\\\")\\n for th in pr:\\n s_op_file.write(th + \\\" \\\")\\n s_op_file.write(\\\"\\\\n\\\")\\n\\n s_op_file.write(\\\"org:\\\")\\n for word in true_label:\\n s_op_file.write(str(word) + \\\" \\\")\\n s_op_file.write(\\\"\\\\n\\\")\\n\\n s_op_file.write(\\\"pre:\\\")\\n for p in prediction:\\n s_op_file.write(str(p) + \\\" \\\")\\n s_op_file.write(\\\"\\\\n\\\")\\n s_op_file.write(\\\"\\\\n\\\")\\n assert len(true_label) == len(prediction)\\n \\n # Write the Precision, Recall and F1-score the model acheived to file \\n s_op_file.write(\\\"\\\\n\\\\nIdentification\\\")\\n s_op_file.write(\\\"\\\\n\\\\tPrecision: {}\\\\n\\\\tRcall: {}\\\\n\\\\tF-1 score: {}\\\\n\\\\n\\\".format(arg_ident[\\\"precision\\\"], arg_ident[\\\"recall\\\"], arg_ident[\\\"f1\\\"]))\\n\\n\\n s_op_file.write(\\\"\\\\nClassification\\\")\\n s_op_file.write(\\\"\\\\n\\\\tPrecision: {}\\\\n\\\\tRcall: {}\\\\n\\\\tF-1 score: {}\\\\n\\\\n\\\".format(arg_class[\\\"precision\\\"], arg_class[\\\"recall\\\"], arg_class[\\\"f1\\\"]))\\n\\n return arg_ident, arg_class\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67164266","0.6673074","0.6545491","0.65359217","0.65239596","0.6493723","0.64730954","0.6470353","0.6446105","0.64450943","0.64450467","0.641691","0.6371628","0.63209","0.6273009","0.62670004","0.6264034","0.62606454","0.62603366","0.62595165","0.6255538","0.6252877","0.6233328","0.6197057","0.6193974","0.6192653","0.6173807","0.61706424","0.6169166","0.61644703","0.6163224","0.61587685","0.6151709","0.6148432","0.6147088","0.61407083","0.6135172","0.61331326","0.6129475","0.61180216","0.61095166","0.61040056","0.61033404","0.60961497","0.6094564","0.6092371","0.6091958","0.6088469","0.60682756","0.6066304","0.60658026","0.60625106","0.6061121","0.6057051","0.6055797","0.6055133","0.60523164","0.60520726","0.604386","0.60429215","0.6038014","0.6037098","0.6034834","0.60315925","0.6029945","0.6014713","0.60091436","0.6004103","0.60016","0.5998678","0.5995674","0.5995031","0.59914553","0.598706","0.5986561","0.5983172","0.5979917","0.5979917","0.59794104","0.59727335","0.59697425","0.5968756","0.59672123","0.5966521","0.59618175","0.59594876","0.59573865","0.59539986","0.59508795","0.5944474","0.5943129","0.59404755","0.59384394","0.5933445","0.5933134","0.5922861","0.5921657","0.59210473","0.59106064","0.5905821"],"string":"[\n \"0.67164266\",\n \"0.6673074\",\n \"0.6545491\",\n \"0.65359217\",\n \"0.65239596\",\n \"0.6493723\",\n \"0.64730954\",\n \"0.6470353\",\n \"0.6446105\",\n \"0.64450943\",\n \"0.64450467\",\n \"0.641691\",\n \"0.6371628\",\n \"0.63209\",\n \"0.6273009\",\n \"0.62670004\",\n \"0.6264034\",\n \"0.62606454\",\n \"0.62603366\",\n \"0.62595165\",\n \"0.6255538\",\n \"0.6252877\",\n \"0.6233328\",\n \"0.6197057\",\n \"0.6193974\",\n \"0.6192653\",\n \"0.6173807\",\n \"0.61706424\",\n \"0.6169166\",\n \"0.61644703\",\n \"0.6163224\",\n \"0.61587685\",\n \"0.6151709\",\n \"0.6148432\",\n \"0.6147088\",\n \"0.61407083\",\n \"0.6135172\",\n \"0.61331326\",\n \"0.6129475\",\n \"0.61180216\",\n \"0.61095166\",\n \"0.61040056\",\n \"0.61033404\",\n \"0.60961497\",\n \"0.6094564\",\n \"0.6092371\",\n \"0.6091958\",\n \"0.6088469\",\n \"0.60682756\",\n \"0.6066304\",\n \"0.60658026\",\n \"0.60625106\",\n \"0.6061121\",\n \"0.6057051\",\n \"0.6055797\",\n \"0.6055133\",\n \"0.60523164\",\n \"0.60520726\",\n \"0.604386\",\n \"0.60429215\",\n \"0.6038014\",\n \"0.6037098\",\n \"0.6034834\",\n \"0.60315925\",\n \"0.6029945\",\n \"0.6014713\",\n \"0.60091436\",\n \"0.6004103\",\n \"0.60016\",\n \"0.5998678\",\n \"0.5995674\",\n \"0.5995031\",\n \"0.59914553\",\n \"0.598706\",\n \"0.5986561\",\n \"0.5983172\",\n \"0.5979917\",\n \"0.5979917\",\n \"0.59794104\",\n \"0.59727335\",\n \"0.59697425\",\n \"0.5968756\",\n \"0.59672123\",\n \"0.5966521\",\n \"0.59618175\",\n \"0.59594876\",\n \"0.59573865\",\n \"0.59539986\",\n \"0.59508795\",\n \"0.5944474\",\n \"0.5943129\",\n \"0.59404755\",\n \"0.59384394\",\n \"0.5933445\",\n \"0.5933134\",\n \"0.5922861\",\n \"0.5921657\",\n \"0.59210473\",\n \"0.59106064\",\n \"0.5905821\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61701393"},"document_rank":{"kind":"string","value":"28"}}},{"rowIdx":85172,"cells":{"query":{"kind":"string","value":"Computes ROUGEL (sentence level) of two collections of sentences."},"document":{"kind":"string","value":"def rouge_l_sentence_level(eval_sentences, ref_sentences):\n\n f1_scores = []\n for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):\n m = float(len(ref_sentence))\n n = float(len(eval_sentence))\n lcs = _len_lcs(eval_sentence, ref_sentence)\n f1_scores.append(_f_lcs(lcs, m, n))\n return np.mean(f1_scores, dtype=np.float32)"},"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 rouge_l_sentence_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n reference_words = _split_into_words(reference_sentences)\n evaluated_words = _split_into_words(evaluated_sentences)\n m = len(reference_words)\n n = len(evaluated_words)\n lcs = _len_lcs(evaluated_words, reference_words)\n return _f_p_r_lcs(lcs, m, n)","def rouge_l_sentence_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n reference_words = _split_into_words(reference_sentences)\n evaluated_words = _split_into_words(evaluated_sentences)\n m = len(reference_words)\n n = len(evaluated_words)\n lcs = _len_lcs(evaluated_words, reference_words)\n return _f_p_r_lcs(lcs, m, n)","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def rouge_l_summary_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n # total number of words in reference sentences\n m = len(_split_into_words(reference_sentences))\n\n # total number of words in evaluated sentences\n n = len(_split_into_words(evaluated_sentences))\n\n union_lcs_sum_across_all_references = 0\n for ref_s in reference_sentences:\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\n ref_s)\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)","def lemmatize_texts_rus(texts):\n sentenized = [[s.text for s in razdel.sentenize(t)] for t in texts]\n texts_lengths = [len(t) for t in sentenized]\n sentences = [s for t in sentenized for s in t]\n\n sentences_lemm = lemmatize_sentences_rus(sentences)\n\n texts_lemm = []\n pos = 0\n for text_length in texts_lengths:\n texts_lemm.append(sentences_lemm[pos:pos + text_length])\n pos += text_length\n\n assert pos == len(sentences)\n assert len(sentenized) == len(texts_lemm)\n assert all(len(s) == len(a) for s, a in zip(sentenized, texts_lemm))\n return texts_lemm, sentenized","def _union_lcs(evaluated_sentences, reference_sentence):\n if len(evaluated_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n lcs_union = set()\n reference_words = _split_into_words([reference_sentence])\n combined_lcs_length = 0\n for eval_s in evaluated_sentences:\n evaluated_words = _split_into_words([eval_s])\n lcs = set(_recon_lcs(reference_words, evaluated_words))\n combined_lcs_length += len(lcs)\n lcs_union = lcs_union.union(lcs)\n\n union_lcs_count = len(lcs_union)\n union_lcs_value = union_lcs_count / combined_lcs_length\n return union_lcs_value","def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\n # sanity check\n assert len(list_of_references) == len(\n hypotheses\n ), \"The number of hypotheses and their reference(s) should be the same\"\n\n # sum matches and max-token-lengths over all sentences\n corpus_n_match = 0\n corpus_n_all = 0\n\n for references, hypothesis in zip(list_of_references, hypotheses):\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\n\n hyp_counts = []\n for reference in references:\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\n\n overlap_ngrams = ref_ngrams & hyp_ngrams\n tp = sum(overlap_ngrams.values()) # True positives.\n\n # While GLEU is defined as the minimum of precision and\n # recall, we can reduce the number of division operations by one by\n # instead finding the maximum of the denominators for the precision\n # and recall formulae, since the numerators are the same:\n # precision = tp / tpfp\n # recall = tp / tpfn\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\n n_all = max(tpfp, tpfn)\n\n if n_all > 0:\n hyp_counts.append((tp, n_all))\n\n # use the reference yielding the highest score\n if hyp_counts:\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\n corpus_n_match += n_match\n corpus_n_all += n_all\n\n # corner case: empty corpus or empty references---don't divide by zero!\n if corpus_n_all == 0:\n gleu_score = 0.0\n else:\n gleu_score = corpus_n_match / corpus_n_all\n\n return gleu_score","def simple_baseline_similarity(s1, s2):\n # Tokenize by sentences into words in lower case \n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\n\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\n \n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\n \n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\n\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\n\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\n\n return word_sim, lemm_sim","def Extended_Lesk(word1,word2):\n\n #Creates a list of the word, and one layer of hyponyms\n list1 = [word1]\n for i in word1.hyponyms():\n list1.append(i)\n list2 = [word2]\n for i in word2.hyponyms():\n list2.append(i)\n\n #Creates a list of each of the above words' definitions, tokenized\n words1 = []\n words2 = []\n for i in list1:\n words1.append([l for l in word_tokenize(i.definition())])\n for i in list2:\n words2.append([l for l in word_tokenize(i.definition())])\n\n #Calculates the Maximum length of the Longest Definition\n lengths = []\n lengths.extend(len(l) for l in words1)\n lengths.extend(len(l) for l in words2)\n maxim = max(lengths)\n\n igramcount = []\n igram1 = []\n igram2 = []\n\n # Creates N-grams for each definition for each N, from 1:max(lengths)\n for i in range(int(maxim)):\n for g in words1:\n for l in ngrams(g, i+1):\n igram1.append(l)\n for f in words2:\n for m in ngrams(f, i+1):\n igram2.append(m)\n\n #For Each N-gram in the first set, which matches that of the Second set,\n # Denoting a form of \"Similarity\" between the two definitions,\n # Record the Value of N into a new List, igramcount.\n for x in set(igram1):\n if x in set(igram2):\n igramcount.append(i + 1)\n\n igram1 = []\n igram2 = []\n\n #Square the values of igramcount, and return the sum as the value of Extended Lesk.\n squared = [number**2 for number in igramcount]\n return sum(squared)","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def compare_sentences(first, second):\n if not len(first) or not len(second):\n return 0\n return len(set(only_important(first)) & set(only_important(second))) / ((len(first) + len(second)) / 2.0)","def word_overlap2(sentence_a, sentence_b):\n a_set = set(word for word in sentence_a) - config.stop_list\n b_set = set(word for word in sentence_b) - config.stop_list\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\n\n return score","def rouge(hypotheses, references):\n\n # Filter out hyps that are of 0 length\n # hyps_and_refs = zip(hypotheses, references)\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\n # hypotheses, references = zip(*hyps_and_refs)\n\n # Calculate ROUGE-1 F1, precision, recall scores\n rouge_1 = [\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\n\n # Calculate ROUGE-2 F1, precision, recall scores\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\n\n # Calculate ROUGE-L F1, precision, recall scores\n rouge_l = [\n rouge_l_sentence_level([hyp], [ref])\n for hyp, ref in zip(hypotheses, references)\n ]\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\n\n return {\n \"rouge_1/f_score\": rouge_1_f,\n \"rouge_1/r_score\": rouge_1_r,\n \"rouge_1/p_score\": rouge_1_p,\n \"rouge_2/f_score\": rouge_2_f,\n \"rouge_2/r_score\": rouge_2_r,\n \"rouge_2/p_score\": rouge_2_p,\n \"rouge_l/f_score\": rouge_l_f,\n \"rouge_l/r_score\": rouge_l_r,\n \"rouge_l/p_score\": rouge_l_p,\n }","def test_lcs_nouns(id1, id2, expected_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n lcs = syn1.lowest_common_subsumer(syn2)\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))","def lemmatize_text_rus(text):\n text_lemm, text_sent = lemmatize_texts_rus([text])\n text_lemm, text_sent = text_lemm[0], text_sent[0]\n return text_lemm, text_sent","def oracle_sentences(\n gold_sentences: tagdata_pb2.Sentences,\n all_sentences: Iterable[tagdata_pb2.Sentences],\n) -> tagdata_pb2.Sentences:\n inner_sentences = list(sentences.sentences for sentences in all_sentences)\n assert all(\n len(gold_sentences.sentences) == len(sentences)\n for sentences in inner_sentences\n ), \"Mismatched lengths\"\n ensembled_sentences = tagdata_pb2.Sentences()\n gen = zip(gold_sentences.sentences, *inner_sentences)\n correct = 0\n total = 0\n for (gold_sentence, *all_sentence) in gen:\n inner_tags = list(sentence.tags for sentence in all_sentence)\n assert all(\n len(gold_sentence.tags) == len(tags) for tags in inner_tags\n ), \"Mismatched lengths\"\n ensembled_sentence = ensembled_sentences.sentences.add()\n for (gold_tag, *all_tags) in zip(gold_sentence.tags, *inner_tags):\n if any(gold_tag == tag for tag in all_tags):\n ensembled_sentence.tags.append(gold_tag)\n correct += 1\n else:\n counts = collections.Counter(all_tags)\n ensembled_sentence.tags.append(counts.most_common(1)[0][0])\n total += 1\n logging.info(\"Accuracy (oracle):\\t%.4f\", correct / total)\n return ensembled_sentences","def compare_sentences(s1,s2):\n\n total_score=0;\n num_total=0;\n for k in s1:\n num_total+=1\n if k in s2:\n if s1[k]==s2[k]:\n score = 1;\n else:\n score = 0;\n else:\n score = 0;\n total_score += score;\n \n for k in s2:\n if k not in s1:\n num_total+=1\n\n logging.info(\"Scored %f out of %d\" % (total_score, num_total));\n\n if num_total==0:\n return 1;\n return float(total_score)/float(num_total)","def sentences(a, b):\n\n # TODO\n return []","def compare_word_selection(selection1,selection2):\n\n num_extra=0;\n num_total=0;\n total_score=0;\n for k in selection1.keys():\n num_total+=1;\n if k not in selection2:\n num_extra+=1;\n else:\n score=compare_sentences(selection1[k],selection2[k]);\n logging.info(\"Score: %f\" % score );\n total_score+=score;\n\n for k in selection2.keys():\n if k not in selection1:\n num_total+=1;\n num_extra+=1;\n\n if num_total==0:\n return 0;\n\n return float(total_score)/float(num_total)","def batch_sentences(sentences, lg_ids=None):\n # sentences = sorted(sentences, key=lambda x: len(x), reverse=True)\n lengths = torch.LongTensor([len(s) + 2 for s in sentences])\n sent = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(1)\n if lg_ids is not None:\n lgs = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(4)\n else:\n lgs = None\n sent[0] = 0\n for i, s in enumerate(sentences):\n if lengths[i] > 2: # if sentence not empty\n sent[1:lengths[i] - 1, i].copy_(torch.from_numpy(s.astype(np.int64)))\n sent[lengths[i] - 1, i] = 2\n if lg_ids is not None:\n lgs[:, i] = lg_ids[i]\n\n if lgs is None:\n return sent, lengths\n return sent, lengths, lgs","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2): \n if (i + startpoint) < (l1 + l2 - 1): \n if l2 - i > startpoint + 1:\n matched = matched + \".\" #dots before they start overlapping\n elif s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" #matched bases\n score = score + 1 #adds one to score\n else:\n matched = matched + \"-\" #not matched bases\n shift, end_shift = startpoint * \".\", (l2 + l1 - startpoint - 2) * \".\"\n # dots at end, but only up until end of dots tailing l1\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\n # this formula. the below check stops it from getting less than l2.\n if startpoint < l1 - 1:\n print(shift + matched + end_shift)\n else:\n print(shift + matched + (l2 - 1) * \".\")\n print(shift + s2 + end_shift)\n print(s1)\n print(str(score) + \"\\n\")\n return score, matched, shift, end_shift","def alleles(gt1, gt2):\n\n\t# Count genotypes 1 and 2\n\tcount = {}\n\tfor g in gt1 :\n\t\tcount[g] = count.get(g, 0) + 1\n\n\tfor g in gt2 :\n\t\tcount[g] = count.get(g, 0) + 1\n\n\t# Find mayor allele (we call it 'ref')\n\tmaxCount = 0\n\tref = ''\n\tfor g in count:\n\t\tif count[g] > maxCount:\n\t\t\tmaxCount = count[g]\n\t\t\tref = g\n\n\t# Find minor allele (we call these one 'alt')\n\talt = ''\n\tfor g in count:\n\t\tif g != ref and g != '0': alt = g\n\n\t# Create a genotype string (VCF style)\n\tgtstr = \"\"\n\tfor i in range(len(gt1)):\n\t\tgtstr += \"\\t\" + gtVcf(ref, alt, gt1[i]) + \"/\" + gtVcf(ref, alt, gt2[i])\n\n\treturn ref, alt, count[alt], gtstr","def compareLemma(l1, l2, cwn):\n l1 = f\"^{l1}$\"\n l2 = f\"^{l2}$\"\n \n l1_lst = [str(li).replace('<CwnSense', '').replace('>', '').replace('(', '').replace(')', '') for li in cwn.find_senses(lemma=l1)]\n l2_lst = [str(li).replace('<CwnSense', '').replace('>', '').replace('(', '').replace(')', '') for li in cwn.find_senses(lemma=l2)]\n \n if len(l1_lst) < len(l2_lst):\n zip_lst = zip(l2_lst, l1_lst)\n long = l2_lst\n short = l1_lst\n else:\n zip_lst = zip(l1_lst, l2_lst)\n long = l1_lst\n short = l2_lst\n \n # Print paired list\n for i, (a, b) in enumerate(zip_lst):\n #print(f\"{a:50}{b:>50}\")\n print(f\"{i+1:>3} {a.ljust(45, ' ')}{b}\") # 使用全形空白\n # Print remaining list\n if len(long) > len(short):\n for item in long[len(list(zip_lst)):]:\n i += 1\n print(f\"{i+1:>3} {item}\")","def lemma_texts(raw_texts):\r\n tokens = pos_tag(word_tokenize(raw_texts))\r\n res = [lemmatize(pos_res[0], get_wordnet_pos(pos_res[1])) for pos_res in tokens]\r\n return \" \".join(res)","def compare_sentences(sentence_a, sentence_b, extra_splits=DEFAULT_SPLITTERS):\n\n def split_sentence(sentence):\n reworked_sentence = sentence.strip()\n for chars in extra_splits:\n reworked_sentence = reworked_sentence.replace(chars, ' ')\n return reworked_sentence.split()\n\n reworked_a = split_sentence(sentence_a)\n reworked_b = split_sentence(sentence_b)\n return compare_iterables(reworked_a, reworked_b)","def get_rouge_est_str_2gram_smart(gold: str, pred: str, stemming=False):\n gold_1, gold_2, gold_st = _get_2gram_sets_keep_stop(gold, stemming) # TODO\n pred_1, pred_2, pred_st = _get_2gram_sets_keep_stop(pred, stemming) # TODO\n rouge_recall_1 = 0\n if len(gold_1) != 0:\n rouge_recall_1 = float(len(gold_1.intersection(pred_1))) / float(len(gold_1))\n\n rouge_pre_1 = 0\n if len(pred_1) != 0:\n rouge_pre_1 = float(len(gold_1.intersection(pred_1))) / float(len(pred_1))\n\n rouge_recall_2 = 0\n if len(gold_2) != 0:\n rouge_recall_2 = float(len(gold_2.intersection(pred_2))) / float(len(gold_2))\n\n rouge_pre_2 = 0\n if len(pred_2) != 0:\n rouge_pre_2 = float(len(gold_2.intersection(pred_2))) / float(len(pred_2))\n\n f1 = 0 if (rouge_recall_1 + rouge_pre_1 == 0) else 2 * (rouge_recall_1 * rouge_pre_1) / (\n rouge_recall_1 + rouge_pre_1)\n f2 = 0 if (rouge_recall_2 + rouge_pre_2 == 0) else 2 * (rouge_recall_2 * rouge_pre_2) / (\n rouge_recall_2 + rouge_pre_2)\n if stemming:\n\n rouge_recall_st = 0\n if len(gold_st) != 0:\n rouge_recall_st = float(len(gold_st.intersection(pred_st))) / float(len(gold_st))\n\n rouge_pre_st = 0\n if len(pred_st) != 0:\n rouge_pre_st = float(len(gold_st.intersection(pred_st))) / float(len(pred_st))\n f_st = 0 if (rouge_recall_st + rouge_pre_st == 0) else 2 * (rouge_recall_st * rouge_pre_st) / (\n rouge_recall_st + rouge_pre_st)\n\n average_f_score = f1 * 0.25 + f2 * 0.5 + 0.25 * f_st\n else:\n average_f_score = (f1 + f2) / 2\n # average_f_score = (f1 ) # TODO\n return average_f_score","def wordSimilarityRatio(sent_1,sent_2):","def batch_sentences_v2(sentences, lm_labels=None):\n # sentences = sorted(sentences, key=lambda x: len(x), reverse=True)\n lengths = torch.LongTensor([len(s) + 2 for s in sentences])\n sent = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(1)\n if lm_labels is not None:\n _labels = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(-1)\n\n sent[0] = 0\n for i, s in enumerate(sentences):\n if lengths[i] > 2: # if sentence not empty\n sent[1:lengths[i] - 1, i].copy_(torch.from_numpy(s.astype(np.int64)))\n if lm_labels is not None:\n lm = np.array(lm_labels[i])\n _labels[1:lengths[i] - 1, i].copy_(torch.from_numpy(lm.astype(np.int64)))\n sent[lengths[i] - 1, i] = 2\n if lm_labels is not None:\n _labels[lengths[i] - 1, i] = -1\n\n if lm_labels is not None:\n return sent, lengths, _labels\n return sent, lengths","def compSeq(s1, s2, lineL=50):\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\n count = 0\n samecount = 0\n outStr = ''\n for linei in range(lineN):\n if (linei+1) * lineL < min(len(s1), len(s2)):\n end = (linei+1) * lineL\n else:\n end = min(len(s1), len(s2))\n outStr += 'Pos %d - %d\\n' % (linei*lineL+1, end-1+1)\n for sitei in range(linei*lineL, end):\n outStr += s1[sitei]\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = ' ' if s1[sitei] == s2[sitei] else '|'\n outStr += out\n count += 1\n samecount += 1 if s1[sitei]==s2[sitei] else 0\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\n outStr += s2[sitei]\n outStr += '\\n\\n'\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\n\\n' % (len(s1), len(s2), 1e2*samecount/count)\n print(outStr)","def sentence_similarity(sentence1, sentence2):\n sentence1 = sentence1.tags\n sentence2 = sentence2.tags\n \n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n \n for synset in synsets1:\n \n li=[synset.path_similarity(ss) for ss in synsets2]\n m=0\n for i in range(len(li)):\n if li[i] is not None and m<li[i]:\n m=li[i]\n if m != 0:\n score += m\n count += 1\n\n if count is 0:\n score = 0\n else:\n score /= count\n return score","def get_left_right_lists(sentence, language):\n left_list = nltk.word_tokenize(replace_accented(sentence.childNodes[0].nodeValue.replace('\\n', '')))\n right_list = nltk.word_tokenize(replace_accented(sentence.childNodes[2].nodeValue.replace('\\n', '')))\n\n left_list = remove_stop_words(left_list, language)\n right_list = remove_stop_words(right_list, language)\n\n left_list = remove_punctuations(left_list)\n right_list = remove_punctuations(right_list)\n\n left_list = lowercase(left_list)\n right_list = lowercase(right_list)\n\n left_list = stemming(left_list, language)\n right_list = stemming(right_list, language)\n\n return left_list, right_list","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2):\n #moves shorter sequence along longer, counting number of matches in\n #each position\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\"\n score = score + 1\n else:\n matched = matched + \"-\"\n\n # gives an output for each startpoint showing the number of matches where\n # * is a match and - is no match, position of the two sequences relative to\n # each other, and the number of matches for that startpoint.\n print(\".\" * startpoint + matched) \n print(\".\" * startpoint + s2)\n print(s1)\n print(score) \n print(\" \")\n\n return score","def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\n pred_len = sum(map(len, pred))\n target_len = sum(map(len, target))\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\n ngrams: Counter = Counter()\n for sentence in sentences:\n ngrams.update(sentence)\n return ngrams\n pred_tokens_count = _get_token_counts(pred)\n target_tokens_count = _get_token_counts(target)\n hits = 0\n for tgt in target:\n lcs = _union_lcs(pred, tgt)\n for token in lcs:\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\n hits += 1\n pred_tokens_count[token] -= 1\n target_tokens_count[token] -= 1\n return _compute_metrics(hits, pred_len, target_len)","def lemmas_similarity(s1, s2, filter_stop_words=True):\n # Tokenize by sentences into words in lower case \n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\n \n if not filter_stop_words:\n tokenized_sentence_1 = [token for token in tokenized_sentence_1 if token not in stop_words]\n tokenized_sentence_2 = [token for token in tokenized_sentence_2 if token not in stop_words]\n \n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\n \n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1] \n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2] # [LEMMA_1, ...]\n \n # Compute similarity\n if len(lemmas_sentence_1) > 0 and len(lemmas_sentence_2) > 0:\n similarity = 1 - jaccard_distance(set(lemmas_sentence_1), set(lemmas_sentence_2))\n # Compute label of similarity \n return similarity\n else:\n return 0","def sentences(a, b):\n\n # creating a list with all the sentences using nltk\n sentencesA = sent_tokenize(a)\n sentencesB = sent_tokenize(b)\n\n same_sentences = []\n\n for sent in sentencesA:\n if sent in sentencesB and sent not in same_sentences:\n same_sentences.append(sent)\n\n return same_sentences","def rouge_l(peer, models, alpha=1):\n matches = 0\n recall_total = 0\n for model in models:\n matches += lcs(model, peer)\n recall_total += len(model)\n precision_total = len(models) * len(peer)\n return _safe_f1(matches, recall_total, precision_total, alpha)","def wordNet_similarity(sentence1, sentence2):\r\n # Tokenize and tag\r\n \r\n # sentence1 = pos_tag(word_tokenize(sentence1))\r\n sentence1=st_tagger.tag(word_tokenize(sentence1))\r\n \r\n # sentence2 = pos_tag(word_tokenize(sentence2))\r\n sentence2=st_tagger.tag(word_tokenize(sentence2))\r\n\r\n \r\n # Get the synsets for the tagged words\r\n #################################################\r\n\r\n # synsets1=[]\r\n # synsets2=[]\r\n # for tagged_word in sentence1:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n # for tagged_word in sentence2:\r\n # print(tagged_word)\r\n # tagged_word = list(tagged_word)\r\n # print(tagged_word)\r\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\r\n\r\n # The code above is the elaboration of code below\r\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\r\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\r\n \r\n # Filter out the Nones in the synonym set\r\n synsets1 = [ss for ss in synsets1 if ss]\r\n synsets2 = [ss for ss in synsets2 if ss]\r\n \r\n score, count = 0.0, 0\r\n \r\n###########################################################################\r\n # for syn1 in synsets1:\r\n # arr_simi_score = []\r\n # print('=========================================')\r\n # print(syn1)\r\n # print('----------------')\r\n # for syn2 in synsets2:\r\n # print(syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n # print(simi_score)\r\n # if simi_score is not None:\r\n # arr_simi_score.append(simi_score)\r\n # print('----------------')\r\n # print(arr_simi_score)\r\n # if(len(arr_simi_score) > 0):\r\n # best = max(arr_simi_score)\r\n # print(best)\r\n # score += best\r\n # count += 1\r\n # # Average the values\r\n # print('score: ', score)\r\n # print('count: ', count)\r\n # score /= count\r\n\r\n###########################################################################\r\n\r\n for syn1 in synsets1:\r\n arr_simi_score = []\r\n # print('=========================================')\r\n print(\"Each word from Synonym se1\",syn1)\r\n # print('----------------')\r\n for syn2 in synsets2:\r\n print(\"Each word from Synonym se2\",syn2)\r\n # simi_score = syn1.path_similarity(syn2)\r\n simi_score = syn1.wup_similarity(syn2)\r\n print(\"word to word path_similarity score\",simi_score)\r\n if simi_score is not None:\r\n arr_simi_score.append(simi_score)\r\n print('----------------')\r\n print(arr_simi_score)\r\n if(len(arr_simi_score) > 0):\r\n best = max(arr_simi_score)\r\n print(\"best score so far\", best)\r\n score += best\r\n count += 1\r\n # Average the values\r\n print('score: ', score)\r\n print('count: ', count)\r\n if count!=0:\r\n score /= count\r\n else:\r\n score=0.0\r\n return score","def _example_from_conllu_sentence(\n self,\n lines: List[str],\n merge_subtoken: bool =False,\n )-> Doc:\n # create a Doc with each subtoken as its own token\n # if merging subtokens, each subtoken orth is the merged subtoken form\n if not Token.has_extension(\"merged_orth\"):\n Token.set_extension(\"merged_orth\", default=\"\")\n if not Token.has_extension(\"merged_lemma\"):\n Token.set_extension(\"merged_lemma\", default=\"\")\n if not Token.has_extension(\"merged_morph\"):\n Token.set_extension(\"merged_morph\", default=\"\")\n if not Token.has_extension(\"merged_spaceafter\"):\n Token.set_extension(\"merged_spaceafter\", default=\"\")\n words, spaces, tags, poses, morphs, lemmas = [], [], [], [], [], []\n heads, deps = [], []\n subtok_word = \"\"\n in_subtok = False\n for i in range(len(lines)):\n line = lines[i]\n parts = line.split(\"\\t\")\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\n if \".\" in id_:\n continue\n if \"-\" in id_:\n in_subtok = True\n if \"-\" in id_:\n in_subtok = True\n subtok_word = word\n subtok_start, subtok_end = id_.split(\"-\")\n subtok_spaceafter = \"SpaceAfter=No\" not in misc\n continue\n if merge_subtoken and in_subtok:\n words.append(subtok_word)\n else:\n words.append(word)\n if in_subtok:\n if id_ == subtok_end:\n spaces.append(subtok_spaceafter)\n else:\n spaces.append(False)\n elif \"SpaceAfter=No\" in misc:\n spaces.append(False)\n else:\n spaces.append(True)\n if in_subtok and id_ == subtok_end:\n subtok_word = \"\"\n in_subtok = False\n id_ = int(id_) - 1\n head = (int(head) - 1) if head not in (\"0\", \"_\") else id_\n tag = pos if tag == \"_\" else tag\n morph = morph if morph != \"_\" else \"\"\n dep = \"ROOT\" if dep == \"root\" else dep\n lemmas.append(lemma)\n poses.append(pos)\n tags.append(tag)\n morphs.append(morph)\n heads.append(head)\n deps.append(dep)\n\n doc: Doc = Doc(self.nlp.vocab, words=words, spaces=spaces)\n for i in range(len(doc)):\n doc[i].tag_ = tags[i]\n doc[i].pos_ = poses[i]\n doc[i].dep_ = deps[i]\n doc[i].lemma_ = lemmas[i]\n doc[i].head = doc[heads[i]]\n doc[i]._.merged_orth = words[i]\n doc[i]._.merged_morph = morphs[i]\n doc[i]._.merged_lemma = lemmas[i]\n doc[i]._.merged_spaceafter = spaces[i]\n if merge_subtoken:\n doc = self._merge_conllu_subtokens(lines, doc)\n return doc","def get_synset_overlap(sentence_a, sentence_b):\n def synsets(word):\n sense_lemmas = []\n for pos in ('n'):#,'a'):\n for i in xrange(5):\n try:\n sense_lemmas += [lemma.name \n for lemma in wn.synset('{0}.{1}.0{2}'.format(word, pos, i)).lemmas]\n except WordNetError: \n pass\n return sense_lemmas\n\n a_set = set(lemma for word in sentence_a for lemma in synsets(word))\n b_set = set(lemma for word in sentence_b for lemma in synsets(word))\n score = len(a_set&b_set)/float(len(a_set|b_set))\n \n return score","def concretize(self, lw: torch.Tensor, uw: torch.Tensor):\n if self.args.attack_type == \"synonym\":\n # lw: (input/output len, output dim, len * input dim)\n # lw = lw.transpose(0, 1) # (output dim, input/output len, len * input dim)\n # uw = uw.transpose(0, 1) # (output dim, input/output len, len * input dim)\n\n dim = lw.size(2) // self.perturbed_words\n concretized_l = torch.zeros(lw.size(0), lw.size(1), device=lw.device)\n concretized_u = torch.zeros(uw.size(0), uw.size(1), device=uw.device)\n for i in range(self.perturbed_words):\n concretized_l -= torch.norm(lw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\n concretized_u += torch.norm(uw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\n\n return concretized_l, concretized_u\n elif self.perturbed_words == 2:\n assert (len(lw.shape) == 3), \"Lw does not have 3 dimensions! It has %d dimensions\" % len(lw.shape)\n half = lw.shape[-1] // 2\n concretized_l = self.concretize_l(lw[:, :, :half]) + self.concretize_l(lw[:, :, half:])\n concretized_u = self.concretize_u(uw[:, :, :half]) + self.concretize_u(uw[:, :, half:])\n return concretized_l, concretized_u\n elif self.perturbed_words == 1:\n return self.concretize_l(lw), self.concretize_u(uw)\n else:\n raise NotImplementedError","def test_lcs_verbs(id1, id2, expected_ids):\n syn1 = germanet_data.get_synset_by_id(id1)\n syn2 = germanet_data.get_synset_by_id(id2)\n lcs = syn1.lowest_common_subsumer(syn2)\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))","def calculate_score(s1, s2, l1, l2, startpoint):\n\n matched = \"\" # to hold string displaying alignments\n score = 0\n for i in range(l2):\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" # * indicates a match\n score = score + 1\n else:\n matched = matched + \"-\" # - indicates no match\n\n return score","def lcs_rouge(self, RTSummary , SystemSummary):\n return (len(RTSummary)+len(SystemSummary) - (self.lcs(RTSummary,SystemSummary)))/2","def get_word_containement_measure(self,l2,l1):\n count = 0\n found_idfs = []\n unfound_idfs = []\n for w in l1:\n val = self.idf.get_tfidf_val(w)\n if (val > 10):\n val = 10\n if w in l2:\n count += 1\n found_idfs.append(val)\n else:\n unfound_idfs.append(val)\n if (len(found_idfs) == 0):\n avg_found = 0\n else:\n avg_found = np.mean(found_idfs)\n if (len(unfound_idfs) ==0):\n avg_unfound = 0\n else:\n avg_unfound = np.mean(unfound_idfs)\n\n\n\n return count / self.normalize_factor, avg_found, avg_unfound","def rgenerate(allele1, allele2, min_length, max_length):\n from .models import Primer\n\n if len(allele1) != len(allele2):\n raise ValueError('Aligned alleles must be the same length.')\n\n allele1 = str(allele1)\n allele2 = str(allele2)\n candidates = []\n\n for size in range(min_length, max_length+1):\n allele1_span = (0, size)\n allele2_span = (0, size)\n\n for i in range(len(allele1)-size):\n if allele1[i:i+size] == allele2[i:i+size]:\n candidates.append(Primer(sequence=allele1[i:i+size],\n allele1_span=allele1_span,\n allele2_span=allele2_span,\n strand=1))\n\n if allele1[i] != '-':\n allele1_span = (allele1_span[0]+1, allele1_span[1]+1)\n\n if allele2[i] != '-':\n allele2_span = (allele2_span[0]+1, allele2_span[1]+1)\n\n return candidates","def sentences(a, b):\n a = set(sent_tokenize(a))\n b = set(sent_tokenize(b))\n return a & b","def compare_lists(l1, l2):\n score = 0\n total = len(l1)\n weight = 110\n\n for item in range(len(l2)):\n if item in range(len(l1)):\n score += math.log(weight/total) * (weight)\n else:\n score += math.log(0.5/total) * (1)\n weight -= 10\n return score","def sentence_lengths(sentence_a, sentence_b):\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))","def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\n # identify and process all subtoken spans to prepare attrs for merging\n subtok_spans = []\n for line in lines:\n parts = line.split(\"\\t\")\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\n if \"-\" in id_:\n subtok_start, subtok_end = id_.split(\"-\")\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\n subtok_spans.append(subtok_span)\n # create merged tag, morph, and lemma values\n tags = []\n morphs = {}\n lemmas = []\n for token in subtok_span:\n tags.append(token.tag_)\n lemmas.append(token.lemma_)\n if token._.merged_morph:\n for feature in token._.merged_morph.split(\"|\"):\n field, values = feature.split(\"=\", 1)\n if field not in morphs:\n morphs[field] = set()\n for value in values.split(\",\"):\n morphs[field].add(value)\n # create merged features for each morph field\n for field, values in morphs.items():\n morphs[field] = field + \"=\" + \",\".join(sorted(values))\n # set the same attrs on all subtok tokens so that whatever head the\n # retokenizer chooses, the final attrs are available on that token\n for token in subtok_span:\n token._.merged_orth = token.orth_\n token._.merged_lemma = \" \".join(lemmas)\n token.tag_ = \"_\".join(tags)\n token._.merged_morph = \"|\".join(sorted(morphs.values()))\n token._.merged_spaceafter = (\n True if subtok_span[-1].whitespace_ else False\n )\n\n with doc.retokenize() as retokenizer:\n for span in subtok_spans:\n retokenizer.merge(span)\n\n return doc","def commonality(left_struc, right_struc):\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\n assert left_struc and right_struc, (left_struc, right_struc)\n if type(left_struc) is dict:\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\n com = float(len(overlap))\n tot = len(overlap.union(left, right))\n else:\n assert type(left_struc) in (list, tuple), left_struc\n com = 0.0\n for elem in left_struc:\n if elem in right_struc:\n com += 1\n tot = max(len(left_struc), len(right_struc))\n\n return com / tot","def sentences(a, b):\n c = [] #Declare list\n\n a = sent_tokenize(a)\n b = sent_tokenize(b)\n\n for x in a:\n for y in b:\n if x == y:\n if not x in c:\n c.append(x)\n return (c)","def get_relatedness(theme1,theme2):\r\n nAB=0\r\n nAB_plus=0\r\n for sentence_1 in theme1.sentences:\r\n for sentence_2 in theme2.sentences:\r\n if cmp(sentence_1[2],sentence_2[2])==0:\r\n nAB=nAB+1\r\n if sentence_1[3]==sentence_2[3]:\r\n nAB_plus=nAB_plus+1\r\n if nAB==0:\r\n return 0\r\n else:\r\n return float(nAB_plus)/float(nAB)","def sentences(a, b):\n setA = set(sent_tokenize(a))\n setB = set(sent_tokenize(b))\n return list(setA & setB)","def merge_overlapping_predictions(tags1: List[str], tags2: List[str]) -> List[str]:\n ret_sequence = []\n prev_label = \"O\"\n\n # Build a coherent sequence out of two\n # spans which predicates' overlap\n\n for tag1, tag2 in zip(tags1, tags2):\n label1 = tag1.split(\"-\", 1)[-1]\n label2 = tag2.split(\"-\", 1)[-1]\n if (label1 == \"V\") or (label2 == \"V\"):\n # Construct maximal predicate length -\n # add predicate tag if any of the sequence predict it\n cur_label = \"V\"\n\n # Else - prefer an argument over 'O' label\n elif label1 != \"O\":\n cur_label = label1\n else:\n cur_label = label2\n\n # Append cur tag to the returned sequence\n cur_tag = get_coherent_next_tag(prev_label, cur_label)\n prev_label = cur_label\n ret_sequence.append(cur_tag)\n return ret_sequence","def Path_Similarity(word1, word2):\n\n # Initial test to confirm unique nouns, otherwise passes back 1\n\n if word1 == word2:\n return 1, word1\n\n # Sets up Initial Variables & Dictionaries\n\n stepup1 = [word1]\n stepup2 = [word2]\n dict1= {}\n dict2= {}\n currentstep1 = []\n currentstep2 = []\n\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\n # for each word to individual dictionaries with the number of iterations\n # as the key to the dictionary. The two dictionaries are saved perpetually\n\n for la in range(50):\n for i in range(len(stepup1)):\n currentstep1 += (stepup1[i].hypernyms())\n for syn in stepup1:\n dict1[syn] = la\n for i in range(len(stepup2)):\n currentstep2 = (stepup2[i].hypernyms())\n for syn in stepup2:\n dict2[syn] = la\n\n # Variables are reset and converted to continue the next stage of the loop\n\n stepup1 = currentstep1\n stepup2 = currentstep2\n currentstep1 = []\n currentstep2 = []\n\n\n # Each loop the dictionaries are checked for matches. I have confirmed that\n # checking each cycle is faster than checking at the end of an arbitrary\n # number of cycles.\n\n # Removes applied words as Possible Subsumers Per Fridays Clas\n dict1.pop(word1)\n dict2.pop(word2)\n\n #Gets possible Least Common Subsumers\n dict1Set = set(dict1)\n dict2Set = set(dict2)\n d = {}\n for name in dict1Set.intersection(dict2Set):\n d[name] = dict1[name]\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\n\n #Returns Actual LCS\n key_lcs = []\n for i in pos_lcs:\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\n\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\n\n return 1/(dict1[lcs] + dict2[lcs]), lcs","def information_content_similarity(s1, s2):\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\n\n # Disambiguate words and create list of sysnsets \n synsets_sentence_1 = []\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_1.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_1.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n synsets_sentence_2 = []\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\n if synset is not None:\n synsets_sentence_2.append(synset)\n else:\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\n if len(found) > 0:\n synsets_sentence_2.append(found[0]) \n #print(\"Warn: lemma [%s] returned no disambiguation...using synset : %s\" % (lemma, found[0])) \n\n score, count = 0.0, 0\n # For each word in the first sentence\n for synset in synsets_sentence_1:\n L = []\n for ss in synsets_sentence_2:\n try:\n L.append(synset.lin_similarity(ss, brown_ic))\n except:\n continue\n if L: \n best_score = max(L)\n score += best_score\n count += 1\n # Average the values\n if count > 0: score /= count\n return score","def linear_nlg(tuple_message_clause: tuple, str_joiner: str = ' ') -> str:\n def get_clause(tup_data) -> str:\n \"\"\"Helper func: returns clause from tup_data using recursion.\"\"\"\n if (tup_data is None) or (len(tup_data) == 0):\n return ''\n\n elif isinstance(tup_data, str):\n return tup_data\n\n elif isinstance(tup_data, (int, float)):\n return Pauser.get_p_level(tup_data)\n \n elif isinstance(tup_data, (tuple, list)):\n\n if isinstance(tup_data[0], str):\n ## List of strings, return choice.\n return random.choice(tup_data)\n\n else:\n # Recursion of tuples in tuple\n speech_list = []\n for clause_list in tup_data:\n clause = get_clause(clause_list)\n speech_list.append(clause)\n\n return str_joiner.join(speech_list)\n else:\n logger.warning(f\"get_clause: Unrecognized data type {tup_data}\")\n \n\n logger.debug(tuple_message_clause)\n speech_list = []\n\n for tup_data in tuple_message_clause:\n clause = get_clause(tup_data)\n speech_list.append( clause)\n \n # logger.debug(speech_list)\n return str_joiner.join(speech_list)","def convertSentenceToConLL(sent_xml_repr, oformat='conll07'):\n import conll_utils as cu ;\n if oformat == 'conllu':\n cu.FIELDS = cu.AUG_CONLLU_COLUMNS ; \n else:\n cu.FIELDS = cu.AUG_CONLL07_COLUMNS ;\n\n pos_field = 'xpostag' if oformat == 'conllu' else 'cpostag' ;\n deps_field = 'deps' if oformat == 'conllu' else 'phead' ;\n sent_node = etree.fromstring(sent_xml_repr);\n conll_sentence = [];\n terminalNodes = [];\n for token_node in sent_node.findall(\".//token\"):\n conll_line, isNer = defaultdict(lambda: '_'), False;\n conll_line['id'] = token_node.attrib['id'];\n for child in token_node:\n if child.tag == 'word': conll_line['form'] = child.text;\n if child.tag == 'lemma': conll_line['lemma'] = child.text;\n if child.tag == 'POS': \n conll_line[pos_field] = child.text.strip();\n conll_line['postag'] = child.text.strip();\n if child.tag == 'NER' and child.text != 'O':\n conll_line.setdefault('feats', {})['nertype'] = child.text.strip();\n isNer = True;\n if isNer == True and child.tag == 'NormalizedNER':\n conll_line.setdefault('feats', {})['normalized_ner'] = child.text.strip();\n #if child.tag == 'TrueCaseText': \n # conll_line['form'] = child.text.strip(); # Truecaser performance seems worse. \n conll_line['feats'] = '|'.join('%s=%s'%(f,v) for f,v in conll_line.get('feats', {}).items());\n if not conll_line['feats']:\n conll_line['feats'] = '_' ;\n terminalNodes.append(conll_line['form']);\n conll_sentence.append(conll_line);\n const_parse = '';\n for parse_node in sent_node.findall(\"parse\"):\n const_parse = parse_node.text.strip();\n if not const_parse.strip(): # parser failed ; no dependency information available either\n return conll_sentence;\n if const_parse not in ['(())', '(ROOT ())', '(ROOT())']: # similar situation \n for conll_line, chunk in zip(conll_sentence, constparse_chunks(const_parse, terminalNodes)):\n conll_line['const_parse'] = chunk;\n #print conll_line['form'], conll_line['postag'];\n try:\n assert( const_parse == ' '.join(conll_line['const_parse'].replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence) );\n except AssertionError:\n print const_parse;\n print ' '.join(conll_line['const_parse'].replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence);\n sys.exit(1);\n except KeyError:\n print const_parse;\n print ' '.join(conll_line.get('const_parse', 'NONE').replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence);\n sys.exit(1);\n for depann_node in sent_node.findall(\".//dependencies\"):\n if depann_node.attrib['type'] == 'basic-dependencies':\n # convert basic dependencies in annotation\n for dep_node in depann_node.findall(\".//dep\"):\n depLabel, head, token = '', -1, -1\n depLabel = dep_node.attrib['type']\n for child in dep_node:\n if child.tag == 'governor': \n head = int(child.attrib['idx'])\n if child.tag == 'dependent': \n token = int(child.attrib['idx'])\n conll_sentence[token-1]['head'] = str(head)\n conll_sentence[token-1]['deprel'] = depLabel\n elif depann_node.attrib['type'] == 'enhanced-dependencies':\n # convert enhanced dependencies in annotation\n for dep_node in depann_node.findall(\".//dep\"):\n depLabel, head, token = '', -1, -1\n depLabel = dep_node.attrib['type']\n for child in dep_node:\n if child.tag == 'governor': \n head = int(child.attrib['idx'])\n if child.tag == 'dependent': \n token = int(child.attrib['idx'])\n conll_sentence[token-1][deps_field] = str(head)+':'+depLabel\n else:\n continue;\n # meta-information from stanford core nlp\n #metainfo = 'line:%s-sent:%s' %(sent_node.attrib['line'].strip(), sent_node.attrib['id'].strip());\n #return (metainfo, conll_sentence);\n return conll_sentence;","def difference(first, second, rf, rs, years=(1980, 2000),smooth=1, corpus='bok'):\n try:\n a_first = nb_ngram(first, years=years, smooth=smooth, corpus=corpus)\n a_second = nb_ngram(second, years=years, smooth=smooth, corpus=corpus)\n a = a_first.join(a_second) \n b_first = nb_ngram(rf, years=years, smooth=smooth, corpus=corpus)\n b_second = nb_ngram(rs, years=years, smooth=smooth, corpus=corpus)\n if rf == rs:\n b_second.columns = [rs + '2']\n b = b_first.join(b_second)\n s_a = a.mean()\n s_b = b.mean()\n f1 = s_a[a.columns[0]]/s_a[a.columns[1]]\n f2 = s_b[b.columns[0]]/s_b[b.columns[1]]\n res = f1/f2\n except:\n res = 'Mangler noen data - har bare for: ' + ', '.join([x for x in a.columns.append(b.columns)])\n return res","def lemmatize_sentences_rus(sentences):\n split = 'fks2hwras1ma39hka766gbk'\n chunk_size = 10000\n\n def handle_chunk(sentences_chunk):\n all_sents = (' ' + split + ' ').join(sentences_chunk)\n all_lemmas = lemmatize_sentence_rus(all_sents).split()\n chunk_res = [[]]\n for lemma in all_lemmas:\n if lemma == split:\n chunk_res.append([])\n else:\n chunk_res[-1].append(lemma)\n\n return chunk_res\n\n res = []\n i = 0\n while i < len(sentences):\n if len(sentences) > chunk_size:\n print(f'Lemmatization: Done for {i} from {len(sentences)} sentences')\n\n i_step = min(chunk_size, len(sentences) - i)\n res.extend(handle_chunk(sentences[i:i + i_step]))\n i += i_step\n\n assert len(res) == len(sentences)\n res = [' '.join(arr) for arr in res]\n return res","def likelihood(A, B, word_list):\n\tstr_buf = []\n\tloglh = 0.0\n\tlh = 1\n\n\t# read each line and compute likelihood.\n\tfor line in sys.stdin:\n\t\tline = line.split()\n\t\t# print(line)\n\t\tif len(line) == 3:\n\t\t\tstr_buf.append((str(line[0]), str(line[1])))\n\n\t\telse:\n\t\t\t# if come to the end of a sentence\n\t\t\tif len(str_buf) != 0:\n\t\t\t\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\n\t\t\t\tfor i in range(len(str_buf) - 1):\n\t\t\t\t\t# print(str_buf[i][0], str_buf[i+1][0])\n\t\t\t\t\tif str_buf[i+1][0] in word_list:\n\t\t\t\t\t\t# print('debug: A[',str_buf[i][1],'][', str_buf[i+1][1],']:', A[ str_buf[i][1] ][ str_buf[i+1][1] ])\n\t\t\t\t\t\t# print('debug: B[',str_buf[i+1][1],'][', [str_buf[i+1][0]], ']:', B[ str_buf[i+1][1] ][str_buf[i+1][0]])\n\t\t\t\t\t\tloglh += ( log(A[ str_buf[i][1] ][ str_buf[i+1][1] ]) + log(B[ str_buf[i+1][1] ][str_buf[i+1][0]]) )\n\t\t\t\t\telse:\n\t\t\t\t\t\t# print('debug: else A[',str_buf[i][1],'][', str_buf[i+1][1],']:', A[ str_buf[i][1] ][ str_buf[i+1][1] ])\n\t\t\t\t\t\t# print('debug: else B[',str_buf[i+1][1],'][', '<UNK>', ']:', B[ str_buf[i+1][1] ][ '<UNK>' ])\n\t\t\t\t\t\tloglh += ( log(A[ str_buf[i][1] ][ str_buf[i+1][1] ]) + log(B[ str_buf[i+1][1] ]['<UNK>']) )\n\n\t\t\t\tlh = e ** loglh\n\t\t\t\t# for s in str_buf:\n\t\t\t\t# \tprint(s[0], end=\" \")\n\t\t\t\t# print(':', lh)\n\t\t\t\tprint(lh)\n\n\t\t\t\tstr_buf = []\t\n\t\t\t\tloglh = 0\n\t\t\t\tlh = 1","def levenshtein_normalised(str1, str2):\n\treturn levenshtein(str1, str2, normalise=True)","def sentence_encoding_rnn_phi(t1, t2):\n return (t1.leaves(), t2.leaves())","def weighted_levenshtein(seq1, seq2, weights, r=0.9, normalise=False):\n\tx1 = 1 + len(seq1)\n\tx2 = 1 + len(seq2)\n\n\talpha = r / ((1 - r) * average_distance)\n\n\t# Initialisation of the matrix\n\td = [] # Using Numpy structures for this is probably not more efficient\n\ttmp = 0.0\n\tfirst_line = [tmp]\n\tfor e in seq2:\n\t\ttmp += weights.get(e, 1)\n\t\tfirst_line.append(tmp)\n\td.append(first_line)\n\ttmp = 0\n\tfor e in seq1:\n\t\ttmp += weights.get(e, 1)\n\t\td.append([tmp] * x2)\n\n\t# Core of the algorithm\n\tfor i in range(1, x1):\n\t\tfor j in range(1, x2):\n\t\t\te1 = seq1[i-1]\n\t\t\te2 = seq2[j-1]\n\n\t\t\tw1 = weights.get(e1, 1)\n\t\t\tw2 = weights.get(e2, 1)\n\n\t\t\td[i][j] = min(\n\t\t\t\t(d[(i-1)][j] + w1), # Deletion of seq1[i]\n\t\t\t\t(d[i][(j-1)] + w2), # Insertion of seq2[j]\n\t\t\t\t(d[(i-1)][(j-1)] + (int(e1 != e2) * max(w1, w2))) # Substitution from seq1[i] to seq2[j]\n\t\t\t)\n\n\traw = d[-1][-1]\n\n\tif(normalise): return (raw / (d[0][-1] + d[-1][0]))\n\treturn raw","def word_order_similarity(self,sentence_1, sentence_2):\n\t words_1 = sentence_1.getList_of_words()\n\t words_2 = sentence_2.getList_of_words()\n\t joint_words = list(set(words_1).union(set(words_2)))\n\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\n\t r1 = self.word_order_vector(words_1, joint_words, windex)\n\t r2 = self.word_order_vector(words_2, joint_words, windex)\n\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))","def verb_overlap(t_xml, h_xml, replacements):\n score = 0\n if t_xml == None or h_xml == None:\n return 0\n t_set = set(get_verbs(t_xml.getroot()))\n h_set = set(get_verbs(h_xml.getroot()))\n if float(len(t_set | h_set)) > 0:\n score = len(t_set & h_set) / float(len(t_set | h_set))\n \n for replacement in replacements:\n if replacement[9] != None and replacement[10] != None:\n t_set = set(get_verbs(replacement[9].getroot()))\n h_set = set(get_verbs(replacement[10].getroot()))\n if float(len(t_set | h_set)) > 0:\n new_score = len(t_set & h_set) / float(len(t_set | h_set))\n if new_score > score:\n score = new_score\n \n return score","def lcs_similarity(s1, s2):\n max_len = 0\n i = 0\n\n while s1[i] == s2[i]:\n max_len += 1\n i += 1\n if len(s1) == i or len(s2) == i:\n break\n\n if len(s1) < len(s2):\n return float(max_len) / len(s2)\n else:\n return float(max_len) / len(s1)","def unit_overlap(self, RTSummary , SystemSummary):\n\n RTSummary_words = self.nlpWrapper.stemmer(tokens=self.nlpWrapper.tokenize(RTSummary))\n SystemSummary_words = self.nlpWrapper.stemmer(tokens=self.nlpWrapper.tokenize(RTSummary))\n commonWords = set(RTSummary_words)&set(SystemSummary_words)\n commonWords = sorted(commonWords, key = lambda k : RTSummary_words.index(k))\n\n return (len(commonWords) / (len(RTSummary)+len(SystemSummary)-len(commonWords)))","def compare_words(word1, word2):\n word1 = word1.lower()\n word2 = word2.lower()\n seg_scores = []\n if len(word1) >= len(word2):\n for i in range(0, len(word1) - len(word2) + 1):\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\n else:\n for i in range(0, len(word2) - len(word1) + 1):\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)","def one_linestring_per_intersection(lines):\n lines_merged = shapely.ops.linemerge(lines)\n\n # intersecting multiline with its bounding box somehow triggers a first\n bounding_box = box(*lines_merged.bounds)\n\n # perform linemerge (one linestring between each crossing only)\n # if this fails, write function to perform this on a bbox-grid and then\n # merge the result\n lines_merged = lines_merged.intersection(bounding_box)\n lines_merged = shapely.ops.linemerge(lines_merged)\n return lines_merged","def sentences(a, b):\n\n # TODO\n a, b = sent_tokenize(a, language='english'), sent_tokenize(b, language='english')\n return list(set([sentence for sentence in a if sentence in b]))","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def word_embedding_levenshtein(seq1, seq2, embeddings, average_distance, r=0.9, normalise=False):\n\tx1 = 1 + len(seq1)\n\tx2 = 1 + len(seq2)\n\n\talpha = r / ((1 - r) * average_distance)\n\n\t# Initialisation of the matrix\n\td = [] # Using Numpy structures for this is probably not more efficient\n\td.append(list(range(x2)))\n\tfor i in range(1, x1):\n\t\td.append([i] * x2)\n\n\t# Core of the algorithm\n\tfor i in range(1, x1):\n\t\tfor j in range(1, x2):\n\t\t\te1 = seq1[i-1]\n\t\t\te2 = seq2[j-1]\n\n\t\t\tif(e1 == e2): c = 0\n\t\t\telse:\n\t\t\t\tv1 = embeddings[e1]\n\t\t\t\tv2 = embeddings[e2]\n\n\t\t\t\tif((v1 is None) or (v2 is None)): c = 1\n\t\t\t\telse:\n\t\t\t\t\tdst = np.linalg.norm(v1 - v2) # Distance 2 (or L2 norm of the difference)\n\n\t\t\t\t\t# Now, we need a function increasing function mapping 0 to 0 and +inf to 1\n\t\t\t\t\tc = 1 - (1 / (1 + (alpha * dst)))\n\n\t\t\t\t\t#c /= r # If you uncomment this line, the cost of a substitution at distance `average_distance` will be 1 and substitutions might have higher cost, up to 1/r. This might be justified as long as `r` is above 0.5 (otherwise, some substitutions might be more expensive than an insertion followed by a deletion).\n\n\t\t\td[i][j] = min(\n\t\t\t\t(d[(i-1)][j] + 1), # Deletion of seq1[i]\n\t\t\t\t(d[i][(j-1)] + 1), # Insertion of seq2[j]\n\t\t\t\t(d[(i-1)][(j-1)] + c) # Substitution from seq1[i] to seq2[j]\n\t\t\t)\n\n\traw = d[-1][-1]\n\n\tif(normalise): return (raw / (len(seq1) + len(seq2)))\n\treturn raw","def overlap_similarity(vect1, vect2, normalize=False, use_bigrams=False):\n overlap = len(set(vect1).intersection(set(vect2)))\n\n if use_bigrams:\n overlap += len(set(bigrams(vect1)).intersection(set(bigrams(vect2))))\n\n if not normalize:\n return overlap\n \n if overlap == 0:\n return 0\n \n return overlap / (math.log10(len(vect1)) + math.log10(len(vect2)))","def sentence_similarity(self,wnsimilarity,sentence1, sentence2,icneed=False):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n \n # Get the synsets for the tagged words\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n \n score, count = 0.0, 0\n # For each word in the first sentence\n for synset in synsets1:\n \n # Get the similarity value of the most similar word in the other sentence\n score_list=[]\n if icneed == True :\n for ss in synsets2:\n try:\n temp=wnsimilarity(synset,ss,self.brown_ic)\n score_list.append(temp)\n except:\n continue\n \n else:\n for ss in synsets2:\n try:\n temp=wnsimilarity(synset,ss)\n score_list.append(temp)\n except:\n continue\n \n \n score_list = np.array(score_list, dtype=np.float64)\n score_list = np.nan_to_num(score_list)\n# print(score_list)\n if len(score_list)>0:\n best_score = np.nanmax(score_list)\n else:\n best_score=0.0\n# print(best_score)\n# print(type(best_score))\n \n # Check that the similarity could have been computed\n if best_score is not None:\n score =score + best_score\n# print(score)\n count = count+ 1\n \n \n# print(\"one sentence over\")\n # Average the values\n score /= count\n return score","def WordDiff(line1, line2, diff_params):\n match_expr, min_match_ratio, min_match_size, _ = diff_params\n exp = EXPRS[match_expr]\n # Strings may have been left undecoded up to now. Assume UTF-8.\n line1 = TryDecode(line1)\n line2 = TryDecode(line2)\n\n a = re.findall(exp, line1, re.U)\n b = re.findall(exp, line2, re.U)\n s = difflib.SequenceMatcher(None, a, b)\n matching_blocks = s.get_matching_blocks()\n ratio = s.ratio()\n # Don't show intra region diffs if both lines are too different and there is\n # more than one block of difference. If there is only one change then we\n # still show the intra region diff regardless of how different the blocks\n # are.\n # Note: We compare len(matching_blocks) with 3 because one block of change\n # results in 2 matching blocks. We add the one special block and we get 3\n # matching blocks per one block of change.\n if ratio < min_match_ratio and len(matching_blocks) > 3:\n return ([(0, 0, 0)], ratio)\n # For now convert to character level blocks because we already have\n # the code to deal with folding across lines for character blocks.\n # Create arrays lena an lenb which have cumulative word lengths\n # corresponding to word positions in a and b\n lena = []\n last = 0\n for w in a:\n lena.append(last)\n last += len(w)\n lenb = []\n last = 0\n for w in b:\n lenb.append(last)\n last += len(w)\n lena.append(len(line1))\n lenb.append(len(line2))\n # Convert to character blocks\n blocks = []\n for s1, s2, blen in matching_blocks[:-1]:\n apos = lena[s1]\n bpos = lenb[s2]\n block_len = lena[s1+blen] - apos\n blocks.append((apos, bpos, block_len))\n # Recreate the special block.\n blocks.append((len(line1), len(line2), 0))\n # Filter any matching blocks which are smaller than the desired threshold.\n # We don't remove matching blocks with only a newline character as doing so\n # results in showing the matching newline character as non matching which\n # doesn't look good.\n blocks = FilterBlocks(blocks, lambda b: (b[2] >= min_match_size or\n line1[b[0]:b[0]+b[2]] == '\\n'))\n return (blocks, ratio)","def get_stats_SWE(self, kelly_list, svalex_list, svalex2_list, word_pictures={}, use_deprel=True,use_ngrams=False):\n s = self.sent\n root_ref = check_root(s)\n\n tokens = []\n\n verb_args = {} #{\"verb1\": {arg1_pos:\"PN\", arg1_deprel:\"SS\", etc.},..}\n self.stats[\"finite\"] = []\n self.stats[\"heads\"] = {}\n self.stats[\"keyword\"] = {}\n self.stats[\"has_subject\"] = 0\n self.stats[\"used_rel_lemmas\"] = [] \n\n # Collect the position ('ref') of the dependency head of each token\n # +1 compared to regular indexes, string type\n for tkn in s.nodes:\n if tkn.deprel == \"ROOT\":\n put_feature_value_list(self.stats[\"heads\"], tkn.ref, tkn) #\"ROOT\"\n else:\n put_feature_value_list(self.stats[\"heads\"], tkn.depheadid, tkn)\n\n for i,t in enumerate(s.nodes):\n\n mapped_token = map_Token_to_dict(t) #just a fix, see dset_proc_aux.py\n tokens.append(mapped_token)\n\n #get statistics from different liguistic levels\n self.stats = self.get_len_stats(t)\n self.stats = self.get_kelly_stats(t, kelly_list)\n if svalex_list:\n self.stats = self.get_svalex_stats(t, svalex_list)\n if svalex2_list:\n self.stats = self.get_svalex2_stats(t, svalex2_list)\n self.stats = self.get_semantic_stats(t)\n self.stats = self.get_morpho_synt_stats(s,t,i)\n if self.params:\n self.stats = self.get_sentmatch_stats(t,s.nodes,word_pictures)\n \n #add lemma unigrams\n lm_ngram = get_lemma_ngrams(s, t, i, \"uni\")\n if lm_ngram:\n put_feature_value_list(self.stats,\"lemma_unigr\", lm_ngram)\n\n if use_ngrams: #bi- and trigrams \n self.stats = get_ngrams(self.stats,s,t,i)\n\n if use_deprel:\n self.stats = self.deprel_stats(t,root_ref, verb_args)\n\n #fix for JSON serialization issue with the Token class\n self.stats[\"tokens\"] = s.nodes # retain a copy of Token instances\n s.nodes = tokens # change Token instances to 'dict'-s\n \n return self.stats","def width_v_l_l(\n model: SingleRhNeutrinoModel, genv: Generation, genl1: Generation, genl2: Generation\n):\n genn = model.gen\n\n if genn == genv:\n return _width_v_l_l(model, genl1)\n\n mu = 0.0\n md = _lepton_masses[genl2]\n ml = _lepton_masses[genl1]\n\n if (genn == genl1) and (genv == genl2):\n return _width_l_u_d(model, mu, md, ml, 1.0)\n\n if (genn == genl2) and (genv == genl1):\n md, ml = ml, md\n return _width_l_u_d(model, mu, md, ml, 1.0)\n\n return 0.0","def get_score(self,sentence_1, sentence_2):\n\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)","def generate_sentence(word1, word2, length, vocab, model):\n reverse_vocab = {idx: word for word, idx in vocab.items()}\n output_string = np.zeros((1, length), dtype=np.int)\n output_string[:, 0: 2] = vocab[word1], vocab[word2]\n\n for end in range(2, length):\n start = end - 2\n output_string[:, end] = np.argmax(model(output_string[:, start:end]), axis=1)\n text = [reverse_vocab[i] for i in list(output_string[0])]\n \n print(\" \".join(text))","def noun_overlap(t_xml, h_xml, replacements):\n score = 0\n if t_xml == None or h_xml == None:\n return 0\n t_set = set(get_nouns(t_xml.getroot()))\n h_set = set(get_nouns(h_xml.getroot()))\n if float(len(t_set | h_set)) > 0:\n score = len(t_set & h_set) / float(len(t_set | h_set))\n \n for replacement in replacements:\n if replacement[9] != None and replacement[10] != None:\n t_set = set(get_nouns(replacement[9].getroot()))\n h_set = set(get_nouns(replacement[10].getroot()))\n if float(len(t_set | h_set)) > 0:\n new_score = len(t_set & h_set) / float(len(t_set | h_set))\n if new_score > score:\n score = new_score\n return score","def rouge_l_fscore(predictions, labels):\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\n tf.float32)\n return rouge_l_f_score, tf.constant(1.0)","def _l1_similarity(self, sentence_one, sentence_two):\n with tf.name_scope(\"l1_similarity\"):\n # Take the L1 norm of the two vectors.\n # Shape: (batch_size, 2*rnn_hidden_size)\n l1_distance = tf.abs(sentence_one - sentence_two)\n\n # Take the sum for each sentence pair\n # Shape: (batch_size, 1)\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\n keep_dims=True)\n\n # Exponentiate the negative summed L1 distance to get the\n # positive-class probability.\n # Shape: (batch_size, 1)\n positive_class_probs = tf.exp(-summed_l1_distance)\n\n # Get the negative class probabilities by subtracting\n # the positive class probabilities from 1.\n # Shape: (batch_size, 1)\n negative_class_probs = 1 - positive_class_probs\n\n # Concatenate the positive and negative class probabilities\n # Shape: (batch_size, 2)\n class_probabilities = tf.concat([negative_class_probs,\n positive_class_probs], 1)\n\n # if class_probabilities has 0's, then taking the log of it\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\n # epsilon and renormalize by the sum of the vector.\n safe_class_probabilities = class_probabilities + 1e-08\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\n axis=1,\n keep_dims=True)\n return safe_class_probabilities","def _l1_similarity(self, sentence_one, sentence_two):\n with tf.name_scope(\"l1_similarity\"):\n # Take the L1 norm of the two vectors.\n # Shape: (batch_size, 2*rnn_hidden_size)\n l1_distance = tf.abs(sentence_one - sentence_two)\n\n # Take the sum for each sentence pair\n # Shape: (batch_size, 1)\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\n keep_dims=True)\n\n # Exponentiate the negative summed L1 distance to get the\n # positive-class probability.\n # Shape: (batch_size, 1)\n positive_class_probs = tf.exp(-summed_l1_distance)\n\n # Get the negative class probabilities by subtracting\n # the positive class probabilities from 1.\n # Shape: (batch_size, 1)\n negative_class_probs = 1 - positive_class_probs\n\n # Concatenate the positive and negative class probabilities\n # Shape: (batch_size, 2)\n class_probabilities = tf.concat([negative_class_probs,\n positive_class_probs], 1)\n\n # if class_probabilities has 0's, then taking the log of it\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\n # epsilon and renormalize by the sum of the vector.\n safe_class_probabilities = class_probabilities + 1e-08\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\n axis=1,\n keep_dims=True)\n return safe_class_probabilities","def compute_readability(text):\n total_words = 0\n total_sentences = 0\n total_syllables = 0\n score = 0\n\n words = text.split()\n total_words = len(text.split()) \n total_sentences = count_sentences(text)\n total_syllables = count_syllables(words)\n \n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\n if score > 90.00:\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\n elif score <= 90.00 and score > 80.00:\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\n elif score <= 80.00 and score > 70.00:\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\n elif score <= 70.00 and score > 60.00:\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\n elif score <= 60.00 and score > 50.00:\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\n elif score <= 50.00 and score > 30.00:\n answer = 'Texto de nível Universitário, difícil de ler.'\n else:\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\n \n print('Pontuação Total:', score, answer)","def generate_analogy(word1, word2, word3, model):\n LoM = model.most_similar(positive=[word2, word3], negative=[word1], topn=100)\n return LoM","def train():\n\tA = collections.defaultdict(dict)\n\tB = collections.defaultdict(dict)\n\tpos_list = []\n\tword_list = []\n\tstr_buf = []\n\n\n\t# read each line and count A and B\n\tfor line in sys.stdin:\n\t\tline = line.split()\n\t\t# print(line)\n\t\tif len(line) == 3:\n\t\t\tstr_buf.append((str(line[0]), str(line[1])))\n\t\t\tword_list.append(str(line[0]))\n\t\t\tpos_list.append(str(line[1]))\n\n\t\telse:\n\t\t\t# if come to the end of a sentence\n\t\t\tif len(str_buf) != 0:\n\t\t\t\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\n\t\t\t\tword_list += ['<s>', '</s>']\n\t\t\t\tpos_list += ['BOS', 'EOS']\n\n\t\t\t\tfor i, s in enumerate(str_buf):\n\t\t\t\t\tif s[0] in B[s[1]]:\n\t\t\t\t\t\tB[s[1]][s[0]] += 1\n\t\t\t\t\telse:\n\t\t\t\t\t\tB[s[1]][s[0]] = 1\n\n\t\t\t\t\tif s[0] != '</s>':\n\t\t\t\t\t\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\n\t\t\t\t\t\tif str_buf[i+1][1] in A[s[1]]:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] += 1\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tA[s[1]][str_buf[i+1][1]] = 1\n\n\t\t\t\tstr_buf = []\n\n\t# get unique POS list and word list\n\tpos_list_uniq = list(set(pos_list))\n\tword_list_uniq = list(set(word_list))\n\n\n\t# assume <UNK>, smoothing, normalize\n\tB_sm = collections.defaultdict(dict)\n\tA_sm = A.copy()\n\n\t# assume words apeear less than 2 times as <UNK>\n\tword_count = collections.Counter(word_list)\n\tfor pos in B:\n\t\tfor word in B[pos]:\n\t\t\tif word_count[word] > 1:\n\t\t\t\tB_sm[pos][word] = B[pos][word]\n\n\t\t\telse: # add <UNK> to B_sm\n\t\t\t\tword_list_uniq.remove(word)\n\t\t\t\tif '<UNK>' in B_sm[pos]:\n\t\t\t\t\tB_sm[pos]['<UNK>'] += 1\n\t\t\t\telse:\n\t\t\t\t\tB_sm[pos]['<UNK>'] = 1\n\n\tword_list_uniq += ['<UNK>']\n\n\t# add 1 smoothing\n\tfor pos in pos_list_uniq:\n\t\tfor word in word_list_uniq:\n\t\t\tif word in B_sm[pos]:\n\t\t\t\tB_sm[pos][word] += 1\n\t\t\telse:\n\t\t\t\tB_sm[pos][word] = 1\n\n\tfor prev in pos_list_uniq:\n\t\tfor next in pos_list_uniq:\n\t\t\tif next in A_sm[prev]:\n\t\t\t\tA_sm[prev][next] += 1\n\t\t\telse:\n\t\t\t\tA_sm[prev][next] = 1\n\n\t# delete instances like A[VB][BOS], A[EOS][VB],\n\t# B[VB]['</s>'], B[EOS]['Jack']\n\n\tfor pos in B_sm:\n\t\tfor word in B_sm[pos]:\n\t\t\tif (pos == 'BOS' and word != '<s>') or \\\n\t\t\t(pos == 'EOS' and word != '</s>') or \\\n\t\t\t(word == '<s>' and pos != 'BOS') or \\\n\t\t\t(word == '</s>' and pos != 'EOS'):\n\t\t\t\tB_sm[pos][word] = 0\n\n\tfor prev in A_sm:\n\t\tfor next in A_sm[prev]:\n\t\t\tif prev == 'EOS' or next == 'BOS':\n\t\t\t\tA_sm[prev][next] = 0\n\n\t# normalize\n\tfor pos in B_sm:\n\t\ts = sum(B_sm[pos].values())\n\t\tfor word in B_sm[pos]:\n\t\t\tif B_sm[pos][word] != 0:\n\t\t\t\tB_sm[pos][word] /= s\n\n\tfor prev in A_sm:\n\t\ts = sum(A_sm[prev].values())\n\t\tfor next in A_sm[prev]:\n\t\t\tif A_sm[prev][next] != 0:\n\t\t\t\tA_sm[prev][next] /= s\n\n\treturn A_sm, B_sm, word_list_uniq","def lcmu(a, b):\n return (abs(a)*abs(b))//gcdi(a, b)","def merge_sentences(sentences):\n full_sentences = []\n for sentence in sentences:\n for arr_word in sentence:\n full_sentences.append(arr_word)\n return full_sentences","def merge_sentences(text: List[str], min_len: int) -> List[str]:\n\n def reducer(acc, x):\n x = x.strip()\n\n if acc and (len(nlp(acc[-1])) < min_len):\n if acc[-1] and (acc[-1][-1]) not in ['.', ':']:\n acc[-1] += '. {}'.format(x)\n else:\n acc[-1] += ' {}'.format(x)\n return acc\n else:\n return acc + [x]\n\n new_text = reduce(reducer, text, [])\n return new_text","def lev(w1, w2):\n\n if len(w1) < len(w2):\n # check if length of word1 is smaller than word2.\n # if so, call function and switch parameters\n return lev(w2, w1)\n elif len(w1) == 0:\n # if the length of word1 equals 0, that means that\n # the Lev' distance is the length of word2\n return len(w2)\n elif len(w2) == 0:\n # if the length of word2 equals 0, that means that\n # the Lev' distance is the length of word1\n return len(w1)\n elif w1 == w2:\n # check if words are simply the same\n return 0\n\n # thanks to the check above, we can assume that w2 is the longest word\n # we use this information to determine the range of 'previous'\n previous = range(len(w2) + 1)\n\n # DEBUG\n # print(previous)\n\n # iterate over the characters of the first word\n for a, char1 in enumerate(w1):\n # DEBUG\n # print(\"i -> \" + str(a))\n # print(\"char1 -> \" + str(char1))\n\n current = [a + 1]\n\n # iterate over the characters of the second word\n for b, char2 in enumerate(w2):\n # DEBUG\n # print(\"j -> \" + str(b))\n # print(\"\\tchar2 -> \" + str(char2))\n\n inserts = previous[b + 1] + 1\n deletions = current[b] + 1\n subs = previous[b] + (char1 != char2)\n\n # DEBUG\n # print(str(char1 != char2))\n # print(\"INSERTS -> \" + str(inserts))\n # print(\"DELS -> \" + str(deletions))\n # print(\"SUBS -> \" + str(subs))\n\n current.append(min(inserts, deletions, subs))\n\n # DEBUG\n # print(\"CURRENT -> \" + str(current))\n previous = current\n\n return previous[-1]","def rocchio_relevance_feedback(query: str, ls_relev: list, ls_irrel: list, weights: tuple = None):\r\n text_collection = ls_relev + ls_irrel + [query]\r\n len_relev, len_irrel = len(ls_relev), len(ls_irrel)\r\n\r\n if weights is None:\r\n weights = (1, 0.75, 0.15)\r\n a, b, c = weights\r\n\r\n vectorizer = TfidfVectorizer(stop_words='english', token_pattern=r'[a-zA-Z]{3,}')\r\n vectorizer.fit(text_collection)\r\n\r\n vec_query = vectorizer.transform([query]).todense()\r\n\r\n if len_relev == 0:\r\n term_relev = 0\r\n else:\r\n mat_relev = vectorizer.transform(ls_relev).todense()\r\n vec_relev = mat_relev.sum(axis=0)\r\n term_relev = vec_relev / len_relev\r\n\r\n if len_irrel == 0:\r\n term_irrel = 0\r\n else:\r\n mat_irrel = vectorizer.transform(ls_irrel).todense()\r\n vec_irrel = mat_irrel.sum(axis=0)\r\n term_irrel = vec_irrel / len_irrel\r\n\r\n vec_new = a * vec_query + b * term_relev - c * term_irrel\r\n\r\n tokens = vectorizer.get_feature_names()\r\n weights = np.asarray(vec_new).reshape(-1)\r\n\r\n return dict(zip(tokens, weights))","def word_overlap3(t_raw, h_raw, replacements):\n t_set = set(word for word in t_raw) - config.stop_list\n h_set = set(word for word in h_raw) - config.stop_list\n score = len(t_set & h_set) / float(len(t_set|h_set)) \n highestscore = 0\n\n for replacement in replacements:\n t_set = set(word for word in replacement[2]) - config.stop_list # replacement[1] = t_raw\n h_set = set(word for word in replacement[3]) - config.stop_list # replacement[2] = h_raw\n newScore = len(t_set & h_set) / float(len(t_set|h_set))\n if newScore > highestscore:\n highestscore = newScore\n return (score + highestscore) /2","def _recon_lcs(x, y):\n i, j = len(x), len(y)\n table = _lcs(x, y)\n\n def _recon(i, j):\n \"\"\"private recon calculation\"\"\"\n if i == 0 or j == 0:\n return []\n elif x[i - 1] == y[j - 1]:\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\n elif table[i - 1, j] > table[i, j - 1]:\n return _recon(i - 1, j)\n else:\n return _recon(i, j - 1)\n\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\n return recon_tuple","def sentences(a, b):\n # Tokenize has the ability to separate, in this case, sentences by finding relevant symbols (.,!,?,etc) in text\n aS1 = set(sent_tokenize(a))\n bS1 = set(sent_tokenize(b))\n\n return aS1 & bS1","def compare_texts(text1, text2):\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))","def rouge_n(evaluated_sentences, reference_sentences, n=2):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\n reference_count = len(reference_ngrams)\n evaluated_count = len(evaluated_ngrams)\n\n # Gets the overlapping ngrams between evaluated and reference\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\n overlapping_count = len(overlapping_ngrams)\n\n # Handle edge case. This isn't mathematically correct, but it's good enough\n if evaluated_count == 0:\n precision = 0.0\n else:\n precision = overlapping_count / evaluated_count\n\n if reference_count == 0:\n recall = 0.0\n else:\n recall = overlapping_count / reference_count\n\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\n\n # return overlapping_count / reference_count\n return f1_score, precision, recall","def sentence_similarity(self,sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n\n # Get the synsets for the tagged words\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n\n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n\n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n vals = [synset.path_similarity(ss) if synset.path_similarity(ss) is not None else 0 for ss in synsets2]\n best_score = max(vals,default=0)\n\n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n # Average the values\n if count == 0:\n return 0\n score /= count\n return score","def main():\n parser = argparse.ArgumentParser(description=main.__doc__)\n parser.add_argument('smooth', type=float, help='amount of Lidstone smoothing to apply')\n parser.add_argument('mincount', type=int, help='minimum count in either language for a word')\n parser.add_argument('wordlist1', help='first wordlist file, in UTF-8 format')\n parser.add_argument('wordlist2', help='second wordlist file, in UTF-8 format')\n args = parser.parse_args()\n\n # Get file or stdin input as utf-8\n infile1 = codecs.open(args.wordlist1, 'Ur', 'utf_8') \n infile2 = codecs.open(args.wordlist2, 'Ur', 'utf_8') \n\n # Compute ratio\n ratios, counts1, counts2 = wordlist_ratio(infile1, infile2, args.smooth, args.mincount)\n\n # Output\n output_ratios(sorted(ratios.items(), key=itemgetter(1)), counts1, counts2, \n codecs.getwriter('utf-8')(sys.stdout))","def sentence_similarity_asym(sentence1, sentence2):\n # Tokenize and tag\n sentence1 = pos_tag(word_tokenize(sentence1))\n sentence2 = pos_tag(word_tokenize(sentence2))\n \n # Get the synsets for the tagged words\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\n \n # Filter out the Nones\n synsets1 = [ss for ss in synsets1 if ss]\n synsets2 = [ss for ss in synsets2 if ss]\n \n score, count = 0.0, 0\n\n # For each word in the first sentence\n for synset in synsets1:\n # Get the similarity value of the most similar word in the other sentence\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\n if len(pathsim) == 0:\n #print sentence1, sentence2\n pathsim = [0]\n best_score = max(pathsim)\n \n # Check that the similarity could have been computed\n if best_score is not None:\n score += best_score\n count += 1\n\n if count == 0:\n return 0\n # Average the values\n score /= count\n return score"],"string":"[\n \"def rouge_l_sentence_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n reference_words = _split_into_words(reference_sentences)\\n evaluated_words = _split_into_words(evaluated_sentences)\\n m = len(reference_words)\\n n = len(evaluated_words)\\n lcs = _len_lcs(evaluated_words, reference_words)\\n return _f_p_r_lcs(lcs, m, n)\",\n \"def rouge_l_sentence_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n reference_words = _split_into_words(reference_sentences)\\n evaluated_words = _split_into_words(evaluated_sentences)\\n m = len(reference_words)\\n n = len(evaluated_words)\\n lcs = _len_lcs(evaluated_words, reference_words)\\n return _f_p_r_lcs(lcs, m, n)\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def rouge_l_summary_level(evaluated_sentences, reference_sentences):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n # total number of words in reference sentences\\n m = len(_split_into_words(reference_sentences))\\n\\n # total number of words in evaluated sentences\\n n = len(_split_into_words(evaluated_sentences))\\n\\n union_lcs_sum_across_all_references = 0\\n for ref_s in reference_sentences:\\n union_lcs_sum_across_all_references += _union_lcs(evaluated_sentences,\\n ref_s)\\n return _f_p_r_lcs(union_lcs_sum_across_all_references, m, n)\",\n \"def lemmatize_texts_rus(texts):\\n sentenized = [[s.text for s in razdel.sentenize(t)] for t in texts]\\n texts_lengths = [len(t) for t in sentenized]\\n sentences = [s for t in sentenized for s in t]\\n\\n sentences_lemm = lemmatize_sentences_rus(sentences)\\n\\n texts_lemm = []\\n pos = 0\\n for text_length in texts_lengths:\\n texts_lemm.append(sentences_lemm[pos:pos + text_length])\\n pos += text_length\\n\\n assert pos == len(sentences)\\n assert len(sentenized) == len(texts_lemm)\\n assert all(len(s) == len(a) for s, a in zip(sentenized, texts_lemm))\\n return texts_lemm, sentenized\",\n \"def _union_lcs(evaluated_sentences, reference_sentence):\\n if len(evaluated_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n lcs_union = set()\\n reference_words = _split_into_words([reference_sentence])\\n combined_lcs_length = 0\\n for eval_s in evaluated_sentences:\\n evaluated_words = _split_into_words([eval_s])\\n lcs = set(_recon_lcs(reference_words, evaluated_words))\\n combined_lcs_length += len(lcs)\\n lcs_union = lcs_union.union(lcs)\\n\\n union_lcs_count = len(lcs_union)\\n union_lcs_value = union_lcs_count / combined_lcs_length\\n return union_lcs_value\",\n \"def corpus_gleu(list_of_references, hypotheses, min_len=1, max_len=4):\\n # sanity check\\n assert len(list_of_references) == len(\\n hypotheses\\n ), \\\"The number of hypotheses and their reference(s) should be the same\\\"\\n\\n # sum matches and max-token-lengths over all sentences\\n corpus_n_match = 0\\n corpus_n_all = 0\\n\\n for references, hypothesis in zip(list_of_references, hypotheses):\\n hyp_ngrams = Counter(everygrams(hypothesis, min_len, max_len))\\n tpfp = sum(hyp_ngrams.values()) # True positives + False positives.\\n\\n hyp_counts = []\\n for reference in references:\\n ref_ngrams = Counter(everygrams(reference, min_len, max_len))\\n tpfn = sum(ref_ngrams.values()) # True positives + False negatives.\\n\\n overlap_ngrams = ref_ngrams & hyp_ngrams\\n tp = sum(overlap_ngrams.values()) # True positives.\\n\\n # While GLEU is defined as the minimum of precision and\\n # recall, we can reduce the number of division operations by one by\\n # instead finding the maximum of the denominators for the precision\\n # and recall formulae, since the numerators are the same:\\n # precision = tp / tpfp\\n # recall = tp / tpfn\\n # gleu_score = min(precision, recall) == tp / max(tpfp, tpfn)\\n n_all = max(tpfp, tpfn)\\n\\n if n_all > 0:\\n hyp_counts.append((tp, n_all))\\n\\n # use the reference yielding the highest score\\n if hyp_counts:\\n n_match, n_all = max(hyp_counts, key=lambda hc: hc[0] / hc[1])\\n corpus_n_match += n_match\\n corpus_n_all += n_all\\n\\n # corner case: empty corpus or empty references---don't divide by zero!\\n if corpus_n_all == 0:\\n gleu_score = 0.0\\n else:\\n gleu_score = corpus_n_match / corpus_n_all\\n\\n return gleu_score\",\n \"def simple_baseline_similarity(s1, s2):\\n # Tokenize by sentences into words in lower case \\n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\\n\\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\\n \\n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1 if not tagged_word in stop_words] \\n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2 if not tagged_word in stop_words] # [LEMMA_1, ...]\\n \\n word_seq_match = difflib.SequenceMatcher(None, tokenized_sentence_1, tokenized_sentence_2)\\n word_match = word_seq_match.find_longest_match(0, len(tokenized_sentence_1), 0, len(tokenized_sentence_2))\\n\\n lemm_seq_match = difflib.SequenceMatcher(None, lemmas_sentence_1, lemmas_sentence_2)\\n lemm_match = lemm_seq_match.find_longest_match(0, len(lemmas_sentence_1), 0, len(lemmas_sentence_2))\\n\\n word_sim = word_match.size/(max(len(tokenized_sentence_1), len(tokenized_sentence_2)) + 0.001)\\n lemm_sim = lemm_match.size/(max(len(lemmas_sentence_1), len(lemmas_sentence_2)) + 0.001)\\n\\n return word_sim, lemm_sim\",\n \"def Extended_Lesk(word1,word2):\\n\\n #Creates a list of the word, and one layer of hyponyms\\n list1 = [word1]\\n for i in word1.hyponyms():\\n list1.append(i)\\n list2 = [word2]\\n for i in word2.hyponyms():\\n list2.append(i)\\n\\n #Creates a list of each of the above words' definitions, tokenized\\n words1 = []\\n words2 = []\\n for i in list1:\\n words1.append([l for l in word_tokenize(i.definition())])\\n for i in list2:\\n words2.append([l for l in word_tokenize(i.definition())])\\n\\n #Calculates the Maximum length of the Longest Definition\\n lengths = []\\n lengths.extend(len(l) for l in words1)\\n lengths.extend(len(l) for l in words2)\\n maxim = max(lengths)\\n\\n igramcount = []\\n igram1 = []\\n igram2 = []\\n\\n # Creates N-grams for each definition for each N, from 1:max(lengths)\\n for i in range(int(maxim)):\\n for g in words1:\\n for l in ngrams(g, i+1):\\n igram1.append(l)\\n for f in words2:\\n for m in ngrams(f, i+1):\\n igram2.append(m)\\n\\n #For Each N-gram in the first set, which matches that of the Second set,\\n # Denoting a form of \\\"Similarity\\\" between the two definitions,\\n # Record the Value of N into a new List, igramcount.\\n for x in set(igram1):\\n if x in set(igram2):\\n igramcount.append(i + 1)\\n\\n igram1 = []\\n igram2 = []\\n\\n #Square the values of igramcount, and return the sum as the value of Extended Lesk.\\n squared = [number**2 for number in igramcount]\\n return sum(squared)\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def compare_sentences(first, second):\\n if not len(first) or not len(second):\\n return 0\\n return len(set(only_important(first)) & set(only_important(second))) / ((len(first) + len(second)) / 2.0)\",\n \"def word_overlap2(sentence_a, sentence_b):\\n a_set = set(word for word in sentence_a) - config.stop_list\\n b_set = set(word for word in sentence_b) - config.stop_list\\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\\n\\n return score\",\n \"def rouge(hypotheses, references):\\n\\n # Filter out hyps that are of 0 length\\n # hyps_and_refs = zip(hypotheses, references)\\n # hyps_and_refs = [_ for _ in hyps_and_refs if len(_[0]) > 0]\\n # hypotheses, references = zip(*hyps_and_refs)\\n\\n # Calculate ROUGE-1 F1, precision, recall scores\\n rouge_1 = [\\n rouge_n([hyp], [ref], 1) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_1_f, rouge_1_p, rouge_1_r = map(np.mean, zip(*rouge_1))\\n\\n # Calculate ROUGE-2 F1, precision, recall scores\\n rouge_2 = [\\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_2_f, rouge_2_p, rouge_2_r = map(np.mean, zip(*rouge_2))\\n\\n # Calculate ROUGE-L F1, precision, recall scores\\n rouge_l = [\\n rouge_l_sentence_level([hyp], [ref])\\n for hyp, ref in zip(hypotheses, references)\\n ]\\n rouge_l_f, rouge_l_p, rouge_l_r = map(np.mean, zip(*rouge_l))\\n\\n return {\\n \\\"rouge_1/f_score\\\": rouge_1_f,\\n \\\"rouge_1/r_score\\\": rouge_1_r,\\n \\\"rouge_1/p_score\\\": rouge_1_p,\\n \\\"rouge_2/f_score\\\": rouge_2_f,\\n \\\"rouge_2/r_score\\\": rouge_2_r,\\n \\\"rouge_2/p_score\\\": rouge_2_p,\\n \\\"rouge_l/f_score\\\": rouge_l_f,\\n \\\"rouge_l/r_score\\\": rouge_l_r,\\n \\\"rouge_l/p_score\\\": rouge_l_p,\\n }\",\n \"def test_lcs_nouns(id1, id2, expected_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n lcs = syn1.lowest_common_subsumer(syn2)\\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))\",\n \"def lemmatize_text_rus(text):\\n text_lemm, text_sent = lemmatize_texts_rus([text])\\n text_lemm, text_sent = text_lemm[0], text_sent[0]\\n return text_lemm, text_sent\",\n \"def oracle_sentences(\\n gold_sentences: tagdata_pb2.Sentences,\\n all_sentences: Iterable[tagdata_pb2.Sentences],\\n) -> tagdata_pb2.Sentences:\\n inner_sentences = list(sentences.sentences for sentences in all_sentences)\\n assert all(\\n len(gold_sentences.sentences) == len(sentences)\\n for sentences in inner_sentences\\n ), \\\"Mismatched lengths\\\"\\n ensembled_sentences = tagdata_pb2.Sentences()\\n gen = zip(gold_sentences.sentences, *inner_sentences)\\n correct = 0\\n total = 0\\n for (gold_sentence, *all_sentence) in gen:\\n inner_tags = list(sentence.tags for sentence in all_sentence)\\n assert all(\\n len(gold_sentence.tags) == len(tags) for tags in inner_tags\\n ), \\\"Mismatched lengths\\\"\\n ensembled_sentence = ensembled_sentences.sentences.add()\\n for (gold_tag, *all_tags) in zip(gold_sentence.tags, *inner_tags):\\n if any(gold_tag == tag for tag in all_tags):\\n ensembled_sentence.tags.append(gold_tag)\\n correct += 1\\n else:\\n counts = collections.Counter(all_tags)\\n ensembled_sentence.tags.append(counts.most_common(1)[0][0])\\n total += 1\\n logging.info(\\\"Accuracy (oracle):\\\\t%.4f\\\", correct / total)\\n return ensembled_sentences\",\n \"def compare_sentences(s1,s2):\\n\\n total_score=0;\\n num_total=0;\\n for k in s1:\\n num_total+=1\\n if k in s2:\\n if s1[k]==s2[k]:\\n score = 1;\\n else:\\n score = 0;\\n else:\\n score = 0;\\n total_score += score;\\n \\n for k in s2:\\n if k not in s1:\\n num_total+=1\\n\\n logging.info(\\\"Scored %f out of %d\\\" % (total_score, num_total));\\n\\n if num_total==0:\\n return 1;\\n return float(total_score)/float(num_total)\",\n \"def sentences(a, b):\\n\\n # TODO\\n return []\",\n \"def compare_word_selection(selection1,selection2):\\n\\n num_extra=0;\\n num_total=0;\\n total_score=0;\\n for k in selection1.keys():\\n num_total+=1;\\n if k not in selection2:\\n num_extra+=1;\\n else:\\n score=compare_sentences(selection1[k],selection2[k]);\\n logging.info(\\\"Score: %f\\\" % score );\\n total_score+=score;\\n\\n for k in selection2.keys():\\n if k not in selection1:\\n num_total+=1;\\n num_extra+=1;\\n\\n if num_total==0:\\n return 0;\\n\\n return float(total_score)/float(num_total)\",\n \"def batch_sentences(sentences, lg_ids=None):\\n # sentences = sorted(sentences, key=lambda x: len(x), reverse=True)\\n lengths = torch.LongTensor([len(s) + 2 for s in sentences])\\n sent = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(1)\\n if lg_ids is not None:\\n lgs = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(4)\\n else:\\n lgs = None\\n sent[0] = 0\\n for i, s in enumerate(sentences):\\n if lengths[i] > 2: # if sentence not empty\\n sent[1:lengths[i] - 1, i].copy_(torch.from_numpy(s.astype(np.int64)))\\n sent[lengths[i] - 1, i] = 2\\n if lg_ids is not None:\\n lgs[:, i] = lg_ids[i]\\n\\n if lgs is None:\\n return sent, lengths\\n return sent, lengths, lgs\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2): \\n if (i + startpoint) < (l1 + l2 - 1): \\n if l2 - i > startpoint + 1:\\n matched = matched + \\\".\\\" #dots before they start overlapping\\n elif s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" #matched bases\\n score = score + 1 #adds one to score\\n else:\\n matched = matched + \\\"-\\\" #not matched bases\\n shift, end_shift = startpoint * \\\".\\\", (l2 + l1 - startpoint - 2) * \\\".\\\"\\n # dots at end, but only up until end of dots tailing l1\\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\\n # this formula. the below check stops it from getting less than l2.\\n if startpoint < l1 - 1:\\n print(shift + matched + end_shift)\\n else:\\n print(shift + matched + (l2 - 1) * \\\".\\\")\\n print(shift + s2 + end_shift)\\n print(s1)\\n print(str(score) + \\\"\\\\n\\\")\\n return score, matched, shift, end_shift\",\n \"def alleles(gt1, gt2):\\n\\n\\t# Count genotypes 1 and 2\\n\\tcount = {}\\n\\tfor g in gt1 :\\n\\t\\tcount[g] = count.get(g, 0) + 1\\n\\n\\tfor g in gt2 :\\n\\t\\tcount[g] = count.get(g, 0) + 1\\n\\n\\t# Find mayor allele (we call it 'ref')\\n\\tmaxCount = 0\\n\\tref = ''\\n\\tfor g in count:\\n\\t\\tif count[g] > maxCount:\\n\\t\\t\\tmaxCount = count[g]\\n\\t\\t\\tref = g\\n\\n\\t# Find minor allele (we call these one 'alt')\\n\\talt = ''\\n\\tfor g in count:\\n\\t\\tif g != ref and g != '0': alt = g\\n\\n\\t# Create a genotype string (VCF style)\\n\\tgtstr = \\\"\\\"\\n\\tfor i in range(len(gt1)):\\n\\t\\tgtstr += \\\"\\\\t\\\" + gtVcf(ref, alt, gt1[i]) + \\\"/\\\" + gtVcf(ref, alt, gt2[i])\\n\\n\\treturn ref, alt, count[alt], gtstr\",\n \"def compareLemma(l1, l2, cwn):\\n l1 = f\\\"^{l1}$\\\"\\n l2 = f\\\"^{l2}$\\\"\\n \\n l1_lst = [str(li).replace('<CwnSense', '').replace('>', '').replace('(', '').replace(')', '') for li in cwn.find_senses(lemma=l1)]\\n l2_lst = [str(li).replace('<CwnSense', '').replace('>', '').replace('(', '').replace(')', '') for li in cwn.find_senses(lemma=l2)]\\n \\n if len(l1_lst) < len(l2_lst):\\n zip_lst = zip(l2_lst, l1_lst)\\n long = l2_lst\\n short = l1_lst\\n else:\\n zip_lst = zip(l1_lst, l2_lst)\\n long = l1_lst\\n short = l2_lst\\n \\n # Print paired list\\n for i, (a, b) in enumerate(zip_lst):\\n #print(f\\\"{a:50}{b:>50}\\\")\\n print(f\\\"{i+1:>3} {a.ljust(45, ' ')}{b}\\\") # 使用全形空白\\n # Print remaining list\\n if len(long) > len(short):\\n for item in long[len(list(zip_lst)):]:\\n i += 1\\n print(f\\\"{i+1:>3} {item}\\\")\",\n \"def lemma_texts(raw_texts):\\r\\n tokens = pos_tag(word_tokenize(raw_texts))\\r\\n res = [lemmatize(pos_res[0], get_wordnet_pos(pos_res[1])) for pos_res in tokens]\\r\\n return \\\" \\\".join(res)\",\n \"def compare_sentences(sentence_a, sentence_b, extra_splits=DEFAULT_SPLITTERS):\\n\\n def split_sentence(sentence):\\n reworked_sentence = sentence.strip()\\n for chars in extra_splits:\\n reworked_sentence = reworked_sentence.replace(chars, ' ')\\n return reworked_sentence.split()\\n\\n reworked_a = split_sentence(sentence_a)\\n reworked_b = split_sentence(sentence_b)\\n return compare_iterables(reworked_a, reworked_b)\",\n \"def get_rouge_est_str_2gram_smart(gold: str, pred: str, stemming=False):\\n gold_1, gold_2, gold_st = _get_2gram_sets_keep_stop(gold, stemming) # TODO\\n pred_1, pred_2, pred_st = _get_2gram_sets_keep_stop(pred, stemming) # TODO\\n rouge_recall_1 = 0\\n if len(gold_1) != 0:\\n rouge_recall_1 = float(len(gold_1.intersection(pred_1))) / float(len(gold_1))\\n\\n rouge_pre_1 = 0\\n if len(pred_1) != 0:\\n rouge_pre_1 = float(len(gold_1.intersection(pred_1))) / float(len(pred_1))\\n\\n rouge_recall_2 = 0\\n if len(gold_2) != 0:\\n rouge_recall_2 = float(len(gold_2.intersection(pred_2))) / float(len(gold_2))\\n\\n rouge_pre_2 = 0\\n if len(pred_2) != 0:\\n rouge_pre_2 = float(len(gold_2.intersection(pred_2))) / float(len(pred_2))\\n\\n f1 = 0 if (rouge_recall_1 + rouge_pre_1 == 0) else 2 * (rouge_recall_1 * rouge_pre_1) / (\\n rouge_recall_1 + rouge_pre_1)\\n f2 = 0 if (rouge_recall_2 + rouge_pre_2 == 0) else 2 * (rouge_recall_2 * rouge_pre_2) / (\\n rouge_recall_2 + rouge_pre_2)\\n if stemming:\\n\\n rouge_recall_st = 0\\n if len(gold_st) != 0:\\n rouge_recall_st = float(len(gold_st.intersection(pred_st))) / float(len(gold_st))\\n\\n rouge_pre_st = 0\\n if len(pred_st) != 0:\\n rouge_pre_st = float(len(gold_st.intersection(pred_st))) / float(len(pred_st))\\n f_st = 0 if (rouge_recall_st + rouge_pre_st == 0) else 2 * (rouge_recall_st * rouge_pre_st) / (\\n rouge_recall_st + rouge_pre_st)\\n\\n average_f_score = f1 * 0.25 + f2 * 0.5 + 0.25 * f_st\\n else:\\n average_f_score = (f1 + f2) / 2\\n # average_f_score = (f1 ) # TODO\\n return average_f_score\",\n \"def wordSimilarityRatio(sent_1,sent_2):\",\n \"def batch_sentences_v2(sentences, lm_labels=None):\\n # sentences = sorted(sentences, key=lambda x: len(x), reverse=True)\\n lengths = torch.LongTensor([len(s) + 2 for s in sentences])\\n sent = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(1)\\n if lm_labels is not None:\\n _labels = torch.LongTensor(lengths.max().item(), lengths.size(0)).fill_(-1)\\n\\n sent[0] = 0\\n for i, s in enumerate(sentences):\\n if lengths[i] > 2: # if sentence not empty\\n sent[1:lengths[i] - 1, i].copy_(torch.from_numpy(s.astype(np.int64)))\\n if lm_labels is not None:\\n lm = np.array(lm_labels[i])\\n _labels[1:lengths[i] - 1, i].copy_(torch.from_numpy(lm.astype(np.int64)))\\n sent[lengths[i] - 1, i] = 2\\n if lm_labels is not None:\\n _labels[lengths[i] - 1, i] = -1\\n\\n if lm_labels is not None:\\n return sent, lengths, _labels\\n return sent, lengths\",\n \"def compSeq(s1, s2, lineL=50):\\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\\n count = 0\\n samecount = 0\\n outStr = ''\\n for linei in range(lineN):\\n if (linei+1) * lineL < min(len(s1), len(s2)):\\n end = (linei+1) * lineL\\n else:\\n end = min(len(s1), len(s2))\\n outStr += 'Pos %d - %d\\\\n' % (linei*lineL+1, end-1+1)\\n for sitei in range(linei*lineL, end):\\n outStr += s1[sitei]\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = ' ' if s1[sitei] == s2[sitei] else '|'\\n outStr += out\\n count += 1\\n samecount += 1 if s1[sitei]==s2[sitei] else 0\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\\n outStr += s2[sitei]\\n outStr += '\\\\n\\\\n'\\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\\\n\\\\n' % (len(s1), len(s2), 1e2*samecount/count)\\n print(outStr)\",\n \"def sentence_similarity(sentence1, sentence2):\\n sentence1 = sentence1.tags\\n sentence2 = sentence2.tags\\n \\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n \\n for synset in synsets1:\\n \\n li=[synset.path_similarity(ss) for ss in synsets2]\\n m=0\\n for i in range(len(li)):\\n if li[i] is not None and m<li[i]:\\n m=li[i]\\n if m != 0:\\n score += m\\n count += 1\\n\\n if count is 0:\\n score = 0\\n else:\\n score /= count\\n return score\",\n \"def get_left_right_lists(sentence, language):\\n left_list = nltk.word_tokenize(replace_accented(sentence.childNodes[0].nodeValue.replace('\\\\n', '')))\\n right_list = nltk.word_tokenize(replace_accented(sentence.childNodes[2].nodeValue.replace('\\\\n', '')))\\n\\n left_list = remove_stop_words(left_list, language)\\n right_list = remove_stop_words(right_list, language)\\n\\n left_list = remove_punctuations(left_list)\\n right_list = remove_punctuations(right_list)\\n\\n left_list = lowercase(left_list)\\n right_list = lowercase(right_list)\\n\\n left_list = stemming(left_list, language)\\n right_list = stemming(right_list, language)\\n\\n return left_list, right_list\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2):\\n #moves shorter sequence along longer, counting number of matches in\\n #each position\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\"\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\"\\n\\n # gives an output for each startpoint showing the number of matches where\\n # * is a match and - is no match, position of the two sequences relative to\\n # each other, and the number of matches for that startpoint.\\n print(\\\".\\\" * startpoint + matched) \\n print(\\\".\\\" * startpoint + s2)\\n print(s1)\\n print(score) \\n print(\\\" \\\")\\n\\n return score\",\n \"def _rouge_lsum_score(pred: Sequence[Sequence[str]], target: Sequence[Sequence[str]]) ->Dict[str, Tensor]:\\n pred_len = sum(map(len, pred))\\n target_len = sum(map(len, target))\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n\\n def _get_token_counts(sentences: Sequence[Sequence[str]]) ->Counter:\\n ngrams: Counter = Counter()\\n for sentence in sentences:\\n ngrams.update(sentence)\\n return ngrams\\n pred_tokens_count = _get_token_counts(pred)\\n target_tokens_count = _get_token_counts(target)\\n hits = 0\\n for tgt in target:\\n lcs = _union_lcs(pred, tgt)\\n for token in lcs:\\n if pred_tokens_count[token] > 0 and target_tokens_count[token] > 0:\\n hits += 1\\n pred_tokens_count[token] -= 1\\n target_tokens_count[token] -= 1\\n return _compute_metrics(hits, pred_len, target_len)\",\n \"def lemmas_similarity(s1, s2, filter_stop_words=True):\\n # Tokenize by sentences into words in lower case \\n tokenized_sentence_1 = nltk.word_tokenize(s1.lower())\\n tokenized_sentence_2 = nltk.word_tokenize(s2.lower())\\n \\n if not filter_stop_words:\\n tokenized_sentence_1 = [token for token in tokenized_sentence_1 if token not in stop_words]\\n tokenized_sentence_2 = [token for token in tokenized_sentence_2 if token not in stop_words]\\n \\n tagged_sentence_1 = pos_tag(tokenized_sentence_1) # [ (word, POS_TAG), ...]\\n tagged_sentence_2 = pos_tag(tokenized_sentence_2) # [ (word, POS_TAG), ...]\\n \\n lemmas_sentence_1 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_1] \\n lemmas_sentence_2 = [lemmatize(tagged_word, wnl) for tagged_word in tagged_sentence_2] # [LEMMA_1, ...]\\n \\n # Compute similarity\\n if len(lemmas_sentence_1) > 0 and len(lemmas_sentence_2) > 0:\\n similarity = 1 - jaccard_distance(set(lemmas_sentence_1), set(lemmas_sentence_2))\\n # Compute label of similarity \\n return similarity\\n else:\\n return 0\",\n \"def sentences(a, b):\\n\\n # creating a list with all the sentences using nltk\\n sentencesA = sent_tokenize(a)\\n sentencesB = sent_tokenize(b)\\n\\n same_sentences = []\\n\\n for sent in sentencesA:\\n if sent in sentencesB and sent not in same_sentences:\\n same_sentences.append(sent)\\n\\n return same_sentences\",\n \"def rouge_l(peer, models, alpha=1):\\n matches = 0\\n recall_total = 0\\n for model in models:\\n matches += lcs(model, peer)\\n recall_total += len(model)\\n precision_total = len(models) * len(peer)\\n return _safe_f1(matches, recall_total, precision_total, alpha)\",\n \"def wordNet_similarity(sentence1, sentence2):\\r\\n # Tokenize and tag\\r\\n \\r\\n # sentence1 = pos_tag(word_tokenize(sentence1))\\r\\n sentence1=st_tagger.tag(word_tokenize(sentence1))\\r\\n \\r\\n # sentence2 = pos_tag(word_tokenize(sentence2))\\r\\n sentence2=st_tagger.tag(word_tokenize(sentence2))\\r\\n\\r\\n \\r\\n # Get the synsets for the tagged words\\r\\n #################################################\\r\\n\\r\\n # synsets1=[]\\r\\n # synsets2=[]\\r\\n # for tagged_word in sentence1:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # synsets1.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n # for tagged_word in sentence2:\\r\\n # print(tagged_word)\\r\\n # tagged_word = list(tagged_word)\\r\\n # print(tagged_word)\\r\\n # synsets2.append(tagged_to_synset(tagged_word[0],tagged_word[1]))\\r\\n\\r\\n # The code above is the elaboration of code below\\r\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\r\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\r\\n \\r\\n # Filter out the Nones in the synonym set\\r\\n synsets1 = [ss for ss in synsets1 if ss]\\r\\n synsets2 = [ss for ss in synsets2 if ss]\\r\\n \\r\\n score, count = 0.0, 0\\r\\n \\r\\n###########################################################################\\r\\n # for syn1 in synsets1:\\r\\n # arr_simi_score = []\\r\\n # print('=========================================')\\r\\n # print(syn1)\\r\\n # print('----------------')\\r\\n # for syn2 in synsets2:\\r\\n # print(syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n # print(simi_score)\\r\\n # if simi_score is not None:\\r\\n # arr_simi_score.append(simi_score)\\r\\n # print('----------------')\\r\\n # print(arr_simi_score)\\r\\n # if(len(arr_simi_score) > 0):\\r\\n # best = max(arr_simi_score)\\r\\n # print(best)\\r\\n # score += best\\r\\n # count += 1\\r\\n # # Average the values\\r\\n # print('score: ', score)\\r\\n # print('count: ', count)\\r\\n # score /= count\\r\\n\\r\\n###########################################################################\\r\\n\\r\\n for syn1 in synsets1:\\r\\n arr_simi_score = []\\r\\n # print('=========================================')\\r\\n print(\\\"Each word from Synonym se1\\\",syn1)\\r\\n # print('----------------')\\r\\n for syn2 in synsets2:\\r\\n print(\\\"Each word from Synonym se2\\\",syn2)\\r\\n # simi_score = syn1.path_similarity(syn2)\\r\\n simi_score = syn1.wup_similarity(syn2)\\r\\n print(\\\"word to word path_similarity score\\\",simi_score)\\r\\n if simi_score is not None:\\r\\n arr_simi_score.append(simi_score)\\r\\n print('----------------')\\r\\n print(arr_simi_score)\\r\\n if(len(arr_simi_score) > 0):\\r\\n best = max(arr_simi_score)\\r\\n print(\\\"best score so far\\\", best)\\r\\n score += best\\r\\n count += 1\\r\\n # Average the values\\r\\n print('score: ', score)\\r\\n print('count: ', count)\\r\\n if count!=0:\\r\\n score /= count\\r\\n else:\\r\\n score=0.0\\r\\n return score\",\n \"def _example_from_conllu_sentence(\\n self,\\n lines: List[str],\\n merge_subtoken: bool =False,\\n )-> Doc:\\n # create a Doc with each subtoken as its own token\\n # if merging subtokens, each subtoken orth is the merged subtoken form\\n if not Token.has_extension(\\\"merged_orth\\\"):\\n Token.set_extension(\\\"merged_orth\\\", default=\\\"\\\")\\n if not Token.has_extension(\\\"merged_lemma\\\"):\\n Token.set_extension(\\\"merged_lemma\\\", default=\\\"\\\")\\n if not Token.has_extension(\\\"merged_morph\\\"):\\n Token.set_extension(\\\"merged_morph\\\", default=\\\"\\\")\\n if not Token.has_extension(\\\"merged_spaceafter\\\"):\\n Token.set_extension(\\\"merged_spaceafter\\\", default=\\\"\\\")\\n words, spaces, tags, poses, morphs, lemmas = [], [], [], [], [], []\\n heads, deps = [], []\\n subtok_word = \\\"\\\"\\n in_subtok = False\\n for i in range(len(lines)):\\n line = lines[i]\\n parts = line.split(\\\"\\\\t\\\")\\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\\n if \\\".\\\" in id_:\\n continue\\n if \\\"-\\\" in id_:\\n in_subtok = True\\n if \\\"-\\\" in id_:\\n in_subtok = True\\n subtok_word = word\\n subtok_start, subtok_end = id_.split(\\\"-\\\")\\n subtok_spaceafter = \\\"SpaceAfter=No\\\" not in misc\\n continue\\n if merge_subtoken and in_subtok:\\n words.append(subtok_word)\\n else:\\n words.append(word)\\n if in_subtok:\\n if id_ == subtok_end:\\n spaces.append(subtok_spaceafter)\\n else:\\n spaces.append(False)\\n elif \\\"SpaceAfter=No\\\" in misc:\\n spaces.append(False)\\n else:\\n spaces.append(True)\\n if in_subtok and id_ == subtok_end:\\n subtok_word = \\\"\\\"\\n in_subtok = False\\n id_ = int(id_) - 1\\n head = (int(head) - 1) if head not in (\\\"0\\\", \\\"_\\\") else id_\\n tag = pos if tag == \\\"_\\\" else tag\\n morph = morph if morph != \\\"_\\\" else \\\"\\\"\\n dep = \\\"ROOT\\\" if dep == \\\"root\\\" else dep\\n lemmas.append(lemma)\\n poses.append(pos)\\n tags.append(tag)\\n morphs.append(morph)\\n heads.append(head)\\n deps.append(dep)\\n\\n doc: Doc = Doc(self.nlp.vocab, words=words, spaces=spaces)\\n for i in range(len(doc)):\\n doc[i].tag_ = tags[i]\\n doc[i].pos_ = poses[i]\\n doc[i].dep_ = deps[i]\\n doc[i].lemma_ = lemmas[i]\\n doc[i].head = doc[heads[i]]\\n doc[i]._.merged_orth = words[i]\\n doc[i]._.merged_morph = morphs[i]\\n doc[i]._.merged_lemma = lemmas[i]\\n doc[i]._.merged_spaceafter = spaces[i]\\n if merge_subtoken:\\n doc = self._merge_conllu_subtokens(lines, doc)\\n return doc\",\n \"def get_synset_overlap(sentence_a, sentence_b):\\n def synsets(word):\\n sense_lemmas = []\\n for pos in ('n'):#,'a'):\\n for i in xrange(5):\\n try:\\n sense_lemmas += [lemma.name \\n for lemma in wn.synset('{0}.{1}.0{2}'.format(word, pos, i)).lemmas]\\n except WordNetError: \\n pass\\n return sense_lemmas\\n\\n a_set = set(lemma for word in sentence_a for lemma in synsets(word))\\n b_set = set(lemma for word in sentence_b for lemma in synsets(word))\\n score = len(a_set&b_set)/float(len(a_set|b_set))\\n \\n return score\",\n \"def concretize(self, lw: torch.Tensor, uw: torch.Tensor):\\n if self.args.attack_type == \\\"synonym\\\":\\n # lw: (input/output len, output dim, len * input dim)\\n # lw = lw.transpose(0, 1) # (output dim, input/output len, len * input dim)\\n # uw = uw.transpose(0, 1) # (output dim, input/output len, len * input dim)\\n\\n dim = lw.size(2) // self.perturbed_words\\n concretized_l = torch.zeros(lw.size(0), lw.size(1), device=lw.device)\\n concretized_u = torch.zeros(uw.size(0), uw.size(1), device=uw.device)\\n for i in range(self.perturbed_words):\\n concretized_l -= torch.norm(lw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\\n concretized_u += torch.norm(uw[:, :, i*dim:(i+1)*dim] * self.args.embedding_radii[i], p=self.q, dim=-1) #.t()\\n\\n return concretized_l, concretized_u\\n elif self.perturbed_words == 2:\\n assert (len(lw.shape) == 3), \\\"Lw does not have 3 dimensions! It has %d dimensions\\\" % len(lw.shape)\\n half = lw.shape[-1] // 2\\n concretized_l = self.concretize_l(lw[:, :, :half]) + self.concretize_l(lw[:, :, half:])\\n concretized_u = self.concretize_u(uw[:, :, :half]) + self.concretize_u(uw[:, :, half:])\\n return concretized_l, concretized_u\\n elif self.perturbed_words == 1:\\n return self.concretize_l(lw), self.concretize_u(uw)\\n else:\\n raise NotImplementedError\",\n \"def test_lcs_verbs(id1, id2, expected_ids):\\n syn1 = germanet_data.get_synset_by_id(id1)\\n syn2 = germanet_data.get_synset_by_id(id2)\\n lcs = syn1.lowest_common_subsumer(syn2)\\n np.testing.assert_equal(sorted([l.id for l in lcs]), sorted(expected_ids))\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n\\n matched = \\\"\\\" # to hold string displaying alignments\\n score = 0\\n for i in range(l2):\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" # * indicates a match\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\" # - indicates no match\\n\\n return score\",\n \"def lcs_rouge(self, RTSummary , SystemSummary):\\n return (len(RTSummary)+len(SystemSummary) - (self.lcs(RTSummary,SystemSummary)))/2\",\n \"def get_word_containement_measure(self,l2,l1):\\n count = 0\\n found_idfs = []\\n unfound_idfs = []\\n for w in l1:\\n val = self.idf.get_tfidf_val(w)\\n if (val > 10):\\n val = 10\\n if w in l2:\\n count += 1\\n found_idfs.append(val)\\n else:\\n unfound_idfs.append(val)\\n if (len(found_idfs) == 0):\\n avg_found = 0\\n else:\\n avg_found = np.mean(found_idfs)\\n if (len(unfound_idfs) ==0):\\n avg_unfound = 0\\n else:\\n avg_unfound = np.mean(unfound_idfs)\\n\\n\\n\\n return count / self.normalize_factor, avg_found, avg_unfound\",\n \"def rgenerate(allele1, allele2, min_length, max_length):\\n from .models import Primer\\n\\n if len(allele1) != len(allele2):\\n raise ValueError('Aligned alleles must be the same length.')\\n\\n allele1 = str(allele1)\\n allele2 = str(allele2)\\n candidates = []\\n\\n for size in range(min_length, max_length+1):\\n allele1_span = (0, size)\\n allele2_span = (0, size)\\n\\n for i in range(len(allele1)-size):\\n if allele1[i:i+size] == allele2[i:i+size]:\\n candidates.append(Primer(sequence=allele1[i:i+size],\\n allele1_span=allele1_span,\\n allele2_span=allele2_span,\\n strand=1))\\n\\n if allele1[i] != '-':\\n allele1_span = (allele1_span[0]+1, allele1_span[1]+1)\\n\\n if allele2[i] != '-':\\n allele2_span = (allele2_span[0]+1, allele2_span[1]+1)\\n\\n return candidates\",\n \"def sentences(a, b):\\n a = set(sent_tokenize(a))\\n b = set(sent_tokenize(b))\\n return a & b\",\n \"def compare_lists(l1, l2):\\n score = 0\\n total = len(l1)\\n weight = 110\\n\\n for item in range(len(l2)):\\n if item in range(len(l1)):\\n score += math.log(weight/total) * (weight)\\n else:\\n score += math.log(0.5/total) * (1)\\n weight -= 10\\n return score\",\n \"def sentence_lengths(sentence_a, sentence_b):\\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))\",\n \"def _merge_conllu_subtokens(self, lines: List[str], doc: Doc)-> Doc:\\n # identify and process all subtoken spans to prepare attrs for merging\\n subtok_spans = []\\n for line in lines:\\n parts = line.split(\\\"\\\\t\\\")\\n id_, word, lemma, pos, tag, morph, head, dep, _1, misc = parts\\n if \\\"-\\\" in id_:\\n subtok_start, subtok_end = id_.split(\\\"-\\\")\\n subtok_span = doc[int(subtok_start) - 1 : int(subtok_end)]\\n subtok_spans.append(subtok_span)\\n # create merged tag, morph, and lemma values\\n tags = []\\n morphs = {}\\n lemmas = []\\n for token in subtok_span:\\n tags.append(token.tag_)\\n lemmas.append(token.lemma_)\\n if token._.merged_morph:\\n for feature in token._.merged_morph.split(\\\"|\\\"):\\n field, values = feature.split(\\\"=\\\", 1)\\n if field not in morphs:\\n morphs[field] = set()\\n for value in values.split(\\\",\\\"):\\n morphs[field].add(value)\\n # create merged features for each morph field\\n for field, values in morphs.items():\\n morphs[field] = field + \\\"=\\\" + \\\",\\\".join(sorted(values))\\n # set the same attrs on all subtok tokens so that whatever head the\\n # retokenizer chooses, the final attrs are available on that token\\n for token in subtok_span:\\n token._.merged_orth = token.orth_\\n token._.merged_lemma = \\\" \\\".join(lemmas)\\n token.tag_ = \\\"_\\\".join(tags)\\n token._.merged_morph = \\\"|\\\".join(sorted(morphs.values()))\\n token._.merged_spaceafter = (\\n True if subtok_span[-1].whitespace_ else False\\n )\\n\\n with doc.retokenize() as retokenizer:\\n for span in subtok_spans:\\n retokenizer.merge(span)\\n\\n return doc\",\n \"def commonality(left_struc, right_struc):\\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\\n assert left_struc and right_struc, (left_struc, right_struc)\\n if type(left_struc) is dict:\\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\\n com = float(len(overlap))\\n tot = len(overlap.union(left, right))\\n else:\\n assert type(left_struc) in (list, tuple), left_struc\\n com = 0.0\\n for elem in left_struc:\\n if elem in right_struc:\\n com += 1\\n tot = max(len(left_struc), len(right_struc))\\n\\n return com / tot\",\n \"def sentences(a, b):\\n c = [] #Declare list\\n\\n a = sent_tokenize(a)\\n b = sent_tokenize(b)\\n\\n for x in a:\\n for y in b:\\n if x == y:\\n if not x in c:\\n c.append(x)\\n return (c)\",\n \"def get_relatedness(theme1,theme2):\\r\\n nAB=0\\r\\n nAB_plus=0\\r\\n for sentence_1 in theme1.sentences:\\r\\n for sentence_2 in theme2.sentences:\\r\\n if cmp(sentence_1[2],sentence_2[2])==0:\\r\\n nAB=nAB+1\\r\\n if sentence_1[3]==sentence_2[3]:\\r\\n nAB_plus=nAB_plus+1\\r\\n if nAB==0:\\r\\n return 0\\r\\n else:\\r\\n return float(nAB_plus)/float(nAB)\",\n \"def sentences(a, b):\\n setA = set(sent_tokenize(a))\\n setB = set(sent_tokenize(b))\\n return list(setA & setB)\",\n \"def merge_overlapping_predictions(tags1: List[str], tags2: List[str]) -> List[str]:\\n ret_sequence = []\\n prev_label = \\\"O\\\"\\n\\n # Build a coherent sequence out of two\\n # spans which predicates' overlap\\n\\n for tag1, tag2 in zip(tags1, tags2):\\n label1 = tag1.split(\\\"-\\\", 1)[-1]\\n label2 = tag2.split(\\\"-\\\", 1)[-1]\\n if (label1 == \\\"V\\\") or (label2 == \\\"V\\\"):\\n # Construct maximal predicate length -\\n # add predicate tag if any of the sequence predict it\\n cur_label = \\\"V\\\"\\n\\n # Else - prefer an argument over 'O' label\\n elif label1 != \\\"O\\\":\\n cur_label = label1\\n else:\\n cur_label = label2\\n\\n # Append cur tag to the returned sequence\\n cur_tag = get_coherent_next_tag(prev_label, cur_label)\\n prev_label = cur_label\\n ret_sequence.append(cur_tag)\\n return ret_sequence\",\n \"def Path_Similarity(word1, word2):\\n\\n # Initial test to confirm unique nouns, otherwise passes back 1\\n\\n if word1 == word2:\\n return 1, word1\\n\\n # Sets up Initial Variables & Dictionaries\\n\\n stepup1 = [word1]\\n stepup2 = [word2]\\n dict1= {}\\n dict2= {}\\n currentstep1 = []\\n currentstep2 = []\\n\\n # Iterates through a loop an arbitrary # of times, adding new hypernyms\\n # for each word to individual dictionaries with the number of iterations\\n # as the key to the dictionary. The two dictionaries are saved perpetually\\n\\n for la in range(50):\\n for i in range(len(stepup1)):\\n currentstep1 += (stepup1[i].hypernyms())\\n for syn in stepup1:\\n dict1[syn] = la\\n for i in range(len(stepup2)):\\n currentstep2 = (stepup2[i].hypernyms())\\n for syn in stepup2:\\n dict2[syn] = la\\n\\n # Variables are reset and converted to continue the next stage of the loop\\n\\n stepup1 = currentstep1\\n stepup2 = currentstep2\\n currentstep1 = []\\n currentstep2 = []\\n\\n\\n # Each loop the dictionaries are checked for matches. I have confirmed that\\n # checking each cycle is faster than checking at the end of an arbitrary\\n # number of cycles.\\n\\n # Removes applied words as Possible Subsumers Per Fridays Clas\\n dict1.pop(word1)\\n dict2.pop(word2)\\n\\n #Gets possible Least Common Subsumers\\n dict1Set = set(dict1)\\n dict2Set = set(dict2)\\n d = {}\\n for name in dict1Set.intersection(dict2Set):\\n d[name] = dict1[name]\\n pos_lcs = [key for min_value in (min(d.values()),) for key in d if d[key] == min_value]\\n\\n #Returns Actual LCS\\n key_lcs = []\\n for i in pos_lcs:\\n key_lcs.append(shortestPath(wn.synset('entity.n.01'),i))\\n lcs = (pos_lcs[key_lcs.index(max(key_lcs))])\\n\\n #Returns path Similarity Value and Synset of LCS; Must Error Proof\\n\\n return 1/(dict1[lcs] + dict2[lcs]), lcs\",\n \"def information_content_similarity(s1, s2):\\n lemmas_sentence_1, tagged_sentence_1 = lemmatize_sentence(s1.lower())\\n lemmas_sentence_2, tagged_sentence_2 = lemmatize_sentence(s2.lower())\\n\\n # Disambiguate words and create list of sysnsets \\n synsets_sentence_1 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_1, tagged_sentence_1):\\n synset = lesk(lemmas_sentence_1, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_1.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_1.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n synsets_sentence_2 = []\\n for (lemma, word_tag) in zip(lemmas_sentence_2, tagged_sentence_2):\\n synset = lesk(lemmas_sentence_2, lemma, wordnet_pos_code(word_tag[1]))\\n if synset is not None:\\n synsets_sentence_2.append(synset)\\n else:\\n found = wordnet.synsets(lemma, wordnet_pos_code(word_tag[1]))\\n if len(found) > 0:\\n synsets_sentence_2.append(found[0]) \\n #print(\\\"Warn: lemma [%s] returned no disambiguation...using synset : %s\\\" % (lemma, found[0])) \\n\\n score, count = 0.0, 0\\n # For each word in the first sentence\\n for synset in synsets_sentence_1:\\n L = []\\n for ss in synsets_sentence_2:\\n try:\\n L.append(synset.lin_similarity(ss, brown_ic))\\n except:\\n continue\\n if L: \\n best_score = max(L)\\n score += best_score\\n count += 1\\n # Average the values\\n if count > 0: score /= count\\n return score\",\n \"def linear_nlg(tuple_message_clause: tuple, str_joiner: str = ' ') -> str:\\n def get_clause(tup_data) -> str:\\n \\\"\\\"\\\"Helper func: returns clause from tup_data using recursion.\\\"\\\"\\\"\\n if (tup_data is None) or (len(tup_data) == 0):\\n return ''\\n\\n elif isinstance(tup_data, str):\\n return tup_data\\n\\n elif isinstance(tup_data, (int, float)):\\n return Pauser.get_p_level(tup_data)\\n \\n elif isinstance(tup_data, (tuple, list)):\\n\\n if isinstance(tup_data[0], str):\\n ## List of strings, return choice.\\n return random.choice(tup_data)\\n\\n else:\\n # Recursion of tuples in tuple\\n speech_list = []\\n for clause_list in tup_data:\\n clause = get_clause(clause_list)\\n speech_list.append(clause)\\n\\n return str_joiner.join(speech_list)\\n else:\\n logger.warning(f\\\"get_clause: Unrecognized data type {tup_data}\\\")\\n \\n\\n logger.debug(tuple_message_clause)\\n speech_list = []\\n\\n for tup_data in tuple_message_clause:\\n clause = get_clause(tup_data)\\n speech_list.append( clause)\\n \\n # logger.debug(speech_list)\\n return str_joiner.join(speech_list)\",\n \"def convertSentenceToConLL(sent_xml_repr, oformat='conll07'):\\n import conll_utils as cu ;\\n if oformat == 'conllu':\\n cu.FIELDS = cu.AUG_CONLLU_COLUMNS ; \\n else:\\n cu.FIELDS = cu.AUG_CONLL07_COLUMNS ;\\n\\n pos_field = 'xpostag' if oformat == 'conllu' else 'cpostag' ;\\n deps_field = 'deps' if oformat == 'conllu' else 'phead' ;\\n sent_node = etree.fromstring(sent_xml_repr);\\n conll_sentence = [];\\n terminalNodes = [];\\n for token_node in sent_node.findall(\\\".//token\\\"):\\n conll_line, isNer = defaultdict(lambda: '_'), False;\\n conll_line['id'] = token_node.attrib['id'];\\n for child in token_node:\\n if child.tag == 'word': conll_line['form'] = child.text;\\n if child.tag == 'lemma': conll_line['lemma'] = child.text;\\n if child.tag == 'POS': \\n conll_line[pos_field] = child.text.strip();\\n conll_line['postag'] = child.text.strip();\\n if child.tag == 'NER' and child.text != 'O':\\n conll_line.setdefault('feats', {})['nertype'] = child.text.strip();\\n isNer = True;\\n if isNer == True and child.tag == 'NormalizedNER':\\n conll_line.setdefault('feats', {})['normalized_ner'] = child.text.strip();\\n #if child.tag == 'TrueCaseText': \\n # conll_line['form'] = child.text.strip(); # Truecaser performance seems worse. \\n conll_line['feats'] = '|'.join('%s=%s'%(f,v) for f,v in conll_line.get('feats', {}).items());\\n if not conll_line['feats']:\\n conll_line['feats'] = '_' ;\\n terminalNodes.append(conll_line['form']);\\n conll_sentence.append(conll_line);\\n const_parse = '';\\n for parse_node in sent_node.findall(\\\"parse\\\"):\\n const_parse = parse_node.text.strip();\\n if not const_parse.strip(): # parser failed ; no dependency information available either\\n return conll_sentence;\\n if const_parse not in ['(())', '(ROOT ())', '(ROOT())']: # similar situation \\n for conll_line, chunk in zip(conll_sentence, constparse_chunks(const_parse, terminalNodes)):\\n conll_line['const_parse'] = chunk;\\n #print conll_line['form'], conll_line['postag'];\\n try:\\n assert( const_parse == ' '.join(conll_line['const_parse'].replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence) );\\n except AssertionError:\\n print const_parse;\\n print ' '.join(conll_line['const_parse'].replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence);\\n sys.exit(1);\\n except KeyError:\\n print const_parse;\\n print ' '.join(conll_line.get('const_parse', 'NONE').replace('_', ' ').replace('*', conll_line['form']) for conll_line in conll_sentence);\\n sys.exit(1);\\n for depann_node in sent_node.findall(\\\".//dependencies\\\"):\\n if depann_node.attrib['type'] == 'basic-dependencies':\\n # convert basic dependencies in annotation\\n for dep_node in depann_node.findall(\\\".//dep\\\"):\\n depLabel, head, token = '', -1, -1\\n depLabel = dep_node.attrib['type']\\n for child in dep_node:\\n if child.tag == 'governor': \\n head = int(child.attrib['idx'])\\n if child.tag == 'dependent': \\n token = int(child.attrib['idx'])\\n conll_sentence[token-1]['head'] = str(head)\\n conll_sentence[token-1]['deprel'] = depLabel\\n elif depann_node.attrib['type'] == 'enhanced-dependencies':\\n # convert enhanced dependencies in annotation\\n for dep_node in depann_node.findall(\\\".//dep\\\"):\\n depLabel, head, token = '', -1, -1\\n depLabel = dep_node.attrib['type']\\n for child in dep_node:\\n if child.tag == 'governor': \\n head = int(child.attrib['idx'])\\n if child.tag == 'dependent': \\n token = int(child.attrib['idx'])\\n conll_sentence[token-1][deps_field] = str(head)+':'+depLabel\\n else:\\n continue;\\n # meta-information from stanford core nlp\\n #metainfo = 'line:%s-sent:%s' %(sent_node.attrib['line'].strip(), sent_node.attrib['id'].strip());\\n #return (metainfo, conll_sentence);\\n return conll_sentence;\",\n \"def difference(first, second, rf, rs, years=(1980, 2000),smooth=1, corpus='bok'):\\n try:\\n a_first = nb_ngram(first, years=years, smooth=smooth, corpus=corpus)\\n a_second = nb_ngram(second, years=years, smooth=smooth, corpus=corpus)\\n a = a_first.join(a_second) \\n b_first = nb_ngram(rf, years=years, smooth=smooth, corpus=corpus)\\n b_second = nb_ngram(rs, years=years, smooth=smooth, corpus=corpus)\\n if rf == rs:\\n b_second.columns = [rs + '2']\\n b = b_first.join(b_second)\\n s_a = a.mean()\\n s_b = b.mean()\\n f1 = s_a[a.columns[0]]/s_a[a.columns[1]]\\n f2 = s_b[b.columns[0]]/s_b[b.columns[1]]\\n res = f1/f2\\n except:\\n res = 'Mangler noen data - har bare for: ' + ', '.join([x for x in a.columns.append(b.columns)])\\n return res\",\n \"def lemmatize_sentences_rus(sentences):\\n split = 'fks2hwras1ma39hka766gbk'\\n chunk_size = 10000\\n\\n def handle_chunk(sentences_chunk):\\n all_sents = (' ' + split + ' ').join(sentences_chunk)\\n all_lemmas = lemmatize_sentence_rus(all_sents).split()\\n chunk_res = [[]]\\n for lemma in all_lemmas:\\n if lemma == split:\\n chunk_res.append([])\\n else:\\n chunk_res[-1].append(lemma)\\n\\n return chunk_res\\n\\n res = []\\n i = 0\\n while i < len(sentences):\\n if len(sentences) > chunk_size:\\n print(f'Lemmatization: Done for {i} from {len(sentences)} sentences')\\n\\n i_step = min(chunk_size, len(sentences) - i)\\n res.extend(handle_chunk(sentences[i:i + i_step]))\\n i += i_step\\n\\n assert len(res) == len(sentences)\\n res = [' '.join(arr) for arr in res]\\n return res\",\n \"def likelihood(A, B, word_list):\\n\\tstr_buf = []\\n\\tloglh = 0.0\\n\\tlh = 1\\n\\n\\t# read each line and compute likelihood.\\n\\tfor line in sys.stdin:\\n\\t\\tline = line.split()\\n\\t\\t# print(line)\\n\\t\\tif len(line) == 3:\\n\\t\\t\\tstr_buf.append((str(line[0]), str(line[1])))\\n\\n\\t\\telse:\\n\\t\\t\\t# if come to the end of a sentence\\n\\t\\t\\tif len(str_buf) != 0:\\n\\t\\t\\t\\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\\n\\t\\t\\t\\tfor i in range(len(str_buf) - 1):\\n\\t\\t\\t\\t\\t# print(str_buf[i][0], str_buf[i+1][0])\\n\\t\\t\\t\\t\\tif str_buf[i+1][0] in word_list:\\n\\t\\t\\t\\t\\t\\t# print('debug: A[',str_buf[i][1],'][', str_buf[i+1][1],']:', A[ str_buf[i][1] ][ str_buf[i+1][1] ])\\n\\t\\t\\t\\t\\t\\t# print('debug: B[',str_buf[i+1][1],'][', [str_buf[i+1][0]], ']:', B[ str_buf[i+1][1] ][str_buf[i+1][0]])\\n\\t\\t\\t\\t\\t\\tloglh += ( log(A[ str_buf[i][1] ][ str_buf[i+1][1] ]) + log(B[ str_buf[i+1][1] ][str_buf[i+1][0]]) )\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t# print('debug: else A[',str_buf[i][1],'][', str_buf[i+1][1],']:', A[ str_buf[i][1] ][ str_buf[i+1][1] ])\\n\\t\\t\\t\\t\\t\\t# print('debug: else B[',str_buf[i+1][1],'][', '<UNK>', ']:', B[ str_buf[i+1][1] ][ '<UNK>' ])\\n\\t\\t\\t\\t\\t\\tloglh += ( log(A[ str_buf[i][1] ][ str_buf[i+1][1] ]) + log(B[ str_buf[i+1][1] ]['<UNK>']) )\\n\\n\\t\\t\\t\\tlh = e ** loglh\\n\\t\\t\\t\\t# for s in str_buf:\\n\\t\\t\\t\\t# \\tprint(s[0], end=\\\" \\\")\\n\\t\\t\\t\\t# print(':', lh)\\n\\t\\t\\t\\tprint(lh)\\n\\n\\t\\t\\t\\tstr_buf = []\\t\\n\\t\\t\\t\\tloglh = 0\\n\\t\\t\\t\\tlh = 1\",\n \"def levenshtein_normalised(str1, str2):\\n\\treturn levenshtein(str1, str2, normalise=True)\",\n \"def sentence_encoding_rnn_phi(t1, t2):\\n return (t1.leaves(), t2.leaves())\",\n \"def weighted_levenshtein(seq1, seq2, weights, r=0.9, normalise=False):\\n\\tx1 = 1 + len(seq1)\\n\\tx2 = 1 + len(seq2)\\n\\n\\talpha = r / ((1 - r) * average_distance)\\n\\n\\t# Initialisation of the matrix\\n\\td = [] # Using Numpy structures for this is probably not more efficient\\n\\ttmp = 0.0\\n\\tfirst_line = [tmp]\\n\\tfor e in seq2:\\n\\t\\ttmp += weights.get(e, 1)\\n\\t\\tfirst_line.append(tmp)\\n\\td.append(first_line)\\n\\ttmp = 0\\n\\tfor e in seq1:\\n\\t\\ttmp += weights.get(e, 1)\\n\\t\\td.append([tmp] * x2)\\n\\n\\t# Core of the algorithm\\n\\tfor i in range(1, x1):\\n\\t\\tfor j in range(1, x2):\\n\\t\\t\\te1 = seq1[i-1]\\n\\t\\t\\te2 = seq2[j-1]\\n\\n\\t\\t\\tw1 = weights.get(e1, 1)\\n\\t\\t\\tw2 = weights.get(e2, 1)\\n\\n\\t\\t\\td[i][j] = min(\\n\\t\\t\\t\\t(d[(i-1)][j] + w1), # Deletion of seq1[i]\\n\\t\\t\\t\\t(d[i][(j-1)] + w2), # Insertion of seq2[j]\\n\\t\\t\\t\\t(d[(i-1)][(j-1)] + (int(e1 != e2) * max(w1, w2))) # Substitution from seq1[i] to seq2[j]\\n\\t\\t\\t)\\n\\n\\traw = d[-1][-1]\\n\\n\\tif(normalise): return (raw / (d[0][-1] + d[-1][0]))\\n\\treturn raw\",\n \"def word_order_similarity(self,sentence_1, sentence_2):\\n\\t words_1 = sentence_1.getList_of_words()\\n\\t words_2 = sentence_2.getList_of_words()\\n\\t joint_words = list(set(words_1).union(set(words_2)))\\n\\t windex = {x[1]: x[0] for x in enumerate(joint_words)}\\n\\t r1 = self.word_order_vector(words_1, joint_words, windex)\\n\\t r2 = self.word_order_vector(words_2, joint_words, windex)\\n\\t return 1.0 - (np.linalg.norm(r1 - r2) / np.linalg.norm(r1 + r2))\",\n \"def verb_overlap(t_xml, h_xml, replacements):\\n score = 0\\n if t_xml == None or h_xml == None:\\n return 0\\n t_set = set(get_verbs(t_xml.getroot()))\\n h_set = set(get_verbs(h_xml.getroot()))\\n if float(len(t_set | h_set)) > 0:\\n score = len(t_set & h_set) / float(len(t_set | h_set))\\n \\n for replacement in replacements:\\n if replacement[9] != None and replacement[10] != None:\\n t_set = set(get_verbs(replacement[9].getroot()))\\n h_set = set(get_verbs(replacement[10].getroot()))\\n if float(len(t_set | h_set)) > 0:\\n new_score = len(t_set & h_set) / float(len(t_set | h_set))\\n if new_score > score:\\n score = new_score\\n \\n return score\",\n \"def lcs_similarity(s1, s2):\\n max_len = 0\\n i = 0\\n\\n while s1[i] == s2[i]:\\n max_len += 1\\n i += 1\\n if len(s1) == i or len(s2) == i:\\n break\\n\\n if len(s1) < len(s2):\\n return float(max_len) / len(s2)\\n else:\\n return float(max_len) / len(s1)\",\n \"def unit_overlap(self, RTSummary , SystemSummary):\\n\\n RTSummary_words = self.nlpWrapper.stemmer(tokens=self.nlpWrapper.tokenize(RTSummary))\\n SystemSummary_words = self.nlpWrapper.stemmer(tokens=self.nlpWrapper.tokenize(RTSummary))\\n commonWords = set(RTSummary_words)&set(SystemSummary_words)\\n commonWords = sorted(commonWords, key = lambda k : RTSummary_words.index(k))\\n\\n return (len(commonWords) / (len(RTSummary)+len(SystemSummary)-len(commonWords)))\",\n \"def compare_words(word1, word2):\\n word1 = word1.lower()\\n word2 = word2.lower()\\n seg_scores = []\\n if len(word1) >= len(word2):\\n for i in range(0, len(word1) - len(word2) + 1):\\n seg_scores.append(find_difference(word1[i:i+len(word2)], word2))\\n else:\\n for i in range(0, len(word2) - len(word1) + 1):\\n seg_scores.append(find_difference(word2[i:i+len(word1)], word1))\\n return round(min(seg_scores) + abs(len(word1) - len(word2))/float(len(max([word1, word2]))),2)\",\n \"def one_linestring_per_intersection(lines):\\n lines_merged = shapely.ops.linemerge(lines)\\n\\n # intersecting multiline with its bounding box somehow triggers a first\\n bounding_box = box(*lines_merged.bounds)\\n\\n # perform linemerge (one linestring between each crossing only)\\n # if this fails, write function to perform this on a bbox-grid and then\\n # merge the result\\n lines_merged = lines_merged.intersection(bounding_box)\\n lines_merged = shapely.ops.linemerge(lines_merged)\\n return lines_merged\",\n \"def sentences(a, b):\\n\\n # TODO\\n a, b = sent_tokenize(a, language='english'), sent_tokenize(b, language='english')\\n return list(set([sentence for sentence in a if sentence in b]))\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def word_embedding_levenshtein(seq1, seq2, embeddings, average_distance, r=0.9, normalise=False):\\n\\tx1 = 1 + len(seq1)\\n\\tx2 = 1 + len(seq2)\\n\\n\\talpha = r / ((1 - r) * average_distance)\\n\\n\\t# Initialisation of the matrix\\n\\td = [] # Using Numpy structures for this is probably not more efficient\\n\\td.append(list(range(x2)))\\n\\tfor i in range(1, x1):\\n\\t\\td.append([i] * x2)\\n\\n\\t# Core of the algorithm\\n\\tfor i in range(1, x1):\\n\\t\\tfor j in range(1, x2):\\n\\t\\t\\te1 = seq1[i-1]\\n\\t\\t\\te2 = seq2[j-1]\\n\\n\\t\\t\\tif(e1 == e2): c = 0\\n\\t\\t\\telse:\\n\\t\\t\\t\\tv1 = embeddings[e1]\\n\\t\\t\\t\\tv2 = embeddings[e2]\\n\\n\\t\\t\\t\\tif((v1 is None) or (v2 is None)): c = 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tdst = np.linalg.norm(v1 - v2) # Distance 2 (or L2 norm of the difference)\\n\\n\\t\\t\\t\\t\\t# Now, we need a function increasing function mapping 0 to 0 and +inf to 1\\n\\t\\t\\t\\t\\tc = 1 - (1 / (1 + (alpha * dst)))\\n\\n\\t\\t\\t\\t\\t#c /= r # If you uncomment this line, the cost of a substitution at distance `average_distance` will be 1 and substitutions might have higher cost, up to 1/r. This might be justified as long as `r` is above 0.5 (otherwise, some substitutions might be more expensive than an insertion followed by a deletion).\\n\\n\\t\\t\\td[i][j] = min(\\n\\t\\t\\t\\t(d[(i-1)][j] + 1), # Deletion of seq1[i]\\n\\t\\t\\t\\t(d[i][(j-1)] + 1), # Insertion of seq2[j]\\n\\t\\t\\t\\t(d[(i-1)][(j-1)] + c) # Substitution from seq1[i] to seq2[j]\\n\\t\\t\\t)\\n\\n\\traw = d[-1][-1]\\n\\n\\tif(normalise): return (raw / (len(seq1) + len(seq2)))\\n\\treturn raw\",\n \"def overlap_similarity(vect1, vect2, normalize=False, use_bigrams=False):\\n overlap = len(set(vect1).intersection(set(vect2)))\\n\\n if use_bigrams:\\n overlap += len(set(bigrams(vect1)).intersection(set(bigrams(vect2))))\\n\\n if not normalize:\\n return overlap\\n \\n if overlap == 0:\\n return 0\\n \\n return overlap / (math.log10(len(vect1)) + math.log10(len(vect2)))\",\n \"def sentence_similarity(self,wnsimilarity,sentence1, sentence2,icneed=False):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n \\n # Get the synsets for the tagged words\\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n \\n score, count = 0.0, 0\\n # For each word in the first sentence\\n for synset in synsets1:\\n \\n # Get the similarity value of the most similar word in the other sentence\\n score_list=[]\\n if icneed == True :\\n for ss in synsets2:\\n try:\\n temp=wnsimilarity(synset,ss,self.brown_ic)\\n score_list.append(temp)\\n except:\\n continue\\n \\n else:\\n for ss in synsets2:\\n try:\\n temp=wnsimilarity(synset,ss)\\n score_list.append(temp)\\n except:\\n continue\\n \\n \\n score_list = np.array(score_list, dtype=np.float64)\\n score_list = np.nan_to_num(score_list)\\n# print(score_list)\\n if len(score_list)>0:\\n best_score = np.nanmax(score_list)\\n else:\\n best_score=0.0\\n# print(best_score)\\n# print(type(best_score))\\n \\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score =score + best_score\\n# print(score)\\n count = count+ 1\\n \\n \\n# print(\\\"one sentence over\\\")\\n # Average the values\\n score /= count\\n return score\",\n \"def WordDiff(line1, line2, diff_params):\\n match_expr, min_match_ratio, min_match_size, _ = diff_params\\n exp = EXPRS[match_expr]\\n # Strings may have been left undecoded up to now. Assume UTF-8.\\n line1 = TryDecode(line1)\\n line2 = TryDecode(line2)\\n\\n a = re.findall(exp, line1, re.U)\\n b = re.findall(exp, line2, re.U)\\n s = difflib.SequenceMatcher(None, a, b)\\n matching_blocks = s.get_matching_blocks()\\n ratio = s.ratio()\\n # Don't show intra region diffs if both lines are too different and there is\\n # more than one block of difference. If there is only one change then we\\n # still show the intra region diff regardless of how different the blocks\\n # are.\\n # Note: We compare len(matching_blocks) with 3 because one block of change\\n # results in 2 matching blocks. We add the one special block and we get 3\\n # matching blocks per one block of change.\\n if ratio < min_match_ratio and len(matching_blocks) > 3:\\n return ([(0, 0, 0)], ratio)\\n # For now convert to character level blocks because we already have\\n # the code to deal with folding across lines for character blocks.\\n # Create arrays lena an lenb which have cumulative word lengths\\n # corresponding to word positions in a and b\\n lena = []\\n last = 0\\n for w in a:\\n lena.append(last)\\n last += len(w)\\n lenb = []\\n last = 0\\n for w in b:\\n lenb.append(last)\\n last += len(w)\\n lena.append(len(line1))\\n lenb.append(len(line2))\\n # Convert to character blocks\\n blocks = []\\n for s1, s2, blen in matching_blocks[:-1]:\\n apos = lena[s1]\\n bpos = lenb[s2]\\n block_len = lena[s1+blen] - apos\\n blocks.append((apos, bpos, block_len))\\n # Recreate the special block.\\n blocks.append((len(line1), len(line2), 0))\\n # Filter any matching blocks which are smaller than the desired threshold.\\n # We don't remove matching blocks with only a newline character as doing so\\n # results in showing the matching newline character as non matching which\\n # doesn't look good.\\n blocks = FilterBlocks(blocks, lambda b: (b[2] >= min_match_size or\\n line1[b[0]:b[0]+b[2]] == '\\\\n'))\\n return (blocks, ratio)\",\n \"def get_stats_SWE(self, kelly_list, svalex_list, svalex2_list, word_pictures={}, use_deprel=True,use_ngrams=False):\\n s = self.sent\\n root_ref = check_root(s)\\n\\n tokens = []\\n\\n verb_args = {} #{\\\"verb1\\\": {arg1_pos:\\\"PN\\\", arg1_deprel:\\\"SS\\\", etc.},..}\\n self.stats[\\\"finite\\\"] = []\\n self.stats[\\\"heads\\\"] = {}\\n self.stats[\\\"keyword\\\"] = {}\\n self.stats[\\\"has_subject\\\"] = 0\\n self.stats[\\\"used_rel_lemmas\\\"] = [] \\n\\n # Collect the position ('ref') of the dependency head of each token\\n # +1 compared to regular indexes, string type\\n for tkn in s.nodes:\\n if tkn.deprel == \\\"ROOT\\\":\\n put_feature_value_list(self.stats[\\\"heads\\\"], tkn.ref, tkn) #\\\"ROOT\\\"\\n else:\\n put_feature_value_list(self.stats[\\\"heads\\\"], tkn.depheadid, tkn)\\n\\n for i,t in enumerate(s.nodes):\\n\\n mapped_token = map_Token_to_dict(t) #just a fix, see dset_proc_aux.py\\n tokens.append(mapped_token)\\n\\n #get statistics from different liguistic levels\\n self.stats = self.get_len_stats(t)\\n self.stats = self.get_kelly_stats(t, kelly_list)\\n if svalex_list:\\n self.stats = self.get_svalex_stats(t, svalex_list)\\n if svalex2_list:\\n self.stats = self.get_svalex2_stats(t, svalex2_list)\\n self.stats = self.get_semantic_stats(t)\\n self.stats = self.get_morpho_synt_stats(s,t,i)\\n if self.params:\\n self.stats = self.get_sentmatch_stats(t,s.nodes,word_pictures)\\n \\n #add lemma unigrams\\n lm_ngram = get_lemma_ngrams(s, t, i, \\\"uni\\\")\\n if lm_ngram:\\n put_feature_value_list(self.stats,\\\"lemma_unigr\\\", lm_ngram)\\n\\n if use_ngrams: #bi- and trigrams \\n self.stats = get_ngrams(self.stats,s,t,i)\\n\\n if use_deprel:\\n self.stats = self.deprel_stats(t,root_ref, verb_args)\\n\\n #fix for JSON serialization issue with the Token class\\n self.stats[\\\"tokens\\\"] = s.nodes # retain a copy of Token instances\\n s.nodes = tokens # change Token instances to 'dict'-s\\n \\n return self.stats\",\n \"def width_v_l_l(\\n model: SingleRhNeutrinoModel, genv: Generation, genl1: Generation, genl2: Generation\\n):\\n genn = model.gen\\n\\n if genn == genv:\\n return _width_v_l_l(model, genl1)\\n\\n mu = 0.0\\n md = _lepton_masses[genl2]\\n ml = _lepton_masses[genl1]\\n\\n if (genn == genl1) and (genv == genl2):\\n return _width_l_u_d(model, mu, md, ml, 1.0)\\n\\n if (genn == genl2) and (genv == genl1):\\n md, ml = ml, md\\n return _width_l_u_d(model, mu, md, ml, 1.0)\\n\\n return 0.0\",\n \"def get_score(self,sentence_1, sentence_2):\\n\\t return self.DELTA * self.semantic_similarity(sentence_1, sentence_2, True) + (1.0 - self.DELTA) * self.word_order_similarity(sentence_1, sentence_2)\",\n \"def generate_sentence(word1, word2, length, vocab, model):\\n reverse_vocab = {idx: word for word, idx in vocab.items()}\\n output_string = np.zeros((1, length), dtype=np.int)\\n output_string[:, 0: 2] = vocab[word1], vocab[word2]\\n\\n for end in range(2, length):\\n start = end - 2\\n output_string[:, end] = np.argmax(model(output_string[:, start:end]), axis=1)\\n text = [reverse_vocab[i] for i in list(output_string[0])]\\n \\n print(\\\" \\\".join(text))\",\n \"def noun_overlap(t_xml, h_xml, replacements):\\n score = 0\\n if t_xml == None or h_xml == None:\\n return 0\\n t_set = set(get_nouns(t_xml.getroot()))\\n h_set = set(get_nouns(h_xml.getroot()))\\n if float(len(t_set | h_set)) > 0:\\n score = len(t_set & h_set) / float(len(t_set | h_set))\\n \\n for replacement in replacements:\\n if replacement[9] != None and replacement[10] != None:\\n t_set = set(get_nouns(replacement[9].getroot()))\\n h_set = set(get_nouns(replacement[10].getroot()))\\n if float(len(t_set | h_set)) > 0:\\n new_score = len(t_set & h_set) / float(len(t_set | h_set))\\n if new_score > score:\\n score = new_score\\n return score\",\n \"def rouge_l_fscore(predictions, labels):\\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\\n tf.float32)\\n return rouge_l_f_score, tf.constant(1.0)\",\n \"def _l1_similarity(self, sentence_one, sentence_two):\\n with tf.name_scope(\\\"l1_similarity\\\"):\\n # Take the L1 norm of the two vectors.\\n # Shape: (batch_size, 2*rnn_hidden_size)\\n l1_distance = tf.abs(sentence_one - sentence_two)\\n\\n # Take the sum for each sentence pair\\n # Shape: (batch_size, 1)\\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\\n keep_dims=True)\\n\\n # Exponentiate the negative summed L1 distance to get the\\n # positive-class probability.\\n # Shape: (batch_size, 1)\\n positive_class_probs = tf.exp(-summed_l1_distance)\\n\\n # Get the negative class probabilities by subtracting\\n # the positive class probabilities from 1.\\n # Shape: (batch_size, 1)\\n negative_class_probs = 1 - positive_class_probs\\n\\n # Concatenate the positive and negative class probabilities\\n # Shape: (batch_size, 2)\\n class_probabilities = tf.concat([negative_class_probs,\\n positive_class_probs], 1)\\n\\n # if class_probabilities has 0's, then taking the log of it\\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\\n # epsilon and renormalize by the sum of the vector.\\n safe_class_probabilities = class_probabilities + 1e-08\\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\\n axis=1,\\n keep_dims=True)\\n return safe_class_probabilities\",\n \"def _l1_similarity(self, sentence_one, sentence_two):\\n with tf.name_scope(\\\"l1_similarity\\\"):\\n # Take the L1 norm of the two vectors.\\n # Shape: (batch_size, 2*rnn_hidden_size)\\n l1_distance = tf.abs(sentence_one - sentence_two)\\n\\n # Take the sum for each sentence pair\\n # Shape: (batch_size, 1)\\n summed_l1_distance = tf.reduce_sum(l1_distance, axis=1,\\n keep_dims=True)\\n\\n # Exponentiate the negative summed L1 distance to get the\\n # positive-class probability.\\n # Shape: (batch_size, 1)\\n positive_class_probs = tf.exp(-summed_l1_distance)\\n\\n # Get the negative class probabilities by subtracting\\n # the positive class probabilities from 1.\\n # Shape: (batch_size, 1)\\n negative_class_probs = 1 - positive_class_probs\\n\\n # Concatenate the positive and negative class probabilities\\n # Shape: (batch_size, 2)\\n class_probabilities = tf.concat([negative_class_probs,\\n positive_class_probs], 1)\\n\\n # if class_probabilities has 0's, then taking the log of it\\n # (e.g. for cross-entropy loss) will cause NaNs. So we add\\n # epsilon and renormalize by the sum of the vector.\\n safe_class_probabilities = class_probabilities + 1e-08\\n safe_class_probabilities /= tf.reduce_sum(safe_class_probabilities,\\n axis=1,\\n keep_dims=True)\\n return safe_class_probabilities\",\n \"def compute_readability(text):\\n total_words = 0\\n total_sentences = 0\\n total_syllables = 0\\n score = 0\\n\\n words = text.split()\\n total_words = len(text.split()) \\n total_sentences = count_sentences(text)\\n total_syllables = count_syllables(words)\\n \\n score = 206.835 - 1.015 * ( total_words / total_sentences) - 84.6 * (total_syllables / total_words)\\n if score > 90.00:\\n answer = 'Texto de nível do 5º ano do Ensino Fundamental, facilmente compreendido por um aluno de 11 anos.'\\n elif score <= 90.00 and score > 80.00:\\n answer = 'Texto de nível do 6º ano do Ensino Fundamental, inglês coloquial para consumidores.'\\n elif score <= 80.00 and score > 70.00:\\n answer = 'Texto de nível do 7º ano do Ensino Fundamental, razoavelmente fácil de ler.'\\n elif score <= 70.00 and score > 60.00:\\n answer = 'Texto de nível do 9º ano do Ensino Fundamental, Inglês simples compreendido por adolescentes de 13 - 15 anos.'\\n elif score <= 60.00 and score > 50.00:\\n answer = 'Texto de 1º a 3º ano do Ensino Médio, razoavelmente difícil de ler.'\\n elif score <= 50.00 and score > 30.00:\\n answer = 'Texto de nível Universitário, difícil de ler.'\\n else:\\n answer = 'Texto de nível de Graduação, muito difícil de ler e mais bem-compreendido por universitários graduados.'\\n \\n print('Pontuação Total:', score, answer)\",\n \"def generate_analogy(word1, word2, word3, model):\\n LoM = model.most_similar(positive=[word2, word3], negative=[word1], topn=100)\\n return LoM\",\n \"def train():\\n\\tA = collections.defaultdict(dict)\\n\\tB = collections.defaultdict(dict)\\n\\tpos_list = []\\n\\tword_list = []\\n\\tstr_buf = []\\n\\n\\n\\t# read each line and count A and B\\n\\tfor line in sys.stdin:\\n\\t\\tline = line.split()\\n\\t\\t# print(line)\\n\\t\\tif len(line) == 3:\\n\\t\\t\\tstr_buf.append((str(line[0]), str(line[1])))\\n\\t\\t\\tword_list.append(str(line[0]))\\n\\t\\t\\tpos_list.append(str(line[1]))\\n\\n\\t\\telse:\\n\\t\\t\\t# if come to the end of a sentence\\n\\t\\t\\tif len(str_buf) != 0:\\n\\t\\t\\t\\tstr_buf = [('<s>','BOS')] + str_buf + [('</s>', 'EOS')]\\n\\t\\t\\t\\tword_list += ['<s>', '</s>']\\n\\t\\t\\t\\tpos_list += ['BOS', 'EOS']\\n\\n\\t\\t\\t\\tfor i, s in enumerate(str_buf):\\n\\t\\t\\t\\t\\tif s[0] in B[s[1]]:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] += 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tB[s[1]][s[0]] = 1\\n\\n\\t\\t\\t\\t\\tif s[0] != '</s>':\\n\\t\\t\\t\\t\\t\\t# print('strbuf[i]:',str_buf[i], 's[1]', s[1])\\n\\t\\t\\t\\t\\t\\tif str_buf[i+1][1] in A[s[1]]:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tA[s[1]][str_buf[i+1][1]] = 1\\n\\n\\t\\t\\t\\tstr_buf = []\\n\\n\\t# get unique POS list and word list\\n\\tpos_list_uniq = list(set(pos_list))\\n\\tword_list_uniq = list(set(word_list))\\n\\n\\n\\t# assume <UNK>, smoothing, normalize\\n\\tB_sm = collections.defaultdict(dict)\\n\\tA_sm = A.copy()\\n\\n\\t# assume words apeear less than 2 times as <UNK>\\n\\tword_count = collections.Counter(word_list)\\n\\tfor pos in B:\\n\\t\\tfor word in B[pos]:\\n\\t\\t\\tif word_count[word] > 1:\\n\\t\\t\\t\\tB_sm[pos][word] = B[pos][word]\\n\\n\\t\\t\\telse: # add <UNK> to B_sm\\n\\t\\t\\t\\tword_list_uniq.remove(word)\\n\\t\\t\\t\\tif '<UNK>' in B_sm[pos]:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] += 1\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tB_sm[pos]['<UNK>'] = 1\\n\\n\\tword_list_uniq += ['<UNK>']\\n\\n\\t# add 1 smoothing\\n\\tfor pos in pos_list_uniq:\\n\\t\\tfor word in word_list_uniq:\\n\\t\\t\\tif word in B_sm[pos]:\\n\\t\\t\\t\\tB_sm[pos][word] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tB_sm[pos][word] = 1\\n\\n\\tfor prev in pos_list_uniq:\\n\\t\\tfor next in pos_list_uniq:\\n\\t\\t\\tif next in A_sm[prev]:\\n\\t\\t\\t\\tA_sm[prev][next] += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tA_sm[prev][next] = 1\\n\\n\\t# delete instances like A[VB][BOS], A[EOS][VB],\\n\\t# B[VB]['</s>'], B[EOS]['Jack']\\n\\n\\tfor pos in B_sm:\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif (pos == 'BOS' and word != '<s>') or \\\\\\n\\t\\t\\t(pos == 'EOS' and word != '</s>') or \\\\\\n\\t\\t\\t(word == '<s>' and pos != 'BOS') or \\\\\\n\\t\\t\\t(word == '</s>' and pos != 'EOS'):\\n\\t\\t\\t\\tB_sm[pos][word] = 0\\n\\n\\tfor prev in A_sm:\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif prev == 'EOS' or next == 'BOS':\\n\\t\\t\\t\\tA_sm[prev][next] = 0\\n\\n\\t# normalize\\n\\tfor pos in B_sm:\\n\\t\\ts = sum(B_sm[pos].values())\\n\\t\\tfor word in B_sm[pos]:\\n\\t\\t\\tif B_sm[pos][word] != 0:\\n\\t\\t\\t\\tB_sm[pos][word] /= s\\n\\n\\tfor prev in A_sm:\\n\\t\\ts = sum(A_sm[prev].values())\\n\\t\\tfor next in A_sm[prev]:\\n\\t\\t\\tif A_sm[prev][next] != 0:\\n\\t\\t\\t\\tA_sm[prev][next] /= s\\n\\n\\treturn A_sm, B_sm, word_list_uniq\",\n \"def lcmu(a, b):\\n return (abs(a)*abs(b))//gcdi(a, b)\",\n \"def merge_sentences(sentences):\\n full_sentences = []\\n for sentence in sentences:\\n for arr_word in sentence:\\n full_sentences.append(arr_word)\\n return full_sentences\",\n \"def merge_sentences(text: List[str], min_len: int) -> List[str]:\\n\\n def reducer(acc, x):\\n x = x.strip()\\n\\n if acc and (len(nlp(acc[-1])) < min_len):\\n if acc[-1] and (acc[-1][-1]) not in ['.', ':']:\\n acc[-1] += '. {}'.format(x)\\n else:\\n acc[-1] += ' {}'.format(x)\\n return acc\\n else:\\n return acc + [x]\\n\\n new_text = reduce(reducer, text, [])\\n return new_text\",\n \"def lev(w1, w2):\\n\\n if len(w1) < len(w2):\\n # check if length of word1 is smaller than word2.\\n # if so, call function and switch parameters\\n return lev(w2, w1)\\n elif len(w1) == 0:\\n # if the length of word1 equals 0, that means that\\n # the Lev' distance is the length of word2\\n return len(w2)\\n elif len(w2) == 0:\\n # if the length of word2 equals 0, that means that\\n # the Lev' distance is the length of word1\\n return len(w1)\\n elif w1 == w2:\\n # check if words are simply the same\\n return 0\\n\\n # thanks to the check above, we can assume that w2 is the longest word\\n # we use this information to determine the range of 'previous'\\n previous = range(len(w2) + 1)\\n\\n # DEBUG\\n # print(previous)\\n\\n # iterate over the characters of the first word\\n for a, char1 in enumerate(w1):\\n # DEBUG\\n # print(\\\"i -> \\\" + str(a))\\n # print(\\\"char1 -> \\\" + str(char1))\\n\\n current = [a + 1]\\n\\n # iterate over the characters of the second word\\n for b, char2 in enumerate(w2):\\n # DEBUG\\n # print(\\\"j -> \\\" + str(b))\\n # print(\\\"\\\\tchar2 -> \\\" + str(char2))\\n\\n inserts = previous[b + 1] + 1\\n deletions = current[b] + 1\\n subs = previous[b] + (char1 != char2)\\n\\n # DEBUG\\n # print(str(char1 != char2))\\n # print(\\\"INSERTS -> \\\" + str(inserts))\\n # print(\\\"DELS -> \\\" + str(deletions))\\n # print(\\\"SUBS -> \\\" + str(subs))\\n\\n current.append(min(inserts, deletions, subs))\\n\\n # DEBUG\\n # print(\\\"CURRENT -> \\\" + str(current))\\n previous = current\\n\\n return previous[-1]\",\n \"def rocchio_relevance_feedback(query: str, ls_relev: list, ls_irrel: list, weights: tuple = None):\\r\\n text_collection = ls_relev + ls_irrel + [query]\\r\\n len_relev, len_irrel = len(ls_relev), len(ls_irrel)\\r\\n\\r\\n if weights is None:\\r\\n weights = (1, 0.75, 0.15)\\r\\n a, b, c = weights\\r\\n\\r\\n vectorizer = TfidfVectorizer(stop_words='english', token_pattern=r'[a-zA-Z]{3,}')\\r\\n vectorizer.fit(text_collection)\\r\\n\\r\\n vec_query = vectorizer.transform([query]).todense()\\r\\n\\r\\n if len_relev == 0:\\r\\n term_relev = 0\\r\\n else:\\r\\n mat_relev = vectorizer.transform(ls_relev).todense()\\r\\n vec_relev = mat_relev.sum(axis=0)\\r\\n term_relev = vec_relev / len_relev\\r\\n\\r\\n if len_irrel == 0:\\r\\n term_irrel = 0\\r\\n else:\\r\\n mat_irrel = vectorizer.transform(ls_irrel).todense()\\r\\n vec_irrel = mat_irrel.sum(axis=0)\\r\\n term_irrel = vec_irrel / len_irrel\\r\\n\\r\\n vec_new = a * vec_query + b * term_relev - c * term_irrel\\r\\n\\r\\n tokens = vectorizer.get_feature_names()\\r\\n weights = np.asarray(vec_new).reshape(-1)\\r\\n\\r\\n return dict(zip(tokens, weights))\",\n \"def word_overlap3(t_raw, h_raw, replacements):\\n t_set = set(word for word in t_raw) - config.stop_list\\n h_set = set(word for word in h_raw) - config.stop_list\\n score = len(t_set & h_set) / float(len(t_set|h_set)) \\n highestscore = 0\\n\\n for replacement in replacements:\\n t_set = set(word for word in replacement[2]) - config.stop_list # replacement[1] = t_raw\\n h_set = set(word for word in replacement[3]) - config.stop_list # replacement[2] = h_raw\\n newScore = len(t_set & h_set) / float(len(t_set|h_set))\\n if newScore > highestscore:\\n highestscore = newScore\\n return (score + highestscore) /2\",\n \"def _recon_lcs(x, y):\\n i, j = len(x), len(y)\\n table = _lcs(x, y)\\n\\n def _recon(i, j):\\n \\\"\\\"\\\"private recon calculation\\\"\\\"\\\"\\n if i == 0 or j == 0:\\n return []\\n elif x[i - 1] == y[j - 1]:\\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\\n elif table[i - 1, j] > table[i, j - 1]:\\n return _recon(i - 1, j)\\n else:\\n return _recon(i, j - 1)\\n\\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\\n return recon_tuple\",\n \"def sentences(a, b):\\n # Tokenize has the ability to separate, in this case, sentences by finding relevant symbols (.,!,?,etc) in text\\n aS1 = set(sent_tokenize(a))\\n bS1 = set(sent_tokenize(b))\\n\\n return aS1 & bS1\",\n \"def compare_texts(text1, text2):\\n return compare_vectors(vectorize_text(text1), vectorize_text(text2))\",\n \"def rouge_n(evaluated_sentences, reference_sentences, n=2):\\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\\n raise ValueError(\\\"Collections must contain at least 1 sentence.\\\")\\n\\n evaluated_ngrams = _get_word_ngrams(n, evaluated_sentences)\\n reference_ngrams = _get_word_ngrams(n, reference_sentences)\\n reference_count = len(reference_ngrams)\\n evaluated_count = len(evaluated_ngrams)\\n\\n # Gets the overlapping ngrams between evaluated and reference\\n overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams)\\n overlapping_count = len(overlapping_ngrams)\\n\\n # Handle edge case. This isn't mathematically correct, but it's good enough\\n if evaluated_count == 0:\\n precision = 0.0\\n else:\\n precision = overlapping_count / evaluated_count\\n\\n if reference_count == 0:\\n recall = 0.0\\n else:\\n recall = overlapping_count / reference_count\\n\\n f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8))\\n\\n # return overlapping_count / reference_count\\n return f1_score, precision, recall\",\n \"def sentence_similarity(self,sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n\\n # Get the synsets for the tagged words\\n synsets1 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [self.tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n\\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n\\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n vals = [synset.path_similarity(ss) if synset.path_similarity(ss) is not None else 0 for ss in synsets2]\\n best_score = max(vals,default=0)\\n\\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n # Average the values\\n if count == 0:\\n return 0\\n score /= count\\n return score\",\n \"def main():\\n parser = argparse.ArgumentParser(description=main.__doc__)\\n parser.add_argument('smooth', type=float, help='amount of Lidstone smoothing to apply')\\n parser.add_argument('mincount', type=int, help='minimum count in either language for a word')\\n parser.add_argument('wordlist1', help='first wordlist file, in UTF-8 format')\\n parser.add_argument('wordlist2', help='second wordlist file, in UTF-8 format')\\n args = parser.parse_args()\\n\\n # Get file or stdin input as utf-8\\n infile1 = codecs.open(args.wordlist1, 'Ur', 'utf_8') \\n infile2 = codecs.open(args.wordlist2, 'Ur', 'utf_8') \\n\\n # Compute ratio\\n ratios, counts1, counts2 = wordlist_ratio(infile1, infile2, args.smooth, args.mincount)\\n\\n # Output\\n output_ratios(sorted(ratios.items(), key=itemgetter(1)), counts1, counts2, \\n codecs.getwriter('utf-8')(sys.stdout))\",\n \"def sentence_similarity_asym(sentence1, sentence2):\\n # Tokenize and tag\\n sentence1 = pos_tag(word_tokenize(sentence1))\\n sentence2 = pos_tag(word_tokenize(sentence2))\\n \\n # Get the synsets for the tagged words\\n synsets1 = [tagged_to_synset(*tagged_word) for tagged_word in sentence1]\\n synsets2 = [tagged_to_synset(*tagged_word) for tagged_word in sentence2]\\n \\n # Filter out the Nones\\n synsets1 = [ss for ss in synsets1 if ss]\\n synsets2 = [ss for ss in synsets2 if ss]\\n \\n score, count = 0.0, 0\\n\\n # For each word in the first sentence\\n for synset in synsets1:\\n # Get the similarity value of the most similar word in the other sentence\\n pathsim = [synset.path_similarity(ss) for ss in synsets2]\\n if len(pathsim) == 0:\\n #print sentence1, sentence2\\n pathsim = [0]\\n best_score = max(pathsim)\\n \\n # Check that the similarity could have been computed\\n if best_score is not None:\\n score += best_score\\n count += 1\\n\\n if count == 0:\\n return 0\\n # Average the values\\n score /= count\\n return score\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6562477","0.6535288","0.6080566","0.6073384","0.5944744","0.5769236","0.57410604","0.56901485","0.5615614","0.556189","0.55066365","0.55035615","0.5495382","0.54569256","0.54294115","0.54145795","0.5409134","0.5398293","0.5385837","0.5370661","0.5333738","0.5332729","0.53162956","0.5306324","0.528914","0.5272849","0.52706444","0.5268327","0.52548164","0.524789","0.52455556","0.5228623","0.522164","0.52153385","0.5208683","0.52077645","0.5197268","0.5189396","0.51870126","0.5175704","0.5164719","0.5161573","0.51523757","0.5143352","0.51184505","0.51169795","0.511638","0.51151556","0.5114233","0.51120204","0.51116484","0.5101527","0.5096253","0.5095814","0.5093926","0.5080522","0.5079004","0.50657964","0.50352013","0.5029724","0.50264394","0.5025653","0.50165415","0.50122416","0.50105035","0.5009496","0.5008677","0.50077397","0.4993739","0.4983151","0.4976409","0.49732965","0.49691832","0.4964926","0.4963346","0.4961648","0.49531475","0.49483702","0.49474284","0.49310386","0.49272484","0.49254322","0.49246085","0.49246085","0.49242193","0.49187237","0.49155456","0.4908279","0.49030247","0.49005088","0.48791394","0.48742616","0.4872043","0.48668995","0.48658094","0.48629898","0.48623335","0.48603612","0.48574713","0.48572308"],"string":"[\n \"0.6562477\",\n \"0.6535288\",\n \"0.6080566\",\n \"0.6073384\",\n \"0.5944744\",\n \"0.5769236\",\n \"0.57410604\",\n \"0.56901485\",\n \"0.5615614\",\n \"0.556189\",\n \"0.55066365\",\n \"0.55035615\",\n \"0.5495382\",\n \"0.54569256\",\n \"0.54294115\",\n \"0.54145795\",\n \"0.5409134\",\n \"0.5398293\",\n \"0.5385837\",\n \"0.5370661\",\n \"0.5333738\",\n \"0.5332729\",\n \"0.53162956\",\n \"0.5306324\",\n \"0.528914\",\n \"0.5272849\",\n \"0.52706444\",\n \"0.5268327\",\n \"0.52548164\",\n \"0.524789\",\n \"0.52455556\",\n \"0.5228623\",\n \"0.522164\",\n \"0.52153385\",\n \"0.5208683\",\n \"0.52077645\",\n \"0.5197268\",\n \"0.5189396\",\n \"0.51870126\",\n \"0.5175704\",\n \"0.5164719\",\n \"0.5161573\",\n \"0.51523757\",\n \"0.5143352\",\n \"0.51184505\",\n \"0.51169795\",\n \"0.511638\",\n \"0.51151556\",\n \"0.5114233\",\n \"0.51120204\",\n \"0.51116484\",\n \"0.5101527\",\n \"0.5096253\",\n \"0.5095814\",\n \"0.5093926\",\n \"0.5080522\",\n \"0.5079004\",\n \"0.50657964\",\n \"0.50352013\",\n \"0.5029724\",\n \"0.50264394\",\n \"0.5025653\",\n \"0.50165415\",\n \"0.50122416\",\n \"0.50105035\",\n \"0.5009496\",\n \"0.5008677\",\n \"0.50077397\",\n \"0.4993739\",\n \"0.4983151\",\n \"0.4976409\",\n \"0.49732965\",\n \"0.49691832\",\n \"0.4964926\",\n \"0.4963346\",\n \"0.4961648\",\n \"0.49531475\",\n \"0.49483702\",\n \"0.49474284\",\n \"0.49310386\",\n \"0.49272484\",\n \"0.49254322\",\n \"0.49246085\",\n \"0.49246085\",\n \"0.49242193\",\n \"0.49187237\",\n \"0.49155456\",\n \"0.4908279\",\n \"0.49030247\",\n \"0.49005088\",\n \"0.48791394\",\n \"0.48742616\",\n \"0.4872043\",\n \"0.48668995\",\n \"0.48658094\",\n \"0.48629898\",\n \"0.48623335\",\n \"0.48603612\",\n \"0.48574713\",\n \"0.48572308\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66352373"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85173,"cells":{"query":{"kind":"string","value":"Returns the length of the Longest Common Subsequence between two seqs."},"document":{"kind":"string","value":"def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]"},"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 longestCommonSubsequence(self, text1: str, text2: str) -> int:\n if len(text1) == 0 or len(text2) == 0:\n return 0\n if text1[0] == text2[0]:\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\n else:\n return max(self.longestCommonSubsequence(text1[1:], text2),\n self.longestCommonSubsequence(text1, text2[1:]))","def _lcs_len(a, b):\n dp = _lcs_dp(a, b)\n return dp[-1][-1]","def lcs_len(x, y):\r\n \r\n if len(x) == 0 or len(y) == 0:\r\n return 0\r\n \r\n xx = x[:-1] # xx = sequence x without its last element \r\n yy = y[:-1]\r\n \r\n if x[-1] == y[-1]: # if last elements of x and y are equal\r\n return lcs_len(xx, yy) + 1\r\n else:\r\n return max(lcs_len(xx, y), lcs_len(x, yy))","def longest_common_subsequence(seq1, seq2):\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\n mat.fill()\n\n lcs = []\n augSeq1, augSeq2 = mat.augmented_sequences()\n for c1, c2 in zip(augSeq1, augSeq2):\n if c1 == c2:\n lcs.append(c1)\n\n return ''.join(lcs)","def lcs_length(s1, s2):\n n = len(s1)\n m = len(s2)\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\n for i in xrange(1, n+1):\n for j in xrange(1, m+1):\n if(s1[i-1]==s2[j-1]):\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\n return matrix[n][m]","def LCS_length(str1, str2):\n if str1 is None or str2 is None:\n return 0\n\n len1 = len(str1)\n len2 = len(str2)\n if len1 == 0 or len2 == 0:\n return 0\n\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\n for i in range(1, len1 + 1):\n for j in range(1, len2 + 1):\n if str1[i - 1] == str2[j - 1]:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\n else:\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\n lcs[i % 2][j] = lcs[i % 2][j - 1]\n else:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\n\n return lcs[len1 % 2][-1]","def longest_common_subsequence(x, y):\n\n # find the length of the strings\n m = len(x)\n n = len(y)\n\n # declaring the array for storing the dp values\n lcs = np.zeros((m + 1, n + 1))\n\n # iterate through each sub problem\n for i in range(m + 1):\n for j in range(n + 1):\n if i == 0 or j == 0:\n lcs[i, j] = 0\n elif x[i - 1] == y[j - 1]:\n lcs[i, j] = lcs[i - 1, j - 1] + 1\n else:\n # use the optimal substructure property\n # of using already computed results previous subproblems\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\n\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\n return lcs[m, n]","def longest_subsequence(s1: str, s2: str, s3: str) -> int:\n # Find the shortest string\n s = min(s1, s2, s3, key=lambda x: len(x))\n total = 0\n ok = False\n while s1:\n for i1, c1 in enumerate(s1):\n for i2, c2 in enumerate(s2):\n if ok:\n ok = False\n break\n if c1 == c2:\n for i3, c3 in enumerate(s3):\n if c1 == c3:\n total += 1\n s1 = s1[i1 + 1:]\n s2 = s2[i2 + 1:]\n s3 = s3[i3 + 1:]\n ok = True\n break\n\n return total","def lcs(s1, s2):\n\n shape = (len(s1) + 1, len(s2) + 1)\n M = np.zeros(shape)\n\n max_length_so_far = 0\n candidates = set()\n\n for i in range(len(s1)):\n for j in range(len(s2)):\n\n if s1[i] == s2[j]:\n M[i+1,j+1] = M[i,j] + 1\n\n if M[i+1,j+1] > max_length_so_far:\n max_length_so_far = int(M[i+1,j+1])\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\n\n elif M[i+1,j+1] == max_length_so_far:\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\n\n else:\n M[i,j] = 0\n\n candidates.add('')\n\n return candidates","def contig_complementary_score(s1, s2) -> int:\n matcher = SequenceMatcher()\n matcher.set_seq1(str(s1))\n matcher.set_seq2(str(s2.complement()))\n _, _, size = matcher.find_longest_match(0, len(s1), 0, len(s2))\n return size","def lengthOfLongestSubstringTwoDistinct(self, s):\n if not s:\n return 0\n\n counters = collections.Counter()\n\n start = end = 0\n max_len = -1\n char_count = 0\n while end < len(s):\n if counters[s[end]] == 0:\n char_count += 1\n counters[s[end]] += 1\n\n while char_count > 2:\n counters[s[start]] -= 1\n if counters[s[start]] == 0:\n char_count -= 1\n start += 1\n\n if max_len < end - start + 1:\n max_len = end - start + 1\n\n return max_len","def longest_common_substring_backtrack(s1, s2, i, j, count):\n if i == len(s1) or j == len(s2):\n return 0\n\n if s1[i-1] == s2[j-1]:\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\n\n else:\n count = max(count,\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\n\n return count","def findLongestCommonSubstring(self, string1, string2):\n countingArray = [[0]*len(string2) for i in range(len(string1))]\n ##we set up an array to locate the possible substrings\n lcss = \"\"\n for row in range(len(countingArray)):\n for column in range(len(countingArray[row])):\n if string1[row] == string2[column]:\n countingArray[row][column] += 1 ##if there's a match the common string length is at least 1\n if not (row == 0 or column == 0):\n countingArray[row][column] += countingArray[row-1][column-1] ##memoize the length of the common string so far\n if countingArray[row][column] > longestLength: ##if it's longer than our current longest string, we'll plan on returning it\n longestLength = countingArray[row][column]\n lcss = string1[row-longestLength+1:row+1]\n return lcss","def longest_common_substring_bottom_up(s1, s2):\n lcs_array = lcs(s1, s2)\n n = len(s1)\n m = len(s2)\n l = lcs_array[n][m]\n result = \"\"\n while l != 0:\n if s1[n - 1] == s2[m - 1]:\n result = s1[n - 1] + result\n l -= 1\n n -= 1\n m -= 1\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\n m -= 1\n else:\n n -= 1\n return result","def lcs_similarity(s1, s2):\n max_len = 0\n i = 0\n\n while s1[i] == s2[i]:\n max_len += 1\n i += 1\n if len(s1) == i or len(s2) == i:\n break\n\n if len(s1) < len(s2):\n return float(max_len) / len(s2)\n else:\n return float(max_len) / len(s1)","def longest(s1, s2):\n return ''.join(sorted(set(s1+s2)))","def commonlen(s1, s2):\n # given \"hi\", \"hip\"\n # izip_longest(\"hi\", \"hip\") -> ('h','h'), ('i','i'), (None, 'p')\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\n try:\n return itertools.dropwhile(\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\n except StopIteration:\n # strings are identical return the len of one of them\n return len(s1)","def overlap_len(range1, range2):\n return min(range1[1], range2[1]) - max(range1[0], range2[0])","def _common_prefix(sequence1, sequence2):\n i = 0\n for elem1, elem2 in zip(sequence1, sequence2):\n if elem1 != elem2:\n return i\n i += 1\n\n # Return length of sequence if sequences are identical\n return min(len(sequence1), len(sequence2))","def m_longest_common_subsequence_2(s):\n\n # Correct me if I'm wrong but I think unsorted list is faster\n lst = list(s)\n\n lcs = lst[0]\n for string in lst[1:]:\n lcs = LCS(lcs, string)\n\n return lcs","def lcs(a, b):\n # This is an adaptation of the standard LCS dynamic programming algorithm\n # tweaked for lower memory consumption.\n # Sequence a is laid out along the rows, b along the columns.\n # Minimize number of columns to minimize required memory\n if len(a) < len(b):\n a, b = b, a\n # Sequence b now has the minimum length\n # Quit early if one sequence is empty\n if len(b) == 0:\n return 0\n # Use a single buffer to store the counts for the current row, and\n # overwrite it on each pass\n row = [0] * len(b)\n for ai in a:\n left = 0\n diag = 0\n for j, bj in enumerate(b):\n up = row[j]\n if ai == bj:\n value = diag + 1\n else:\n value = max(left, up)\n row[j] = value\n left = value\n diag = up\n # Return the last cell of the last row\n return left","def getCommon(self, st1, st2):\n fl = len(st1)\n shorter = len(st2)\n if fl < shorter:\n shorter = fl\n \n i = 0\n while i < shorter:\n if st1[i] != st2[i]:\n break\n i += 1\n return i","def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]","def real_overlap(from_sequence, to_sequence):\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\n start = 0\n start_pos_from = -1\n start_pos_to = -1\n size = -1\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\n len(from_sequence), 0, len(to_sequence))\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\n start = start_pos_from+1\n\n return size","def _lcs_dp(a, b):\n dp = [[0 for _ in range(0, len(b) + 1)]\n for _ in range(0, len(a) + 1)]\n # dp[i][j]: lcs_len(a[:i], b[:j])\n for i in range(1, len(a) + 1):\n for j in range(1, len(b) + 1):\n if a[i - 1] == b[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp","def longest_common_substring_iterative_bottom_up(s1, s2):\n\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\n\n for i in range(1, len(s1)+1):\n for j in range(1, len(s2)+1):\n\n if s1[i-1] == s2[j-1]:\n\n # previous count is cache[i-1][j-1]\n cache[i][j] = cache[i-1][j-1] + 1\n else:\n cache[i][j] = max(cache[i-1][j-1],\n max(cache[i-1][j],\n cache[i][j-1]))\n\n return cache[-1][-1]","def get_seq_overlap(seq1, seq2):\n\n overlap = 0\n for i in range(len(seq1)):\n if seq1[i] != \"-\" and seq2[i] != \"-\":\n overlap += 1\n\n return overlap","def sentence_lengths(sentence_a, sentence_b):\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))","def _get_overlap(word1, word2):\n max_overlap = min(len(word1), len(word2))\n max_found = 0\n for size in range(1, max_overlap+1):\n suffix = word1[-size:]\n prefix = word2[:size]\n if suffix == prefix:\n max_found = size\n return max_found","def common(s1, s2):\n cl = commonlen(s1, s2)\n return s2[:cl]","def levenshtein(seq1: str, seq2: str) -> int:\n if seq1 == \"\":\n return len(seq2)\n if seq2 == \"\":\n return len(seq1)\n if seq1[-1] == seq2[-1]:\n cost = 0\n else:\n cost = 1\n \n result = min([levenshtein(seq1[:-1], seq2) + 1,\n levenshtein(seq1, seq2[:-1]) + 1,\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\n return result","def compare_eq_len(a, b):\n n = len(a)\n m = len(b)\n\n # slide b across a from left to right till from just overlapping till full overlap\n overlap = 0 # stores length of the overlap\n lconcat = \"\" # this stores the shortest common superstring\n for j in range(m):\n starta = 0\n enda = j+1\n startb = m - (j+1)\n endb = m\n if a[starta:enda] == b[startb:endb]:\n # if an overlap is found, check if it is larger than the previously detected one\n # print(\"overlap found\")\n if len(a[starta:enda]) > overlap: \n overlap = len(a[starta:enda]) \n lconcat = b + a[enda:] # this is the current shortest common superstring\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # print(\"-\")\n\n # slide b across a so that b starts from one element past a after full overlap\n rconcat = \"\"\n for j in range(m-1):\n starta = j+1\n enda = m\n startb = 0\n endb = m - (j+1)\n if a[starta:enda] == b[startb:endb]:\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \n # print(\"overlap found\")\n overlap = len(a[starta:enda]) \n rconcat = a + b[endb:]\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # after checking for overlaps there may be 1 or no shortest common\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\n # or the concatenation of a and b if there are no overlaps. We may have to make some\n # arbitrary choices here.\n\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\n superstring = lconcat \n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\n superstring = rconcat\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\n superstring = lconcat\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\n superstring = rconcat\n return superstring","def _common_length_of(l1, l2=None, l3=None):\n args = [];\n if l1 != None: args.append(l1)\n if l2 != None: args.append(l2)\n if l3 != None: args.append(l3)\n\n length = None\n num = 0\n for l in args:\n for i in l:\n num += 1\n length_i = len(i)\n if length!=None and length_i!=length:\n raise ValueError, \"Argument lengths differ!\"\n length = length_i\n\n return num, length","def longest_shared_between(cls, seq_1, seq_2):\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\n condition = lambda n, c, p: 'B' not in c.seq_ids\n out = lambda n, c, p: p + n.label\n unshared = tree.root.bfs_paths(condition, out)\n shortest = next(unshared)\n common = [shortest]\n for possible in unshared:\n if len(possible) > len(shortest) and not possible[-1] == '$':\n shortest = possible\n common = [possible]\n elif len(possible) == len(shortest) and not possible[-1] == '$':\n common.append(possible)\n return min(common)","def get_length_of_longest_sub_array(l):\n if len(l) < 1:\n return 0\n\n longest_seen_sequence = 0\n\n this_sequence_length = 1\n\n previous = l[0]\n\n for _, current in enumerate(l):\n\n if current > previous:\n this_sequence_length = this_sequence_length + 1\n\n if this_sequence_length > longest_seen_sequence:\n longest_seen_sequence = this_sequence_length\n\n else:\n this_sequence_length = 1\n\n if this_sequence_length > longest_seen_sequence:\n longest_seen_sequence = this_sequence_length\n\n previous = current\n\n return longest_seen_sequence","def lungime_multimi(multime_1, multime_2):\n if len(multime_1) < len(multime_2):\n return len(multime_1)\n else:\n return len(multime_2)","def common_prefix_length(s, u):\n length = 0\n for cs, cu in zip(s, u):\n if cs != cu:\n break\n length += 1\n return length","def overlap(s1, s2):\n for i in range(min(len(s1), len(s2)), 0, -1):\n if s1.endswith(s2[:i]):\n return i\n return 0","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def compare_str(seq1, seq2):\n if seq1 == seq2:\n return 1\n ld = Levenshtein.distance(seq1, seq2)\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\n return (longest - ld) / longest","def length(a, b):\n return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]))","def LPSubsequenceLength(str):\n return len(LPSubsequence(str))","def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:\n counts = Counter(val for arr in arrays for val in arr)\n res = []\n for val, count in counts.items():\n if count == len(arrays): res.append(val)\n return res","def longest_common_prefix(fst: str, snd: str) -> str:\n bound = 0\n for a, b in zip(fst, snd):\n if a != b:\n break\n bound += 1\n return fst[:bound]","def findLongestCommonSubstringManyStrings(listOfStrings):","def commonCharacterCount(s1, s2):\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))","def overlap(s1, s2):\n j = len(s2) - 1\n while j >= 0 and not s1.endswith(s2[:j + 1]):\n j -= 1\n return j","def longest_common_substring_memoization(s1, s2, i, j, count, cache):\n\n if i == len(s1) or j == len(s2):\n return 0\n\n if cache[i][j] != -1:\n return cache[i][j]\n\n if s1[i-1] == s2[j-1]:\n count = 1 + longest_common_substring_memoization(s1, s2, i+1, j+1, count, cache)\n\n else:\n count = max(count,\n max(longest_common_substring_memoization(s1, s2, i+1, j, count, cache),\n longest_common_substring_memoization(s1, s2, i, j+1, count, cache)))\n\n cache[i][j] = count\n return cache[i][j]","def longest_ORF(dna):\n both_strings=find_all_ORFs_both_strands(dna)\n L=max(both_strings,key=len)\n Q=len(L)\n return Q\n\n #save out put of find all orfboth string to some variable","def count_padding_bases(seq1, seq2):\n if len(seq1) <= len(seq2):\n shorter, longer = seq1, seq2\n else:\n shorter, longer = seq2, seq1\n\n n = 0\n for base1, base2 in zip(shorter, longer[: len(shorter)]):\n if base1 == base2:\n n += 1\n else:\n break\n\n return n","def common_prefix_len(self, other: \"ProofPath\") -> int:\n if self.start() == other.start():\n return self.match_len(other, self.start())\n\n return 0","def string_distance(s1, s2):\n if len(s1) != len(s2):\n return 1\n diff_count = 0\n for c1, c2, in zip(s1, s2):\n if c1 != c2:\n diff_count += 1\n return diff_count","def find_lcs(l1: str, l2: str, length1: int, length2: int):\n \"\"\" Theorem:{\n Initialize matrix with 0 for first row and colm\n If s1[i] = s2[j], update matrix[i][j] with value\n of matrix[i-1][j-1]+1\n Else update matrix[i][j] with max of value among\n matrix[i][j-1],matrix[i-1][j]\n Matrix[n][m] will be lcs\n }\n \"\"\"\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\n for i in range(0, length2+1):\n for j in range(0, length1+1):\n if i == 0 or j == 0:\n matrix[i][j] = 0\n elif l1[j-1] == l2[i-1]:\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\n lcs = [None for i in range(0, matrix[length2][length1])]\n index = matrix[length2][length1]\n m = length2 \n n = length1\n while(m > -1 and n > -1):\n if l2[m-1] == l1[n-1]:\n lcs[index-1] = l2[m-1]\n index -= 1\n m -= 1\n n -= 1\n elif matrix[m-1][n] > matrix[m][n-1]:\n m -= 1\n else:\n n -= 1\n return lcs","def _getLongestLength(self, listOfLists):\n\t\tmax = -1\n\t\tfor list in listOfLists:\n\t\t\tif len(list) > max:\n\t\t\t\tmax = len(list)\n\t\treturn max","def find_largest_overlaps(string_one, string_two):\n two_overlaps_suffix_one = overlap(string_one, string_two)\n one_overlaps_suffix_two = overlap(string_two, string_one)\n\n return two_overlaps_suffix_one, one_overlaps_suffix_two","def _find_common_tail(self, l1, l2):\n i = -1\n try:\n while l1[i] == l2[i]:\n i -= 1\n except IndexError:\n # One list is the tail of the other\n pass\n # i now gives the last differing element\n assert i < -1\n return i+1","def lengthOfLongestSubstring(s):\n arr = [1] * len(s)\n i = 0\n j = 1\n while j < len(s):\n if s[j] not in s[i:j]:\n arr[i] += 1\n j = j + 1\n else:\n i = i + 1\n j = i + 1\n return max(arr)","def lengthOfLongestSubstring(self, s):\n longest = 0\n i = 0\n j = 0\n n = len(s)\n seen = {}\n while i < n and j < n:\n c = s[j]\n if c in seen:\n i = seen[c] + 1\n seen[c] = j\n j += 1\n longest = max(longest, j-i)\n\n return longest","def find_LCS(seq1, seq2, all=False):\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\n\n for i in range(1, len(seq1) + 1):\n for j in range(1, len(seq2) + 1):\n inter = seq1[i - 1].intersection(seq2[j - 1])\n\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\n C[i - 1][j],\n C[i][j - 1]])\n\n # now we need to backtrack the structure to get the pattern\n if all:\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\n return {i[1:] for i in all_lcs}\n\n lcs = []\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\n return lcs","def overlap(a, b, min_length=3):\n start = 0 # start all the way at the left\n\n while True:\n start = a.find(b[:min_length], start) # look for b's suffix i a\n if start == -1: # no more occurrences to right\n return 0\n # found occurrence; check for full suffix/prefix match\n if b.startswith(a[start:]):\n return len(a) - start\n start += 1 # move just paat previous match","def length_aln_on_sequence(start, end):\n return end - start + 1","def common_suffix(s1, s2):\n if not s1 or not s2:\n return None\n # revert the seqs and get a common prefix\n common = common_prefix(s1[::-1], s2[::-1])\n # revert back\n if common:\n return common[::-1]\n else:\n return common","def lcs(s1, s2):\n n = len(s1)\n m = len(s2)\n # initialise 2d array with size n+1 x m+1\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\n # build array of LCS counters\n for i in range(n + 1):\n for j in range(m + 1):\n if i == 0 or j == 0:\n lcs_array[i][j] = 0\n elif s1[i - 1] == s2[j - 1]:\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\n else:\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\n return lcs_array","def common_token_len(self, w1, d1, w2, d2):\n w1_tk = set(self.__stem_Tokens(w1))\n w2_tk = set(self.__stem_Tokens(w2))\n common_len = len(w1_tk.intersection(w2_tk))\n return common_len","def longest_common_prefix(strings: list):\n raise NotImplemented","def overlap(a, b, min_length=3):\r\n start = 0 # start all the way at the left\r\n while True:\r\n start = a.find(b[:min_length], start) # look for b's prefix in a\r\n if start == -1: # no more occurrences to right\r\n return 0\r\n # found occurrence; check for full suffix/prefix match\r\n if b.startswith(a[start:]):\r\n return len(a)-start\r\n start += 1 # move just past previous match\r","def longestPalindromeSubseq(self, s: str) -> int:\n n = len(s)\n dp = [[1] * n for _ in range(n)]\n for length in range(1, n + 1):\n for i in range(n - length + 1):\n j = i + length - 1\n print(i, j)\n if length == 1:\n dp[i][j] = 1\n elif s[i] == s[j]:\n dp[i][j] = dp[i + 1][j - 1] + 2\n else:\n dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])\n return dp[0][n - 1]","def lcs_dp(strA, strB):\n rows = len(strA) + 1\n cols = len(strB) + 1\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\n\n for row in range(1, rows):\n for col in range(1, cols):\n if strA[row - 1] == strB[col - 1]:\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\n else:\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\n return dp_table[rows-1][cols-1]","def longest_word_length(words):","def overlap(string_one: str, string_two: str):\n len_s_one = len(string_one)\n len_s_two = len(string_two)\n\n # Content of the tuple => (start_index, stop_index, string from start_index to stop_index)\n largest_overlap = {\"suffix_string\": string_one,\n \"prefix_string\": string_two,\n \"overlap\": None,\n \"weight\": 0}\n len_overlap = 0\n # Iterate over every suffix from string one from right to left\n for i in range(len_s_one, 0, -1):\n # Current suffix from string one\n current_suffix_one = string_one[i - 1:len_s_one]\n\n # Iterate over every prefix of string two from left to right\n for j in range(len_s_two + 1):\n current_prefix_two = string_two[:j]\n if current_suffix_one == current_prefix_two:\n tmp_len = len(current_prefix_two)\n if tmp_len > len_overlap:\n len_overlap = tmp_len\n\n largest_overlap[\"suffix_start\"] = i - 1\n largest_overlap[\"suffix_end\"] = len_s_one\n\n largest_overlap[\"prefix_start\"] = 0\n largest_overlap[\"prefix_end\"] = j\n\n largest_overlap[\"weight\"] = tmp_len\n largest_overlap[\"overlap\"] = current_suffix_one\n return largest_overlap","def length_of_longest_substring(s):\n def compare():\n return max(cur_length, longest_substring)\n\n longest_substring = 0\n cur_substring = \"\"\n for c in s:\n if c in cur_substring:\n cur_length = len(cur_substring)\n longest_substring = compare()\n cur_substring = c\n else:\n cur_substring += c\n return compare()","def fn(i1, i2):\n if i1 == len(word1): return len(word2) - i2\n if i2 == len(word2): return len(word1) - i1\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))","def calc_length(self):\n return AtomMath.length(self.atom1.position - self.atom2.position)","def commonality(left_struc, right_struc):\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\n assert left_struc and right_struc, (left_struc, right_struc)\n if type(left_struc) is dict:\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\n com = float(len(overlap))\n tot = len(overlap.union(left, right))\n else:\n assert type(left_struc) in (list, tuple), left_struc\n com = 0.0\n for elem in left_struc:\n if elem in right_struc:\n com += 1\n tot = max(len(left_struc), len(right_struc))\n\n return com / tot","def _sequence_overlap(seq1: Sequence, seq2: Sequence):\n diff = SequenceMatcher(None, seq1, seq2)\n # Drop last matching block, since this is always a dummy entry, with length=1.\n return diff.get_matching_blocks()[:-1]","def longestAwesome(self, s: str) -> int:\n\n # So we are moving right, and reducing length by 1\n # for every time we move right - we start from the longest substring that can be formed to lowest one\n # So the moment, we find something we can instantly breal\n\n max_length = 0\n\n if s == s[::-1]:\n return len(s)\n\n for i in range(0, len(s)):\n left = i\n right = len(s)\n\n if right - left > max_length:\n\n while right > left:\n\n candidate = s[left:right]\n # print(f\"The candidate is: {candidate}\")\n ctr = Counter(candidate)\n\n # initial base check\n odd_cnt = 0\n fl = False\n for k, v in ctr.items():\n if v & 1:\n odd_cnt += 1\n if odd_cnt > 1:\n fl = True\n break\n\n if not fl:\n if max_length < (right - left):\n max_length = right - left\n # max_length = max(max_length, len(candidate))\n\n right -= 1\n\n return max_length","def complementary_score(s1, s2) -> int:\n aligner = Align.PairwiseAligner()\n aligner.mode = 'local'\n aligner.open_gap_score = -1000 # Don't want any gaps!\n # score = the number of complementary nucleotides between s1 and s2.\n return aligner.score(str(s1), str(s2.complement()))","def longest_sequence(start=1, end=1000000):\n\n max_length = 0\n max_start_value = 0\n\n # generate sequence for each value\n for i in range(start, end):\n current = generate_sequence(i)\n\n # if the current sequence is the longest, update values\n if len(current) > max_length:\n max_length = len(current)\n max_start_value = i\n\n return max_length, max_start_value","def _matched_len(self, string, idx1, idx2):\n\n str_len = len(string)\n if idx1 == idx2:\n return str_len - idx1\n counter = 0\n while idx1 < str_len and idx2 < str_len and string[idx1] == string[idx2]:\n counter += 1\n idx1 += 1\n idx2 += 1\n\n return counter","def length_dist(self,synset_1, synset_2):\n\t l_dist = sys.maxsize\n\t if synset_1 is None or synset_2 is None: \n\t return 0.0\n\t if synset_1 == synset_2:\n\t # if synset_1 and synset_2 are the same synset return 0\n\t l_dist = 0.0\n\t else:\n\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \n\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\n\t if len(wset_1.intersection(wset_2)) > 0:\n\t # if synset_1 != synset_2 but there is word overlap, return 1.0\n\t l_dist = 1.0\n\t else:\n\t # just compute the shortest path between the two\n\t l_dist = synset_1.shortest_path_distance(synset_2)\n\t if l_dist is None:\n\t l_dist = 0.0\n\t # normalize path length to the range [0,1]\n\t return math.exp(-self.ALPHA * l_dist)","def get_common_words_count(arr1, arr2):\n return len(list(set(arr1).intersection(arr2)))","def determine_max_length(sequences, ids):\n max_len = 0\n for i in ids:\n if len(sequences[i]) > max_len:\n max_len = len(sequences[i])\n\n return max_len","def overlap_coefficient(a, b):\n\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\n\n\tintersection = set.intersection(a_words, b_words)\n\tlength_a_words, length_b_words = len(a_words), len(b_words)\n\n\t#empty sets\n\tif length_a_words == 0 or length_b_words == 0: return 0\n\n\t#try to compute overlap_coefficient\n\ttry: overlap_coefficient = len(intersection)/min(length_a_words,length_b_words)\n\texcept: overlap_coefficient = 0\n\n\treturn overlap_coefficient","def longest_seq(n):\n max_seq = 0\n for i in range(SEQ_LENGTH):\n max_seq = max(max_seq, longest_seq_of_1s(n, i))\n\n return max_seq","def number_of_differences(str1, str2):\n return sum(str1[i] != str2[i] for i in range(len(str1)))","def _l_distance(first_string, second_string):\n if len(first_string) > len(second_string):\n first_string, second_string = second_string, first_string\n distances = list(range(len(first_string) + 1))\n for index2, char2 in enumerate(second_string):\n new_distances = [index2 + 1]\n for index1, char1 in enumerate(first_string):\n if char1 == char2:\n new_distances.append(distances[index1])\n else:\n new_distances.append(1 + min((distances[index1], distances[index1 + 1], new_distances[-1])))\n distances = new_distances\n return distances[-1]","def count_sequence_mismatches(seq):\n trans_table = str.maketrans('ACGT', 'TGCA')\n half_len = len(seq) // 2\n second_half = seq[-half_len:].translate(trans_table)\n mismatches = 0\n for i in range(half_len):\n if seq[i] != second_half[-i - 1]:\n mismatches += 1\n return mismatches","def overlap(s1,s2):\n if len(s1) >= len(s2):\n longer = s1.lower()\n shorter = s2.lower()\n else:\n longer = s2.lower()\n shorter = s1.lower()\n s3 = shorter + longer # by default this is our combination \n if shorter in longer: # return if shorter is contained in longer\n return longer\n else:\n for i in rnage(1,len(shorter)):\n if shorter[i:] == longer[:len(shorter[i:])]:\n #checks if shorter is in beginning of longer\n s3 = shorter + longer[len(shorter[i:]):]\n break\n for i in reversed(range(len(shorter))):\n if shorter[:i] == longer[-len(shorter[:i]):]:\n # checks if shorter is in ending of longer\n if len(s3) > len(longer[:-len(shorter[:i])] + shorter:\n s3 = longer[:-len(shorter[:i])] + shorter\n break\n return s3","def helper(s1,s2):\n # start with string of smaller len\n if len(s1) > len(s2): # swap\n temp = s1\n s1 = s2\n s2 = temp\n\n ans = 0\n\n # build two counters\n counter1 = collections.Counter(s1)\n counter2 = collections.Counter(s2)\n for item in counter1:\n ans += min(counter1[item],counter2[item])\n\n return ans","def determineIdenticalBases(string1, string2):\n S = 0\n D = 0\n if len(string1) != len(string2):\n return -1\n for i in range(len(string1)):\n if checkForNOrGap(string1[i]) and checkForNOrGap(string2[i]) :\n if string1[i] == string2[i]:\n S += 1\n else:\n D += 1\n return S, D","def determineIdenticalBases(string1, string2):\n S = 0\n D = 0\n if len(string1) != len(string2):\n return -1\n for i in range(len(string1)):\n if checkForNOrGap(string1[i]) and checkForNOrGap(string2[i]) :\n if string1[i] == string2[i]:\n S += 1\n else:\n D += 1\n return S, D","def word_overlap2(sentence_a, sentence_b):\n a_set = set(word for word in sentence_a) - config.stop_list\n b_set = set(word for word in sentence_b) - config.stop_list\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\n\n return score","def lcs_pairwise(s1: str, s2: str, k: int, length: int):\n\n for i in range(0, len(s1) - length + 1):\n for j in range(0, len(s2) - length + 1):\n sub1 = s1[i: i + length]\n sub2 = s2[j: j + length]\n result = pairwise2.align.globalxx(sub1, sub2)\n if result[0][2] >= length - k - 1:\n print(str(i) + \" \" + str(j) + \" \" + str(length - result[0][2]) + \" \" +\n sub1 + \" \" + sub2, end=\"\\t\")\n else:\n print(str(i) + \" \" + str(j) + \" N N N\", end=\"\\t\")\n print(\"\")","def get_length_of_longest_sentence(self):\n sentence_lengths = [len(s.words) for s in self.blob.sentences]\n return max(sentence_lengths)","def is_longer(dna1, dna2):\n return get_length(dna1) > get_length(dna2)","def get_lcp(s,sa):\n lcp = list()\n lcp.append(0)\n for i in range(1,len(sa)):\n lcp.append( longest_prefix_length(s, sa[i], sa[i-1]) )\n return lcp","def get_overlap(a, b):\n return max(0, min(a[1], b[1]) - max(a[0], b[0]))","def count_mismatches(seq1, seq2, max_mm):\r\n mm = 0\r\n for i in range(min(len(seq2), len(seq1))):\r\n if seq1[i] != seq2[i]:\r\n mm += 1\r\n if mm > max_mm:\r\n return mm\r\n return mm","def longest_prefix_length(s, i, j):\n l = 0\n while (i+l < len(s)) and (j+l < len(s)):\n if s[i+l] != s[j+l]:\n break\n l += 1\n return l"],"string":"[\n \"def longestCommonSubsequence(self, text1: str, text2: str) -> int:\\n if len(text1) == 0 or len(text2) == 0:\\n return 0\\n if text1[0] == text2[0]:\\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\\n else:\\n return max(self.longestCommonSubsequence(text1[1:], text2),\\n self.longestCommonSubsequence(text1, text2[1:]))\",\n \"def _lcs_len(a, b):\\n dp = _lcs_dp(a, b)\\n return dp[-1][-1]\",\n \"def lcs_len(x, y):\\r\\n \\r\\n if len(x) == 0 or len(y) == 0:\\r\\n return 0\\r\\n \\r\\n xx = x[:-1] # xx = sequence x without its last element \\r\\n yy = y[:-1]\\r\\n \\r\\n if x[-1] == y[-1]: # if last elements of x and y are equal\\r\\n return lcs_len(xx, yy) + 1\\r\\n else:\\r\\n return max(lcs_len(xx, y), lcs_len(x, yy))\",\n \"def longest_common_subsequence(seq1, seq2):\\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\\n mat.fill()\\n\\n lcs = []\\n augSeq1, augSeq2 = mat.augmented_sequences()\\n for c1, c2 in zip(augSeq1, augSeq2):\\n if c1 == c2:\\n lcs.append(c1)\\n\\n return ''.join(lcs)\",\n \"def lcs_length(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\\n for i in xrange(1, n+1):\\n for j in xrange(1, m+1):\\n if(s1[i-1]==s2[j-1]):\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\\n return matrix[n][m]\",\n \"def LCS_length(str1, str2):\\n if str1 is None or str2 is None:\\n return 0\\n\\n len1 = len(str1)\\n len2 = len(str2)\\n if len1 == 0 or len2 == 0:\\n return 0\\n\\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\\n for i in range(1, len1 + 1):\\n for j in range(1, len2 + 1):\\n if str1[i - 1] == str2[j - 1]:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\\n else:\\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\\n lcs[i % 2][j] = lcs[i % 2][j - 1]\\n else:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\\n\\n return lcs[len1 % 2][-1]\",\n \"def longest_common_subsequence(x, y):\\n\\n # find the length of the strings\\n m = len(x)\\n n = len(y)\\n\\n # declaring the array for storing the dp values\\n lcs = np.zeros((m + 1, n + 1))\\n\\n # iterate through each sub problem\\n for i in range(m + 1):\\n for j in range(n + 1):\\n if i == 0 or j == 0:\\n lcs[i, j] = 0\\n elif x[i - 1] == y[j - 1]:\\n lcs[i, j] = lcs[i - 1, j - 1] + 1\\n else:\\n # use the optimal substructure property\\n # of using already computed results previous subproblems\\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\\n\\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\\n return lcs[m, n]\",\n \"def longest_subsequence(s1: str, s2: str, s3: str) -> int:\\n # Find the shortest string\\n s = min(s1, s2, s3, key=lambda x: len(x))\\n total = 0\\n ok = False\\n while s1:\\n for i1, c1 in enumerate(s1):\\n for i2, c2 in enumerate(s2):\\n if ok:\\n ok = False\\n break\\n if c1 == c2:\\n for i3, c3 in enumerate(s3):\\n if c1 == c3:\\n total += 1\\n s1 = s1[i1 + 1:]\\n s2 = s2[i2 + 1:]\\n s3 = s3[i3 + 1:]\\n ok = True\\n break\\n\\n return total\",\n \"def lcs(s1, s2):\\n\\n shape = (len(s1) + 1, len(s2) + 1)\\n M = np.zeros(shape)\\n\\n max_length_so_far = 0\\n candidates = set()\\n\\n for i in range(len(s1)):\\n for j in range(len(s2)):\\n\\n if s1[i] == s2[j]:\\n M[i+1,j+1] = M[i,j] + 1\\n\\n if M[i+1,j+1] > max_length_so_far:\\n max_length_so_far = int(M[i+1,j+1])\\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\\n\\n elif M[i+1,j+1] == max_length_so_far:\\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\\n\\n else:\\n M[i,j] = 0\\n\\n candidates.add('')\\n\\n return candidates\",\n \"def contig_complementary_score(s1, s2) -> int:\\n matcher = SequenceMatcher()\\n matcher.set_seq1(str(s1))\\n matcher.set_seq2(str(s2.complement()))\\n _, _, size = matcher.find_longest_match(0, len(s1), 0, len(s2))\\n return size\",\n \"def lengthOfLongestSubstringTwoDistinct(self, s):\\n if not s:\\n return 0\\n\\n counters = collections.Counter()\\n\\n start = end = 0\\n max_len = -1\\n char_count = 0\\n while end < len(s):\\n if counters[s[end]] == 0:\\n char_count += 1\\n counters[s[end]] += 1\\n\\n while char_count > 2:\\n counters[s[start]] -= 1\\n if counters[s[start]] == 0:\\n char_count -= 1\\n start += 1\\n\\n if max_len < end - start + 1:\\n max_len = end - start + 1\\n\\n return max_len\",\n \"def longest_common_substring_backtrack(s1, s2, i, j, count):\\n if i == len(s1) or j == len(s2):\\n return 0\\n\\n if s1[i-1] == s2[j-1]:\\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\\n\\n else:\\n count = max(count,\\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\\n\\n return count\",\n \"def findLongestCommonSubstring(self, string1, string2):\\n countingArray = [[0]*len(string2) for i in range(len(string1))]\\n ##we set up an array to locate the possible substrings\\n lcss = \\\"\\\"\\n for row in range(len(countingArray)):\\n for column in range(len(countingArray[row])):\\n if string1[row] == string2[column]:\\n countingArray[row][column] += 1 ##if there's a match the common string length is at least 1\\n if not (row == 0 or column == 0):\\n countingArray[row][column] += countingArray[row-1][column-1] ##memoize the length of the common string so far\\n if countingArray[row][column] > longestLength: ##if it's longer than our current longest string, we'll plan on returning it\\n longestLength = countingArray[row][column]\\n lcss = string1[row-longestLength+1:row+1]\\n return lcss\",\n \"def longest_common_substring_bottom_up(s1, s2):\\n lcs_array = lcs(s1, s2)\\n n = len(s1)\\n m = len(s2)\\n l = lcs_array[n][m]\\n result = \\\"\\\"\\n while l != 0:\\n if s1[n - 1] == s2[m - 1]:\\n result = s1[n - 1] + result\\n l -= 1\\n n -= 1\\n m -= 1\\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\\n m -= 1\\n else:\\n n -= 1\\n return result\",\n \"def lcs_similarity(s1, s2):\\n max_len = 0\\n i = 0\\n\\n while s1[i] == s2[i]:\\n max_len += 1\\n i += 1\\n if len(s1) == i or len(s2) == i:\\n break\\n\\n if len(s1) < len(s2):\\n return float(max_len) / len(s2)\\n else:\\n return float(max_len) / len(s1)\",\n \"def longest(s1, s2):\\n return ''.join(sorted(set(s1+s2)))\",\n \"def commonlen(s1, s2):\\n # given \\\"hi\\\", \\\"hip\\\"\\n # izip_longest(\\\"hi\\\", \\\"hip\\\") -> ('h','h'), ('i','i'), (None, 'p')\\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\\n try:\\n return itertools.dropwhile(\\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\\n except StopIteration:\\n # strings are identical return the len of one of them\\n return len(s1)\",\n \"def overlap_len(range1, range2):\\n return min(range1[1], range2[1]) - max(range1[0], range2[0])\",\n \"def _common_prefix(sequence1, sequence2):\\n i = 0\\n for elem1, elem2 in zip(sequence1, sequence2):\\n if elem1 != elem2:\\n return i\\n i += 1\\n\\n # Return length of sequence if sequences are identical\\n return min(len(sequence1), len(sequence2))\",\n \"def m_longest_common_subsequence_2(s):\\n\\n # Correct me if I'm wrong but I think unsorted list is faster\\n lst = list(s)\\n\\n lcs = lst[0]\\n for string in lst[1:]:\\n lcs = LCS(lcs, string)\\n\\n return lcs\",\n \"def lcs(a, b):\\n # This is an adaptation of the standard LCS dynamic programming algorithm\\n # tweaked for lower memory consumption.\\n # Sequence a is laid out along the rows, b along the columns.\\n # Minimize number of columns to minimize required memory\\n if len(a) < len(b):\\n a, b = b, a\\n # Sequence b now has the minimum length\\n # Quit early if one sequence is empty\\n if len(b) == 0:\\n return 0\\n # Use a single buffer to store the counts for the current row, and\\n # overwrite it on each pass\\n row = [0] * len(b)\\n for ai in a:\\n left = 0\\n diag = 0\\n for j, bj in enumerate(b):\\n up = row[j]\\n if ai == bj:\\n value = diag + 1\\n else:\\n value = max(left, up)\\n row[j] = value\\n left = value\\n diag = up\\n # Return the last cell of the last row\\n return left\",\n \"def getCommon(self, st1, st2):\\n fl = len(st1)\\n shorter = len(st2)\\n if fl < shorter:\\n shorter = fl\\n \\n i = 0\\n while i < shorter:\\n if st1[i] != st2[i]:\\n break\\n i += 1\\n return i\",\n \"def _len_lcs(x, y):\\n table = _lcs(x, y)\\n n, m = len(x), len(y)\\n return table[n, m]\",\n \"def real_overlap(from_sequence, to_sequence):\\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\\n start = 0\\n start_pos_from = -1\\n start_pos_to = -1\\n size = -1\\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\\\\n len(from_sequence), 0, len(to_sequence))\\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\\n start = start_pos_from+1\\n\\n return size\",\n \"def _lcs_dp(a, b):\\n dp = [[0 for _ in range(0, len(b) + 1)]\\n for _ in range(0, len(a) + 1)]\\n # dp[i][j]: lcs_len(a[:i], b[:j])\\n for i in range(1, len(a) + 1):\\n for j in range(1, len(b) + 1):\\n if a[i - 1] == b[j - 1]:\\n dp[i][j] = dp[i - 1][j - 1] + 1\\n else:\\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\\n return dp\",\n \"def longest_common_substring_iterative_bottom_up(s1, s2):\\n\\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\\n\\n for i in range(1, len(s1)+1):\\n for j in range(1, len(s2)+1):\\n\\n if s1[i-1] == s2[j-1]:\\n\\n # previous count is cache[i-1][j-1]\\n cache[i][j] = cache[i-1][j-1] + 1\\n else:\\n cache[i][j] = max(cache[i-1][j-1],\\n max(cache[i-1][j],\\n cache[i][j-1]))\\n\\n return cache[-1][-1]\",\n \"def get_seq_overlap(seq1, seq2):\\n\\n overlap = 0\\n for i in range(len(seq1)):\\n if seq1[i] != \\\"-\\\" and seq2[i] != \\\"-\\\":\\n overlap += 1\\n\\n return overlap\",\n \"def sentence_lengths(sentence_a, sentence_b):\\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))\",\n \"def _get_overlap(word1, word2):\\n max_overlap = min(len(word1), len(word2))\\n max_found = 0\\n for size in range(1, max_overlap+1):\\n suffix = word1[-size:]\\n prefix = word2[:size]\\n if suffix == prefix:\\n max_found = size\\n return max_found\",\n \"def common(s1, s2):\\n cl = commonlen(s1, s2)\\n return s2[:cl]\",\n \"def levenshtein(seq1: str, seq2: str) -> int:\\n if seq1 == \\\"\\\":\\n return len(seq2)\\n if seq2 == \\\"\\\":\\n return len(seq1)\\n if seq1[-1] == seq2[-1]:\\n cost = 0\\n else:\\n cost = 1\\n \\n result = min([levenshtein(seq1[:-1], seq2) + 1,\\n levenshtein(seq1, seq2[:-1]) + 1,\\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\\n return result\",\n \"def compare_eq_len(a, b):\\n n = len(a)\\n m = len(b)\\n\\n # slide b across a from left to right till from just overlapping till full overlap\\n overlap = 0 # stores length of the overlap\\n lconcat = \\\"\\\" # this stores the shortest common superstring\\n for j in range(m):\\n starta = 0\\n enda = j+1\\n startb = m - (j+1)\\n endb = m\\n if a[starta:enda] == b[startb:endb]:\\n # if an overlap is found, check if it is larger than the previously detected one\\n # print(\\\"overlap found\\\")\\n if len(a[starta:enda]) > overlap: \\n overlap = len(a[starta:enda]) \\n lconcat = b + a[enda:] # this is the current shortest common superstring\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # print(\\\"-\\\")\\n\\n # slide b across a so that b starts from one element past a after full overlap\\n rconcat = \\\"\\\"\\n for j in range(m-1):\\n starta = j+1\\n enda = m\\n startb = 0\\n endb = m - (j+1)\\n if a[starta:enda] == b[startb:endb]:\\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \\n # print(\\\"overlap found\\\")\\n overlap = len(a[starta:enda]) \\n rconcat = a + b[endb:]\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # after checking for overlaps there may be 1 or no shortest common\\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\\n # or the concatenation of a and b if there are no overlaps. We may have to make some\\n # arbitrary choices here.\\n\\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\\n superstring = lconcat \\n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\\n superstring = rconcat\\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\\n superstring = lconcat\\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\\n superstring = rconcat\\n return superstring\",\n \"def _common_length_of(l1, l2=None, l3=None):\\n args = [];\\n if l1 != None: args.append(l1)\\n if l2 != None: args.append(l2)\\n if l3 != None: args.append(l3)\\n\\n length = None\\n num = 0\\n for l in args:\\n for i in l:\\n num += 1\\n length_i = len(i)\\n if length!=None and length_i!=length:\\n raise ValueError, \\\"Argument lengths differ!\\\"\\n length = length_i\\n\\n return num, length\",\n \"def longest_shared_between(cls, seq_1, seq_2):\\n tree = cls(seq_2 + '$', 'B').append_named_sequence(seq_1 + '$', 'A')\\n condition = lambda n, c, p: 'B' not in c.seq_ids\\n out = lambda n, c, p: p + n.label\\n unshared = tree.root.bfs_paths(condition, out)\\n shortest = next(unshared)\\n common = [shortest]\\n for possible in unshared:\\n if len(possible) > len(shortest) and not possible[-1] == '$':\\n shortest = possible\\n common = [possible]\\n elif len(possible) == len(shortest) and not possible[-1] == '$':\\n common.append(possible)\\n return min(common)\",\n \"def get_length_of_longest_sub_array(l):\\n if len(l) < 1:\\n return 0\\n\\n longest_seen_sequence = 0\\n\\n this_sequence_length = 1\\n\\n previous = l[0]\\n\\n for _, current in enumerate(l):\\n\\n if current > previous:\\n this_sequence_length = this_sequence_length + 1\\n\\n if this_sequence_length > longest_seen_sequence:\\n longest_seen_sequence = this_sequence_length\\n\\n else:\\n this_sequence_length = 1\\n\\n if this_sequence_length > longest_seen_sequence:\\n longest_seen_sequence = this_sequence_length\\n\\n previous = current\\n\\n return longest_seen_sequence\",\n \"def lungime_multimi(multime_1, multime_2):\\n if len(multime_1) < len(multime_2):\\n return len(multime_1)\\n else:\\n return len(multime_2)\",\n \"def common_prefix_length(s, u):\\n length = 0\\n for cs, cu in zip(s, u):\\n if cs != cu:\\n break\\n length += 1\\n return length\",\n \"def overlap(s1, s2):\\n for i in range(min(len(s1), len(s2)), 0, -1):\\n if s1.endswith(s2[:i]):\\n return i\\n return 0\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def compare_str(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n ld = Levenshtein.distance(seq1, seq2)\\n longest = len(seq1 if len(seq1) > len(seq2) else seq2)\\n return (longest - ld) / longest\",\n \"def length(a, b):\\n return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]))\",\n \"def LPSubsequenceLength(str):\\n return len(LPSubsequence(str))\",\n \"def longestCommomSubsequence(self, arrays: List[List[int]]) -> List[int]:\\n counts = Counter(val for arr in arrays for val in arr)\\n res = []\\n for val, count in counts.items():\\n if count == len(arrays): res.append(val)\\n return res\",\n \"def longest_common_prefix(fst: str, snd: str) -> str:\\n bound = 0\\n for a, b in zip(fst, snd):\\n if a != b:\\n break\\n bound += 1\\n return fst[:bound]\",\n \"def findLongestCommonSubstringManyStrings(listOfStrings):\",\n \"def commonCharacterCount(s1, s2):\\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))\",\n \"def overlap(s1, s2):\\n j = len(s2) - 1\\n while j >= 0 and not s1.endswith(s2[:j + 1]):\\n j -= 1\\n return j\",\n \"def longest_common_substring_memoization(s1, s2, i, j, count, cache):\\n\\n if i == len(s1) or j == len(s2):\\n return 0\\n\\n if cache[i][j] != -1:\\n return cache[i][j]\\n\\n if s1[i-1] == s2[j-1]:\\n count = 1 + longest_common_substring_memoization(s1, s2, i+1, j+1, count, cache)\\n\\n else:\\n count = max(count,\\n max(longest_common_substring_memoization(s1, s2, i+1, j, count, cache),\\n longest_common_substring_memoization(s1, s2, i, j+1, count, cache)))\\n\\n cache[i][j] = count\\n return cache[i][j]\",\n \"def longest_ORF(dna):\\n both_strings=find_all_ORFs_both_strands(dna)\\n L=max(both_strings,key=len)\\n Q=len(L)\\n return Q\\n\\n #save out put of find all orfboth string to some variable\",\n \"def count_padding_bases(seq1, seq2):\\n if len(seq1) <= len(seq2):\\n shorter, longer = seq1, seq2\\n else:\\n shorter, longer = seq2, seq1\\n\\n n = 0\\n for base1, base2 in zip(shorter, longer[: len(shorter)]):\\n if base1 == base2:\\n n += 1\\n else:\\n break\\n\\n return n\",\n \"def common_prefix_len(self, other: \\\"ProofPath\\\") -> int:\\n if self.start() == other.start():\\n return self.match_len(other, self.start())\\n\\n return 0\",\n \"def string_distance(s1, s2):\\n if len(s1) != len(s2):\\n return 1\\n diff_count = 0\\n for c1, c2, in zip(s1, s2):\\n if c1 != c2:\\n diff_count += 1\\n return diff_count\",\n \"def find_lcs(l1: str, l2: str, length1: int, length2: int):\\n \\\"\\\"\\\" Theorem:{\\n Initialize matrix with 0 for first row and colm\\n If s1[i] = s2[j], update matrix[i][j] with value\\n of matrix[i-1][j-1]+1\\n Else update matrix[i][j] with max of value among\\n matrix[i][j-1],matrix[i-1][j]\\n Matrix[n][m] will be lcs\\n }\\n \\\"\\\"\\\"\\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\\n for i in range(0, length2+1):\\n for j in range(0, length1+1):\\n if i == 0 or j == 0:\\n matrix[i][j] = 0\\n elif l1[j-1] == l2[i-1]:\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\\n lcs = [None for i in range(0, matrix[length2][length1])]\\n index = matrix[length2][length1]\\n m = length2 \\n n = length1\\n while(m > -1 and n > -1):\\n if l2[m-1] == l1[n-1]:\\n lcs[index-1] = l2[m-1]\\n index -= 1\\n m -= 1\\n n -= 1\\n elif matrix[m-1][n] > matrix[m][n-1]:\\n m -= 1\\n else:\\n n -= 1\\n return lcs\",\n \"def _getLongestLength(self, listOfLists):\\n\\t\\tmax = -1\\n\\t\\tfor list in listOfLists:\\n\\t\\t\\tif len(list) > max:\\n\\t\\t\\t\\tmax = len(list)\\n\\t\\treturn max\",\n \"def find_largest_overlaps(string_one, string_two):\\n two_overlaps_suffix_one = overlap(string_one, string_two)\\n one_overlaps_suffix_two = overlap(string_two, string_one)\\n\\n return two_overlaps_suffix_one, one_overlaps_suffix_two\",\n \"def _find_common_tail(self, l1, l2):\\n i = -1\\n try:\\n while l1[i] == l2[i]:\\n i -= 1\\n except IndexError:\\n # One list is the tail of the other\\n pass\\n # i now gives the last differing element\\n assert i < -1\\n return i+1\",\n \"def lengthOfLongestSubstring(s):\\n arr = [1] * len(s)\\n i = 0\\n j = 1\\n while j < len(s):\\n if s[j] not in s[i:j]:\\n arr[i] += 1\\n j = j + 1\\n else:\\n i = i + 1\\n j = i + 1\\n return max(arr)\",\n \"def lengthOfLongestSubstring(self, s):\\n longest = 0\\n i = 0\\n j = 0\\n n = len(s)\\n seen = {}\\n while i < n and j < n:\\n c = s[j]\\n if c in seen:\\n i = seen[c] + 1\\n seen[c] = j\\n j += 1\\n longest = max(longest, j-i)\\n\\n return longest\",\n \"def find_LCS(seq1, seq2, all=False):\\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\\n\\n for i in range(1, len(seq1) + 1):\\n for j in range(1, len(seq2) + 1):\\n inter = seq1[i - 1].intersection(seq2[j - 1])\\n\\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\\n C[i - 1][j],\\n C[i][j - 1]])\\n\\n # now we need to backtrack the structure to get the pattern\\n if all:\\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\\n return {i[1:] for i in all_lcs}\\n\\n lcs = []\\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\\n return lcs\",\n \"def overlap(a, b, min_length=3):\\n start = 0 # start all the way at the left\\n\\n while True:\\n start = a.find(b[:min_length], start) # look for b's suffix i a\\n if start == -1: # no more occurrences to right\\n return 0\\n # found occurrence; check for full suffix/prefix match\\n if b.startswith(a[start:]):\\n return len(a) - start\\n start += 1 # move just paat previous match\",\n \"def length_aln_on_sequence(start, end):\\n return end - start + 1\",\n \"def common_suffix(s1, s2):\\n if not s1 or not s2:\\n return None\\n # revert the seqs and get a common prefix\\n common = common_prefix(s1[::-1], s2[::-1])\\n # revert back\\n if common:\\n return common[::-1]\\n else:\\n return common\",\n \"def lcs(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n # initialise 2d array with size n+1 x m+1\\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\\n # build array of LCS counters\\n for i in range(n + 1):\\n for j in range(m + 1):\\n if i == 0 or j == 0:\\n lcs_array[i][j] = 0\\n elif s1[i - 1] == s2[j - 1]:\\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\\n else:\\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\\n return lcs_array\",\n \"def common_token_len(self, w1, d1, w2, d2):\\n w1_tk = set(self.__stem_Tokens(w1))\\n w2_tk = set(self.__stem_Tokens(w2))\\n common_len = len(w1_tk.intersection(w2_tk))\\n return common_len\",\n \"def longest_common_prefix(strings: list):\\n raise NotImplemented\",\n \"def overlap(a, b, min_length=3):\\r\\n start = 0 # start all the way at the left\\r\\n while True:\\r\\n start = a.find(b[:min_length], start) # look for b's prefix in a\\r\\n if start == -1: # no more occurrences to right\\r\\n return 0\\r\\n # found occurrence; check for full suffix/prefix match\\r\\n if b.startswith(a[start:]):\\r\\n return len(a)-start\\r\\n start += 1 # move just past previous match\\r\",\n \"def longestPalindromeSubseq(self, s: str) -> int:\\n n = len(s)\\n dp = [[1] * n for _ in range(n)]\\n for length in range(1, n + 1):\\n for i in range(n - length + 1):\\n j = i + length - 1\\n print(i, j)\\n if length == 1:\\n dp[i][j] = 1\\n elif s[i] == s[j]:\\n dp[i][j] = dp[i + 1][j - 1] + 2\\n else:\\n dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])\\n return dp[0][n - 1]\",\n \"def lcs_dp(strA, strB):\\n rows = len(strA) + 1\\n cols = len(strB) + 1\\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\\n\\n for row in range(1, rows):\\n for col in range(1, cols):\\n if strA[row - 1] == strB[col - 1]:\\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\\n else:\\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\\n return dp_table[rows-1][cols-1]\",\n \"def longest_word_length(words):\",\n \"def overlap(string_one: str, string_two: str):\\n len_s_one = len(string_one)\\n len_s_two = len(string_two)\\n\\n # Content of the tuple => (start_index, stop_index, string from start_index to stop_index)\\n largest_overlap = {\\\"suffix_string\\\": string_one,\\n \\\"prefix_string\\\": string_two,\\n \\\"overlap\\\": None,\\n \\\"weight\\\": 0}\\n len_overlap = 0\\n # Iterate over every suffix from string one from right to left\\n for i in range(len_s_one, 0, -1):\\n # Current suffix from string one\\n current_suffix_one = string_one[i - 1:len_s_one]\\n\\n # Iterate over every prefix of string two from left to right\\n for j in range(len_s_two + 1):\\n current_prefix_two = string_two[:j]\\n if current_suffix_one == current_prefix_two:\\n tmp_len = len(current_prefix_two)\\n if tmp_len > len_overlap:\\n len_overlap = tmp_len\\n\\n largest_overlap[\\\"suffix_start\\\"] = i - 1\\n largest_overlap[\\\"suffix_end\\\"] = len_s_one\\n\\n largest_overlap[\\\"prefix_start\\\"] = 0\\n largest_overlap[\\\"prefix_end\\\"] = j\\n\\n largest_overlap[\\\"weight\\\"] = tmp_len\\n largest_overlap[\\\"overlap\\\"] = current_suffix_one\\n return largest_overlap\",\n \"def length_of_longest_substring(s):\\n def compare():\\n return max(cur_length, longest_substring)\\n\\n longest_substring = 0\\n cur_substring = \\\"\\\"\\n for c in s:\\n if c in cur_substring:\\n cur_length = len(cur_substring)\\n longest_substring = compare()\\n cur_substring = c\\n else:\\n cur_substring += c\\n return compare()\",\n \"def fn(i1, i2):\\n if i1 == len(word1): return len(word2) - i2\\n if i2 == len(word2): return len(word1) - i1\\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))\",\n \"def calc_length(self):\\n return AtomMath.length(self.atom1.position - self.atom2.position)\",\n \"def commonality(left_struc, right_struc):\\n assert type(left_struc) is type(right_struc), (left_struc, right_struc)\\n assert left_struc and right_struc, (left_struc, right_struc)\\n if type(left_struc) is dict:\\n (overlap, left, right) = compute_keysets(left_struc, right_struc)\\n com = float(len(overlap))\\n tot = len(overlap.union(left, right))\\n else:\\n assert type(left_struc) in (list, tuple), left_struc\\n com = 0.0\\n for elem in left_struc:\\n if elem in right_struc:\\n com += 1\\n tot = max(len(left_struc), len(right_struc))\\n\\n return com / tot\",\n \"def _sequence_overlap(seq1: Sequence, seq2: Sequence):\\n diff = SequenceMatcher(None, seq1, seq2)\\n # Drop last matching block, since this is always a dummy entry, with length=1.\\n return diff.get_matching_blocks()[:-1]\",\n \"def longestAwesome(self, s: str) -> int:\\n\\n # So we are moving right, and reducing length by 1\\n # for every time we move right - we start from the longest substring that can be formed to lowest one\\n # So the moment, we find something we can instantly breal\\n\\n max_length = 0\\n\\n if s == s[::-1]:\\n return len(s)\\n\\n for i in range(0, len(s)):\\n left = i\\n right = len(s)\\n\\n if right - left > max_length:\\n\\n while right > left:\\n\\n candidate = s[left:right]\\n # print(f\\\"The candidate is: {candidate}\\\")\\n ctr = Counter(candidate)\\n\\n # initial base check\\n odd_cnt = 0\\n fl = False\\n for k, v in ctr.items():\\n if v & 1:\\n odd_cnt += 1\\n if odd_cnt > 1:\\n fl = True\\n break\\n\\n if not fl:\\n if max_length < (right - left):\\n max_length = right - left\\n # max_length = max(max_length, len(candidate))\\n\\n right -= 1\\n\\n return max_length\",\n \"def complementary_score(s1, s2) -> int:\\n aligner = Align.PairwiseAligner()\\n aligner.mode = 'local'\\n aligner.open_gap_score = -1000 # Don't want any gaps!\\n # score = the number of complementary nucleotides between s1 and s2.\\n return aligner.score(str(s1), str(s2.complement()))\",\n \"def longest_sequence(start=1, end=1000000):\\n\\n max_length = 0\\n max_start_value = 0\\n\\n # generate sequence for each value\\n for i in range(start, end):\\n current = generate_sequence(i)\\n\\n # if the current sequence is the longest, update values\\n if len(current) > max_length:\\n max_length = len(current)\\n max_start_value = i\\n\\n return max_length, max_start_value\",\n \"def _matched_len(self, string, idx1, idx2):\\n\\n str_len = len(string)\\n if idx1 == idx2:\\n return str_len - idx1\\n counter = 0\\n while idx1 < str_len and idx2 < str_len and string[idx1] == string[idx2]:\\n counter += 1\\n idx1 += 1\\n idx2 += 1\\n\\n return counter\",\n \"def length_dist(self,synset_1, synset_2):\\n\\t l_dist = sys.maxsize\\n\\t if synset_1 is None or synset_2 is None: \\n\\t return 0.0\\n\\t if synset_1 == synset_2:\\n\\t # if synset_1 and synset_2 are the same synset return 0\\n\\t l_dist = 0.0\\n\\t else:\\n\\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \\n\\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\\n\\t if len(wset_1.intersection(wset_2)) > 0:\\n\\t # if synset_1 != synset_2 but there is word overlap, return 1.0\\n\\t l_dist = 1.0\\n\\t else:\\n\\t # just compute the shortest path between the two\\n\\t l_dist = synset_1.shortest_path_distance(synset_2)\\n\\t if l_dist is None:\\n\\t l_dist = 0.0\\n\\t # normalize path length to the range [0,1]\\n\\t return math.exp(-self.ALPHA * l_dist)\",\n \"def get_common_words_count(arr1, arr2):\\n return len(list(set(arr1).intersection(arr2)))\",\n \"def determine_max_length(sequences, ids):\\n max_len = 0\\n for i in ids:\\n if len(sequences[i]) > max_len:\\n max_len = len(sequences[i])\\n\\n return max_len\",\n \"def overlap_coefficient(a, b):\\n\\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\\n\\n\\tintersection = set.intersection(a_words, b_words)\\n\\tlength_a_words, length_b_words = len(a_words), len(b_words)\\n\\n\\t#empty sets\\n\\tif length_a_words == 0 or length_b_words == 0: return 0\\n\\n\\t#try to compute overlap_coefficient\\n\\ttry: overlap_coefficient = len(intersection)/min(length_a_words,length_b_words)\\n\\texcept: overlap_coefficient = 0\\n\\n\\treturn overlap_coefficient\",\n \"def longest_seq(n):\\n max_seq = 0\\n for i in range(SEQ_LENGTH):\\n max_seq = max(max_seq, longest_seq_of_1s(n, i))\\n\\n return max_seq\",\n \"def number_of_differences(str1, str2):\\n return sum(str1[i] != str2[i] for i in range(len(str1)))\",\n \"def _l_distance(first_string, second_string):\\n if len(first_string) > len(second_string):\\n first_string, second_string = second_string, first_string\\n distances = list(range(len(first_string) + 1))\\n for index2, char2 in enumerate(second_string):\\n new_distances = [index2 + 1]\\n for index1, char1 in enumerate(first_string):\\n if char1 == char2:\\n new_distances.append(distances[index1])\\n else:\\n new_distances.append(1 + min((distances[index1], distances[index1 + 1], new_distances[-1])))\\n distances = new_distances\\n return distances[-1]\",\n \"def count_sequence_mismatches(seq):\\n trans_table = str.maketrans('ACGT', 'TGCA')\\n half_len = len(seq) // 2\\n second_half = seq[-half_len:].translate(trans_table)\\n mismatches = 0\\n for i in range(half_len):\\n if seq[i] != second_half[-i - 1]:\\n mismatches += 1\\n return mismatches\",\n \"def overlap(s1,s2):\\n if len(s1) >= len(s2):\\n longer = s1.lower()\\n shorter = s2.lower()\\n else:\\n longer = s2.lower()\\n shorter = s1.lower()\\n s3 = shorter + longer # by default this is our combination \\n if shorter in longer: # return if shorter is contained in longer\\n return longer\\n else:\\n for i in rnage(1,len(shorter)):\\n if shorter[i:] == longer[:len(shorter[i:])]:\\n #checks if shorter is in beginning of longer\\n s3 = shorter + longer[len(shorter[i:]):]\\n break\\n for i in reversed(range(len(shorter))):\\n if shorter[:i] == longer[-len(shorter[:i]):]:\\n # checks if shorter is in ending of longer\\n if len(s3) > len(longer[:-len(shorter[:i])] + shorter:\\n s3 = longer[:-len(shorter[:i])] + shorter\\n break\\n return s3\",\n \"def helper(s1,s2):\\n # start with string of smaller len\\n if len(s1) > len(s2): # swap\\n temp = s1\\n s1 = s2\\n s2 = temp\\n\\n ans = 0\\n\\n # build two counters\\n counter1 = collections.Counter(s1)\\n counter2 = collections.Counter(s2)\\n for item in counter1:\\n ans += min(counter1[item],counter2[item])\\n\\n return ans\",\n \"def determineIdenticalBases(string1, string2):\\n S = 0\\n D = 0\\n if len(string1) != len(string2):\\n return -1\\n for i in range(len(string1)):\\n if checkForNOrGap(string1[i]) and checkForNOrGap(string2[i]) :\\n if string1[i] == string2[i]:\\n S += 1\\n else:\\n D += 1\\n return S, D\",\n \"def determineIdenticalBases(string1, string2):\\n S = 0\\n D = 0\\n if len(string1) != len(string2):\\n return -1\\n for i in range(len(string1)):\\n if checkForNOrGap(string1[i]) and checkForNOrGap(string2[i]) :\\n if string1[i] == string2[i]:\\n S += 1\\n else:\\n D += 1\\n return S, D\",\n \"def word_overlap2(sentence_a, sentence_b):\\n a_set = set(word for word in sentence_a) - config.stop_list\\n b_set = set(word for word in sentence_b) - config.stop_list\\n score = len(a_set&b_set)/float(len(a_set|b_set))# len(s1&s2)/max(len(s1),len(s2))\\n\\n return score\",\n \"def lcs_pairwise(s1: str, s2: str, k: int, length: int):\\n\\n for i in range(0, len(s1) - length + 1):\\n for j in range(0, len(s2) - length + 1):\\n sub1 = s1[i: i + length]\\n sub2 = s2[j: j + length]\\n result = pairwise2.align.globalxx(sub1, sub2)\\n if result[0][2] >= length - k - 1:\\n print(str(i) + \\\" \\\" + str(j) + \\\" \\\" + str(length - result[0][2]) + \\\" \\\" +\\n sub1 + \\\" \\\" + sub2, end=\\\"\\\\t\\\")\\n else:\\n print(str(i) + \\\" \\\" + str(j) + \\\" N N N\\\", end=\\\"\\\\t\\\")\\n print(\\\"\\\")\",\n \"def get_length_of_longest_sentence(self):\\n sentence_lengths = [len(s.words) for s in self.blob.sentences]\\n return max(sentence_lengths)\",\n \"def is_longer(dna1, dna2):\\n return get_length(dna1) > get_length(dna2)\",\n \"def get_lcp(s,sa):\\n lcp = list()\\n lcp.append(0)\\n for i in range(1,len(sa)):\\n lcp.append( longest_prefix_length(s, sa[i], sa[i-1]) )\\n return lcp\",\n \"def get_overlap(a, b):\\n return max(0, min(a[1], b[1]) - max(a[0], b[0]))\",\n \"def count_mismatches(seq1, seq2, max_mm):\\r\\n mm = 0\\r\\n for i in range(min(len(seq2), len(seq1))):\\r\\n if seq1[i] != seq2[i]:\\r\\n mm += 1\\r\\n if mm > max_mm:\\r\\n return mm\\r\\n return mm\",\n \"def longest_prefix_length(s, i, j):\\n l = 0\\n while (i+l < len(s)) and (j+l < len(s)):\\n if s[i+l] != s[j+l]:\\n break\\n l += 1\\n return l\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.793082","0.78713226","0.78309524","0.7427125","0.73440653","0.7278892","0.7266744","0.71712285","0.7093681","0.6894858","0.68482155","0.6788144","0.67197895","0.6692162","0.6673714","0.6666056","0.6649898","0.6628876","0.66177297","0.6613877","0.6545006","0.6537446","0.653296","0.6520107","0.6497813","0.6434627","0.6425142","0.63973445","0.6353099","0.6326057","0.6320935","0.6316239","0.6297724","0.62928087","0.6233935","0.6231135","0.6210447","0.6204186","0.6195011","0.6174846","0.617047","0.6161163","0.6159465","0.61474174","0.61381423","0.61240584","0.6104708","0.60996777","0.6089251","0.6087365","0.60348463","0.6012995","0.5996124","0.5995464","0.5988446","0.5981433","0.5978519","0.5973662","0.5965043","0.5963335","0.5953212","0.5941847","0.59415835","0.59347475","0.5934116","0.5926459","0.5925055","0.59199077","0.59168947","0.5876522","0.58547854","0.58464545","0.58462805","0.5843139","0.58321214","0.58254325","0.58249307","0.5811702","0.5807924","0.5790177","0.577699","0.57607967","0.5748985","0.57427126","0.57350695","0.5731838","0.5730378","0.57289267","0.57201564","0.5713881","0.5713881","0.57109034","0.57053936","0.57019025","0.56959546","0.56944865","0.56670624","0.56578135","0.5654567"],"string":"[\n \"0.793082\",\n \"0.78713226\",\n \"0.78309524\",\n \"0.7427125\",\n \"0.73440653\",\n \"0.7278892\",\n \"0.7266744\",\n \"0.71712285\",\n \"0.7093681\",\n \"0.6894858\",\n \"0.68482155\",\n \"0.6788144\",\n \"0.67197895\",\n \"0.6692162\",\n \"0.6673714\",\n \"0.6666056\",\n \"0.6649898\",\n \"0.6628876\",\n \"0.66177297\",\n \"0.6613877\",\n \"0.6545006\",\n \"0.6537446\",\n \"0.653296\",\n \"0.6520107\",\n \"0.6497813\",\n \"0.6434627\",\n \"0.6425142\",\n \"0.63973445\",\n \"0.6353099\",\n \"0.6326057\",\n \"0.6320935\",\n \"0.6316239\",\n \"0.6297724\",\n \"0.62928087\",\n \"0.6233935\",\n \"0.6231135\",\n \"0.6210447\",\n \"0.6204186\",\n \"0.6195011\",\n \"0.6174846\",\n \"0.617047\",\n \"0.6161163\",\n \"0.6159465\",\n \"0.61474174\",\n \"0.61381423\",\n \"0.61240584\",\n \"0.6104708\",\n \"0.60996777\",\n \"0.6089251\",\n \"0.6087365\",\n \"0.60348463\",\n \"0.6012995\",\n \"0.5996124\",\n \"0.5995464\",\n \"0.5988446\",\n \"0.5981433\",\n \"0.5978519\",\n \"0.5973662\",\n \"0.5965043\",\n \"0.5963335\",\n \"0.5953212\",\n \"0.5941847\",\n \"0.59415835\",\n \"0.59347475\",\n \"0.5934116\",\n \"0.5926459\",\n \"0.5925055\",\n \"0.59199077\",\n \"0.59168947\",\n \"0.5876522\",\n \"0.58547854\",\n \"0.58464545\",\n \"0.58462805\",\n \"0.5843139\",\n \"0.58321214\",\n \"0.58254325\",\n \"0.58249307\",\n \"0.5811702\",\n \"0.5807924\",\n \"0.5790177\",\n \"0.577699\",\n \"0.57607967\",\n \"0.5748985\",\n \"0.57427126\",\n \"0.57350695\",\n \"0.5731838\",\n \"0.5730378\",\n \"0.57289267\",\n \"0.57201564\",\n \"0.5713881\",\n \"0.5713881\",\n \"0.57109034\",\n \"0.57053936\",\n \"0.57019025\",\n \"0.56959546\",\n \"0.56944865\",\n \"0.56670624\",\n \"0.56578135\",\n \"0.5654567\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6606945"},"document_rank":{"kind":"string","value":"21"}}},{"rowIdx":85174,"cells":{"query":{"kind":"string","value":"Computes the length of the LCS between two seqs. The implementation below uses a DP programming algorithm and runs in O(nm) time where n = len(x) and m = len(y)."},"document":{"kind":"string","value":"def _lcs(x, y):\n n, m = len(x), len(y)\n table = dict()\n for i in range(n + 1):\n for j in range(m + 1):\n if i == 0 or j == 0:\n table[i, j] = 0\n elif x[i - 1] == y[j - 1]:\n table[i, j] = table[i - 1, j - 1] + 1\n else:\n table[i, j] = max(table[i - 1, j], table[i, j - 1])\n return table"},"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 _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]","def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]","def lcs_len(x, y):\r\n \r\n if len(x) == 0 or len(y) == 0:\r\n return 0\r\n \r\n xx = x[:-1] # xx = sequence x without its last element \r\n yy = y[:-1]\r\n \r\n if x[-1] == y[-1]: # if last elements of x and y are equal\r\n return lcs_len(xx, yy) + 1\r\n else:\r\n return max(lcs_len(xx, y), lcs_len(x, yy))","def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]","def lcs_length(s1, s2):\n n = len(s1)\n m = len(s2)\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\n for i in xrange(1, n+1):\n for j in xrange(1, m+1):\n if(s1[i-1]==s2[j-1]):\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\n return matrix[n][m]","def _lcs_dp(a, b):\n dp = [[0 for _ in range(0, len(b) + 1)]\n for _ in range(0, len(a) + 1)]\n # dp[i][j]: lcs_len(a[:i], b[:j])\n for i in range(1, len(a) + 1):\n for j in range(1, len(b) + 1):\n if a[i - 1] == b[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp","def LCS_length(str1, str2):\n if str1 is None or str2 is None:\n return 0\n\n len1 = len(str1)\n len2 = len(str2)\n if len1 == 0 or len2 == 0:\n return 0\n\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\n for i in range(1, len1 + 1):\n for j in range(1, len2 + 1):\n if str1[i - 1] == str2[j - 1]:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\n else:\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\n lcs[i % 2][j] = lcs[i % 2][j - 1]\n else:\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\n\n return lcs[len1 % 2][-1]","def lcs(s1, s2):\n\n shape = (len(s1) + 1, len(s2) + 1)\n M = np.zeros(shape)\n\n max_length_so_far = 0\n candidates = set()\n\n for i in range(len(s1)):\n for j in range(len(s2)):\n\n if s1[i] == s2[j]:\n M[i+1,j+1] = M[i,j] + 1\n\n if M[i+1,j+1] > max_length_so_far:\n max_length_so_far = int(M[i+1,j+1])\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\n\n elif M[i+1,j+1] == max_length_so_far:\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\n\n else:\n M[i,j] = 0\n\n candidates.add('')\n\n return candidates","def _lcs_len(a, b):\n dp = _lcs_dp(a, b)\n return dp[-1][-1]","def lcs(a, b):\n # This is an adaptation of the standard LCS dynamic programming algorithm\n # tweaked for lower memory consumption.\n # Sequence a is laid out along the rows, b along the columns.\n # Minimize number of columns to minimize required memory\n if len(a) < len(b):\n a, b = b, a\n # Sequence b now has the minimum length\n # Quit early if one sequence is empty\n if len(b) == 0:\n return 0\n # Use a single buffer to store the counts for the current row, and\n # overwrite it on each pass\n row = [0] * len(b)\n for ai in a:\n left = 0\n diag = 0\n for j, bj in enumerate(b):\n up = row[j]\n if ai == bj:\n value = diag + 1\n else:\n value = max(left, up)\n row[j] = value\n left = value\n diag = up\n # Return the last cell of the last row\n return left","def longest_common_subsequence(x, y):\n\n # find the length of the strings\n m = len(x)\n n = len(y)\n\n # declaring the array for storing the dp values\n lcs = np.zeros((m + 1, n + 1))\n\n # iterate through each sub problem\n for i in range(m + 1):\n for j in range(n + 1):\n if i == 0 or j == 0:\n lcs[i, j] = 0\n elif x[i - 1] == y[j - 1]:\n lcs[i, j] = lcs[i - 1, j - 1] + 1\n else:\n # use the optimal substructure property\n # of using already computed results previous subproblems\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\n\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\n return lcs[m, n]","def lcs(s1, s2):\n n = len(s1)\n m = len(s2)\n # initialise 2d array with size n+1 x m+1\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\n # build array of LCS counters\n for i in range(n + 1):\n for j in range(m + 1):\n if i == 0 or j == 0:\n lcs_array[i][j] = 0\n elif s1[i - 1] == s2[j - 1]:\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\n else:\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\n return lcs_array","def find_lcs(l1: str, l2: str, length1: int, length2: int):\n \"\"\" Theorem:{\n Initialize matrix with 0 for first row and colm\n If s1[i] = s2[j], update matrix[i][j] with value\n of matrix[i-1][j-1]+1\n Else update matrix[i][j] with max of value among\n matrix[i][j-1],matrix[i-1][j]\n Matrix[n][m] will be lcs\n }\n \"\"\"\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\n for i in range(0, length2+1):\n for j in range(0, length1+1):\n if i == 0 or j == 0:\n matrix[i][j] = 0\n elif l1[j-1] == l2[i-1]:\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\n lcs = [None for i in range(0, matrix[length2][length1])]\n index = matrix[length2][length1]\n m = length2 \n n = length1\n while(m > -1 and n > -1):\n if l2[m-1] == l1[n-1]:\n lcs[index-1] = l2[m-1]\n index -= 1\n m -= 1\n n -= 1\n elif matrix[m-1][n] > matrix[m][n-1]:\n m -= 1\n else:\n n -= 1\n return lcs","def lcs_pairwise(s1: str, s2: str, k: int, length: int):\n\n for i in range(0, len(s1) - length + 1):\n for j in range(0, len(s2) - length + 1):\n sub1 = s1[i: i + length]\n sub2 = s2[j: j + length]\n result = pairwise2.align.globalxx(sub1, sub2)\n if result[0][2] >= length - k - 1:\n print(str(i) + \" \" + str(j) + \" \" + str(length - result[0][2]) + \" \" +\n sub1 + \" \" + sub2, end=\"\\t\")\n else:\n print(str(i) + \" \" + str(j) + \" N N N\", end=\"\\t\")\n print(\"\")","def lcs_dp(A, B):\n m = len(A)\n n = len(B) \n # array for storing the intermediate calculations \n temp_arr = [[None]*(n+1) for ]","def _lcs(x, y):\n n, m = len(x), len(y)\n table = dict()\n for i in range(n + 1):\n for j in range(m + 1):\n if i == 0 or j == 0:\n table[i, j] = 0\n elif x[i - 1] == y[j - 1]:\n table[i, j] = table[i - 1, j - 1] + 1\n else:\n table[i, j] = max(table[i - 1, j], table[i, j - 1])\n return table","def lcs(X, Y):\n m, n = len(X), len(Y)\n L = [[0 for x in range(n + 1)] for x in range(m + 1)]\n\n # Following steps build L[m+1][n+1] in bottom up fashion. Note\n # that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1]\n for i in range(m + 1):\n for j in range(n + 1):\n if i == 0 or j == 0:\n L[i][j] = 0\n elif X[i - 1] == Y[j - 1]:\n L[i][j] = L[i - 1][j - 1] + 1\n else:\n L[i][j] = max(L[i - 1][j], L[i][j - 1])\n\n # Following code is used to print LCS\n index = L[m][n]\n\n # Create a character array to store the lcs string\n lcs = [''] * (index + 1)\n lcs[index] = ''\n\n # Start from the right-most-bottom-most corner and\n # one by one store characters in lcs[]\n i = m\n j = n\n while i > 0 and j > 0:\n\n # If current character in X[] and Y are same, then\n # current character is part of LCS\n if X[i - 1] == Y[j - 1]:\n lcs[index - 1] = X[i - 1]\n i -= 1\n j -= 1\n index -= 1\n\n # If not same, then find the larger of two and\n # go in the direction of larger value\n elif L[i - 1][j] > L[i][j - 1]:\n i -= 1\n else:\n j -= 1\n\n return lcs[:-1]","def lcs_similarity(s1, s2):\n max_len = 0\n i = 0\n\n while s1[i] == s2[i]:\n max_len += 1\n i += 1\n if len(s1) == i or len(s2) == i:\n break\n\n if len(s1) < len(s2):\n return float(max_len) / len(s2)\n else:\n return float(max_len) / len(s1)","def lcs_dp(strA, strB):\n rows = len(strA) + 1\n cols = len(strB) + 1\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\n\n for row in range(1, rows):\n for col in range(1, cols):\n if strA[row - 1] == strB[col - 1]:\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\n else:\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\n return dp_table[rows-1][cols-1]","def _calc_lcs(\n self,\n reference: str,\n hypothesis: str) -> int:\n words_ref = ['<S>'] + reference.split(' ')\n words_hyp = ['<S>'] + hypothesis.split(' ')\n\n # calc LCS by DP\n N = len(words_ref)\n M = len(words_hyp)\n LCS = []\n\n for i in range(N):\n LCS.append([0] * M)\n\n for i in range(1, N):\n for j in range(1, M):\n if words_ref[i - 1] == words_hyp[j - 1]:\n LCS[i][j] = LCS[i - 1][j - 1] + 1\n else:\n LCS[i][j] = max(LCS[i - 1][j], LCS[i][j - 1])\n\n return LCS[N-1][M-1]","def all_lcs(X, Y):\n return back_track_all(lcs_length(X, Y), X, Y, len(X), len(Y))","def _compute_lcs(source, target):\n table = _lcs_table(source, target)\n return _backtrack(table, source, target, len(source), len(target))","def find_LCS(seq1, seq2, all=False):\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\n\n for i in range(1, len(seq1) + 1):\n for j in range(1, len(seq2) + 1):\n inter = seq1[i - 1].intersection(seq2[j - 1])\n\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\n C[i - 1][j],\n C[i][j - 1]])\n\n # now we need to backtrack the structure to get the pattern\n if all:\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\n return {i[1:] for i in all_lcs}\n\n lcs = []\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\n return lcs","def lcs_dp(strA, strB):\n rows = len(strA) + 1\n cols = len(strB) + 1\n\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\n \n\n for row in range(rows):\n for col in range(cols):\n if len(strA) == 0 or len(strB) == 0:\n dp_table[row][col] = 0\n \n elif strA[row-1] == strB[col-1]:\n dp_table[row][col] = dp_table[row-1][col-1] + 1\n \n else:\n dp_table[row][col] = max(dp_table[row-1][col], dp_table[row][col-1])\n\n print(dp_table)\n return dp_table[rows-1][cols-1]","def lcs_le(x: List, y: List) -> Tuple[Matrix, atrix]:\n m = len(x)\n n = len(y)\n lcs_matrix = [[None]*(n+1) for i in range(m+1)\n # each index is a optimal solution for each subproblem\n direction_matrix = [[None]*n for i in range(m)]\n # if either indecd is 0 then each element is 0\n for i n ranage(1, m+1):\n lcs_matrix[i][0] = 0\n for j in range(n+1):\n lcs_matrix[0][j] = 0\n for i in range(m):\n for j in range(n):\n if x[i] == y[j]:\n lcs_matrix[i+1][j+1] = lcs_matrix[i][j]+1\n direction_matrix[i][j] = Direction.UPPER_LEFT\n elif lcs_matrix[i][j+1] >= lcs_matrix[i+1][j]:\n lcs_matrix[i+1][j+1] = lcs_matrix[i][j+1]\n direction_matrix[i][j] = Direction.UP\n else:\n lcs_matrix[i+1][j+1] = lcs_matrix[i+1][j]\n direction_matrix[i][j] = Direction.LEFT\n return lcs_matrix, index_matrix","def _recon_lcs(x, y):\n i, j = len(x), len(y)\n table = _lcs(x, y)\n\n def _recon(i, j):\n \"\"\"private recon calculation\"\"\"\n if i == 0 or j == 0:\n return []\n elif x[i - 1] == y[j - 1]:\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\n elif table[i - 1, j] > table[i, j - 1]:\n return _recon(i - 1, j)\n else:\n return _recon(i, j - 1)\n\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\n return recon_tuple","def longest_common_subsequence(seq1, seq2):\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\n mat.fill()\n\n lcs = []\n augSeq1, augSeq2 = mat.augmented_sequences()\n for c1, c2 in zip(augSeq1, augSeq2):\n if c1 == c2:\n lcs.append(c1)\n\n return ''.join(lcs)","def _recon_lcs(x, y):\n i, j = len(x), len(y)\n table = _lcs(x, y)\n\n def _recon(i, j):\n \"\"\"private recon calculation\"\"\"\n if i == 0 or j == 0:\n return []\n elif x[i - 1] == y[j - 1]:\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\n elif table[i - 1, j] > table[i, j - 1]:\n return _recon(i - 1, j)\n else:\n return _recon(i, j - 1)\n\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\n return recon_tuple","def overlap_len(range1, range2):\n return min(range1[1], range2[1]) - max(range1[0], range2[0])","def lcs_dp(strA, strB):\r\n rows = len(strA) + 1\r\n cols = len(strB) + 1\r\n\r\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\r\n\r\n # TODO: Fill in the table using a nested for loop.\r\n\r\n return dp_table[rows-1][cols-1]","def levenshtein(seq1: str, seq2: str) -> int:\n if seq1 == \"\":\n return len(seq2)\n if seq2 == \"\":\n return len(seq1)\n if seq1[-1] == seq2[-1]:\n cost = 0\n else:\n cost = 1\n \n result = min([levenshtein(seq1[:-1], seq2) + 1,\n levenshtein(seq1, seq2[:-1]) + 1,\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\n return result","def optimal_string_alignment_distance(s1, s2):\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n # s1 = utils.unicode_normalize(s1)\n # s2 = utils.unicode_normalize(s2)\n\n n1, n2 = len(s1), len(s2)\n\n dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]\n\n for i in range(0, n1 + 1):\n dp[i][0] = i\n for j in range(0, n2 + 1):\n dp[0][j] = j\n\n for i in range(1, n1 + 1):\n for j in range(1, n2 + 1):\n cost = 0 if s1[i - 1] == s2[j - 1] else 1\n\n dp[i][j] = min(dp[i][j - 1] + 1,\n dp[i - 1][j] + 1,\n dp[i - 1][j - 1] + cost)\n\n if i > 1 and j > 1 and s1[i - 1] == s2[j - 2] and s1[i - 2] == s2[j - 1]:\n dp[i][j] = min(dp[i][j], dp[i - 2][j - 2] + cost)\n\n return dp[n1][n2]","def damerau_levenshtein_distance(s1, s2):\n\n utils.check_for_none(s1, s2)\n utils.check_for_type(str, s1, s2)\n\n # s1 = utils.unicode_normalize(s1)\n # s2 = utils.unicode_normalize(s2)\n\n n1, n2 = len(s1), len(s2)\n infinite = n1 + n2\n\n char_arr = defaultdict(int)\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\n\n dp[0][0] = infinite\n for i in range(0, n1 + 1):\n dp[i + 1][0] = infinite\n dp[i + 1][1] = i\n for i in range(0, n2 + 1):\n dp[0][i + 1] = infinite\n dp[1][i + 1] = i\n\n for i in range(1, n1 + 1):\n db = 0\n for j in range(1, n2 + 1):\n i1 = char_arr[s2[j - 1]]\n j1 = db\n cost = 1\n if s1[i - 1] == s2[j - 1]:\n cost = 0\n db = j\n\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\n dp[i + 1][j] + 1,\n dp[i][j + 1] + 1,\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\n char_arr[s1[i - 1]] = i\n\n return dp[n1 + 1][n2 + 1]","def contig_complementary_score(s1, s2) -> int:\n matcher = SequenceMatcher()\n matcher.set_seq1(str(s1))\n matcher.set_seq2(str(s2.complement()))\n _, _, size = matcher.find_longest_match(0, len(s1), 0, len(s2))\n return size","def longest_common_substring_iterative_bottom_up(s1, s2):\n\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\n\n for i in range(1, len(s1)+1):\n for j in range(1, len(s2)+1):\n\n if s1[i-1] == s2[j-1]:\n\n # previous count is cache[i-1][j-1]\n cache[i][j] = cache[i-1][j-1] + 1\n else:\n cache[i][j] = max(cache[i-1][j-1],\n max(cache[i-1][j],\n cache[i][j-1]))\n\n return cache[-1][-1]","def real_overlap(from_sequence, to_sequence):\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\n start = 0\n start_pos_from = -1\n start_pos_to = -1\n size = -1\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\n len(from_sequence), 0, len(to_sequence))\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\n start = start_pos_from+1\n\n return size","def longest_common_substring_bottom_up(s1, s2):\n lcs_array = lcs(s1, s2)\n n = len(s1)\n m = len(s2)\n l = lcs_array[n][m]\n result = \"\"\n while l != 0:\n if s1[n - 1] == s2[m - 1]:\n result = s1[n - 1] + result\n l -= 1\n n -= 1\n m -= 1\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\n m -= 1\n else:\n n -= 1\n return result","def count_padding_bases(seq1, seq2):\n if len(seq1) <= len(seq2):\n shorter, longer = seq1, seq2\n else:\n shorter, longer = seq2, seq1\n\n n = 0\n for base1, base2 in zip(shorter, longer[: len(shorter)]):\n if base1 == base2:\n n += 1\n else:\n break\n\n return n","def compare_eq_len(a, b):\n n = len(a)\n m = len(b)\n\n # slide b across a from left to right till from just overlapping till full overlap\n overlap = 0 # stores length of the overlap\n lconcat = \"\" # this stores the shortest common superstring\n for j in range(m):\n starta = 0\n enda = j+1\n startb = m - (j+1)\n endb = m\n if a[starta:enda] == b[startb:endb]:\n # if an overlap is found, check if it is larger than the previously detected one\n # print(\"overlap found\")\n if len(a[starta:enda]) > overlap: \n overlap = len(a[starta:enda]) \n lconcat = b + a[enda:] # this is the current shortest common superstring\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # print(\"-\")\n\n # slide b across a so that b starts from one element past a after full overlap\n rconcat = \"\"\n for j in range(m-1):\n starta = j+1\n enda = m\n startb = 0\n endb = m - (j+1)\n if a[starta:enda] == b[startb:endb]:\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \n # print(\"overlap found\")\n overlap = len(a[starta:enda]) \n rconcat = a + b[endb:]\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\n\n # after checking for overlaps there may be 1 or no shortest common\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\n # or the concatenation of a and b if there are no overlaps. We may have to make some\n # arbitrary choices here.\n\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\n superstring = lconcat \n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\n superstring = rconcat\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\n superstring = lconcat\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\n superstring = rconcat\n return superstring","def length_dist(self,synset_1, synset_2):\n\t l_dist = sys.maxsize\n\t if synset_1 is None or synset_2 is None: \n\t return 0.0\n\t if synset_1 == synset_2:\n\t # if synset_1 and synset_2 are the same synset return 0\n\t l_dist = 0.0\n\t else:\n\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \n\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\n\t if len(wset_1.intersection(wset_2)) > 0:\n\t # if synset_1 != synset_2 but there is word overlap, return 1.0\n\t l_dist = 1.0\n\t else:\n\t # just compute the shortest path between the two\n\t l_dist = synset_1.shortest_path_distance(synset_2)\n\t if l_dist is None:\n\t l_dist = 0.0\n\t # normalize path length to the range [0,1]\n\t return math.exp(-self.ALPHA * l_dist)","def levenshteinDistance(s1, s2):\n singleLetterMapping = {DOWNLEFT: '1', DOWN:'2', DOWNRIGHT:'3',\n LEFT:'4', RIGHT:'6',\n UPLEFT:'7', UP:'8', UPRIGHT:'9'}\n\n len1 = len([singleLetterMapping[letter] for letter in s1])\n len2 = len([singleLetterMapping[letter] for letter in s2])\n\n matrix = list(range(len1 + 1)) * (len2 + 1)\n for i in range(len2 + 1):\n matrix[i] = list(range(i, i + len1 + 1))\n for i in range(len2):\n for j in range(len1):\n if s1[j] == s2[i]:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j])\n else:\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j] + 1)\n return matrix[len2][len1]","def lcs_hamming_only_matches(s1: str, s2: str, k: int, length: int, matches_lst: List):\n count = 0\n for i in range(0, len(s1) - length + 1):\n for j in range(0, len(s2) - length + 1):\n sub1 = s1[i: i + length]\n sub2 = s2[j: j + length]\n result = hamming_distance(sub1, sub2)\n if result <= k:\n matches_lst.append([i, j, result, sub1, sub2])\n count += 1\n # print(\"total matches: \" + str(count))\n return count","def length(a, b):\n return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]))","def _lcs_diff_cent(s1, s2):\n m = len(s1)\n n = len(s2)\n\n if s1 == s2:\n return 0\n if m == 0: # When user given query is empty then that is like '*'' (match all)\n return 0\n if n == 0:\n return 100\n\n matrix = [[0] * (n + 1)] * (m + 1)\n for i in range(1, m+1):\n for j in range(1, n+1):\n if s1[i-1] == s2[j-1]:\n matrix[i][j] = matrix[i-1][j-1] + 1\n else:\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\n\n return int( ( 1 - float(matrix[m][n]) / m ) * 100 )","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2):\n #moves shorter sequence along longer, counting number of matches in\n #each position\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\"\n score = score + 1\n else:\n matched = matched + \"-\"\n\n # gives an output for each startpoint showing the number of matches where\n # * is a match and - is no match, position of the two sequences relative to\n # each other, and the number of matches for that startpoint.\n print(\".\" * startpoint + matched) \n print(\".\" * startpoint + s2)\n print(s1)\n print(score) \n print(\" \")\n\n return score","def helper(s1,s2):\n # start with string of smaller len\n if len(s1) > len(s2): # swap\n temp = s1\n s1 = s2\n s2 = temp\n\n ans = 0\n\n # build two counters\n counter1 = collections.Counter(s1)\n counter2 = collections.Counter(s2)\n for item in counter1:\n ans += min(counter1[item],counter2[item])\n\n return ans","def judge(n1: List[int], n2: List[int]) -> int:\n\tmin_length = min(len(n1),len(n2))\n\tpass_count = 0\n\tfor i in range(min_length):\n\t\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\n\n\treturn pass_count","def LCSubSeq(X, Y, m, n):\n LCSuff = [[0 for k in range (n+1)] for l in range(m+1)]\n result = 0\n\n for i in range(m+1):\n for j in range(n+1):\n if (i==0 or j==0):\n LCSuff[i][j] = 0\n elif (X[i-1] == Y[j - 1]):\n LCSuff[i][j] = LCSuff[i-1][j-1] + 1\n result = max(result, LCSuff[i][j])\n else:\n LCSuff[i][j] = 0\n return result","def countingPointMutations(seq1, seq2):\n seqLength = len(list(seq1))\n \n hammingDistance=0;\n for i in range(0,seqLength):\n if list(seq1)[i]!=list(seq2)[i]:\n hammingDistance = hammingDistance+1;\n return hammingDistance","def get_lcp(s,sa):\n lcp = list()\n lcp.append(0)\n for i in range(1,len(sa)):\n lcp.append( longest_prefix_length(s, sa[i], sa[i-1]) )\n return lcp","def _l_distance(first_string, second_string):\n if len(first_string) > len(second_string):\n first_string, second_string = second_string, first_string\n distances = list(range(len(first_string) + 1))\n for index2, char2 in enumerate(second_string):\n new_distances = [index2 + 1]\n for index1, char1 in enumerate(first_string):\n if char1 == char2:\n new_distances.append(distances[index1])\n else:\n new_distances.append(1 + min((distances[index1], distances[index1 + 1], new_distances[-1])))\n distances = new_distances\n return distances[-1]","def pairing_strength(sequence1, sequence2):\n if len(sequence1) != len(sequence2):\n raise SequenceError(\"Sequences are not the same length.\")\n r_sequence2 = [base for base in sequence2[::-1]]\n\n score = 0\n for i in xrange(len(sequence1)):\n score += base_pairing_score(sequence1[i], r_sequence2[i])\n return score","def lev(w1, w2):\n\n if len(w1) < len(w2):\n # check if length of word1 is smaller than word2.\n # if so, call function and switch parameters\n return lev(w2, w1)\n elif len(w1) == 0:\n # if the length of word1 equals 0, that means that\n # the Lev' distance is the length of word2\n return len(w2)\n elif len(w2) == 0:\n # if the length of word2 equals 0, that means that\n # the Lev' distance is the length of word1\n return len(w1)\n elif w1 == w2:\n # check if words are simply the same\n return 0\n\n # thanks to the check above, we can assume that w2 is the longest word\n # we use this information to determine the range of 'previous'\n previous = range(len(w2) + 1)\n\n # DEBUG\n # print(previous)\n\n # iterate over the characters of the first word\n for a, char1 in enumerate(w1):\n # DEBUG\n # print(\"i -> \" + str(a))\n # print(\"char1 -> \" + str(char1))\n\n current = [a + 1]\n\n # iterate over the characters of the second word\n for b, char2 in enumerate(w2):\n # DEBUG\n # print(\"j -> \" + str(b))\n # print(\"\\tchar2 -> \" + str(char2))\n\n inserts = previous[b + 1] + 1\n deletions = current[b] + 1\n subs = previous[b] + (char1 != char2)\n\n # DEBUG\n # print(str(char1 != char2))\n # print(\"INSERTS -> \" + str(inserts))\n # print(\"DELS -> \" + str(deletions))\n # print(\"SUBS -> \" + str(subs))\n\n current.append(min(inserts, deletions, subs))\n\n # DEBUG\n # print(\"CURRENT -> \" + str(current))\n previous = current\n\n return previous[-1]","def commonlen(s1, s2):\n # given \"hi\", \"hip\"\n # izip_longest(\"hi\", \"hip\") -> ('h','h'), ('i','i'), (None, 'p')\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\n try:\n return itertools.dropwhile(\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\n except StopIteration:\n # strings are identical return the len of one of them\n return len(s1)","def m_longest_common_subsequence_2(s):\n\n # Correct me if I'm wrong but I think unsorted list is faster\n lst = list(s)\n\n lcs = lst[0]\n for string in lst[1:]:\n lcs = LCS(lcs, string)\n\n return lcs","def cm_lengths(starts, stops, recombination_data):\n np_starts = np.array(starts, dtype = np.uint32, copy = False)\n np_stops = np.array(stops, dtype = np.uint32, copy = False)\n cm_starts = cumulative_cm(np_starts, recombination_data)\n cm_stops = cumulative_cm(np_stops, recombination_data)\n return cm_stops - cm_starts","def overlap_coefficient(a, b):\n\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\n\n\tintersection = set.intersection(a_words, b_words)\n\tlength_a_words, length_b_words = len(a_words), len(b_words)\n\n\t#empty sets\n\tif length_a_words == 0 or length_b_words == 0: return 0\n\n\t#try to compute overlap_coefficient\n\ttry: overlap_coefficient = len(intersection)/min(length_a_words,length_b_words)\n\texcept: overlap_coefficient = 0\n\n\treturn overlap_coefficient","def longest_subsequence(s1: str, s2: str, s3: str) -> int:\n # Find the shortest string\n s = min(s1, s2, s3, key=lambda x: len(x))\n total = 0\n ok = False\n while s1:\n for i1, c1 in enumerate(s1):\n for i2, c2 in enumerate(s2):\n if ok:\n ok = False\n break\n if c1 == c2:\n for i3, c3 in enumerate(s3):\n if c1 == c3:\n total += 1\n s1 = s1[i1 + 1:]\n s2 = s2[i2 + 1:]\n s3 = s3[i3 + 1:]\n ok = True\n break\n\n return total","def fn(i1, i2):\n if i1 == len(word1): return len(word2) - i2\n if i2 == len(word2): return len(word1) - i1\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))","def _calc_distance(hmm1, hmm2, seqs2):\n p12 = hmm1.calc_loglikelihood(seqs2)\n p22 = hmm2.calc_loglikelihood(seqs2)\n # calc total number of elements in all sequences\n # TODO: consider the case when number of elements vary from seq to seq\n n_elements = len(seqs2) * len(seqs2[0])\n return (p22 - p12) / n_elements","def _lcs(pred_tokens: Sequence[str], target_tokens: Sequence[str], return_full_table: bool=False) ->Union[int, Sequence[Sequence[int]]]:\n lcs = [([0] * (len(pred_tokens) + 1)) for _ in range(len(target_tokens) + 1)]\n for i in range(1, len(target_tokens) + 1):\n for j in range(1, len(pred_tokens) + 1):\n if target_tokens[i - 1] == pred_tokens[j - 1]:\n lcs[i][j] = lcs[i - 1][j - 1] + 1\n else:\n lcs[i][j] = max(lcs[i - 1][j], lcs[i][j - 1])\n if return_full_table:\n return lcs\n return lcs[-1][-1]","def sentence_lengths(sentence_a, sentence_b):\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))","def calculate_score(s1, s2, l1, l2, startpoint):\n\n matched = \"\" # to hold string displaying alignments\n score = 0\n for i in range(l2):\n if (i + startpoint) < l1:\n if s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" # * indicates a match\n score = score + 1\n else:\n matched = matched + \"-\" # - indicates no match\n\n return score","def calculate_score(s1, s2, l1, l2, startpoint):\n matched = \"\" # to hold string displaying alignements\n score = 0\n for i in range(l2): \n if (i + startpoint) < (l1 + l2 - 1): \n if l2 - i > startpoint + 1:\n matched = matched + \".\" #dots before they start overlapping\n elif s1[i + startpoint] == s2[i]: # if the bases match\n matched = matched + \"*\" #matched bases\n score = score + 1 #adds one to score\n else:\n matched = matched + \"-\" #not matched bases\n shift, end_shift = startpoint * \".\", (l2 + l1 - startpoint - 2) * \".\"\n # dots at end, but only up until end of dots tailing l1\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\n # this formula. the below check stops it from getting less than l2.\n if startpoint < l1 - 1:\n print(shift + matched + end_shift)\n else:\n print(shift + matched + (l2 - 1) * \".\")\n print(shift + s2 + end_shift)\n print(s1)\n print(str(score) + \"\\n\")\n return score, matched, shift, end_shift","def common_prefix_length(s, u):\n length = 0\n for cs, cu in zip(s, u):\n if cs != cu:\n break\n length += 1\n return length","def edit_distance(str1, str2):\n\n if not str1:\n return len(str2)\n if not str2:\n return len(str1)\n\n DP = [[-1 for __ in str2] for ___ in str1]\n DP[0][0] = 0 if str1[0] == str2[0] else 1\n\n\n for x, let1 in enumerate(str1):\n startat = 0\n if x == 0:\n startat = 1\n for y, let2 in enumerate(str2[startat:], startat):\n minimum = float('inf')\n if x != 0:\n minimum = min(DP[x-1][y] + 1, minimum)\n if y != 0:\n minimum = min(DP[x-1][y-1] + (0 if let1 == let2 else 1), minimum)\n if y != 0:\n minimum = min(DP[x][y-1] + 1, minimum)\n\n DP[x][y] = minimum\n\n return DP[len(str1) - 1][len(str2) - 1]","def lengthOfLIS(self, nums: List[int]) -> int:\n# time complexity: O(n^2), space complexity: O(n)\n# this is inspired by the solution provided by the question.\n# dp\n# the idea is to use a list longest to record say i-th element in nums, if as the last of the longest possible subsquence, how long the subsquence would be.\n \n\n# time complexity: O(nlogn), space complexity: O(n)\n# dp with binary search\n# the key idea is to use a list to store the longest possible sequence, but the element in the list is not necessarily correct. Every element say record_long[i] in the list means the end of longest subsequence of length i+1\n# this is inspired by @bolinq in the discussion area.\n import bisect\n record_long = []\n for num in nums:\n index = bisect.bisect_left(record_long, num)\n if index == len(record_long):\n record_long.append(num)\n else:\n record_long[index] = num\n \n return len(record_long)","def whatIsLCS (store, word1, word2):\n j = len(word1)\n i = len(word2)\n LCS = ''\n \n while (i>0 and j>0): # Until we hit one of the axis\n if (store[i][j] == store[i-1][j]): # Letter from word 2 doesn't match\n store[i][j] = 'X' # Marking path through table\n i-=1\n printTable(store, word1, word2, 'slow', 'back', 3, LCS) \n\n elif (store[i][j] == store[i][j-1]): # Letter from word 1 doesn't match\n store[i][j] = 'X'\n j-=1\n printTable(store, word1, word2, 'slow', 'back', 4, LCS) \n \n else: # Letters match!\n LCS = word1[j-1] + LCS # Add letter to LCS\n store[i][j] = 'X' \n i-=1\n j-=1\n printTable(store, word1, word2, 'slow', 'back', 5, LCS)\n \n store[i][j] = 'X' # Fixing bug that didn't fill out the last step\n printTable(store, word1, word2, 'slow', 'back', 6, LCS)\n \n return LCS","def longest(s1, s2):\n return ''.join(sorted(set(s1+s2)))","def levenshtein_distance(first, second):\n if len(first) > len(second):\n first, second = second, first\n if len(second) == 0:\n return len(first)\n first_length = len(first) + 1\n second_length = len(second) + 1\n distance_matrix = [range(second_length) for x in range(first_length)]\n for i in range(1, first_length):\n for j in range(1, second_length):\n deletion = distance_matrix[i-1][j] + 1\n insertion = distance_matrix[i][j-1] + 1\n substitution = distance_matrix[i-1][j-1]\n if first[i-1] != second[j-1]:\n substitution += 1\n distance_matrix[i][j] = min(insertion, deletion, substitution)\n\n return distance_matrix[first_length-1][second_length-1]","def string_distance(s1, s2):\n if len(s1) != len(s2):\n return 1\n diff_count = 0\n for c1, c2, in zip(s1, s2):\n if c1 != c2:\n diff_count += 1\n return diff_count","def calculate_distance(seq1,seq2):\r\n mmcounter = 0 #mismatchcount\r\n seqlen = 0 #sequence length\r\n \r\n #cout the sequence length and mismatches\r\n for i in range(len(seq1)):\r\n if seq1[i]!='-' and seq2[i]!='-':\r\n seqlen += 1\r\n if seq1[i] != seq2[i]:\r\n mmcounter += 1\r\n #compute p\r\n p = (mmcounter/seqlen)\r\n #adjust p \r\n if p >= 0.75:\r\n pcorr = float(30)\r\n else:\r\n pcorr = (-3/4)*np.log(1-((4/3)*p))\r\n \r\n return(pcorr)","def two_point_length(tuple1, tuple2):\n tot_sum = 0\n tot_sum += pow(tuple1[0]-tuple2[0], 2)\n tot_sum += pow(tuple1[1]-tuple2[1], 2)\n tot_sum += pow(tuple1[2]-tuple2[2], 2)\n final_len = pow(tot_sum, 1/2)\n return final_len","def leveinshtein_distance(source,target):\r\n\t#Step 1\r\n\ts_len=len(source)\r\n\tt_len=len(target)\r\n\tcost=0\r\n\tif(s_len==0):\r\n\t\treturn t_len\r\n\tif(t_len==0):\r\n\t\treturn s_len\r\n\tprint(\"Dimensions:\\n\\tN:%d\\n\\tM:%d\"%(s_len,t_len))\r\n\t#Step 2\r\n\tmatrix=[[0 for _ in range(0,t_len+1)] for _ in range(0, s_len+1)]\r\n\t#Initialize first row 0..s_len\r\n\tfor idx in range(0,s_len+1):\r\n\t\tmatrix[idx][0]=idx\r\n\t#Initialize the first column 0..t_len\r\n\tfor idx in range(0, t_len+1):\r\n\t\tmatrix[0][idx]=idx\r\n\tprint(\"===Original===\")\r\n\tprint_matrix(matrix,source,target)\r\n\t#Step 3\r\n\tfor i in range(1,s_len+1):\r\n\t\tch=source[i-1]\r\n\t\t#print(ch)\r\n\t\t#Step 4\r\n\t\tfor j in range(1,t_len+1):\r\n\t\t\t#print(\">%s\"%target[j-1])\r\n\t\t\t#Step 5\r\n\t\t\tif ch==target[j-1]:\r\n\t\t\t\tcost=0\r\n\t\t\telse:\r\n\t\t\t\tcost=1\r\n\t\t\t#Step 6\r\n\t\t\t\r\n\t\t\t#print(\"(i,j)=>(%d,%d)\"%(i,j))\r\n\t\t\t#print(matrix[i][j])\r\n\t\t\tmatrix[i][j]=minimum(\r\n\t\t\t\tmatrix[i-1][j]+1,\r\n\t\t\t\tmatrix[i][j-1]+1,\r\n\t\t\t\tmatrix[i-1][j-1]+cost\r\n\t\t\t)\r\n\tprint(\"===Final Matrix===\")\r\n\tprint_matrix(matrix,source,target)\r\n\treturn matrix[s_len-1][t_len-1]","def compSeq(s1, s2, lineL=50):\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\n count = 0\n samecount = 0\n outStr = ''\n for linei in range(lineN):\n if (linei+1) * lineL < min(len(s1), len(s2)):\n end = (linei+1) * lineL\n else:\n end = min(len(s1), len(s2))\n outStr += 'Pos %d - %d\\n' % (linei*lineL+1, end-1+1)\n for sitei in range(linei*lineL, end):\n outStr += s1[sitei]\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = ' ' if s1[sitei] == s2[sitei] else '|'\n outStr += out\n count += 1\n samecount += 1 if s1[sitei]==s2[sitei] else 0\n outStr += '\\n'\n for sitei in range(linei*lineL, end):\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\n outStr += s2[sitei]\n outStr += '\\n\\n'\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\n\\n' % (len(s1), len(s2), 1e2*samecount/count)\n print(outStr)","def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n if len(text1) == 0 or len(text2) == 0:\n return 0\n if text1[0] == text2[0]:\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\n else:\n return max(self.longestCommonSubsequence(text1[1:], text2),\n self.longestCommonSubsequence(text1, text2[1:]))","def makingAnagrams(s1, s2):\n min_del = 0\n\n x = Counter(s1)\n y = Counter(s2)\n\n for key in x:\n if x[key] > 0 and x[key] > y[key]:\n min_del += x[key] - y[key]\n x[key] -= x[key] - y[key]\n elif x[key] == y[key]:\n pass\n elif x[key] > 0 and x[key] < y[key]:\n min_del += y[key] - x[key]\n y[key] -= y[key] - x[key]\n\n for key in y:\n if y[key] > 0 and y[key] > x[key]:\n min_del += y[key] - x[key]\n y[key] -= y[key] - x[key]\n elif x[key] == y[key]:\n pass\n elif y[key] > 0 and y[key] < x[key]:\n min_del += x[key] - y[key]\n x[key] -= x[key] - y[key]\n\n return min_del","def lengthOfLongestSubstringTwoDistinct(self, s):\n if not s:\n return 0\n\n counters = collections.Counter()\n\n start = end = 0\n max_len = -1\n char_count = 0\n while end < len(s):\n if counters[s[end]] == 0:\n char_count += 1\n counters[s[end]] += 1\n\n while char_count > 2:\n counters[s[start]] -= 1\n if counters[s[start]] == 0:\n char_count -= 1\n start += 1\n\n if max_len < end - start + 1:\n max_len = end - start + 1\n\n return max_len","def lcs_recursion(A, B, m, n):\n if m == 0 or n == 0:\n return 0\n elif A[m - 1] == B[n - 1]:\n return 1 + lcs_recursion(A, B, m - 1, n - 1)\n else:\n return max(lcs_recursion(A, B, m, n - 1),\n lcs_recursion(A, B, m - 1, n))","def _pairwise_dist(self,seq1,seq2):\n \n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))","def _common_prefix(sequence1, sequence2):\n i = 0\n for elem1, elem2 in zip(sequence1, sequence2):\n if elem1 != elem2:\n return i\n i += 1\n\n # Return length of sequence if sequences are identical\n return min(len(sequence1), len(sequence2))","def nb_editdistance(seq_vec1, seq_vec2, distance_matrix=identity_nb_distance_matrix, gap_penalty=1):\n \n q_L = seq_vec1.shape[0]\n s_L = seq_vec2.shape[0]\n if q_L == s_L:\n \"\"\"No gaps: substitution distance\n This will make it differ from a strict edit-distance since\n the optimal edit-distance may insert same number of gaps in both sequences\"\"\"\n dist = 0\n for i in range(q_L):\n dist += distance_matrix[seq_vec1[i], seq_vec2[i]]\n return dist\n\n ldmat = np.zeros((q_L, s_L), dtype=np.int16)\n for row in range(1, q_L):\n ldmat[row, 0] = row * gap_penalty\n\n for col in range(1, s_L):\n ldmat[0, col] = col * gap_penalty\n \n for col in range(1, s_L):\n for row in range(1, q_L):\n ldmat[row, col] = min(ldmat[row-1, col] + gap_penalty,\n ldmat[row, col-1] + gap_penalty,\n ldmat[row-1, col-1] + distance_matrix[seq_vec1[row-1], seq_vec2[col-1]]) # substitution\n return ldmat[row, col]","def common_prefix_len(self, other: \"ProofPath\") -> int:\n if self.start() == other.start():\n return self.match_len(other, self.start())\n\n return 0","def _lcs_table(source, target):\n rows = len(source)\n cols = len(target)\n lcs_table = [[0] * (cols + 1) for _ in range(rows + 1)]\n for i in range(1, rows + 1):\n for j in range(1, cols + 1):\n if source[i - 1] == target[j - 1]:\n lcs_table[i][j] = lcs_table[i - 1][j - 1] + 1\n else:\n lcs_table[i][j] = max(lcs_table[i - 1][j], lcs_table[i][j - 1])\n return lcs_table","def _edit_dist(s1, s2):\r\n dist = 0\r\n for i in range(len(s1)):\r\n if s1[i] != s2[i]:\r\n dist += 1\r\n return dist","def levenshtein_distance(s1,s2):\n\n\t\tif len(s1) < len(s2):\n\t\t\treturn Searcher.levenshtein_distance(s2, s1)\n\n\t\t# len(s1) >= len(s2)\n\t\tif len(s2) == 0:\n\t\t\treturn len(s1)\n\n\t\tprevious_row = range(len(s2) + 1)\n\t\tfor i, c1 in enumerate(s1):\n\t\t\tcurrent_row = [i + 1]\n\t\t\tfor j, c2 in enumerate(s2):\n\t\t\t\tinsertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\n\t\t\t\tdeletions = current_row[j] + 1 # than s2\n\t\t\t\tsubstitutions = previous_row[j] + (c1 != c2)\n\t\t\t\tcurrent_row.append(min(insertions, deletions, substitutions))\n\t\t\tprevious_row = current_row\n\t\t\n\t\treturn previous_row[-1]","def mincost(L,m,n):\n # find the length of the strings\n # declaring the array for storing the dp values\n tc = [[0]*(n + 1) for i in range(m + 1)]\n tc[0][0]=L[0][0]\n for i in range(1,m + 1):\n tc[i][0]=tc[i-1][0]+L[i][0]\n for j in range(1,n + 1):\n tc[0][j]=tc[0][j-1]+L[0][j]\n for i in range(1,m+1):\n for j in range(1,n+1):\n tc[i][j]=min(tc[i-1][j-1],tc[i-1][j],tc[i][j-1])+L[i][j]\n\n\n # L[m][n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\n return tc[m][n]","def commonCharacterCount(s1, s2):\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))","def jaccard_distance(label1, label2):\r\n return (len(label1.union(label2)) - len(label1.intersection(label2)))/len(label1.union(label2))","def cort(s1, s2):\n num = 0.0\n sum_square_x = 0.0\n sum_square_y = 0.0\n for t in range(len(s1) - 1):\n slope_1 = s1[t + 1] - s1[t]\n slope_2 = s2[t + 1] - s2[t]\n num += slope_1 * slope_2\n sum_square_x += slope_1 * slope_1\n sum_square_y += slope_2 * slope_2\n return num / (np.sqrt(sum_square_x * sum_square_y))","def get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b, horiz_4ch_a, horiz_4ch_b, lowest_pt_2ch, lowest_pt_4ch):\n top_center_2ch = (np.asarray(horiz_2ch_a[0]) + np.asarray(horiz_2ch_b[0])) / 2.0\n L_2ch = np.linalg.norm(top_center_2ch - np.asarray(lowest_pt_2ch))/1000.0\n\n top_center_4ch = (np.asarray(horiz_4ch_a[0]) + np.asarray(horiz_4ch_b[0])) / 2.0\n L_4ch = np.linalg.norm(top_center_4ch - np.asarray(lowest_pt_4ch))/1000.0\n\n if L_2ch > L_4ch:\n L = L_2ch\n else:\n L = L_4ch\n\n return L","def lungime_multimi(multime_1, multime_2):\n if len(multime_1) < len(multime_2):\n return len(multime_1)\n else:\n return len(multime_2)","def dynamic(a, b):\n m = len(a)\n n = len(b)\n d = [[0 for i in range(n)] for j in range(m)] # d[i][j] is length of common sequence of consecutive\n prev = [-1 for j in range(n)] # numbers that ends with a[i] == b[j]\n global_max = 0\n global_pos = -1\n for i in range(0, m):\n for j in range(0, n): # iterate through all the elements by dual circle\n if a[i] == b[j]: # if pair is equal then check if there is sequence that ends with a[i]-1\n max_len = 0 # find longest sequence ends with a[i]-1\n max_prev = -1\n for k in range(i+1):\n for l in range(j+1):\n if k == i and l == j:\n continue\n if d[k][l] > max_len and a[k] == b[l] == a[i] - 1:\n max_len = d[k][l]\n max_prev = l\n d[i][j] = max_len + 1\n if d[i][j] > global_max:\n global_max = d[i][j]\n global_pos = j\n prev[j] = max_prev\n\n res = [] # rebuild the answer\n while global_pos != -1:\n res.append(b[global_pos])\n global_pos = prev[global_pos]\n\n return res[::-1]","def Levenshtein(a, b):\n v0 = list(range(len(b)+1))\n v1 = list(range(len(b)+1)) # Or whatever.\n\n for i in range(len(a)):\n v1[0] = i + 1\n\n for j in range(len(b)):\n deletionCost = v0[j + 1] + 1\n insertionCost = v1[j] + 1\n substitutionCost = v0[j] if a[i] == b[j] else v0[j]+1\n v1[j + 1] = min(deletionCost, insertionCost, substitutionCost)\n\n v1, v0 = v0, v1\n return v0[len(b)]","def length_sq(pos1, pos2):\n return sum((x-y)**2 for (x,y) in zip(pos1, pos2))","def compare(seq1, seq2):\n if seq1 == seq2:\n return 1\n len_diff = len(seq1) / len(seq2)\n if len_diff > 1:\n len_diff = 1 / len_diff\n\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\n\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\n if overall == 1 or overall == 0:\n return overall\n\n try:\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\n except ValueError:\n return 0\n\n return (len_diff + max_match + overall) / 3","def lengthOfLIS(self, nums):\n n = len(nums)\n if n <= 1:\n return n\n\n max_len = 0\n\n dp = [0] * n\n for i, num in enumerate(nums):\n if i == 0:\n dp[0] = 1\n max_len = 1\n else:\n prev_max = 0\n for j in xrange(i):\n if nums[j] < num:\n prev_max = max(prev_max, dp[j])\n dp[i] = prev_max + 1\n max_len = max(max_len, dp[i])\n\n return max_len","def lcms(argg: range) -> int:\n l = 1\n for arg in argg:\n l = lcm(l, arg)\n return l","def longest_common_substring_backtrack(s1, s2, i, j, count):\n if i == len(s1) or j == len(s2):\n return 0\n\n if s1[i-1] == s2[j-1]:\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\n\n else:\n count = max(count,\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\n\n return count"],"string":"[\n \"def _len_lcs(x, y):\\n table = _lcs(x, y)\\n n, m = len(x), len(y)\\n return table[n, m]\",\n \"def _len_lcs(x, y):\\n table = _lcs(x, y)\\n n, m = len(x), len(y)\\n return table[n, m]\",\n \"def lcs_len(x, y):\\r\\n \\r\\n if len(x) == 0 or len(y) == 0:\\r\\n return 0\\r\\n \\r\\n xx = x[:-1] # xx = sequence x without its last element \\r\\n yy = y[:-1]\\r\\n \\r\\n if x[-1] == y[-1]: # if last elements of x and y are equal\\r\\n return lcs_len(xx, yy) + 1\\r\\n else:\\r\\n return max(lcs_len(xx, y), lcs_len(x, yy))\",\n \"def _len_lcs(x, y):\\n table = _lcs(x, y)\\n n, m = len(x), len(y)\\n return table[n, m]\",\n \"def lcs_length(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n matrix = [([0]*(m+1)) for i in xrange(n+1)]\\n for i in xrange(1, n+1):\\n for j in xrange(1, m+1):\\n if(s1[i-1]==s2[j-1]):\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i-1][j], matrix[i][j-1])\\n return matrix[n][m]\",\n \"def _lcs_dp(a, b):\\n dp = [[0 for _ in range(0, len(b) + 1)]\\n for _ in range(0, len(a) + 1)]\\n # dp[i][j]: lcs_len(a[:i], b[:j])\\n for i in range(1, len(a) + 1):\\n for j in range(1, len(b) + 1):\\n if a[i - 1] == b[j - 1]:\\n dp[i][j] = dp[i - 1][j - 1] + 1\\n else:\\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\\n return dp\",\n \"def LCS_length(str1, str2):\\n if str1 is None or str2 is None:\\n return 0\\n\\n len1 = len(str1)\\n len2 = len(str2)\\n if len1 == 0 or len2 == 0:\\n return 0\\n\\n lcs = [[0 for _ in range(len2 + 1)] for _ in range(2)]\\n for i in range(1, len1 + 1):\\n for j in range(1, len2 + 1):\\n if str1[i - 1] == str2[j - 1]:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j - 1] + 1\\n else:\\n if lcs[i % 2][j - 1] >= lcs[(i - 1) % 2][j]:\\n lcs[i % 2][j] = lcs[i % 2][j - 1]\\n else:\\n lcs[i % 2][j] = lcs[(i - 1) % 2][j]\\n\\n return lcs[len1 % 2][-1]\",\n \"def lcs(s1, s2):\\n\\n shape = (len(s1) + 1, len(s2) + 1)\\n M = np.zeros(shape)\\n\\n max_length_so_far = 0\\n candidates = set()\\n\\n for i in range(len(s1)):\\n for j in range(len(s2)):\\n\\n if s1[i] == s2[j]:\\n M[i+1,j+1] = M[i,j] + 1\\n\\n if M[i+1,j+1] > max_length_so_far:\\n max_length_so_far = int(M[i+1,j+1])\\n candidates = {s1[i - max_length_so_far + 1: i + 1]}\\n\\n elif M[i+1,j+1] == max_length_so_far:\\n candidates.add(s1[i - max_length_so_far + 1: i + 1])\\n\\n else:\\n M[i,j] = 0\\n\\n candidates.add('')\\n\\n return candidates\",\n \"def _lcs_len(a, b):\\n dp = _lcs_dp(a, b)\\n return dp[-1][-1]\",\n \"def lcs(a, b):\\n # This is an adaptation of the standard LCS dynamic programming algorithm\\n # tweaked for lower memory consumption.\\n # Sequence a is laid out along the rows, b along the columns.\\n # Minimize number of columns to minimize required memory\\n if len(a) < len(b):\\n a, b = b, a\\n # Sequence b now has the minimum length\\n # Quit early if one sequence is empty\\n if len(b) == 0:\\n return 0\\n # Use a single buffer to store the counts for the current row, and\\n # overwrite it on each pass\\n row = [0] * len(b)\\n for ai in a:\\n left = 0\\n diag = 0\\n for j, bj in enumerate(b):\\n up = row[j]\\n if ai == bj:\\n value = diag + 1\\n else:\\n value = max(left, up)\\n row[j] = value\\n left = value\\n diag = up\\n # Return the last cell of the last row\\n return left\",\n \"def longest_common_subsequence(x, y):\\n\\n # find the length of the strings\\n m = len(x)\\n n = len(y)\\n\\n # declaring the array for storing the dp values\\n lcs = np.zeros((m + 1, n + 1))\\n\\n # iterate through each sub problem\\n for i in range(m + 1):\\n for j in range(n + 1):\\n if i == 0 or j == 0:\\n lcs[i, j] = 0\\n elif x[i - 1] == y[j - 1]:\\n lcs[i, j] = lcs[i - 1, j - 1] + 1\\n else:\\n # use the optimal substructure property\\n # of using already computed results previous subproblems\\n lcs[i, j] = max(lcs[i - 1, j], lcs[i, j - 1])\\n\\n # L[m,n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\\n return lcs[m, n]\",\n \"def lcs(s1, s2):\\n n = len(s1)\\n m = len(s2)\\n # initialise 2d array with size n+1 x m+1\\n lcs_array = [[None for _ in range(m + 1)] for _ in range(n + 1)]\\n # build array of LCS counters\\n for i in range(n + 1):\\n for j in range(m + 1):\\n if i == 0 or j == 0:\\n lcs_array[i][j] = 0\\n elif s1[i - 1] == s2[j - 1]:\\n lcs_array[i][j] = lcs_array[i - 1][j - 1] + 1\\n else:\\n lcs_array[i][j] = max(lcs_array[i - 1][j], lcs_array[i][j - 1])\\n return lcs_array\",\n \"def find_lcs(l1: str, l2: str, length1: int, length2: int):\\n \\\"\\\"\\\" Theorem:{\\n Initialize matrix with 0 for first row and colm\\n If s1[i] = s2[j], update matrix[i][j] with value\\n of matrix[i-1][j-1]+1\\n Else update matrix[i][j] with max of value among\\n matrix[i][j-1],matrix[i-1][j]\\n Matrix[n][m] will be lcs\\n }\\n \\\"\\\"\\\"\\n matrix = [[None]*(length1+1) for i in range(0, length2+1)]\\n for i in range(0, length2+1):\\n for j in range(0, length1+1):\\n if i == 0 or j == 0:\\n matrix[i][j] = 0\\n elif l1[j-1] == l2[i-1]:\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\\n lcs = [None for i in range(0, matrix[length2][length1])]\\n index = matrix[length2][length1]\\n m = length2 \\n n = length1\\n while(m > -1 and n > -1):\\n if l2[m-1] == l1[n-1]:\\n lcs[index-1] = l2[m-1]\\n index -= 1\\n m -= 1\\n n -= 1\\n elif matrix[m-1][n] > matrix[m][n-1]:\\n m -= 1\\n else:\\n n -= 1\\n return lcs\",\n \"def lcs_pairwise(s1: str, s2: str, k: int, length: int):\\n\\n for i in range(0, len(s1) - length + 1):\\n for j in range(0, len(s2) - length + 1):\\n sub1 = s1[i: i + length]\\n sub2 = s2[j: j + length]\\n result = pairwise2.align.globalxx(sub1, sub2)\\n if result[0][2] >= length - k - 1:\\n print(str(i) + \\\" \\\" + str(j) + \\\" \\\" + str(length - result[0][2]) + \\\" \\\" +\\n sub1 + \\\" \\\" + sub2, end=\\\"\\\\t\\\")\\n else:\\n print(str(i) + \\\" \\\" + str(j) + \\\" N N N\\\", end=\\\"\\\\t\\\")\\n print(\\\"\\\")\",\n \"def lcs_dp(A, B):\\n m = len(A)\\n n = len(B) \\n # array for storing the intermediate calculations \\n temp_arr = [[None]*(n+1) for ]\",\n \"def _lcs(x, y):\\n n, m = len(x), len(y)\\n table = dict()\\n for i in range(n + 1):\\n for j in range(m + 1):\\n if i == 0 or j == 0:\\n table[i, j] = 0\\n elif x[i - 1] == y[j - 1]:\\n table[i, j] = table[i - 1, j - 1] + 1\\n else:\\n table[i, j] = max(table[i - 1, j], table[i, j - 1])\\n return table\",\n \"def lcs(X, Y):\\n m, n = len(X), len(Y)\\n L = [[0 for x in range(n + 1)] for x in range(m + 1)]\\n\\n # Following steps build L[m+1][n+1] in bottom up fashion. Note\\n # that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1]\\n for i in range(m + 1):\\n for j in range(n + 1):\\n if i == 0 or j == 0:\\n L[i][j] = 0\\n elif X[i - 1] == Y[j - 1]:\\n L[i][j] = L[i - 1][j - 1] + 1\\n else:\\n L[i][j] = max(L[i - 1][j], L[i][j - 1])\\n\\n # Following code is used to print LCS\\n index = L[m][n]\\n\\n # Create a character array to store the lcs string\\n lcs = [''] * (index + 1)\\n lcs[index] = ''\\n\\n # Start from the right-most-bottom-most corner and\\n # one by one store characters in lcs[]\\n i = m\\n j = n\\n while i > 0 and j > 0:\\n\\n # If current character in X[] and Y are same, then\\n # current character is part of LCS\\n if X[i - 1] == Y[j - 1]:\\n lcs[index - 1] = X[i - 1]\\n i -= 1\\n j -= 1\\n index -= 1\\n\\n # If not same, then find the larger of two and\\n # go in the direction of larger value\\n elif L[i - 1][j] > L[i][j - 1]:\\n i -= 1\\n else:\\n j -= 1\\n\\n return lcs[:-1]\",\n \"def lcs_similarity(s1, s2):\\n max_len = 0\\n i = 0\\n\\n while s1[i] == s2[i]:\\n max_len += 1\\n i += 1\\n if len(s1) == i or len(s2) == i:\\n break\\n\\n if len(s1) < len(s2):\\n return float(max_len) / len(s2)\\n else:\\n return float(max_len) / len(s1)\",\n \"def lcs_dp(strA, strB):\\n rows = len(strA) + 1\\n cols = len(strB) + 1\\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\\n\\n for row in range(1, rows):\\n for col in range(1, cols):\\n if strA[row - 1] == strB[col - 1]:\\n dp_table[row][col] = dp_table[row - 1][col - 1] + 1\\n else:\\n dp_table[row][col] = max(dp_table[row][col - 1], dp_table[row - 1][col])\\n return dp_table[rows-1][cols-1]\",\n \"def _calc_lcs(\\n self,\\n reference: str,\\n hypothesis: str) -> int:\\n words_ref = ['<S>'] + reference.split(' ')\\n words_hyp = ['<S>'] + hypothesis.split(' ')\\n\\n # calc LCS by DP\\n N = len(words_ref)\\n M = len(words_hyp)\\n LCS = []\\n\\n for i in range(N):\\n LCS.append([0] * M)\\n\\n for i in range(1, N):\\n for j in range(1, M):\\n if words_ref[i - 1] == words_hyp[j - 1]:\\n LCS[i][j] = LCS[i - 1][j - 1] + 1\\n else:\\n LCS[i][j] = max(LCS[i - 1][j], LCS[i][j - 1])\\n\\n return LCS[N-1][M-1]\",\n \"def all_lcs(X, Y):\\n return back_track_all(lcs_length(X, Y), X, Y, len(X), len(Y))\",\n \"def _compute_lcs(source, target):\\n table = _lcs_table(source, target)\\n return _backtrack(table, source, target, len(source), len(target))\",\n \"def find_LCS(seq1, seq2, all=False):\\n C = [[0 for j in range(len(seq2) + 1)] for i in range(len(seq1) + 1)]\\n\\n for i in range(1, len(seq1) + 1):\\n for j in range(1, len(seq2) + 1):\\n inter = seq1[i - 1].intersection(seq2[j - 1])\\n\\n C[i][j] = max([C[i - 1][j - 1] + len(inter),\\n C[i - 1][j],\\n C[i][j - 1]])\\n\\n # now we need to backtrack the structure to get the pattern\\n if all:\\n all_lcs = backtrack_all_LCS(C, seq1, seq2, len(seq1), len(seq2))\\n return {i[1:] for i in all_lcs}\\n\\n lcs = []\\n backtrack_LCS(C, seq1, seq2, len(seq1), len(seq2), lcs)\\n return lcs\",\n \"def lcs_dp(strA, strB):\\n rows = len(strA) + 1\\n cols = len(strB) + 1\\n\\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\\n \\n\\n for row in range(rows):\\n for col in range(cols):\\n if len(strA) == 0 or len(strB) == 0:\\n dp_table[row][col] = 0\\n \\n elif strA[row-1] == strB[col-1]:\\n dp_table[row][col] = dp_table[row-1][col-1] + 1\\n \\n else:\\n dp_table[row][col] = max(dp_table[row-1][col], dp_table[row][col-1])\\n\\n print(dp_table)\\n return dp_table[rows-1][cols-1]\",\n \"def lcs_le(x: List, y: List) -> Tuple[Matrix, atrix]:\\n m = len(x)\\n n = len(y)\\n lcs_matrix = [[None]*(n+1) for i in range(m+1)\\n # each index is a optimal solution for each subproblem\\n direction_matrix = [[None]*n for i in range(m)]\\n # if either indecd is 0 then each element is 0\\n for i n ranage(1, m+1):\\n lcs_matrix[i][0] = 0\\n for j in range(n+1):\\n lcs_matrix[0][j] = 0\\n for i in range(m):\\n for j in range(n):\\n if x[i] == y[j]:\\n lcs_matrix[i+1][j+1] = lcs_matrix[i][j]+1\\n direction_matrix[i][j] = Direction.UPPER_LEFT\\n elif lcs_matrix[i][j+1] >= lcs_matrix[i+1][j]:\\n lcs_matrix[i+1][j+1] = lcs_matrix[i][j+1]\\n direction_matrix[i][j] = Direction.UP\\n else:\\n lcs_matrix[i+1][j+1] = lcs_matrix[i+1][j]\\n direction_matrix[i][j] = Direction.LEFT\\n return lcs_matrix, index_matrix\",\n \"def _recon_lcs(x, y):\\n i, j = len(x), len(y)\\n table = _lcs(x, y)\\n\\n def _recon(i, j):\\n \\\"\\\"\\\"private recon calculation\\\"\\\"\\\"\\n if i == 0 or j == 0:\\n return []\\n elif x[i - 1] == y[j - 1]:\\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\\n elif table[i - 1, j] > table[i, j - 1]:\\n return _recon(i - 1, j)\\n else:\\n return _recon(i, j - 1)\\n\\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\\n return recon_tuple\",\n \"def longest_common_subsequence(seq1, seq2):\\n mat = DPMatrix(seq1, seq2, match=1, mismatch=0, gap=0)\\n mat.fill()\\n\\n lcs = []\\n augSeq1, augSeq2 = mat.augmented_sequences()\\n for c1, c2 in zip(augSeq1, augSeq2):\\n if c1 == c2:\\n lcs.append(c1)\\n\\n return ''.join(lcs)\",\n \"def _recon_lcs(x, y):\\n i, j = len(x), len(y)\\n table = _lcs(x, y)\\n\\n def _recon(i, j):\\n \\\"\\\"\\\"private recon calculation\\\"\\\"\\\"\\n if i == 0 or j == 0:\\n return []\\n elif x[i - 1] == y[j - 1]:\\n return _recon(i - 1, j - 1) + [(x[i - 1], i)]\\n elif table[i - 1, j] > table[i, j - 1]:\\n return _recon(i - 1, j)\\n else:\\n return _recon(i, j - 1)\\n\\n recon_tuple = tuple(map(lambda x: x[0], _recon(i, j)))\\n return recon_tuple\",\n \"def overlap_len(range1, range2):\\n return min(range1[1], range2[1]) - max(range1[0], range2[0])\",\n \"def lcs_dp(strA, strB):\\r\\n rows = len(strA) + 1\\r\\n cols = len(strB) + 1\\r\\n\\r\\n dp_table = [[0 for j in range(cols)] for i in range(rows)]\\r\\n\\r\\n # TODO: Fill in the table using a nested for loop.\\r\\n\\r\\n return dp_table[rows-1][cols-1]\",\n \"def levenshtein(seq1: str, seq2: str) -> int:\\n if seq1 == \\\"\\\":\\n return len(seq2)\\n if seq2 == \\\"\\\":\\n return len(seq1)\\n if seq1[-1] == seq2[-1]:\\n cost = 0\\n else:\\n cost = 1\\n \\n result = min([levenshtein(seq1[:-1], seq2) + 1,\\n levenshtein(seq1, seq2[:-1]) + 1,\\n levenshtein(seq1[:-1], seq2[:-1]) + cost ])\\n return result\",\n \"def optimal_string_alignment_distance(s1, s2):\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n # s1 = utils.unicode_normalize(s1)\\n # s2 = utils.unicode_normalize(s2)\\n\\n n1, n2 = len(s1), len(s2)\\n\\n dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]\\n\\n for i in range(0, n1 + 1):\\n dp[i][0] = i\\n for j in range(0, n2 + 1):\\n dp[0][j] = j\\n\\n for i in range(1, n1 + 1):\\n for j in range(1, n2 + 1):\\n cost = 0 if s1[i - 1] == s2[j - 1] else 1\\n\\n dp[i][j] = min(dp[i][j - 1] + 1,\\n dp[i - 1][j] + 1,\\n dp[i - 1][j - 1] + cost)\\n\\n if i > 1 and j > 1 and s1[i - 1] == s2[j - 2] and s1[i - 2] == s2[j - 1]:\\n dp[i][j] = min(dp[i][j], dp[i - 2][j - 2] + cost)\\n\\n return dp[n1][n2]\",\n \"def damerau_levenshtein_distance(s1, s2):\\n\\n utils.check_for_none(s1, s2)\\n utils.check_for_type(str, s1, s2)\\n\\n # s1 = utils.unicode_normalize(s1)\\n # s2 = utils.unicode_normalize(s2)\\n\\n n1, n2 = len(s1), len(s2)\\n infinite = n1 + n2\\n\\n char_arr = defaultdict(int)\\n dp = [[0] * (n2 + 2) for _ in range(n1 + 2)]\\n\\n dp[0][0] = infinite\\n for i in range(0, n1 + 1):\\n dp[i + 1][0] = infinite\\n dp[i + 1][1] = i\\n for i in range(0, n2 + 1):\\n dp[0][i + 1] = infinite\\n dp[1][i + 1] = i\\n\\n for i in range(1, n1 + 1):\\n db = 0\\n for j in range(1, n2 + 1):\\n i1 = char_arr[s2[j - 1]]\\n j1 = db\\n cost = 1\\n if s1[i - 1] == s2[j - 1]:\\n cost = 0\\n db = j\\n\\n dp[i + 1][j + 1] = min(dp[i][j] + cost,\\n dp[i + 1][j] + 1,\\n dp[i][j + 1] + 1,\\n dp[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1))\\n char_arr[s1[i - 1]] = i\\n\\n return dp[n1 + 1][n2 + 1]\",\n \"def contig_complementary_score(s1, s2) -> int:\\n matcher = SequenceMatcher()\\n matcher.set_seq1(str(s1))\\n matcher.set_seq2(str(s2.complement()))\\n _, _, size = matcher.find_longest_match(0, len(s1), 0, len(s2))\\n return size\",\n \"def longest_common_substring_iterative_bottom_up(s1, s2):\\n\\n cache = [[0] * (len(s2)+1) for _ in range(-1, len(s1))]\\n\\n for i in range(1, len(s1)+1):\\n for j in range(1, len(s2)+1):\\n\\n if s1[i-1] == s2[j-1]:\\n\\n # previous count is cache[i-1][j-1]\\n cache[i][j] = cache[i-1][j-1] + 1\\n else:\\n cache[i][j] = max(cache[i-1][j-1],\\n max(cache[i-1][j],\\n cache[i][j-1]))\\n\\n return cache[-1][-1]\",\n \"def real_overlap(from_sequence, to_sequence):\\n sequence_overlap = difflib.SequenceMatcher(None, from_sequence, to_sequence)\\n start = 0\\n start_pos_from = -1\\n start_pos_to = -1\\n size = -1\\n while start_pos_to != 0 or not start_pos_from+size == len(from_sequence):\\n start_pos_from, start_pos_to, size = sequence_overlap.find_longest_match(start, \\\\\\n len(from_sequence), 0, len(to_sequence))\\n if not start_pos_to == 0 or not start_pos_from+size == len(from_sequence):\\n start = start_pos_from+1\\n\\n return size\",\n \"def longest_common_substring_bottom_up(s1, s2):\\n lcs_array = lcs(s1, s2)\\n n = len(s1)\\n m = len(s2)\\n l = lcs_array[n][m]\\n result = \\\"\\\"\\n while l != 0:\\n if s1[n - 1] == s2[m - 1]:\\n result = s1[n - 1] + result\\n l -= 1\\n n -= 1\\n m -= 1\\n elif lcs_array[n][m - 1] >= lcs_array[n - 1][m]:\\n m -= 1\\n else:\\n n -= 1\\n return result\",\n \"def count_padding_bases(seq1, seq2):\\n if len(seq1) <= len(seq2):\\n shorter, longer = seq1, seq2\\n else:\\n shorter, longer = seq2, seq1\\n\\n n = 0\\n for base1, base2 in zip(shorter, longer[: len(shorter)]):\\n if base1 == base2:\\n n += 1\\n else:\\n break\\n\\n return n\",\n \"def compare_eq_len(a, b):\\n n = len(a)\\n m = len(b)\\n\\n # slide b across a from left to right till from just overlapping till full overlap\\n overlap = 0 # stores length of the overlap\\n lconcat = \\\"\\\" # this stores the shortest common superstring\\n for j in range(m):\\n starta = 0\\n enda = j+1\\n startb = m - (j+1)\\n endb = m\\n if a[starta:enda] == b[startb:endb]:\\n # if an overlap is found, check if it is larger than the previously detected one\\n # print(\\\"overlap found\\\")\\n if len(a[starta:enda]) > overlap: \\n overlap = len(a[starta:enda]) \\n lconcat = b + a[enda:] # this is the current shortest common superstring\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # print(\\\"-\\\")\\n\\n # slide b across a so that b starts from one element past a after full overlap\\n rconcat = \\\"\\\"\\n for j in range(m-1):\\n starta = j+1\\n enda = m\\n startb = 0\\n endb = m - (j+1)\\n if a[starta:enda] == b[startb:endb]:\\n if len(a[starta:enda]) > overlap: # if there is a bigger overlap then save it \\n # print(\\\"overlap found\\\")\\n overlap = len(a[starta:enda]) \\n rconcat = a + b[endb:]\\n # print(starta, enda, startb, endb, a[starta:enda], b[startb:endb])\\n\\n # after checking for overlaps there may be 1 or no shortest common\\n # superstrings stored in both lconcat and rconcat. Choose the shortest one if it exists\\n # or the concatenation of a and b if there are no overlaps. We may have to make some\\n # arbitrary choices here.\\n\\n if not lconcat and not rconcat: # both lconcat and rconcat are empty, no overlaps\\n superstring = a + b # append b to a (could prepend here too, this is an arbitrary choice)\\n elif lconcat and not rconcat: # lconcat contains overlap and rconcat is empty\\n superstring = lconcat \\n elif rconcat and not lconcat: # rconcat contains overlap and lconcat is empty\\n superstring = rconcat\\n elif rconcat and lconcat and (len(lconcat) <= len(rconcat)): # use lconcat if it is shorter or equal len to rconat\\n superstring = lconcat\\n elif rconcat and lconcat and (len(rconcat) < len(lconcat)): # use rconcat only if it is shorter than lconat\\n superstring = rconcat\\n return superstring\",\n \"def length_dist(self,synset_1, synset_2):\\n\\t l_dist = sys.maxsize\\n\\t if synset_1 is None or synset_2 is None: \\n\\t return 0.0\\n\\t if synset_1 == synset_2:\\n\\t # if synset_1 and synset_2 are the same synset return 0\\n\\t l_dist = 0.0\\n\\t else:\\n\\t wset_1 = set([str(x.name()) for x in synset_1.lemmas()]) \\n\\t wset_2 = set([str(x.name()) for x in synset_2.lemmas()])\\n\\t if len(wset_1.intersection(wset_2)) > 0:\\n\\t # if synset_1 != synset_2 but there is word overlap, return 1.0\\n\\t l_dist = 1.0\\n\\t else:\\n\\t # just compute the shortest path between the two\\n\\t l_dist = synset_1.shortest_path_distance(synset_2)\\n\\t if l_dist is None:\\n\\t l_dist = 0.0\\n\\t # normalize path length to the range [0,1]\\n\\t return math.exp(-self.ALPHA * l_dist)\",\n \"def levenshteinDistance(s1, s2):\\n singleLetterMapping = {DOWNLEFT: '1', DOWN:'2', DOWNRIGHT:'3',\\n LEFT:'4', RIGHT:'6',\\n UPLEFT:'7', UP:'8', UPRIGHT:'9'}\\n\\n len1 = len([singleLetterMapping[letter] for letter in s1])\\n len2 = len([singleLetterMapping[letter] for letter in s2])\\n\\n matrix = list(range(len1 + 1)) * (len2 + 1)\\n for i in range(len2 + 1):\\n matrix[i] = list(range(i, i + len1 + 1))\\n for i in range(len2):\\n for j in range(len1):\\n if s1[j] == s2[i]:\\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j])\\n else:\\n matrix[i+1][j+1] = min(matrix[i+1][j] + 1, matrix[i][j+1] + 1, matrix[i][j] + 1)\\n return matrix[len2][len1]\",\n \"def lcs_hamming_only_matches(s1: str, s2: str, k: int, length: int, matches_lst: List):\\n count = 0\\n for i in range(0, len(s1) - length + 1):\\n for j in range(0, len(s2) - length + 1):\\n sub1 = s1[i: i + length]\\n sub2 = s2[j: j + length]\\n result = hamming_distance(sub1, sub2)\\n if result <= k:\\n matches_lst.append([i, j, result, sub1, sub2])\\n count += 1\\n # print(\\\"total matches: \\\" + str(count))\\n return count\",\n \"def length(a, b):\\n return sqrt((a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]))\",\n \"def _lcs_diff_cent(s1, s2):\\n m = len(s1)\\n n = len(s2)\\n\\n if s1 == s2:\\n return 0\\n if m == 0: # When user given query is empty then that is like '*'' (match all)\\n return 0\\n if n == 0:\\n return 100\\n\\n matrix = [[0] * (n + 1)] * (m + 1)\\n for i in range(1, m+1):\\n for j in range(1, n+1):\\n if s1[i-1] == s2[j-1]:\\n matrix[i][j] = matrix[i-1][j-1] + 1\\n else:\\n matrix[i][j] = max(matrix[i][j-1], matrix[i-1][j])\\n\\n return int( ( 1 - float(matrix[m][n]) / m ) * 100 )\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2):\\n #moves shorter sequence along longer, counting number of matches in\\n #each position\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\"\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\"\\n\\n # gives an output for each startpoint showing the number of matches where\\n # * is a match and - is no match, position of the two sequences relative to\\n # each other, and the number of matches for that startpoint.\\n print(\\\".\\\" * startpoint + matched) \\n print(\\\".\\\" * startpoint + s2)\\n print(s1)\\n print(score) \\n print(\\\" \\\")\\n\\n return score\",\n \"def helper(s1,s2):\\n # start with string of smaller len\\n if len(s1) > len(s2): # swap\\n temp = s1\\n s1 = s2\\n s2 = temp\\n\\n ans = 0\\n\\n # build two counters\\n counter1 = collections.Counter(s1)\\n counter2 = collections.Counter(s2)\\n for item in counter1:\\n ans += min(counter1[item],counter2[item])\\n\\n return ans\",\n \"def judge(n1: List[int], n2: List[int]) -> int:\\n\\tmin_length = min(len(n1),len(n2))\\n\\tpass_count = 0\\n\\tfor i in range(min_length):\\n\\t\\tpass_count += get_lowest_16(n1[i]) == get_lowest_16(n2[i])\\n\\n\\treturn pass_count\",\n \"def LCSubSeq(X, Y, m, n):\\n LCSuff = [[0 for k in range (n+1)] for l in range(m+1)]\\n result = 0\\n\\n for i in range(m+1):\\n for j in range(n+1):\\n if (i==0 or j==0):\\n LCSuff[i][j] = 0\\n elif (X[i-1] == Y[j - 1]):\\n LCSuff[i][j] = LCSuff[i-1][j-1] + 1\\n result = max(result, LCSuff[i][j])\\n else:\\n LCSuff[i][j] = 0\\n return result\",\n \"def countingPointMutations(seq1, seq2):\\n seqLength = len(list(seq1))\\n \\n hammingDistance=0;\\n for i in range(0,seqLength):\\n if list(seq1)[i]!=list(seq2)[i]:\\n hammingDistance = hammingDistance+1;\\n return hammingDistance\",\n \"def get_lcp(s,sa):\\n lcp = list()\\n lcp.append(0)\\n for i in range(1,len(sa)):\\n lcp.append( longest_prefix_length(s, sa[i], sa[i-1]) )\\n return lcp\",\n \"def _l_distance(first_string, second_string):\\n if len(first_string) > len(second_string):\\n first_string, second_string = second_string, first_string\\n distances = list(range(len(first_string) + 1))\\n for index2, char2 in enumerate(second_string):\\n new_distances = [index2 + 1]\\n for index1, char1 in enumerate(first_string):\\n if char1 == char2:\\n new_distances.append(distances[index1])\\n else:\\n new_distances.append(1 + min((distances[index1], distances[index1 + 1], new_distances[-1])))\\n distances = new_distances\\n return distances[-1]\",\n \"def pairing_strength(sequence1, sequence2):\\n if len(sequence1) != len(sequence2):\\n raise SequenceError(\\\"Sequences are not the same length.\\\")\\n r_sequence2 = [base for base in sequence2[::-1]]\\n\\n score = 0\\n for i in xrange(len(sequence1)):\\n score += base_pairing_score(sequence1[i], r_sequence2[i])\\n return score\",\n \"def lev(w1, w2):\\n\\n if len(w1) < len(w2):\\n # check if length of word1 is smaller than word2.\\n # if so, call function and switch parameters\\n return lev(w2, w1)\\n elif len(w1) == 0:\\n # if the length of word1 equals 0, that means that\\n # the Lev' distance is the length of word2\\n return len(w2)\\n elif len(w2) == 0:\\n # if the length of word2 equals 0, that means that\\n # the Lev' distance is the length of word1\\n return len(w1)\\n elif w1 == w2:\\n # check if words are simply the same\\n return 0\\n\\n # thanks to the check above, we can assume that w2 is the longest word\\n # we use this information to determine the range of 'previous'\\n previous = range(len(w2) + 1)\\n\\n # DEBUG\\n # print(previous)\\n\\n # iterate over the characters of the first word\\n for a, char1 in enumerate(w1):\\n # DEBUG\\n # print(\\\"i -> \\\" + str(a))\\n # print(\\\"char1 -> \\\" + str(char1))\\n\\n current = [a + 1]\\n\\n # iterate over the characters of the second word\\n for b, char2 in enumerate(w2):\\n # DEBUG\\n # print(\\\"j -> \\\" + str(b))\\n # print(\\\"\\\\tchar2 -> \\\" + str(char2))\\n\\n inserts = previous[b + 1] + 1\\n deletions = current[b] + 1\\n subs = previous[b] + (char1 != char2)\\n\\n # DEBUG\\n # print(str(char1 != char2))\\n # print(\\\"INSERTS -> \\\" + str(inserts))\\n # print(\\\"DELS -> \\\" + str(deletions))\\n # print(\\\"SUBS -> \\\" + str(subs))\\n\\n current.append(min(inserts, deletions, subs))\\n\\n # DEBUG\\n # print(\\\"CURRENT -> \\\" + str(current))\\n previous = current\\n\\n return previous[-1]\",\n \"def commonlen(s1, s2):\\n # given \\\"hi\\\", \\\"hip\\\"\\n # izip_longest(\\\"hi\\\", \\\"hip\\\") -> ('h','h'), ('i','i'), (None, 'p')\\n # enumerate -> (0,('h','h')), (1,('i','i')), (2,(None, 'p'))\\n # dropwhile(lambda (i,(x,y)): x == 5 -> (2,(None,'p')) ...\\n try:\\n return itertools.dropwhile(\\n lambda (i, (x, y)): x == y, enumerate(zip(s1, s2))).next()[0]\\n except StopIteration:\\n # strings are identical return the len of one of them\\n return len(s1)\",\n \"def m_longest_common_subsequence_2(s):\\n\\n # Correct me if I'm wrong but I think unsorted list is faster\\n lst = list(s)\\n\\n lcs = lst[0]\\n for string in lst[1:]:\\n lcs = LCS(lcs, string)\\n\\n return lcs\",\n \"def cm_lengths(starts, stops, recombination_data):\\n np_starts = np.array(starts, dtype = np.uint32, copy = False)\\n np_stops = np.array(stops, dtype = np.uint32, copy = False)\\n cm_starts = cumulative_cm(np_starts, recombination_data)\\n cm_stops = cumulative_cm(np_stops, recombination_data)\\n return cm_stops - cm_starts\",\n \"def overlap_coefficient(a, b):\\n\\ta_words, b_words = map(norm.set_clean_tokens, [a,b])\\n\\n\\tintersection = set.intersection(a_words, b_words)\\n\\tlength_a_words, length_b_words = len(a_words), len(b_words)\\n\\n\\t#empty sets\\n\\tif length_a_words == 0 or length_b_words == 0: return 0\\n\\n\\t#try to compute overlap_coefficient\\n\\ttry: overlap_coefficient = len(intersection)/min(length_a_words,length_b_words)\\n\\texcept: overlap_coefficient = 0\\n\\n\\treturn overlap_coefficient\",\n \"def longest_subsequence(s1: str, s2: str, s3: str) -> int:\\n # Find the shortest string\\n s = min(s1, s2, s3, key=lambda x: len(x))\\n total = 0\\n ok = False\\n while s1:\\n for i1, c1 in enumerate(s1):\\n for i2, c2 in enumerate(s2):\\n if ok:\\n ok = False\\n break\\n if c1 == c2:\\n for i3, c3 in enumerate(s3):\\n if c1 == c3:\\n total += 1\\n s1 = s1[i1 + 1:]\\n s2 = s2[i2 + 1:]\\n s3 = s3[i3 + 1:]\\n ok = True\\n break\\n\\n return total\",\n \"def fn(i1, i2):\\n if i1 == len(word1): return len(word2) - i2\\n if i2 == len(word2): return len(word1) - i1\\n if word1[i1] == word2[i2]: return fn(i1+1, i2+1)\\n return 1 + min(fn(i1+1,i2), fn(i1, i2+1))\",\n \"def _calc_distance(hmm1, hmm2, seqs2):\\n p12 = hmm1.calc_loglikelihood(seqs2)\\n p22 = hmm2.calc_loglikelihood(seqs2)\\n # calc total number of elements in all sequences\\n # TODO: consider the case when number of elements vary from seq to seq\\n n_elements = len(seqs2) * len(seqs2[0])\\n return (p22 - p12) / n_elements\",\n \"def _lcs(pred_tokens: Sequence[str], target_tokens: Sequence[str], return_full_table: bool=False) ->Union[int, Sequence[Sequence[int]]]:\\n lcs = [([0] * (len(pred_tokens) + 1)) for _ in range(len(target_tokens) + 1)]\\n for i in range(1, len(target_tokens) + 1):\\n for j in range(1, len(pred_tokens) + 1):\\n if target_tokens[i - 1] == pred_tokens[j - 1]:\\n lcs[i][j] = lcs[i - 1][j - 1] + 1\\n else:\\n lcs[i][j] = max(lcs[i - 1][j], lcs[i][j - 1])\\n if return_full_table:\\n return lcs\\n return lcs[-1][-1]\",\n \"def sentence_lengths(sentence_a, sentence_b):\\n return abs(len(sentence_a)-len(sentence_b))/float(min(len(sentence_a),len(sentence_b)))\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n\\n matched = \\\"\\\" # to hold string displaying alignments\\n score = 0\\n for i in range(l2):\\n if (i + startpoint) < l1:\\n if s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" # * indicates a match\\n score = score + 1\\n else:\\n matched = matched + \\\"-\\\" # - indicates no match\\n\\n return score\",\n \"def calculate_score(s1, s2, l1, l2, startpoint):\\n matched = \\\"\\\" # to hold string displaying alignements\\n score = 0\\n for i in range(l2): \\n if (i + startpoint) < (l1 + l2 - 1): \\n if l2 - i > startpoint + 1:\\n matched = matched + \\\".\\\" #dots before they start overlapping\\n elif s1[i + startpoint] == s2[i]: # if the bases match\\n matched = matched + \\\"*\\\" #matched bases\\n score = score + 1 #adds one to score\\n else:\\n matched = matched + \\\"-\\\" #not matched bases\\n shift, end_shift = startpoint * \\\".\\\", (l2 + l1 - startpoint - 2) * \\\".\\\"\\n # dots at end, but only up until end of dots tailing l1\\n # if startpoint is bigger than l1-2, end shift is less than l2 according to\\n # this formula. the below check stops it from getting less than l2.\\n if startpoint < l1 - 1:\\n print(shift + matched + end_shift)\\n else:\\n print(shift + matched + (l2 - 1) * \\\".\\\")\\n print(shift + s2 + end_shift)\\n print(s1)\\n print(str(score) + \\\"\\\\n\\\")\\n return score, matched, shift, end_shift\",\n \"def common_prefix_length(s, u):\\n length = 0\\n for cs, cu in zip(s, u):\\n if cs != cu:\\n break\\n length += 1\\n return length\",\n \"def edit_distance(str1, str2):\\n\\n if not str1:\\n return len(str2)\\n if not str2:\\n return len(str1)\\n\\n DP = [[-1 for __ in str2] for ___ in str1]\\n DP[0][0] = 0 if str1[0] == str2[0] else 1\\n\\n\\n for x, let1 in enumerate(str1):\\n startat = 0\\n if x == 0:\\n startat = 1\\n for y, let2 in enumerate(str2[startat:], startat):\\n minimum = float('inf')\\n if x != 0:\\n minimum = min(DP[x-1][y] + 1, minimum)\\n if y != 0:\\n minimum = min(DP[x-1][y-1] + (0 if let1 == let2 else 1), minimum)\\n if y != 0:\\n minimum = min(DP[x][y-1] + 1, minimum)\\n\\n DP[x][y] = minimum\\n\\n return DP[len(str1) - 1][len(str2) - 1]\",\n \"def lengthOfLIS(self, nums: List[int]) -> int:\\n# time complexity: O(n^2), space complexity: O(n)\\n# this is inspired by the solution provided by the question.\\n# dp\\n# the idea is to use a list longest to record say i-th element in nums, if as the last of the longest possible subsquence, how long the subsquence would be.\\n \\n\\n# time complexity: O(nlogn), space complexity: O(n)\\n# dp with binary search\\n# the key idea is to use a list to store the longest possible sequence, but the element in the list is not necessarily correct. Every element say record_long[i] in the list means the end of longest subsequence of length i+1\\n# this is inspired by @bolinq in the discussion area.\\n import bisect\\n record_long = []\\n for num in nums:\\n index = bisect.bisect_left(record_long, num)\\n if index == len(record_long):\\n record_long.append(num)\\n else:\\n record_long[index] = num\\n \\n return len(record_long)\",\n \"def whatIsLCS (store, word1, word2):\\n j = len(word1)\\n i = len(word2)\\n LCS = ''\\n \\n while (i>0 and j>0): # Until we hit one of the axis\\n if (store[i][j] == store[i-1][j]): # Letter from word 2 doesn't match\\n store[i][j] = 'X' # Marking path through table\\n i-=1\\n printTable(store, word1, word2, 'slow', 'back', 3, LCS) \\n\\n elif (store[i][j] == store[i][j-1]): # Letter from word 1 doesn't match\\n store[i][j] = 'X'\\n j-=1\\n printTable(store, word1, word2, 'slow', 'back', 4, LCS) \\n \\n else: # Letters match!\\n LCS = word1[j-1] + LCS # Add letter to LCS\\n store[i][j] = 'X' \\n i-=1\\n j-=1\\n printTable(store, word1, word2, 'slow', 'back', 5, LCS)\\n \\n store[i][j] = 'X' # Fixing bug that didn't fill out the last step\\n printTable(store, word1, word2, 'slow', 'back', 6, LCS)\\n \\n return LCS\",\n \"def longest(s1, s2):\\n return ''.join(sorted(set(s1+s2)))\",\n \"def levenshtein_distance(first, second):\\n if len(first) > len(second):\\n first, second = second, first\\n if len(second) == 0:\\n return len(first)\\n first_length = len(first) + 1\\n second_length = len(second) + 1\\n distance_matrix = [range(second_length) for x in range(first_length)]\\n for i in range(1, first_length):\\n for j in range(1, second_length):\\n deletion = distance_matrix[i-1][j] + 1\\n insertion = distance_matrix[i][j-1] + 1\\n substitution = distance_matrix[i-1][j-1]\\n if first[i-1] != second[j-1]:\\n substitution += 1\\n distance_matrix[i][j] = min(insertion, deletion, substitution)\\n\\n return distance_matrix[first_length-1][second_length-1]\",\n \"def string_distance(s1, s2):\\n if len(s1) != len(s2):\\n return 1\\n diff_count = 0\\n for c1, c2, in zip(s1, s2):\\n if c1 != c2:\\n diff_count += 1\\n return diff_count\",\n \"def calculate_distance(seq1,seq2):\\r\\n mmcounter = 0 #mismatchcount\\r\\n seqlen = 0 #sequence length\\r\\n \\r\\n #cout the sequence length and mismatches\\r\\n for i in range(len(seq1)):\\r\\n if seq1[i]!='-' and seq2[i]!='-':\\r\\n seqlen += 1\\r\\n if seq1[i] != seq2[i]:\\r\\n mmcounter += 1\\r\\n #compute p\\r\\n p = (mmcounter/seqlen)\\r\\n #adjust p \\r\\n if p >= 0.75:\\r\\n pcorr = float(30)\\r\\n else:\\r\\n pcorr = (-3/4)*np.log(1-((4/3)*p))\\r\\n \\r\\n return(pcorr)\",\n \"def two_point_length(tuple1, tuple2):\\n tot_sum = 0\\n tot_sum += pow(tuple1[0]-tuple2[0], 2)\\n tot_sum += pow(tuple1[1]-tuple2[1], 2)\\n tot_sum += pow(tuple1[2]-tuple2[2], 2)\\n final_len = pow(tot_sum, 1/2)\\n return final_len\",\n \"def leveinshtein_distance(source,target):\\r\\n\\t#Step 1\\r\\n\\ts_len=len(source)\\r\\n\\tt_len=len(target)\\r\\n\\tcost=0\\r\\n\\tif(s_len==0):\\r\\n\\t\\treturn t_len\\r\\n\\tif(t_len==0):\\r\\n\\t\\treturn s_len\\r\\n\\tprint(\\\"Dimensions:\\\\n\\\\tN:%d\\\\n\\\\tM:%d\\\"%(s_len,t_len))\\r\\n\\t#Step 2\\r\\n\\tmatrix=[[0 for _ in range(0,t_len+1)] for _ in range(0, s_len+1)]\\r\\n\\t#Initialize first row 0..s_len\\r\\n\\tfor idx in range(0,s_len+1):\\r\\n\\t\\tmatrix[idx][0]=idx\\r\\n\\t#Initialize the first column 0..t_len\\r\\n\\tfor idx in range(0, t_len+1):\\r\\n\\t\\tmatrix[0][idx]=idx\\r\\n\\tprint(\\\"===Original===\\\")\\r\\n\\tprint_matrix(matrix,source,target)\\r\\n\\t#Step 3\\r\\n\\tfor i in range(1,s_len+1):\\r\\n\\t\\tch=source[i-1]\\r\\n\\t\\t#print(ch)\\r\\n\\t\\t#Step 4\\r\\n\\t\\tfor j in range(1,t_len+1):\\r\\n\\t\\t\\t#print(\\\">%s\\\"%target[j-1])\\r\\n\\t\\t\\t#Step 5\\r\\n\\t\\t\\tif ch==target[j-1]:\\r\\n\\t\\t\\t\\tcost=0\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tcost=1\\r\\n\\t\\t\\t#Step 6\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t#print(\\\"(i,j)=>(%d,%d)\\\"%(i,j))\\r\\n\\t\\t\\t#print(matrix[i][j])\\r\\n\\t\\t\\tmatrix[i][j]=minimum(\\r\\n\\t\\t\\t\\tmatrix[i-1][j]+1,\\r\\n\\t\\t\\t\\tmatrix[i][j-1]+1,\\r\\n\\t\\t\\t\\tmatrix[i-1][j-1]+cost\\r\\n\\t\\t\\t)\\r\\n\\tprint(\\\"===Final Matrix===\\\")\\r\\n\\tprint_matrix(matrix,source,target)\\r\\n\\treturn matrix[s_len-1][t_len-1]\",\n \"def compSeq(s1, s2, lineL=50):\\n lineN = int(np.ceil(min(len(s1), len(s2))/lineL))\\n count = 0\\n samecount = 0\\n outStr = ''\\n for linei in range(lineN):\\n if (linei+1) * lineL < min(len(s1), len(s2)):\\n end = (linei+1) * lineL\\n else:\\n end = min(len(s1), len(s2))\\n outStr += 'Pos %d - %d\\\\n' % (linei*lineL+1, end-1+1)\\n for sitei in range(linei*lineL, end):\\n outStr += s1[sitei]\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = ' ' if s1[sitei] == s2[sitei] else '|'\\n outStr += out\\n count += 1\\n samecount += 1 if s1[sitei]==s2[sitei] else 0\\n outStr += '\\\\n'\\n for sitei in range(linei*lineL, end):\\n out = '.' if s1[sitei] == s2[sitei] else s2[sitei]\\n outStr += s2[sitei]\\n outStr += '\\\\n\\\\n'\\n outStr += 'Seq1 (%d) and Seq2 (%d) are %1.1f%% similar\\\\n\\\\n' % (len(s1), len(s2), 1e2*samecount/count)\\n print(outStr)\",\n \"def longestCommonSubsequence(self, text1: str, text2: str) -> int:\\n if len(text1) == 0 or len(text2) == 0:\\n return 0\\n if text1[0] == text2[0]:\\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\\n else:\\n return max(self.longestCommonSubsequence(text1[1:], text2),\\n self.longestCommonSubsequence(text1, text2[1:]))\",\n \"def makingAnagrams(s1, s2):\\n min_del = 0\\n\\n x = Counter(s1)\\n y = Counter(s2)\\n\\n for key in x:\\n if x[key] > 0 and x[key] > y[key]:\\n min_del += x[key] - y[key]\\n x[key] -= x[key] - y[key]\\n elif x[key] == y[key]:\\n pass\\n elif x[key] > 0 and x[key] < y[key]:\\n min_del += y[key] - x[key]\\n y[key] -= y[key] - x[key]\\n\\n for key in y:\\n if y[key] > 0 and y[key] > x[key]:\\n min_del += y[key] - x[key]\\n y[key] -= y[key] - x[key]\\n elif x[key] == y[key]:\\n pass\\n elif y[key] > 0 and y[key] < x[key]:\\n min_del += x[key] - y[key]\\n x[key] -= x[key] - y[key]\\n\\n return min_del\",\n \"def lengthOfLongestSubstringTwoDistinct(self, s):\\n if not s:\\n return 0\\n\\n counters = collections.Counter()\\n\\n start = end = 0\\n max_len = -1\\n char_count = 0\\n while end < len(s):\\n if counters[s[end]] == 0:\\n char_count += 1\\n counters[s[end]] += 1\\n\\n while char_count > 2:\\n counters[s[start]] -= 1\\n if counters[s[start]] == 0:\\n char_count -= 1\\n start += 1\\n\\n if max_len < end - start + 1:\\n max_len = end - start + 1\\n\\n return max_len\",\n \"def lcs_recursion(A, B, m, n):\\n if m == 0 or n == 0:\\n return 0\\n elif A[m - 1] == B[n - 1]:\\n return 1 + lcs_recursion(A, B, m - 1, n - 1)\\n else:\\n return max(lcs_recursion(A, B, m, n - 1),\\n lcs_recursion(A, B, m - 1, n))\",\n \"def _pairwise_dist(self,seq1,seq2):\\n \\n return jf.damerau_levenshtein_distance(str(seq1), str(seq2))\",\n \"def _common_prefix(sequence1, sequence2):\\n i = 0\\n for elem1, elem2 in zip(sequence1, sequence2):\\n if elem1 != elem2:\\n return i\\n i += 1\\n\\n # Return length of sequence if sequences are identical\\n return min(len(sequence1), len(sequence2))\",\n \"def nb_editdistance(seq_vec1, seq_vec2, distance_matrix=identity_nb_distance_matrix, gap_penalty=1):\\n \\n q_L = seq_vec1.shape[0]\\n s_L = seq_vec2.shape[0]\\n if q_L == s_L:\\n \\\"\\\"\\\"No gaps: substitution distance\\n This will make it differ from a strict edit-distance since\\n the optimal edit-distance may insert same number of gaps in both sequences\\\"\\\"\\\"\\n dist = 0\\n for i in range(q_L):\\n dist += distance_matrix[seq_vec1[i], seq_vec2[i]]\\n return dist\\n\\n ldmat = np.zeros((q_L, s_L), dtype=np.int16)\\n for row in range(1, q_L):\\n ldmat[row, 0] = row * gap_penalty\\n\\n for col in range(1, s_L):\\n ldmat[0, col] = col * gap_penalty\\n \\n for col in range(1, s_L):\\n for row in range(1, q_L):\\n ldmat[row, col] = min(ldmat[row-1, col] + gap_penalty,\\n ldmat[row, col-1] + gap_penalty,\\n ldmat[row-1, col-1] + distance_matrix[seq_vec1[row-1], seq_vec2[col-1]]) # substitution\\n return ldmat[row, col]\",\n \"def common_prefix_len(self, other: \\\"ProofPath\\\") -> int:\\n if self.start() == other.start():\\n return self.match_len(other, self.start())\\n\\n return 0\",\n \"def _lcs_table(source, target):\\n rows = len(source)\\n cols = len(target)\\n lcs_table = [[0] * (cols + 1) for _ in range(rows + 1)]\\n for i in range(1, rows + 1):\\n for j in range(1, cols + 1):\\n if source[i - 1] == target[j - 1]:\\n lcs_table[i][j] = lcs_table[i - 1][j - 1] + 1\\n else:\\n lcs_table[i][j] = max(lcs_table[i - 1][j], lcs_table[i][j - 1])\\n return lcs_table\",\n \"def _edit_dist(s1, s2):\\r\\n dist = 0\\r\\n for i in range(len(s1)):\\r\\n if s1[i] != s2[i]:\\r\\n dist += 1\\r\\n return dist\",\n \"def levenshtein_distance(s1,s2):\\n\\n\\t\\tif len(s1) < len(s2):\\n\\t\\t\\treturn Searcher.levenshtein_distance(s2, s1)\\n\\n\\t\\t# len(s1) >= len(s2)\\n\\t\\tif len(s2) == 0:\\n\\t\\t\\treturn len(s1)\\n\\n\\t\\tprevious_row = range(len(s2) + 1)\\n\\t\\tfor i, c1 in enumerate(s1):\\n\\t\\t\\tcurrent_row = [i + 1]\\n\\t\\t\\tfor j, c2 in enumerate(s2):\\n\\t\\t\\t\\tinsertions = previous_row[j + 1] + 1 # j+1 instead of j since previous_row and current_row are one character longer\\n\\t\\t\\t\\tdeletions = current_row[j] + 1 # than s2\\n\\t\\t\\t\\tsubstitutions = previous_row[j] + (c1 != c2)\\n\\t\\t\\t\\tcurrent_row.append(min(insertions, deletions, substitutions))\\n\\t\\t\\tprevious_row = current_row\\n\\t\\t\\n\\t\\treturn previous_row[-1]\",\n \"def mincost(L,m,n):\\n # find the length of the strings\\n # declaring the array for storing the dp values\\n tc = [[0]*(n + 1) for i in range(m + 1)]\\n tc[0][0]=L[0][0]\\n for i in range(1,m + 1):\\n tc[i][0]=tc[i-1][0]+L[i][0]\\n for j in range(1,n + 1):\\n tc[0][j]=tc[0][j-1]+L[0][j]\\n for i in range(1,m+1):\\n for j in range(1,n+1):\\n tc[i][j]=min(tc[i-1][j-1],tc[i-1][j],tc[i][j-1])+L[i][j]\\n\\n\\n # L[m][n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\\n return tc[m][n]\",\n \"def commonCharacterCount(s1, s2):\\n return sum(min(s1.count(x),s2.count(x)) for x in set(s1))\",\n \"def jaccard_distance(label1, label2):\\r\\n return (len(label1.union(label2)) - len(label1.intersection(label2)))/len(label1.union(label2))\",\n \"def cort(s1, s2):\\n num = 0.0\\n sum_square_x = 0.0\\n sum_square_y = 0.0\\n for t in range(len(s1) - 1):\\n slope_1 = s1[t + 1] - s1[t]\\n slope_2 = s2[t + 1] - s2[t]\\n num += slope_1 * slope_2\\n sum_square_x += slope_1 * slope_1\\n sum_square_y += slope_2 * slope_2\\n return num / (np.sqrt(sum_square_x * sum_square_y))\",\n \"def get_length_of_LV_cavity(horiz_2ch_a, horiz_2ch_b, horiz_4ch_a, horiz_4ch_b, lowest_pt_2ch, lowest_pt_4ch):\\n top_center_2ch = (np.asarray(horiz_2ch_a[0]) + np.asarray(horiz_2ch_b[0])) / 2.0\\n L_2ch = np.linalg.norm(top_center_2ch - np.asarray(lowest_pt_2ch))/1000.0\\n\\n top_center_4ch = (np.asarray(horiz_4ch_a[0]) + np.asarray(horiz_4ch_b[0])) / 2.0\\n L_4ch = np.linalg.norm(top_center_4ch - np.asarray(lowest_pt_4ch))/1000.0\\n\\n if L_2ch > L_4ch:\\n L = L_2ch\\n else:\\n L = L_4ch\\n\\n return L\",\n \"def lungime_multimi(multime_1, multime_2):\\n if len(multime_1) < len(multime_2):\\n return len(multime_1)\\n else:\\n return len(multime_2)\",\n \"def dynamic(a, b):\\n m = len(a)\\n n = len(b)\\n d = [[0 for i in range(n)] for j in range(m)] # d[i][j] is length of common sequence of consecutive\\n prev = [-1 for j in range(n)] # numbers that ends with a[i] == b[j]\\n global_max = 0\\n global_pos = -1\\n for i in range(0, m):\\n for j in range(0, n): # iterate through all the elements by dual circle\\n if a[i] == b[j]: # if pair is equal then check if there is sequence that ends with a[i]-1\\n max_len = 0 # find longest sequence ends with a[i]-1\\n max_prev = -1\\n for k in range(i+1):\\n for l in range(j+1):\\n if k == i and l == j:\\n continue\\n if d[k][l] > max_len and a[k] == b[l] == a[i] - 1:\\n max_len = d[k][l]\\n max_prev = l\\n d[i][j] = max_len + 1\\n if d[i][j] > global_max:\\n global_max = d[i][j]\\n global_pos = j\\n prev[j] = max_prev\\n\\n res = [] # rebuild the answer\\n while global_pos != -1:\\n res.append(b[global_pos])\\n global_pos = prev[global_pos]\\n\\n return res[::-1]\",\n \"def Levenshtein(a, b):\\n v0 = list(range(len(b)+1))\\n v1 = list(range(len(b)+1)) # Or whatever.\\n\\n for i in range(len(a)):\\n v1[0] = i + 1\\n\\n for j in range(len(b)):\\n deletionCost = v0[j + 1] + 1\\n insertionCost = v1[j] + 1\\n substitutionCost = v0[j] if a[i] == b[j] else v0[j]+1\\n v1[j + 1] = min(deletionCost, insertionCost, substitutionCost)\\n\\n v1, v0 = v0, v1\\n return v0[len(b)]\",\n \"def length_sq(pos1, pos2):\\n return sum((x-y)**2 for (x,y) in zip(pos1, pos2))\",\n \"def compare(seq1, seq2):\\n if seq1 == seq2:\\n return 1\\n len_diff = len(seq1) / len(seq2)\\n if len_diff > 1:\\n len_diff = 1 / len_diff\\n\\n ngrams1 = {tuple(ng) for ng in get_all_ngrams(seq1)}\\n ngrams2 = {tuple(ng) for ng in get_all_ngrams(seq2)}\\n\\n overall = len(ngrams1 & ngrams2) / len(ngrams1 | ngrams2)\\n if overall == 1 or overall == 0:\\n return overall\\n\\n try:\\n max_match = len(max(ngrams1 & ngrams2, key=len)) / len(seq1)\\n except ValueError:\\n return 0\\n\\n return (len_diff + max_match + overall) / 3\",\n \"def lengthOfLIS(self, nums):\\n n = len(nums)\\n if n <= 1:\\n return n\\n\\n max_len = 0\\n\\n dp = [0] * n\\n for i, num in enumerate(nums):\\n if i == 0:\\n dp[0] = 1\\n max_len = 1\\n else:\\n prev_max = 0\\n for j in xrange(i):\\n if nums[j] < num:\\n prev_max = max(prev_max, dp[j])\\n dp[i] = prev_max + 1\\n max_len = max(max_len, dp[i])\\n\\n return max_len\",\n \"def lcms(argg: range) -> int:\\n l = 1\\n for arg in argg:\\n l = lcm(l, arg)\\n return l\",\n \"def longest_common_substring_backtrack(s1, s2, i, j, count):\\n if i == len(s1) or j == len(s2):\\n return 0\\n\\n if s1[i-1] == s2[j-1]:\\n count = 1 + longest_common_substring_backtrack(s1, s2, i+1, j+1, count)\\n\\n else:\\n count = max(count,\\n max(longest_common_substring_backtrack(s1, s2, i+1, j, count),\\n longest_common_substring_backtrack(s1, s2, i, j+1, count)))\\n\\n return count\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8111537","0.8111537","0.805192","0.8049781","0.79654235","0.7889462","0.77578354","0.77516085","0.762071","0.7560494","0.735811","0.72106427","0.6993349","0.6856335","0.67487043","0.66640663","0.6648296","0.6540758","0.654009","0.6442203","0.6368005","0.6361462","0.62989175","0.6281552","0.6263806","0.6219216","0.6156325","0.6142721","0.6119162","0.60984826","0.6036246","0.59816253","0.5981367","0.59722114","0.59368014","0.59351337","0.59336025","0.58996224","0.5896019","0.5889282","0.5880069","0.5867092","0.5864971","0.58634216","0.5853274","0.58140355","0.5805879","0.57964724","0.57910424","0.57847726","0.57704365","0.5767281","0.57475597","0.5729644","0.57171166","0.5715779","0.5704684","0.5693108","0.5688469","0.5671032","0.56572723","0.5656022","0.56474346","0.5640425","0.56309485","0.56270075","0.5625802","0.56050414","0.557315","0.5571581","0.5565121","0.55616134","0.55556345","0.55461335","0.55428964","0.5533675","0.5524344","0.5522365","0.5518401","0.551695","0.5513784","0.55074054","0.5506781","0.5502183","0.54916584","0.54826444","0.54703593","0.5470076","0.54682213","0.5466406","0.5451152","0.54419607","0.54360455","0.54352546","0.54298216","0.54229605","0.53953725","0.5394636","0.53943974"],"string":"[\n \"0.8111537\",\n \"0.8111537\",\n \"0.805192\",\n \"0.8049781\",\n \"0.79654235\",\n \"0.7889462\",\n \"0.77578354\",\n \"0.77516085\",\n \"0.762071\",\n \"0.7560494\",\n \"0.735811\",\n \"0.72106427\",\n \"0.6993349\",\n \"0.6856335\",\n \"0.67487043\",\n \"0.66640663\",\n \"0.6648296\",\n \"0.6540758\",\n \"0.654009\",\n \"0.6442203\",\n \"0.6368005\",\n \"0.6361462\",\n \"0.62989175\",\n \"0.6281552\",\n \"0.6263806\",\n \"0.6219216\",\n \"0.6156325\",\n \"0.6142721\",\n \"0.6119162\",\n \"0.60984826\",\n \"0.6036246\",\n \"0.59816253\",\n \"0.5981367\",\n \"0.59722114\",\n \"0.59368014\",\n \"0.59351337\",\n \"0.59336025\",\n \"0.58996224\",\n \"0.5896019\",\n \"0.5889282\",\n \"0.5880069\",\n \"0.5867092\",\n \"0.5864971\",\n \"0.58634216\",\n \"0.5853274\",\n \"0.58140355\",\n \"0.5805879\",\n \"0.57964724\",\n \"0.57910424\",\n \"0.57847726\",\n \"0.57704365\",\n \"0.5767281\",\n \"0.57475597\",\n \"0.5729644\",\n \"0.57171166\",\n \"0.5715779\",\n \"0.5704684\",\n \"0.5693108\",\n \"0.5688469\",\n \"0.5671032\",\n \"0.56572723\",\n \"0.5656022\",\n \"0.56474346\",\n \"0.5640425\",\n \"0.56309485\",\n \"0.56270075\",\n \"0.5625802\",\n \"0.56050414\",\n \"0.557315\",\n \"0.5571581\",\n \"0.5565121\",\n \"0.55616134\",\n \"0.55556345\",\n \"0.55461335\",\n \"0.55428964\",\n \"0.5533675\",\n \"0.5524344\",\n \"0.5522365\",\n \"0.5518401\",\n \"0.551695\",\n \"0.5513784\",\n \"0.55074054\",\n \"0.5506781\",\n \"0.5502183\",\n \"0.54916584\",\n \"0.54826444\",\n \"0.54703593\",\n \"0.5470076\",\n \"0.54682213\",\n \"0.5466406\",\n \"0.5451152\",\n \"0.54419607\",\n \"0.54360455\",\n \"0.54352546\",\n \"0.54298216\",\n \"0.54229605\",\n \"0.53953725\",\n \"0.5394636\",\n \"0.53943974\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6708936"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":85175,"cells":{"query":{"kind":"string","value":"Computes the LCSbased Fmeasure score."},"document":{"kind":"string","value":"def _f_lcs(llcs, m, n):\n r_lcs = llcs / m\n p_lcs = llcs / n\n beta = p_lcs / (r_lcs + 1e-12)\n num = (1 + (beta ** 2)) * r_lcs * p_lcs\n denom = r_lcs + ((beta ** 2) * p_lcs)\n f_lcs = num / (denom + 1e-12)\n return f_lcs"},"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 computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\r\n return self.f1score","def calculate_flesch_score(text):\n\n # Use the given formula and call other functions to get the values\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\n text)\n\n return score","def get_f_score(self):\n return self.get_g_score() + self.get_h_score()","def fScore(cMatrix):\n if precision(cMatrix) + recall(cMatrix) == 0:\n return precision(cMatrix)\n else:\n return 2 * precision(cMatrix) * recall(cMatrix) / (precision(cMatrix) + recall(cMatrix))","def _chrf_score_compute(total_preds_char_n_grams: Dict[int, Tensor], total_preds_word_n_grams: Dict[int, Tensor], total_target_char_n_grams: Dict[int, Tensor], total_target_word_n_grams: Dict[int, Tensor], total_matching_char_n_grams: Dict[int, Tensor], total_matching_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n chrf_f_score = _calculate_fscore(total_matching_char_n_grams, total_matching_word_n_grams, total_preds_char_n_grams, total_preds_word_n_grams, total_target_char_n_grams, total_target_word_n_grams, n_order, beta)\n return chrf_f_score","def compute_prf(self, counts_dict):\n precision = counts_dict[\"correct\"] / counts_dict[\"predicted\"] if counts_dict[\"predicted\"] else 0.0\n recall = counts_dict[\"correct\"] / counts_dict[\"gold\"] if counts_dict[\"gold\"] else 0.0\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\n\n return {\"precision\": precision, \"recall\": recall, \"fscore\": fscore}","def fmeasure(B, hits, misses, falses) :\n x = ((1 + B**2) * hits) / ((1 + B**2) * hits + B**2 * misses + falses)\n return x","def fmeasure(B, hits, misses, falses) :\r\n x = ((1 + B**2) * hits) / ((1 + B**2) * hits + B**2 * misses + falses)\r\n return x","def f1_score(self):","def muc_scores(self):\n A_card, B_card = self.shape\n V_card = len(self)\n N = self.grand_total\n\n recall = _div(N - V_card, N - A_card)\n precision = _div(N - V_card, N - B_card)\n fscore = hmean(recall, precision)\n return precision, recall, fscore","def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\n best_f_score = tensor(0.0)\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\n for target in targets:\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\n if f_score > best_f_score:\n best_f_score = f_score\n best_matching_char_n_grams = matching_char_n_grams\n best_matching_word_n_grams = matching_word_n_grams\n best_target_char_n_grams = target_char_n_grams\n best_target_word_n_grams = target_word_n_grams\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams","def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\n\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\n \"\"\"Get n-gram level f-score.\"\"\"\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\n return f_score\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\n return f_score","def compute_rouge_l(output, reference, mode='f'):\n assert mode in list('fpr') # F-1, precision, recall\n lcs = _lcs_len(output, reference)\n if lcs == 0:\n score = 0.0\n else:\n precision = lcs / len(output)\n recall = lcs / len(reference)\n f_score = 2 * (precision * recall) / (precision + recall)\n if mode == 'p':\n score = precision\n if mode == 'r':\n score = recall\n else:\n score = f_score\n return score","def score_calc(self, annotations, predictions):\n if isinstance(sqrtm, UnsupportedPackage):\n sqrtm.raise_error(self.__provider__)\n\n assert annotations.shape[1] == predictions.shape[1], \"Expected equal length of feature vectors\"\n\n mu_real, mu_gen = annotations.mean(axis=0), predictions.mean(axis=0)\n cov_real, cov_gen = np.cov(annotations, rowvar=False), np.cov(predictions, rowvar=False)\n mdiff = mu_real - mu_gen\n\n covmean = sqrtm(cov_real.dot(cov_gen))\n if not np.isfinite(covmean).all():\n offset = np.eye(cov_real.shape[0]) * self.eps\n covmean = sqrtm((cov_real + offset).dot(cov_gen + offset))\n if np.iscomplexobj(covmean):\n covmean = covmean.real\n\n fid = mdiff.dot(mdiff) + np.trace(cov_real + cov_gen - 2 * covmean)\n return fid","def fmeasure(y_true, y_pred):\n return fbeta_score(y_true, y_pred, beta=1)","def fmeasure(y_true, y_pred):\n return fbeta_score(y_true, y_pred, beta=1)","def fmeasure(y_true, y_pred):\n return fbeta_score(y_true, y_pred, beta=1)","def fmeasure(y_true, y_pred):\n return fbeta_score(y_true, y_pred, beta=1)","def test_lfc_ml():\n levels = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar\n temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -49.]) * units.celsius\n dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof)\n assert_almost_equal(lfc_pressure, 601.225 * units.mbar, 2)\n assert_almost_equal(lfc_temp, -1.90688 * units.degC, 2)","def _compute_scores(self, triples):\n # compute scores as sum(s * p * o)\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\n return scores","def calculate_f1_score(y_test, y_pred):\n print('# Running precision, recall and F1-score')\n print('# F1-Score:\\t\\t%.2f' % (f1_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Precision:\\t\\t%.2f' % (precision_score(y_test, y_pred, average=\"macro\") * 100))\n print('# Recall:\\t\\t%.2f' % (recall_score(y_test, y_pred, average=\"macro\") * 100))","def scoring(estimator, features_test, labels_test):\n pred = estimator.predict(features_test)\n p = metrics.precision_score(labels_test, pred, average='micro')\n r = metrics.recall_score(labels_test, pred, average='micro')\n if p > 0.3 and r > 0.3:\n return metrics.f1_score(labels_test, pred, average='macro')\n return 0","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def _F_performance(self, score, thresholds, condition):\r\n if type(thresholds) is float:\r\n thresholds = self._compute_thresholds(thresholds)\r\n F = np.zeros(shape=(1, len(thresholds)))\r\n impostors = 0\r\n L = len(score)\r\n for count, thr in enumerate(thresholds):\r\n N = 0\r\n for idx in range(0, L):\r\n N += condition(score[idx], thr)\r\n F[0, count] = N / L\r\n return F[0]","def score(label_recall, label_precision, pred_recall, pred_precision):\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\n\n return 0.4*f11 + 0.6*f12","def calculate(self):\n\n beta = 1 # or 0.5 or 2 can also calculate F2 or F0.5 measure\n\n beta_squared = beta * beta\n precision = Precision()\n precision.confusion_matrix = self.confusion_matrix\n precision = precision.calculate()\n recall = Recall()\n recall.confusion_matrix = self.confusion_matrix\n recall = recall.calculate()\n\n denominator = beta_squared * precision + recall\n\n if denominator != 0:\n return (1 + beta_squared) * ((precision * recall) / denominator)\n else:\n return 0","def custom_scoring(y_te, y_pred):\n #weights computed with training data set\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\n \n ## F1 SCORES\n #evaluate F1 score, precision and recall for each label, \n #along with custom proportionally weighted F1 score\n #and built in weighted and macro F1 scores\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\n f = F1Score(8, threshold = 0.5, average = 'weighted')\n f.update_state(y_te, y_pred)\n wf1 = f.result().numpy() #weighted f1 score\n f.reset_states()\n f = F1Score(8, threshold = 0.5, average = 'macro')\n f.update_state(y_te, y_pred)\n mf1 = f.result().numpy() #macro f1 score\n f.reset_states()\n\n ##EDIT DISTANCE\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\n\n ##ACCURACY\n #evaluate accuracy per label\n acc_tab = Acc(y_te, y_pred)\n\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab","def compute_score(self):\n for i in xrange(FRAMES):\n # STRIKE\n if self.frames[i][0] == 10:\n # CONSECUTIVE STRIKE\n if self.frames[i + 1][0] == 10:\n self.scores.append(self.frames[i][0] +\n self.frames[i + 1][0] +\n self.frames[i + 2][0])\n else:\n self.scores.append(self.frames[i][0] +\n self.frames[i + 1][0] +\n self.frames[i + 1][1])\n # SPARE\n elif (self.frames[i][0] + self.frames[i][1] == 10):\n self.scores.append(self.frames[i][0] + self.frames[i][1] +\n self.frames[i + 1][0])\n # NEITHER\n else:\n self.scores.append(self.frames[i][0] + self.frames[i][1])\n # Total Score\n for score in self.scores:\n self.score += score","def score_full(self, params):\n\n if type(params) is not MixedLMParams:\n params = MixedLMParams.from_packed(params, self.k_fe,\n self.use_sqrt)\n\n fe_params = params.get_fe_params()\n cov_re = params.get_cov_re()\n try:\n cov_re_inv = np.linalg.inv(cov_re)\n except np.linalg.LinAlgError:\n cov_re_inv = None\n\n score_fe = np.zeros(self.k_fe, dtype=np.float64)\n score_re = np.zeros(self.k_re2, dtype=np.float64)\n\n # Handle the covariance penalty.\n if self.cov_pen is not None:\n score_re -= self.cov_pen.grad(cov_re, cov_re_inv)\n\n # Handle the fixed effects penalty.\n if self.fe_pen is not None:\n score_fe -= self.fe_pen.grad(fe_params)\n\n # resid' V^{-1} resid, summed over the groups (a scalar)\n rvir = 0.\n\n # exog' V^{-1} resid, summed over the groups (a k_fe\n # dimensional vector)\n xtvir = 0.\n\n # exog' V^{_1} exog, summed over the groups (a k_fe x k_fe\n # matrix)\n xtvix = 0.\n\n # V^{-1} exog' dV/dQ_jj exog V^{-1}, where Q_jj is the jj^th\n # covariance parameter.\n xtax = [0.,] * self.k_re2\n\n # Temporary related to the gradient of log |V|\n dlv = np.zeros(self.k_re2, dtype=np.float64)\n\n # resid' V^{-1} dV/dQ_jj V^{-1} resid (a scalar)\n rvavr = np.zeros(self.k_re2, dtype=np.float64)\n\n for k in range(self.n_groups):\n\n exog = self.exog_li[k]\n ex_r = self.exog_re_li[k]\n ex2_r = self.exog_re2_li[k]\n\n # The residuals\n expval = np.dot(exog, fe_params)\n resid = self.endog_li[k] - expval\n\n if self.reml:\n viexog = _smw_solve(1., ex_r, ex2_r, cov_re,\n cov_re_inv, exog)\n xtvix += np.dot(exog.T, viexog)\n\n # Contributions to the covariance parameter gradient\n jj = 0\n vex = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\n ex_r)\n vir = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\n resid)\n for jj,mat in self._gen_dV_dPsi(ex_r):\n dlv[jj] = np.trace(_smw_solve(1., ex_r, ex2_r, cov_re,\n cov_re_inv, mat))\n rvavr[jj] += np.dot(vir, np.dot(mat, vir))\n if self.reml:\n xtax[jj] += np.dot(viexog.T, np.dot(mat, viexog))\n\n # Contribution of log|V| to the covariance parameter\n # gradient.\n score_re -= 0.5 * dlv\n\n # Needed for the fixed effects params gradient\n rvir += np.dot(resid, vir)\n xtvir += np.dot(exog.T, vir)\n\n fac = self.n_totobs\n if self.reml:\n fac -= self.exog.shape[1]\n\n score_fe += fac * xtvir / rvir\n score_re += 0.5 * fac * rvavr / rvir\n\n if self.reml:\n for j in range(self.k_re2):\n score_re[j] += 0.5 * np.trace(np.linalg.solve(\n xtvix, xtax[j]))\n\n score_vec = np.concatenate((score_fe, score_re))\n\n if self._freepat is not None:\n return self._freepat.get_packed() * score_vec\n else:\n return score_vec","def test_f_measure(self) -> None:\n brent_spot_anno = {\n \"6\": [219, 230, 288],\n \"8\": [227, 381],\n \"9\": [86, 219, 230, 279, 375],\n \"12\": [169, 172, 217, 228, 287, 368, 382, 389, 409],\n \"13\": [170, 180, 219, 229, 246, 271, 286, 379, 409, 444, 483],\n }\n\n brent_spot_prophet_default_cploc = [259, 279, 299, 319, 339, 359]\n\n # scores are defined in\n # https://github.com/alan-turing-institute/TCPDBench/blob/master/analysis/output/summaries/summary_brent_spot.json\n\n f_brent_spot = f_measure(\n annotations=brent_spot_anno, predictions=brent_spot_prophet_default_cploc\n )\n self.assertAlmostEqual(f_brent_spot[\"f_score\"], 0.2485875706214689, places=3)\n self.assertAlmostEqual(f_brent_spot[\"precision\"], 0.2857142857142857, places=3)\n self.assertAlmostEqual(f_brent_spot[\"recall\"], 0.21999999999999997, places=3)","def rouge_l_fscore(predictions, labels):\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\n tf.float32)\n return rouge_l_f_score, tf.constant(1.0)","def _calculate_score(self):\n mul = self._check_board()\n if mul > 0:\n inc = 100 * mul + ((mul - 1) * 25)\n self.score += inc","def score( self ):\r\n result = 0.0\r\n for rr in self.ee.getRsrcs( ):\r\n value = self.scoreRsrc( rr )\r\n result += value\r\n print( \"INFO: Value for the schedule is %s \" % ( rr, result ) )\r\n return( result )","def fscore(links_true, links_pred=None):\n\n prec = precision(links_true, links_pred)\n rec = recall(links_true, links_pred)\n\n return float(2 * prec * rec / (prec + rec))","def score(self, params):\n\n if self.use_sqrt:\n return self.score_sqrt(params)\n else:\n return self.score_full(params)","def model(**params):\n N_frb = 0\n vs = []\n hs = []\n cs = []\n ncands = []\n\n for cand in candlist:\n c_res = calculate_metric_terms(\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\n )\n t, frb_found, h, c, v = c_res\n vs.append(v)\n hs.append(h)\n cs.append(c)\n ncands.append(t)\n\n if frb_found:\n N_frb += 1\n\n vs = np.array(vs)\n hs = np.array(hs)\n cs = np.array(cs)\n c_avg = np.average(cs, axis=0, weights=ncands)\n h_avg = np.average(hs, axis=0, weights=ncands)\n v_avg = np.average(vs, axis=0, weights=ncands)\n recall = N_frb / len(vs)\n score = v_avg * recall\n\n return score","def _score_lcs(target_tokens, prediction_tokens):\n\n if not target_tokens or not prediction_tokens:\n return scoring.Score(precision=0, recall=0, fmeasure=0)\n\n # Compute length of LCS from the bottom up in a table (DP appproach).\n cols = len(prediction_tokens) + 1\n rows = len(target_tokens) + 1\n lcs_table = np.zeros((rows, cols))\n for i in xrange(1, rows):\n for j in xrange(1, cols):\n if target_tokens[i - 1] == prediction_tokens[j - 1]:\n lcs_table[i, j] = lcs_table[i - 1, j - 1] + 1\n else:\n lcs_table[i, j] = max(lcs_table[i - 1, j], lcs_table[i, j - 1])\n lcs_length = lcs_table[-1, -1]\n\n precision = lcs_length / len(prediction_tokens)\n recall = lcs_length / len(target_tokens)\n fmeasure = scoring.fmeasure(precision, recall)\n\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)","def _compute_score(img_binary: np.ndarray, s: float) -> float:\n img_sheared = _shear_img(img_binary, s, 0)\n h = img_sheared.shape[0]\n\n img_sheared_mask = img_sheared > 0\n first_fg_px = np.argmax(img_sheared_mask, axis=0)\n last_fg_px = h - np.argmax(img_sheared_mask[::-1], axis=0)\n num_fg_px = np.sum(img_sheared_mask, axis=0)\n\n dist_fg_px = last_fg_px - first_fg_px\n col_mask = np.bitwise_and(num_fg_px > 0, dist_fg_px == num_fg_px)\n masked_dist_fg_px = dist_fg_px[col_mask]\n\n score = sum(masked_dist_fg_px ** 2)\n return score","def get_score(self):\r\n return self.lcp.get_score()","def calculate_f2_score(predictions, actuals):\n predictions = predictions > 0.5\n # fbeta_score throws a confusing error if inputs are not numpy arrays\n predictions, actuals, = np.array(predictions), np.array(actuals)\n # We need to use average='samples' here, any other average method will generate bogus results\n return fbeta_score(actuals, predictions, beta=2, average='samples')","def __lm_scores(en_id, txt, prefix):\n feat_field_dict = {'title': econfig.TITLE, 'sAbs': econfig.SHORT_ABS, 'lAbs': econfig.LONG_ABS,\n 'links': econfig.WIKILINKS, 'cats': econfig.CATEGORIES, 'catchall': Lucene.FIELDNAME_CONTENTS}\n ftr_extractor = QuerySimFeat(txt)\n scores = dict()\n for feature_name, field in feat_field_dict.iteritems():\n lm_score = ftr_extractor.nllr_lm_score(en_id, field) # lm_score(en_id, field)\n scores[prefix + feature_name] = lm_score if lm_score is not None else 0\n return scores","def score(self, s):\n fv = s.feature_vector\n product = fv.dot(self.params.T)[0, 0]\n return s.score(lmwt=self.lmwt) + product","def computeF1_macro(confusion_matrix, matching, num_clusters):\r\n # Permute the matrix columns\r\n permuted_confusion_matrix = np.zeros([num_clusters, num_clusters])\r\n for cluster in range(num_clusters):\r\n matched_cluster = matching[cluster]\r\n permuted_confusion_matrix[:, cluster] = confusion_matrix[:, matched_cluster]\r\n# Compute the F1 score for every cluster\r\n F1_score = 0\r\n for cluster in range(num_clusters):\r\n TP = permuted_confusion_matrix[cluster,cluster]\r\n FP = np.sum(permuted_confusion_matrix[:,cluster]) - TP\r\n FN = np.sum(permuted_confusion_matrix[cluster,:]) - TP\r\n precision = TP/(TP + FP)\r\n recall = TP/(TP + FN)\r\n f1 = stats.hmean([precision,recall])\r\n F1_score += f1\r\n F1_score /= num_clusters\r\n return F1_score","def _cal_score(self, primary_category_label, secondary_category_label, actual_category_label, max_level):\n primary_categories = self._get_categories(primary_category_label)\n if not secondary_category_label:\n secondary_categories = None\n else:\n secondary_categories = self._get_categories(secondary_category_label)\n actual_categories = self._get_categories(actual_category_label)\n total_score = 0\n ignored_primary = False\n ignored_secondary = False\n for i in range(0, max_level + 1):\n if primary_categories and i < len(primary_categories):\n pv = primary_categories[i]\n else:\n pv = None\n if actual_categories and i < len(actual_categories):\n av = actual_categories[i]\n else:\n av = None\n if secondary_categories and i < len(secondary_categories):\n sv = secondary_categories[i]\n else:\n sv = None\n primary_equal = pv == av\n secondary_equal = (secondary_categories is not None) and sv == av\n if not primary_equal:\n ignored_primary = True\n if not secondary_equal:\n ignored_secondary = True\n\n if not ignored_primary:\n total_score += self.level_scores[i]\n\n if ignored_primary and (not ignored_secondary):\n total_score += 0.5 * self.level_scores[i]\n\n return total_score","def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\n pred_len, target_len = len(pred), len(target)\n if 0 in (pred_len, target_len):\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\n lcs: int = _lcs(pred, target)\n return _compute_metrics(lcs, pred_len, target_len)","def score(self, input_fn=None, steps=None):\n return np.sum(\n self.evaluate(\n input_fn=input_fn, steps=steps)[KMeansClustering.SCORES])","def stats(detections, faces):\n vp, fp, fn, vn = 0, 0, 0, 0\n max_label = np.max(faces[:, 0])\n for i in range(max_label + 1):\n detections_i = get_label_with_index(detections, i)\n faces_i = get_label_with_index(faces, i)\n local_vp = 0\n for face in faces_i:\n found = False\n for detection in detections_i:\n if intersection_ratio(face, detection) >= 0.5:\n found = True\n break\n if found:\n vp += 1\n local_vp += 1\n else:\n fn += 1\n fp += len(detections_i) - local_vp\n\n precision = vp / (vp + fp)\n rappel = vp / (vp + fn)\n f_score = 2 * ((precision * rappel) / (precision + rappel))\n\n return precision, rappel, f_score","def calculate_performance(scorecard):\n \n scorecard_array = numpy.asarray(scorecard)\n performance = scorecard_array.sum() / scorecard_array.size\n\n return performance","def calc_score(score):\n if not score:\n return 0\n dbot_score = 1\n if score >= 95:\n dbot_score = 3\n elif score >= 75:\n dbot_score = 2\n return dbot_score","def t_score(colloc_count, c_pattern, c_lw, n):\r\n score = (colloc_count - (c_pattern * c_lw) / n) / (sqrt(colloc_count))\r\n return score","def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\"malaria\", confusion_matrix_title=\"\"):\n # demonstration of calculating metrics for a neural network model using sklearn\n if not binary_classifcation:\n # For multiclass classification.\n accuracy = accuracy_score(actual_labels, preds_labels)\n precision = precision_score(actual_labels, preds_labels, average=\"macro\")\n recall = recall_score(actual_labels, preds_labels, average=\"macro\")\n f1 = f1_score(actual_labels, preds_labels, average=\"macro\")\n print('Accuracy: %f' % accuracy)\n print('Precision: %f' % precision)\n print('Recall: %f' % recall)\n print('F1 score: %f' % f1)\n\n else:\n accuracy = accuracy_score(actual_labels, preds_labels)\n print('Accuracy: %f' % accuracy)\n # # precision tp / (tp + fp)\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Precision: %f' % precision)\n # recall: tp / (tp + fn)\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\n print('Recall: %f' % recall)\n # f1: 2 tp / (2 tp + fp + fn)\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\n print('F1 score: %f' % f1)\n # ROC AUC\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\n # print('ROC AUC: %f' % auc)\n\n # confusion matrix\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\n display_labels=list(np.unique(actual_labels)),\n cmap=plt.cm.Blues,\n normalize=None)\n disp.ax_.set_title(confusion_matrix_title)\n plt.show()\n matrix = confusion_matrix(actual_labels, preds_labels)\n print(matrix)\n # if plot_confusion_matrix:\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))","def f1_score(self):\n self.overall_f1_score = f1_score(\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\n self.classes_f1_score = f1_score(\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)","def compute_scores(self):\n if self.num_classes == 2:\n score_1 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold=0.5,\n )[1]\n\n score_2 = self.competition_metric(\n helmet_threshold=0.5,\n impact_threshold_ratio=0.5,\n )[1]\n\n score_3 = self.competition_metric(\n impact_threshold=0.5,\n )[1]\n else:\n score_1 = self.detection_metric(threshold=0.1)\n score_2 = self.detection_metric(threshold=0.25)\n score_3 = self.detection_metric(threshold=0.5)\n\n return score_1, score_2, score_3","def _calculate_score(lsh, minhash, total_num_events):\n neighbours = lsh.query(minhash)\n return float(len(neighbours)) / float(total_num_events)","def f1_score(model_id, test_set_id, rubric_id):\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\n\n for key in rubrication_result:\n if rubrication_result[key] == answers[key]:\n if rubrication_result[key] == 1:\n result['true_positive'] += 1\n else:\n result['true_negative'] += 1\n else:\n if rubrication_result[key] == 1:\n result['false_positive'] += 1\n else:\n result['false_negative'] += 1\n if (result['true_positive'] + result['false_positive']) > 0:\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\n else:\n result['precision'] = 0\n if (result['true_positive'] + result['false_negative']) > 0:\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\n else:\n result['recall'] = 0\n if (result['precision'] + result['recall']) > 0:\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\n else:\n result['f1'] = 0\n return result","def cv_score(clf, x, y, score_func):\r\n result = 0\r\n nfold = 5\r\n for train, test in KFold(y.size, nfold): # split data into train/test groups, 5 times\r\n clf.fit(x[train], y[train]) # fit\r\n result += score_func(clf, x[test], y[test]) # evaluate score function on held-out data\r\n return result / nfold # average\r","def f_measure(precision, recall, beta=config.F_MEASURE_BETA):\n if precision + recall <= 0:\n return 0.\n beta_sq = beta ** 2\n return (1 + beta_sq) * precision * recall / (beta_sq * precision + recall)","def _calculate_score_with_threshold(self):\n\n clue_number = 0\n positive_score, negative_score = 0, 0\n negative_number = 0\n total_score = 0\n\n # find largest negative score\n largest_negative_score = -1.\n for ix, (card, score) in enumerate(self.sorted_card_score_pairs):\n # find maximum score of negative word\n if card.color not in [self.team, \"DOUBLE\"]:\n largest_negative_score = score\n break\n\n # add scores higher than threshold + largest negative score to positive_score\n for card, score in self.sorted_card_score_pairs:\n if (score > (self.delta+largest_negative_score)\n and card.color in [self.team, \"DOUBLE\"]):\n clue_number += 1\n positive_score += score\n elif card.color not in [self.team, \"DOUBLE\"]:\n negative_score += score\n negative_number += 1\n else:\n continue\n\n if not self.penalize_negative:\n self.logger.info(\"negative score set to 0.\")\n negative_score = 0\n\n # if threshold(delta) is large, there will be no clues.\n # try to give at least one clue\n # select the positive card with score larger than largest_negative_score.\n if clue_number == 0:\n self.logger.debug(\"clue number: 0.\")\n for card, score in self.sorted_card_score_pairs:\n if card.color in [self.team, \"DOUBLE\"]:\n positive_score = score\n clue_number += 1\n self.cropped_threshold = score - largest_negative_score\n else:\n positive_score = 0\n break\n\n if self.normalize_negative:\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score / negative_number\n else:\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score\n self.logger.debug(\"word: {}, positive_score: {}, negative_score: {}, total_score: {}\".format(self.clue, positive_score, negative_score, total_score))\n return total_score, clue_number","def f1_score(precision, recall):\n if precision + recall == 0:\n return 0\n return 2 * precision * recall / (precision + recall)","def calculate_precinct_score(pt, dstrct):\n return pt.F(dstrct)","def getScore(self):\n tempscore = 1000 - 0.01*self.timeDriving \n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\n tempscore += self.checkpoint *1000\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\n return tempscore","def score_fn(self):\n raise NotImplementedError()","def get_score(snack_data, percentage_data, snack, snack_query, protein_query, carb_query, fat_query):\n\tstart_time = time.time()\n\n\t#Load necessary data\n\t\"\"\"\twith open ('../../../Data/percentagesDict.pickle', 'rb') as f:\n\t\tpercentage_data = pickle.load(f)\n\n\twith open ('../../../Data/FINAL_snacks_data.pickle', 'rb') as f:\n\t\tsnack_data = pickle.load(f)\"\"\"\n\n\t#Set constants\n\tLOW_FAT = .3\n\tHIGH_FAT = .6\n\tLOW_CARB = .1\n\tHIGH_CARB = .2\n\tLOW_PRO = .2\n\tHIGH_PRO = .4\n\n\t#Convert macro percentages to 'high', 'med', 'low' categories\n\tfat = percentage_data[snack]['fat']\n\tprotein = percentage_data[snack]['protein']\n\tcarb = percentage_data[snack]['carb']\n\n\tif fat > HIGH_FAT:\n\t\tfat_content = 'high'\n\telif fat < LOW_FAT:\n\t\tfat_content = 'low'\n\telse:\n\t\tfat_content = 'med'\n\n\tif protein > HIGH_PRO:\n\t\tprotein_content = 'high'\n\telif protein < LOW_PRO:\n\t\tprotein_content = 'low'\n\telse:\n\t\tprotein_content = 'med'\n\n\tif carb > HIGH_CARB:\n\t\tcarb_content = 'high'\n\telif carb < LOW_CARB:\n\t\tcarb_content = 'low'\n\telse:\n\t\tcarb_content = 'med'\n\n\t#Set x values\n\tx1 = fat_query == fat_content\n\tx2 = carb_query == carb_content\n\tx3 = protein_query == protein_content\n\tx4 = cooccur(snack_data, snack, snack_query) \n\tx5 = snack_data[snack]['rating']\n\n\tw1 = 1\n\tw2 = 1\n\tw3 = 1\n\tw4 = 1\n\tw5 = 1\n\t\n\t#print('x1: {}, x2: {}, x3: {}, x4: {}, x5: {}'.format(x1, x2, x3, x4, x5))\n\t#print(\"get_score() time: --- %s seconds ---\" % (time.time() - start_time))\n\n\n\treturn w1*x1 + w2*x2 + w3*x3 + w4*x4 + w5*x5","def score(self):","def stats_f1score_per_class(cm):\n # defined as 2 * recall * prec / recall + prec\n sums = (np.sum(cm, axis=1) + np.sum(cm, axis=0))\n mask = (sums>0)\n sums[sums==0] = 1\n f1score_per_class = 2 * np.diag(cm) / sums\n f1score_per_class[np.logical_not(mask)] = -1\n average_f1_score = f1score_per_class[mask].mean()\n return average_f1_score, f1score_per_class","def calculate_score(truck, job):\n score = 0\n score += W1 * calculate_distance(job.source_long, job.source_lat, truck.current_long, truck.current_lat)\n print(score)\n score += W2 * calculate_distance(job.destination_long, job.destination_lat, truck.base_long, truck.base_lat)\n print(score)\n score += W3 * job.price\n print(score)\n score += W4 * job.price / job.getDistance()\n print(score)\n\n return score","def measureSJF(p):\r\n\treturn measureFCFS(msort(p))","def bestF(score_matrix, gold_lex):\n np.seterr(divide='ignore', invalid='ignore') # get nans instead of division by zero\n best_f = 0\n best_th = 0\n\n for th in np.linspace(0, 1, 101): # threshold\n lex = (score_matrix >= th)\n p = np.sum(lex * (lex == gold_lex)) / np.sum(lex)\n r = np.sum(lex * (lex == gold_lex)) / np.sum(gold_lex)\n f = 2 * (p * r) / (p + r)\n\n if f > best_f:\n best_f = f\n best_th = th\n\n return best_f, best_th","def generateScore(self):\n totalFreq = self.lazySum(key=None)\n for file in self._candidate_files:\n filename = os.path.basename(file)\n score_file = os.path.join(self._score_dir, filename)\n with open(score_file, 'w') as ofd:\n with open(file) as ifd:\n for line in ifd:\n words = line.strip().split('\\t')\n if len(words) < 2 or any(map(lambda word:len(word)<2, words)):\n continue\n\n XFreq = self.lazySum(words[0])\n YFreq = self.lazySum(words[1])\n XYFreq = self.lazySum(line.strip())\n # frequences filter\n #if XYFreq < 2 or XYFreq > 24:\n # continue\n if YFreq == 0 or XFreq == 0 or XYFreq == 0:\n # because when generating grams, we last last words' frequency\n continue\n PX = XFreq * 1.0 / totalFreq\n PY = YFreq * 1.0 / totalFreq\n PXY = XYFreq * 1.0 / totalFreq\n score = math.log(PXY/PX/PY, 2) * XYFreq\n #print \"Freq:\", XFreq, YFreq, XYFreq\n result = \"{0}\\t{1:.2f}\\n\".format(line.strip(), score)\n ofd.write(result)","def compute_f_score(alpha, true_positves, false_positives, false_negatives):\n num = true_positves\n den = np.float64(alpha * (true_positves + false_positives) +\\\n (1 - alpha) * (true_positves + false_negatives))\n with np.errstate(divide='ignore', invalid='ignore'):\n return num / den","def fscore(self, beta=1.0):\n return hmean_weighted(self.precision(), self.recall(), beta ** 2)","def _compute_score(self):\n\n sgml_path = str(self.sgml_file.name)\n text_path = sgml_path.replace('.sgm', '.txt')\n ref_path = 'testsets/wmt18.ende.ref.txt'\n\n from sacrebleu import process_to_text, corpus_bleu\n from pathlib import Path\n\n if not Path(text_path).exists():\n process_to_text(sgml_path, text_path)\n\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\n\n bleu = corpus_bleu(hyp_stream, [ref_stream])\n\n self.score = bleu.score\n self.save()","def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\r\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\r\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\r\n\r\n if p + r > 0:\r\n return 2 * p * r / (p + r)\r\n else:\r\n return 0","def score(self) -> FAIRResultCommonScore:\n return self._score","def calc_fcts(self):\n flow_fcts = {}\n print \"Computing FCTS:\"\n for flowID, pkts in self.flow_pkts.items():\n fct = (pkts[-1][0] - pkts[0][0])*1e-6\n flow_fcts[flowID] = fct \n print '\\tflow {:>3} FCT = {:<8.2f} ms'.format(flowID, fct)\n avg_fct = np.average(flow_fcts.values())\n std_fct = np.std(flow_fcts.values())\n print 'Average FCT = {:>8.3f} +/- {:<8.3f} ms'.format(avg_fct, std_fct)","def cal_F1(loader, model):\n correct = 0\n total = 0\n model.eval()\n cof_mat = np.zeros ((4,4))\n Ns = np.zeros(4)\n ns = np.zeros(4)\n for data, labels in loader:\n data_batch, label_batch = data.to(device), labels.to(device)\n outputs = F.softmax(model(data_batch), dim=1)\n predicted = outputs.max(1, keepdim=True)[1]\n total += label_batch.size(0)\n correct += predicted.eq(label_batch.view_as(predicted)).sum().item()\n acc = label_batch.view_as(predicted)\n for (a,p) in zip(acc, predicted):\n cof_mat[a][p] += 1\n Ns[a] += 1\n ns[p] += 1\n F1 = 0.0\n for i in range(len(Ns)):\n tempF = cof_mat[i][i]*2.0 /(Ns[i] + ns[i])\n F1 = F1+ tempF\n print('F1'+str(i)+':',tempF)\n F1 = F1/4.0\n print('cofmat',cof_mat)\n return 100 * correct / total, F1","def disp_score():","def compute(self, idx, input_scores, input_names):\n title = self._legends[idx] if self._legends is not None else None\n headers = [\"\" or title, \"Dev. %s\" % input_names[0]]\n if self._eval and input_scores[1] is not None:\n headers.append(\"eval % s\" % input_names[1])\n if self._criterion == \"rr\":\n rr = bob.measure.recognition_rate(input_scores[0], self._thres[idx])\n dev_rr = \"%.1f%%\" % (100 * rr)\n raws = [[\"RR\", dev_rr]]\n if self._eval and input_scores[1] is not None:\n rr = bob.measure.recognition_rate(\n input_scores[1], self._thres[idx]\n )\n eval_rr = \"%.1f%%\" % (100 * rr)\n raws[0].append(eval_rr)\n click.echo(\n tabulate(raws, headers, self._tablefmt), file=self.log_file\n )\n elif self._criterion == \"mindcf\":\n if \"cost\" in self._ctx.meta:\n cost = self._ctx.meta.get(\"cost\", 0.99)\n threshold = (\n bob.measure.min_weighted_error_rate_threshold(\n input_scores[0][0], input_scores[0][1], cost\n )\n if self._thres is None\n else self._thres[idx]\n )\n if self._thres is None:\n click.echo(\n \"[minDCF - Cost:%f] Threshold on Development set `%s`: %e\"\n % (cost, input_names[0], threshold),\n file=self.log_file,\n )\n else:\n click.echo(\n \"[minDCF] User defined Threshold: %e\" % threshold,\n file=self.log_file,\n )\n # apply threshold to development set\n far, frr = bob.measure.farfrr(\n input_scores[0][0], input_scores[0][1], threshold\n )\n dev_far_str = \"%.1f%%\" % (100 * far)\n dev_frr_str = \"%.1f%%\" % (100 * frr)\n dev_mindcf_str = \"%.1f%%\" % (\n (cost * far + (1 - cost) * frr) * 100.0\n )\n raws = [\n [\"FAR\", dev_far_str],\n [\"FRR\", dev_frr_str],\n [\"minDCF\", dev_mindcf_str],\n ]\n if self._eval and input_scores[1] is not None:\n # apply threshold to development set\n far, frr = bob.measure.farfrr(\n input_scores[1][0], input_scores[1][1], threshold\n )\n eval_far_str = \"%.1f%%\" % (100 * far)\n eval_frr_str = \"%.1f%%\" % (100 * frr)\n eval_mindcf_str = \"%.1f%%\" % (\n (cost * far + (1 - cost) * frr) * 100.0\n )\n raws[0].append(eval_far_str)\n raws[1].append(eval_frr_str)\n raws[2].append(eval_mindcf_str)\n click.echo(\n tabulate(raws, headers, self._tablefmt), file=self.log_file\n )\n elif self._criterion == \"cllr\":\n cllr = bob.measure.calibration.cllr(\n input_scores[0][0], input_scores[0][1]\n )\n min_cllr = bob.measure.calibration.min_cllr(\n input_scores[0][0], input_scores[0][1]\n )\n dev_cllr_str = \"%.1f%%\" % cllr\n dev_min_cllr_str = \"%.1f%%\" % min_cllr\n raws = [[\"Cllr\", dev_cllr_str], [\"minCllr\", dev_min_cllr_str]]\n if self._eval and input_scores[1] is not None:\n cllr = bob.measure.calibration.cllr(\n input_scores[1][0], input_scores[1][1]\n )\n min_cllr = bob.measure.calibration.min_cllr(\n input_scores[1][0], input_scores[1][1]\n )\n eval_cllr_str = \"%.1f%%\" % cllr\n eval_min_cllr_str = \"%.1f%%\" % min_cllr\n raws[0].append(eval_cllr_str)\n raws[1].append(eval_min_cllr_str)\n click.echo(\n tabulate(raws, headers, self._tablefmt), file=self.log_file\n )\n else:\n title = self._legends[idx] if self._legends is not None else None\n all_metrics = self._get_all_metrics(idx, input_scores, input_names)\n headers = [\" \" or title, \"Development\"]\n rows = [\n [self.names[0], all_metrics[0][0]],\n [self.names[1], all_metrics[0][1]],\n [self.names[2], all_metrics[0][2]],\n [self.names[3], all_metrics[0][3]],\n [self.names[4], all_metrics[0][4]],\n [self.names[5], all_metrics[0][5]],\n ]\n\n if self._eval:\n # computes statistics for the eval set based on the threshold a\n # priori\n headers.append(\"Evaluation\")\n rows[0].append(all_metrics[1][0])\n rows[1].append(all_metrics[1][1])\n rows[2].append(all_metrics[1][2])\n rows[3].append(all_metrics[1][3])\n rows[4].append(all_metrics[1][4])\n rows[5].append(all_metrics[1][5])\n\n click.echo(\n tabulate(rows, headers, self._tablefmt), file=self.log_file\n )","def calculate_score(self):\n try:\n self.score = self.__total_comment_score / float(self.num_comments)\n except ZeroDivisionError:\n self.score = float(0)","def costMeasure(self, map):\n\n if self.activeCostMeasure == 0:\n return self.faceMeans(map).faceMeanDiff\n elif self.activeCostMeasure == 1:\n return self.faceMeans(map).faceHomogeneity\n elif self.activeCostMeasure == 2:\n return self.faceMeans(map).faceTTest\n elif self.activeCostMeasure == 3:\n def brightness(dart, fm = self.faceMeans(map)):\n return max(vigra.norm(fm[dart.leftFaceLabel()]),\n vigra.norm(fm[dart.rightFaceLabel()]))\n return brightness\n elif self.activeCostMeasure == 4:\n return map.wsStats.dartPassValue\n elif self.activeCostMeasure == 5:\n return map.wsStats.dynamics\n elif self.activeCostMeasure == 6:\n return self.edgeGradients(map).dartMin\n elif self.activeCostMeasure == 7:\n return self.edgeGradients(map).average\n elif self.activeCostMeasure == 8:\n return self.edgeGradients(map, True).quantile(0.5)\n elif self.activeCostMeasure == 9:\n return self.edgeGradients(map).max\n elif self.activeCostMeasure == 10:\n return statistics.mergedIsoperimetricQuotient\n elif self.activeCostMeasure == 11:\n return statistics.mergedContourLength\n else:\n raise RuntimeError(\"Wrong cost measure (%s)\" % self.activeCostMeasure)","def get_f1(self,common_len,RTSummary,SystemSummary):\n recall = self.get_recall(common_len,RTSummary)\n precision = self.get_precision(common_len,SystemSummary)\n if precision<=0 or recall <=0:\n return 0.0\n else:\n return ((2 * recall * precision)/(recall + precision))","def measure(self, X2, X3, start_index): \n \n power = self.power\n X2 = np.array(X2)\n X3 = np.array(X3)\n if len(X2) == 0:\n score = 0\n else:\n X2 = np.fft.fft(X2);\n X3 = np.fft.fft(X3)\n score = np.linalg.norm(X2 - X3, ord = power)/len(X3)\n self.decision_scores_.append((start_index, score))\n return score","def get_score(self, solution: np.array) -> float:\n pass","def computeOverallScore(self,m):\n \n def _computeOverallScore(scalars):\n \"\"\"Given a netCDF4 group of scalars, blend them into an overall score\"\"\"\n scores = {}\n variables = [v for v in scalars.variables.keys() if \"Score\" in v and \"Overall\" not in v]\n for region in self.regions:\n overall_score = 0.\n sum_of_weights = 0.\n for v in variables:\n if region not in v: continue\n score = v.replace(region,\"\").strip()\n weight = 1.\n if self.weight.has_key(score): weight = self.weight[score]\n overall_score += weight*scalars.variables[v][...]\n sum_of_weights += weight\n overall_score /= max(sum_of_weights,1e-12)\n scores[\"Overall Score %s\" % region] = overall_score\n return scores\n\n fname = os.path.join(self.output_path,\"%s_%s.nc\" % (self.name,m.name))\n if not os.path.isfile(fname): return\n with Dataset(fname,mode=\"r+\") as dataset:\n datasets = [dataset.groups[grp] for grp in dataset.groups if \"scalars\" not in grp]\n groups = [grp for grp in dataset.groups if \"scalars\" not in grp]\n datasets.append(dataset)\n groups .append(None)\n for dset,grp in zip(datasets,groups):\n if \"scalars\" in dset.groups:\n scalars = dset.groups[\"scalars\"]\n score = _computeOverallScore(scalars)\n for key in score.keys():\n if key in scalars.variables:\n scalars.variables[key][0] = score[key]\n else:\n Variable(data=score[key],name=key,unit=\"1\").toNetCDF4(dataset,group=grp)","def compute_performance(cm):\n\n tp = np.diagonal(cm).astype(np.float)\n tpfp = np.sum(cm, axis=0).astype(np.float) # sum of each col\n tpfn = np.sum(cm, axis=1).astype(np.float) # sum of each row\n acc = np.sum(tp) / np.sum(cm)\n precision = tp / tpfp\n recall = tp / tpfn\n f1 = (2 * precision * recall) / (precision + recall)\n mf1 = np.mean(f1)\n\n total = np.sum(cm)\n n_each_class = tpfn\n\n return total, n_each_class, acc, mf1, precision, recall, f1","def f2_score(self, y_true=None, y_pred=None, labels=None, average=\"macro\", decimal=None, **kwargs):\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\n\n list_f2 = np.array([item[\"f2\"] for item in metrics.values()])\n list_weights = np.array([item[\"n_true\"] for item in metrics.values()])\n\n if average == \"micro\":\n tp_global = np.sum(np.diag(matrix))\n fp_global = fn_global = np.sum(matrix) - tp_global\n precision = tp_global / (tp_global + fp_global)\n recall = tp_global / (tp_global + fn_global)\n f2 = (5 * precision * recall) / (4 * precision + recall)\n elif average == \"macro\":\n f2 = np.mean(list_f2)\n elif average == \"weighted\":\n f2 = np.dot(list_weights, list_f2) / np.sum(list_weights)\n else:\n f2 = dict([(label, np.round(item[\"f2\"], decimal)) for label, item in metrics.items()])\n return f2 if type(f2) == dict else np.round(f2, decimal)","def _f_p_r_lcs(llcs, m, n):\n r_lcs = llcs / m\n p_lcs = llcs / n\n beta = p_lcs / (r_lcs + 1e-12)\n num = (1 + (beta**2)) * r_lcs * p_lcs\n denom = r_lcs + ((beta**2) * p_lcs)\n f_lcs = num / (denom + 1e-12)\n return f_lcs, p_lcs, r_lcs","def get_score(self):\n files_flare = self.generate_flare_set()\n files_non_flare = self.generate_non_flare_set()\n timeseries = []\n y = []\n scores = {}\n column_mapping = self.__get_column_mapping()\n for col in tqdm(range(1, 25)):\n for file in tqdm(files_flare):\n s = Sample(\"FL\", file).get_data().iloc[:, col].values\n y.append(self.mapping[file[0]])\n timeseries.append(s)\n\n for file in tqdm(files_non_flare):\n s = Sample(\"NF\", file).get_data().iloc[:, col].values\n y.append(self.mapping[file[0]])\n timeseries.append(s)\n embed = self.get_embed_vector(timeseries)\n\n embed_y = KMeans(n_clusters=5).fit_predict(embed)\n y = np.array(y).flatten()\n scores[column_mapping[col]] = self.relevance_score(embed_y, y)\n timeseries = []\n y = []\n scores_data = pd.DataFrame.from_dict(scores, orient='index', columns=['Relevance Score']).sort_values(\n by='Relevance Score', ascending=False)\n return scores_data","def calc_intersection_true_data_baselines_data_cnt():\n# final_sen_scores = linux_base_path + \"/final_sen_scores/\"\n final_sen_scores = base_path + \"\\\\final_sen_scores\\\\\"\n top_k_docs_values = [50]\n lambda_f = \"1\"\n claim_sen_true_relevance_dict = read_pickle(\"claim_sen_relevance_dict_\"+curr_source)\n claims_dict = read_pickle(\"claim_dict\")\n intersection_count_avg_all_claims =0\n exclude = set(string.punctuation)\n \n for k_val in top_k_docs_values:\n intersection_count = 0\n for alpha in range(10,11,1): #change just for test!\n for beta in range(0,1,1):\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\n curr_baseline_final_sen_score_dict = read_pickle(final_sen_scores+\"clm_num_key_final_ranked_list_sen_alpha_\"+str(alpha_f)+\"_beta_\"+str(beta_f)+\"_top_k_docs_\"+str(k_val)+\"_lambda_\"+str(lambda_f)+\"_sorted\")\n for clm in curr_baseline_final_sen_score_dict.keys():\n curr_clm_baseline_set = set()\n curr_true_relevance_set = set()\n for (sen,score) in curr_baseline_final_sen_score_dict[clm]:\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\n sen_no_space = sen_no_punc.replace(\" \",\"\")\n curr_clm_baseline_set.add(sen_no_space)\n for (sen,score) in claim_sen_true_relevance_dict[claims_dict[clm]]:\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\n sen_no_space = sen_no_punc.replace(\" \",\"\")\n curr_true_relevance_set.add(sen_no_space) \n intersection_count += len(curr_clm_baseline_set.intersection(curr_true_relevance_set))\n intersection_count_avg_all_claims += float(float(intersection_count)/float(110))\n intersection_count_avg_all_claims = float(float(intersection_count_avg_all_claims)/float(len(curr_baseline_final_sen_score_dict.keys())))\n print \"intersection_count_avg_all_claims:\"+str(intersection_count_avg_all_claims)","def calc_score(allcourses, student_list, chambers):\n\n\t# start-score of a valid schedule\n\tpoints = 1000\n\tallcoursespoints = []\n\troomlocks_per_day = 28\n\n\t#* create groups and dict to keep up the days per activity *#\n\n\t# iterate over courses\n\tfor course in allcourses:\n\n\t\tcoursepoints = 0\n\n\t\t# if seminar(s) exist\n\t\tif course.seminars > 0:\n\n\t\t\t# create list with amount of seminar-groups\n\t\t\tgroups = list(range(1, int(course.seminars) + 1))\n\n\t\t# if practical exist\n\t\telif course.practicals > 0:\n\n\t\t\t# create list with amount of practical-groups\n\t\t\tgroups = list(range(1, int(course.practicals) + 1))\n\n\t\t# otherwise only one group (lecture)\n\t\telse:\n\t\t\tgroups = [1]\n\n\t\t# create dict with groupnumber as key, [days] as values\n\t\tdayActivity = {k: [] for k in groups}\n\n\t\t#* subtract points based on activities per day *#\n\n\t\t# iterate over activities per course\n\t\tfor activity in course.activities:\n\n\t\t\t# determine day\n\t\t\tday = int(activity[0] / roomlocks_per_day)\n\n\t\t\t# if activity = lecture\n\t\t\tif activity[2] == 0:\n\n\t\t\t\t# add day to list linked to lecture\n\t\t\t\tfor group in groups:\n\t\t\t\t\tdayActivity[group].append(day)\n\n\t\t\t# for seminars and practicals\n\t\t\telse:\n\n\t\t\t\t# add day to list linked to group\n\t\t\t\tdayActivity[activity[2]].append(day)\n\n\t\t# for each group\n\t\tfor group in groups:\n\n\t\t\t# for each working day\n\t\t\tfor day in range(0, 5):\n\n\t\t\t\t# count how many of the same activities a day\n\t\t\t\tday_occurance = dayActivity[group].count(day)\n\n\t\t\t\t# if more often than 1\n\t\t\t\tif day_occurance > 1:\n\n\t\t\t\t\t# substract points\n\t\t\t\t\tpoints -= ((day_occurance - 1) * 10)\n\t\t\t\t\tcoursepoints -= ((day_occurance - 1) * 10)\n\n\t\t#* add points for spreading of activities over week *#\n\n\t\t# iterate over groups\n\t\tfor group in groups:\n\n\t\t\t# when 2 activities in week\n\t\t\tif (len(dayActivity[group]) == 2):\n\n\t\t\t\t# add points if they are spread (mo- thu, mo-fri)\n\t\t\t\tif (abs(dayActivity[group][0] - dayActivity[group][1]) >= 3):\n\t\t\t\t\tpoints += 20\n\t\t\t\t\tcoursepoints += 20\n\n\t\t\t# when 3 activities in the week\n\t\t\tif (len(dayActivity[group]) == 3):\n\n\t\t\t\t# add points if spread (mo-we-fr)\n\t\t\t\tif 0 in dayActivity[group] and 2 in dayActivity[group] and 4 in dayActivity[group]:\n\t\t\t\t\tpoints += 20\n\t\t\t\t\tcoursepoints += 20\n\n\t\t\t# if 4 activities in the week\n\t\t\tif (len(dayActivity[group]) == 4):\n\n\t\t\t\t# add points if spread (mo-tu-th-fr)\n\t\t\t\tif 0 in dayActivity[group] and 1 in dayActivity[group] and 3 in dayActivity[group] and 4 in dayActivity[group]:\n\t\t\t\t\tpoints += 20\n\t\t\t\t\tcoursepoints += 20\n\n\t\t# for each activity of a course\n\t\tfor activity in course.activities:\n\n\t\t\t# substract room and timelock\n\t\t\troom, timelock = translate_roomlock(activity[0])\n\n\t\t\t# for lectures\n\t\t\tif activity[2] == 0:\n\n\t\t\t\t# if too many students for room\n\t\t\t\tif int(chambers[room].capacity) < course.students:\n\n\t\t\t\t\t# substract points\n\t\t\t\t\tmaluspoints = course.students - int(chambers[room].capacity)\n\t\t\t\t\tpoints -= maluspoints\n\t\t\t\t\tcoursepoints -= maluspoints\n\n\t\t\t# for practical/seminars\n\t\t\telse:\n\n\t\t\t\t# if seminar\n\t\t\t\tif course.seminars > 0:\n\n\t\t\t\t\t# and too many students fro room, substract points\n\t\t\t\t\tif int(chambers[room].capacity) < course.maxstudentssem:\n\n\t\t\t\t\t\t# substract points\n\t\t\t\t\t\tmaluspoints = course.maxstudentssem - int(chambers[room].capacity)\n\t\t\t\t\t\tpoints -= maluspoints\n\t\t\t\t\t\tcoursepoints -= maluspoints\n\n\t\t\t\t# if practical\n\t\t\t\telse:\n\n\t\t\t\t\t# and too many students from room, substract points\n\t\t\t\t\tif int(chambers[room].capacity) < course.maxstudentsprac:\n\t\t\t\t\t\tmaluspoints = course.maxstudentsprac - int(chambers[room].capacity)\n\t\t\t\t\t\tpoints -= maluspoints\n\t\t\t\t\t\tcoursepoints -= maluspoints\n\n\t\t# add points of allcourses\n\t\tallcoursespoints.append([course.name, coursepoints])\n\n\t#* substract points when 2 courses on same time *#\n\n\t# for all students\n\tfor student in student_list:\n\n\t\t# create empty list\n\t\ttimelocks_student = []\n\n\t\t# for each activity in schedule\n\t\tfor activity in student.schedule:\n\n\t\t\t# if roomlock is occupied substract points\n\t\t\tif activity[0] in timelocks_student:\n\t\t\t\tpoints -= 1\n\t\t\t\tcoursepoints -= 1\n\n\t\t\t# add roomlock to list\n\t\t\ttimelocks_student.append(activity[0])\n\n\treturn points","def calculate_LC(read):\n k_values = []\n for i in range(1,len(read)+1):\n k_values.append(i)\n observed_kmers = []\n for i in k_values:\n observed_kmers.append((count_kmers_observed(read, i)))\n possible_kmers = []\n for i in k_values:\n possible_kmers.append(count_kmers_possible(read, i))\n df = pd.DataFrame(list(zip(k_values, observed_kmers, possible_kmers)), columns = ['k','observed kmers','possible kmers'])\n df.at['Total', 'observed kmers'] = df['observed kmers'].sum()\n df.at['Total', 'possible kmers'] = df['possible kmers'].sum()\n x = int(df.at['Total', 'observed kmers'])\n y = int(df.at['Total', 'possible kmers'])\n LC = (x/y)\n return(LC)","def _f1_score_(prediction, ground_truth):\n prediction_tokens = _normalize_answer(prediction).split()\n ground_truth_tokens = _normalize_answer(ground_truth).split()\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(prediction_tokens)\n recall = 1.0 * num_same / len(ground_truth_tokens)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def scoring(self):\n pass","def _f_p_r_lcs(llcs, m, n):\n r_lcs = llcs / m\n p_lcs = llcs / n\n beta = p_lcs / (r_lcs + 1e-12)\n num = (1 + (beta ** 2)) * r_lcs * p_lcs\n denom = r_lcs + ((beta ** 2) * p_lcs)\n f_lcs = num / (denom + 1e-12)\n return f_lcs, p_lcs, r_lcs","def get_score(self, int_img):\n score = 0\n if self.type == FeatureType.TWO_VERTICAL:\n first = ii.sum_region(int_img, self.top_left, (self.top_left[0] + self.width, int(self.top_left[1] + self.height / 2)))\n second = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 2)), self.bottom_right)\n score = first - second\n elif self.type == FeatureType.TWO_HORIZONTAL:\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 2), self.top_left[1] + self.height))\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), self.top_left[1]), self.bottom_right)\n score = first - second\n elif self.type == FeatureType.THREE_HORIZONTAL:\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 3), self.top_left[1] + self.height))\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 3), self.top_left[1]), (int(self.top_left[0] + 2 * self.width / 3), self.top_left[1] + self.height))\n third = ii.sum_region(int_img, (int(self.top_left[0] + 2 * self.width / 3), self.top_left[1]), self.bottom_right)\n score = first - second + third\n elif self.type == FeatureType.THREE_VERTICAL:\n first = ii.sum_region(int_img, self.top_left, (self.bottom_right[0], int(self.top_left[1] + self.height / 3)))\n second = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 3)), (self.bottom_right[0], int(self.top_left[1] + 2 * self.height / 3)))\n third = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + 2 * self.height / 3)), self.bottom_right)\n score = first - second + third\n elif self.type == FeatureType.FOUR:\n # top left area\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 2), int(self.top_left[1] + self.height / 2)))\n # top right area\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), self.top_left[1]), (self.bottom_right[0], int(self.top_left[1] + self.height / 2)))\n # bottom left area\n third = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 2)), (int(self.top_left[0] + self.width / 2), self.bottom_right[1]))\n # bottom right area\n fourth = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), int(self.top_left[1] + self.height / 2)), self.bottom_right)\n score = first - second - third + fourth\n return score","def get_score(score_map, test_result):\n if test_result < score_map[20]:\n return int((test_result / score_map[20]) * 20)\n elif test_result < score_map[40]:\n return int(20 + (test_result - score_map[20]) / (score_map[40] - score_map[20]) * 20)\n elif test_result < score_map[60]:\n return int(40 + (test_result - score_map[40]) / (score_map[60] - score_map[40]) * 20)\n elif test_result < score_map[85]:\n return int(60 + (test_result - score_map[60]) / (score_map[85] - score_map[60]) * 20)\n elif test_result < score_map[100]:\n return int(85 + (test_result - score_map[85]) / (score_map[100] - score_map[85]) * 20)\n else:\n return 100","def performance_metric(y_true, y_pred):\n f1_arr = []\n for i in range(np.shape(y_pred)[1]):\n f1 = f1_score(np.array(y_true)[:, i], y_pred[:, i], average='weighted')\n f1_arr.append(f1)\n \n score = np.mean(f1_arr)\n return score","def compute_score_fast(verbose=1):\n res = []\n\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\n for start in range(0, len(train), batch):\n end = min(len(train), start + batch)\n train_batch = train[start:end]\n\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\n score = score_reshape(score, features)\n\n res.append(score)\n\n return res","def raw_score(self,X,Y):\n return self.rf.score(X,Y)","def F1_score(y, model):\n\tp = precision(y, model)\n\tr = recall(y, model)\n\tf = 2*((p*r)/(p+r))\n\treturn f"],"string":"[\n \"def computeFScores(self, targetLabels, actualLabels):\\r\\n if self.prMeasures is None:\\r\\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\\r\\n if self.prMeasures[0] == 0:\\r\\n return 0\\r\\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[1] / (0.0 + self.prMeasures[0] + self.prMeasures[1])\\r\\n return self.f1score\",\n \"def calculate_flesch_score(text):\\n\\n # Use the given formula and call other functions to get the values\\n score = 206.835 - 1.015 * count_words(text) / count_sentences(text) - 84.6 * count_syllables(text) / count_words(\\n text)\\n\\n return score\",\n \"def get_f_score(self):\\n return self.get_g_score() + self.get_h_score()\",\n \"def fScore(cMatrix):\\n if precision(cMatrix) + recall(cMatrix) == 0:\\n return precision(cMatrix)\\n else:\\n return 2 * precision(cMatrix) * recall(cMatrix) / (precision(cMatrix) + recall(cMatrix))\",\n \"def _chrf_score_compute(total_preds_char_n_grams: Dict[int, Tensor], total_preds_word_n_grams: Dict[int, Tensor], total_target_char_n_grams: Dict[int, Tensor], total_target_word_n_grams: Dict[int, Tensor], total_matching_char_n_grams: Dict[int, Tensor], total_matching_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n chrf_f_score = _calculate_fscore(total_matching_char_n_grams, total_matching_word_n_grams, total_preds_char_n_grams, total_preds_word_n_grams, total_target_char_n_grams, total_target_word_n_grams, n_order, beta)\\n return chrf_f_score\",\n \"def compute_prf(self, counts_dict):\\n precision = counts_dict[\\\"correct\\\"] / counts_dict[\\\"predicted\\\"] if counts_dict[\\\"predicted\\\"] else 0.0\\n recall = counts_dict[\\\"correct\\\"] / counts_dict[\\\"gold\\\"] if counts_dict[\\\"gold\\\"] else 0.0\\n fscore = 2 * precision * recall / (precision + recall) if precision + recall else 0.0\\n\\n return {\\\"precision\\\": precision, \\\"recall\\\": recall, \\\"fscore\\\": fscore}\",\n \"def fmeasure(B, hits, misses, falses) :\\n x = ((1 + B**2) * hits) / ((1 + B**2) * hits + B**2 * misses + falses)\\n return x\",\n \"def fmeasure(B, hits, misses, falses) :\\r\\n x = ((1 + B**2) * hits) / ((1 + B**2) * hits + B**2 * misses + falses)\\r\\n return x\",\n \"def f1_score(self):\",\n \"def muc_scores(self):\\n A_card, B_card = self.shape\\n V_card = len(self)\\n N = self.grand_total\\n\\n recall = _div(N - V_card, N - A_card)\\n precision = _div(N - V_card, N - B_card)\\n fscore = hmean(recall, precision)\\n return precision, recall, fscore\",\n \"def _calculate_sentence_level_chrf_score(targets: List[str], pred_char_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], pred_word_n_grams_counts: Dict[int, Dict[Tuple[str, ...], Tensor]], preds_char_n_grams: Dict[int, Tensor], preds_word_n_grams: Dict[int, Tensor], n_char_order: int, n_word_order: int, n_order: float, beta: float, lowercase: bool, whitespace: bool) ->Tuple[Tensor, Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor], Dict[int, Tensor]]:\\n best_f_score = tensor(0.0)\\n best_matching_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_matching_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_char_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n best_target_word_n_grams: Dict[int, Tensor] = defaultdict(lambda : tensor(0.0))\\n for target in targets:\\n target_char_n_grams_counts, target_word_n_grams_counts, target_char_n_grams, target_word_n_grams = _get_n_grams_counts_and_total_ngrams(target, n_char_order, n_word_order, lowercase, whitespace)\\n matching_char_n_grams = _get_ngram_matches(target_char_n_grams_counts, pred_char_n_grams_counts)\\n matching_word_n_grams = _get_ngram_matches(target_word_n_grams_counts, pred_word_n_grams_counts)\\n f_score = _calculate_fscore(matching_char_n_grams, matching_word_n_grams, preds_char_n_grams, preds_word_n_grams, target_char_n_grams, target_word_n_grams, n_order, beta)\\n if f_score > best_f_score:\\n best_f_score = f_score\\n best_matching_char_n_grams = matching_char_n_grams\\n best_matching_word_n_grams = matching_word_n_grams\\n best_target_char_n_grams = target_char_n_grams\\n best_target_word_n_grams = target_word_n_grams\\n return best_f_score, best_matching_char_n_grams, best_matching_word_n_grams, best_target_char_n_grams, best_target_word_n_grams\",\n \"def _calculate_fscore(matching_char_n_grams: Dict[int, Tensor], matching_word_n_grams: Dict[int, Tensor], hyp_char_n_grams: Dict[int, Tensor], hyp_word_n_grams: Dict[int, Tensor], ref_char_n_grams: Dict[int, Tensor], ref_word_n_grams: Dict[int, Tensor], n_order: float, beta: float) ->Tensor:\\n\\n def _get_n_gram_fscore(matching_n_grams: Dict[int, Tensor], ref_n_grams: Dict[int, Tensor], hyp_n_grams: Dict[int, Tensor], beta: float) ->Dict[int, Tensor]:\\n \\\"\\\"\\\"Get n-gram level f-score.\\\"\\\"\\\"\\n precision: Dict[int, Tensor] = {n: (matching_n_grams[n] / hyp_n_grams[n] if hyp_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n recall: Dict[int, Tensor] = {n: (matching_n_grams[n] / ref_n_grams[n] if ref_n_grams[n] > 0 else tensor(0.0)) for n in matching_n_grams}\\n denominator: Dict[int, Tensor] = {n: torch.max(beta ** 2 * precision[n] + recall[n], _EPS_SMOOTHING) for n in matching_n_grams}\\n f_score: Dict[int, Tensor] = {n: ((1 + beta ** 2) * precision[n] * recall[n] / denominator[n]) for n in matching_n_grams}\\n return f_score\\n char_n_gram_f_score = _get_n_gram_fscore(matching_char_n_grams, ref_char_n_grams, hyp_char_n_grams, beta)\\n word_n_gram_f_score = _get_n_gram_fscore(matching_word_n_grams, ref_word_n_grams, hyp_word_n_grams, beta)\\n f_score = (sum(char_n_gram_f_score.values()) + sum(word_n_gram_f_score.values())) / tensor(n_order)\\n return f_score\",\n \"def compute_rouge_l(output, reference, mode='f'):\\n assert mode in list('fpr') # F-1, precision, recall\\n lcs = _lcs_len(output, reference)\\n if lcs == 0:\\n score = 0.0\\n else:\\n precision = lcs / len(output)\\n recall = lcs / len(reference)\\n f_score = 2 * (precision * recall) / (precision + recall)\\n if mode == 'p':\\n score = precision\\n if mode == 'r':\\n score = recall\\n else:\\n score = f_score\\n return score\",\n \"def score_calc(self, annotations, predictions):\\n if isinstance(sqrtm, UnsupportedPackage):\\n sqrtm.raise_error(self.__provider__)\\n\\n assert annotations.shape[1] == predictions.shape[1], \\\"Expected equal length of feature vectors\\\"\\n\\n mu_real, mu_gen = annotations.mean(axis=0), predictions.mean(axis=0)\\n cov_real, cov_gen = np.cov(annotations, rowvar=False), np.cov(predictions, rowvar=False)\\n mdiff = mu_real - mu_gen\\n\\n covmean = sqrtm(cov_real.dot(cov_gen))\\n if not np.isfinite(covmean).all():\\n offset = np.eye(cov_real.shape[0]) * self.eps\\n covmean = sqrtm((cov_real + offset).dot(cov_gen + offset))\\n if np.iscomplexobj(covmean):\\n covmean = covmean.real\\n\\n fid = mdiff.dot(mdiff) + np.trace(cov_real + cov_gen - 2 * covmean)\\n return fid\",\n \"def fmeasure(y_true, y_pred):\\n return fbeta_score(y_true, y_pred, beta=1)\",\n \"def fmeasure(y_true, y_pred):\\n return fbeta_score(y_true, y_pred, beta=1)\",\n \"def fmeasure(y_true, y_pred):\\n return fbeta_score(y_true, y_pred, beta=1)\",\n \"def fmeasure(y_true, y_pred):\\n return fbeta_score(y_true, y_pred, beta=1)\",\n \"def test_lfc_ml():\\n levels = np.array([959., 779.2, 751.3, 724.3, 700., 269.]) * units.mbar\\n temperatures = np.array([22.2, 14.6, 12., 9.4, 7., -49.]) * units.celsius\\n dewpoints = np.array([19., -11.2, -10.8, -10.4, -10., -53.2]) * units.celsius\\n __, t_mixed, td_mixed = mixed_parcel(levels, temperatures, dewpoints)\\n mixed_parcel_prof = parcel_profile(levels, t_mixed, td_mixed)\\n lfc_pressure, lfc_temp = lfc(levels, temperatures, dewpoints, mixed_parcel_prof)\\n assert_almost_equal(lfc_pressure, 601.225 * units.mbar, 2)\\n assert_almost_equal(lfc_temp, -1.90688 * units.degC, 2)\",\n \"def _compute_scores(self, triples):\\n # compute scores as sum(s * p * o)\\n scores = tf.reduce_sum(triples[0] * triples[1] * triples[2], 1)\\n return scores\",\n \"def calculate_f1_score(y_test, y_pred):\\n print('# Running precision, recall and F1-score')\\n print('# F1-Score:\\\\t\\\\t%.2f' % (f1_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Precision:\\\\t\\\\t%.2f' % (precision_score(y_test, y_pred, average=\\\"macro\\\") * 100))\\n print('# Recall:\\\\t\\\\t%.2f' % (recall_score(y_test, y_pred, average=\\\"macro\\\") * 100))\",\n \"def scoring(estimator, features_test, labels_test):\\n pred = estimator.predict(features_test)\\n p = metrics.precision_score(labels_test, pred, average='micro')\\n r = metrics.recall_score(labels_test, pred, average='micro')\\n if p > 0.3 and r > 0.3:\\n return metrics.f1_score(labels_test, pred, average='macro')\\n return 0\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def _F_performance(self, score, thresholds, condition):\\r\\n if type(thresholds) is float:\\r\\n thresholds = self._compute_thresholds(thresholds)\\r\\n F = np.zeros(shape=(1, len(thresholds)))\\r\\n impostors = 0\\r\\n L = len(score)\\r\\n for count, thr in enumerate(thresholds):\\r\\n N = 0\\r\\n for idx in range(0, L):\\r\\n N += condition(score[idx], thr)\\r\\n F[0, count] = N / L\\r\\n return F[0]\",\n \"def score(label_recall, label_precision, pred_recall, pred_precision):\\n f11 = 6*label_recall*label_precision/(5*label_recall+label_precision)\\n f12 = 5*pred_recall*pred_precision/(2*pred_recall+3*pred_precision)\\n\\n return 0.4*f11 + 0.6*f12\",\n \"def calculate(self):\\n\\n beta = 1 # or 0.5 or 2 can also calculate F2 or F0.5 measure\\n\\n beta_squared = beta * beta\\n precision = Precision()\\n precision.confusion_matrix = self.confusion_matrix\\n precision = precision.calculate()\\n recall = Recall()\\n recall.confusion_matrix = self.confusion_matrix\\n recall = recall.calculate()\\n\\n denominator = beta_squared * precision + recall\\n\\n if denominator != 0:\\n return (1 + beta_squared) * ((precision * recall) / denominator)\\n else:\\n return 0\",\n \"def custom_scoring(y_te, y_pred):\\n #weights computed with training data set\\n w = np.array([0.02409584, 0.00787456, 0.03685528, 0.01760536, 0.04589969, 0.8483942 , 0.01724058, 0.00203449]);\\n \\n ## F1 SCORES\\n #evaluate F1 score, precision and recall for each label, \\n #along with custom proportionally weighted F1 score\\n #and built in weighted and macro F1 scores\\n F1_tab, Ptab, Rtab, pf1 = F1_score(y_te, y_pred, w)\\n f = F1Score(8, threshold = 0.5, average = 'weighted')\\n f.update_state(y_te, y_pred)\\n wf1 = f.result().numpy() #weighted f1 score\\n f.reset_states()\\n f = F1Score(8, threshold = 0.5, average = 'macro')\\n f.update_state(y_te, y_pred)\\n mf1 = f.result().numpy() #macro f1 score\\n f.reset_states()\\n\\n ##EDIT DISTANCE\\n #edit_dist_av = LevDistMultilabels(y_true, y_pred)\\n\\n ##ACCURACY\\n #evaluate accuracy per label\\n acc_tab = Acc(y_te, y_pred)\\n\\n return wf1, mf1, pf1, F1_tab, Ptab, Rtab, acc_tab\",\n \"def compute_score(self):\\n for i in xrange(FRAMES):\\n # STRIKE\\n if self.frames[i][0] == 10:\\n # CONSECUTIVE STRIKE\\n if self.frames[i + 1][0] == 10:\\n self.scores.append(self.frames[i][0] +\\n self.frames[i + 1][0] +\\n self.frames[i + 2][0])\\n else:\\n self.scores.append(self.frames[i][0] +\\n self.frames[i + 1][0] +\\n self.frames[i + 1][1])\\n # SPARE\\n elif (self.frames[i][0] + self.frames[i][1] == 10):\\n self.scores.append(self.frames[i][0] + self.frames[i][1] +\\n self.frames[i + 1][0])\\n # NEITHER\\n else:\\n self.scores.append(self.frames[i][0] + self.frames[i][1])\\n # Total Score\\n for score in self.scores:\\n self.score += score\",\n \"def score_full(self, params):\\n\\n if type(params) is not MixedLMParams:\\n params = MixedLMParams.from_packed(params, self.k_fe,\\n self.use_sqrt)\\n\\n fe_params = params.get_fe_params()\\n cov_re = params.get_cov_re()\\n try:\\n cov_re_inv = np.linalg.inv(cov_re)\\n except np.linalg.LinAlgError:\\n cov_re_inv = None\\n\\n score_fe = np.zeros(self.k_fe, dtype=np.float64)\\n score_re = np.zeros(self.k_re2, dtype=np.float64)\\n\\n # Handle the covariance penalty.\\n if self.cov_pen is not None:\\n score_re -= self.cov_pen.grad(cov_re, cov_re_inv)\\n\\n # Handle the fixed effects penalty.\\n if self.fe_pen is not None:\\n score_fe -= self.fe_pen.grad(fe_params)\\n\\n # resid' V^{-1} resid, summed over the groups (a scalar)\\n rvir = 0.\\n\\n # exog' V^{-1} resid, summed over the groups (a k_fe\\n # dimensional vector)\\n xtvir = 0.\\n\\n # exog' V^{_1} exog, summed over the groups (a k_fe x k_fe\\n # matrix)\\n xtvix = 0.\\n\\n # V^{-1} exog' dV/dQ_jj exog V^{-1}, where Q_jj is the jj^th\\n # covariance parameter.\\n xtax = [0.,] * self.k_re2\\n\\n # Temporary related to the gradient of log |V|\\n dlv = np.zeros(self.k_re2, dtype=np.float64)\\n\\n # resid' V^{-1} dV/dQ_jj V^{-1} resid (a scalar)\\n rvavr = np.zeros(self.k_re2, dtype=np.float64)\\n\\n for k in range(self.n_groups):\\n\\n exog = self.exog_li[k]\\n ex_r = self.exog_re_li[k]\\n ex2_r = self.exog_re2_li[k]\\n\\n # The residuals\\n expval = np.dot(exog, fe_params)\\n resid = self.endog_li[k] - expval\\n\\n if self.reml:\\n viexog = _smw_solve(1., ex_r, ex2_r, cov_re,\\n cov_re_inv, exog)\\n xtvix += np.dot(exog.T, viexog)\\n\\n # Contributions to the covariance parameter gradient\\n jj = 0\\n vex = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n ex_r)\\n vir = _smw_solve(1., ex_r, ex2_r, cov_re, cov_re_inv,\\n resid)\\n for jj,mat in self._gen_dV_dPsi(ex_r):\\n dlv[jj] = np.trace(_smw_solve(1., ex_r, ex2_r, cov_re,\\n cov_re_inv, mat))\\n rvavr[jj] += np.dot(vir, np.dot(mat, vir))\\n if self.reml:\\n xtax[jj] += np.dot(viexog.T, np.dot(mat, viexog))\\n\\n # Contribution of log|V| to the covariance parameter\\n # gradient.\\n score_re -= 0.5 * dlv\\n\\n # Needed for the fixed effects params gradient\\n rvir += np.dot(resid, vir)\\n xtvir += np.dot(exog.T, vir)\\n\\n fac = self.n_totobs\\n if self.reml:\\n fac -= self.exog.shape[1]\\n\\n score_fe += fac * xtvir / rvir\\n score_re += 0.5 * fac * rvavr / rvir\\n\\n if self.reml:\\n for j in range(self.k_re2):\\n score_re[j] += 0.5 * np.trace(np.linalg.solve(\\n xtvix, xtax[j]))\\n\\n score_vec = np.concatenate((score_fe, score_re))\\n\\n if self._freepat is not None:\\n return self._freepat.get_packed() * score_vec\\n else:\\n return score_vec\",\n \"def test_f_measure(self) -> None:\\n brent_spot_anno = {\\n \\\"6\\\": [219, 230, 288],\\n \\\"8\\\": [227, 381],\\n \\\"9\\\": [86, 219, 230, 279, 375],\\n \\\"12\\\": [169, 172, 217, 228, 287, 368, 382, 389, 409],\\n \\\"13\\\": [170, 180, 219, 229, 246, 271, 286, 379, 409, 444, 483],\\n }\\n\\n brent_spot_prophet_default_cploc = [259, 279, 299, 319, 339, 359]\\n\\n # scores are defined in\\n # https://github.com/alan-turing-institute/TCPDBench/blob/master/analysis/output/summaries/summary_brent_spot.json\\n\\n f_brent_spot = f_measure(\\n annotations=brent_spot_anno, predictions=brent_spot_prophet_default_cploc\\n )\\n self.assertAlmostEqual(f_brent_spot[\\\"f_score\\\"], 0.2485875706214689, places=3)\\n self.assertAlmostEqual(f_brent_spot[\\\"precision\\\"], 0.2857142857142857, places=3)\\n self.assertAlmostEqual(f_brent_spot[\\\"recall\\\"], 0.21999999999999997, places=3)\",\n \"def rouge_l_fscore(predictions, labels):\\n outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)\\n rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),\\n tf.float32)\\n return rouge_l_f_score, tf.constant(1.0)\",\n \"def _calculate_score(self):\\n mul = self._check_board()\\n if mul > 0:\\n inc = 100 * mul + ((mul - 1) * 25)\\n self.score += inc\",\n \"def score( self ):\\r\\n result = 0.0\\r\\n for rr in self.ee.getRsrcs( ):\\r\\n value = self.scoreRsrc( rr )\\r\\n result += value\\r\\n print( \\\"INFO: Value for the schedule is %s \\\" % ( rr, result ) )\\r\\n return( result )\",\n \"def fscore(links_true, links_pred=None):\\n\\n prec = precision(links_true, links_pred)\\n rec = recall(links_true, links_pred)\\n\\n return float(2 * prec * rec / (prec + rec))\",\n \"def score(self, params):\\n\\n if self.use_sqrt:\\n return self.score_sqrt(params)\\n else:\\n return self.score_full(params)\",\n \"def model(**params):\\n N_frb = 0\\n vs = []\\n hs = []\\n cs = []\\n ncands = []\\n\\n for cand in candlist:\\n c_res = calculate_metric_terms(\\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\\n )\\n t, frb_found, h, c, v = c_res\\n vs.append(v)\\n hs.append(h)\\n cs.append(c)\\n ncands.append(t)\\n\\n if frb_found:\\n N_frb += 1\\n\\n vs = np.array(vs)\\n hs = np.array(hs)\\n cs = np.array(cs)\\n c_avg = np.average(cs, axis=0, weights=ncands)\\n h_avg = np.average(hs, axis=0, weights=ncands)\\n v_avg = np.average(vs, axis=0, weights=ncands)\\n recall = N_frb / len(vs)\\n score = v_avg * recall\\n\\n return score\",\n \"def _score_lcs(target_tokens, prediction_tokens):\\n\\n if not target_tokens or not prediction_tokens:\\n return scoring.Score(precision=0, recall=0, fmeasure=0)\\n\\n # Compute length of LCS from the bottom up in a table (DP appproach).\\n cols = len(prediction_tokens) + 1\\n rows = len(target_tokens) + 1\\n lcs_table = np.zeros((rows, cols))\\n for i in xrange(1, rows):\\n for j in xrange(1, cols):\\n if target_tokens[i - 1] == prediction_tokens[j - 1]:\\n lcs_table[i, j] = lcs_table[i - 1, j - 1] + 1\\n else:\\n lcs_table[i, j] = max(lcs_table[i - 1, j], lcs_table[i, j - 1])\\n lcs_length = lcs_table[-1, -1]\\n\\n precision = lcs_length / len(prediction_tokens)\\n recall = lcs_length / len(target_tokens)\\n fmeasure = scoring.fmeasure(precision, recall)\\n\\n return scoring.Score(precision=precision, recall=recall, fmeasure=fmeasure)\",\n \"def _compute_score(img_binary: np.ndarray, s: float) -> float:\\n img_sheared = _shear_img(img_binary, s, 0)\\n h = img_sheared.shape[0]\\n\\n img_sheared_mask = img_sheared > 0\\n first_fg_px = np.argmax(img_sheared_mask, axis=0)\\n last_fg_px = h - np.argmax(img_sheared_mask[::-1], axis=0)\\n num_fg_px = np.sum(img_sheared_mask, axis=0)\\n\\n dist_fg_px = last_fg_px - first_fg_px\\n col_mask = np.bitwise_and(num_fg_px > 0, dist_fg_px == num_fg_px)\\n masked_dist_fg_px = dist_fg_px[col_mask]\\n\\n score = sum(masked_dist_fg_px ** 2)\\n return score\",\n \"def get_score(self):\\r\\n return self.lcp.get_score()\",\n \"def calculate_f2_score(predictions, actuals):\\n predictions = predictions > 0.5\\n # fbeta_score throws a confusing error if inputs are not numpy arrays\\n predictions, actuals, = np.array(predictions), np.array(actuals)\\n # We need to use average='samples' here, any other average method will generate bogus results\\n return fbeta_score(actuals, predictions, beta=2, average='samples')\",\n \"def __lm_scores(en_id, txt, prefix):\\n feat_field_dict = {'title': econfig.TITLE, 'sAbs': econfig.SHORT_ABS, 'lAbs': econfig.LONG_ABS,\\n 'links': econfig.WIKILINKS, 'cats': econfig.CATEGORIES, 'catchall': Lucene.FIELDNAME_CONTENTS}\\n ftr_extractor = QuerySimFeat(txt)\\n scores = dict()\\n for feature_name, field in feat_field_dict.iteritems():\\n lm_score = ftr_extractor.nllr_lm_score(en_id, field) # lm_score(en_id, field)\\n scores[prefix + feature_name] = lm_score if lm_score is not None else 0\\n return scores\",\n \"def score(self, s):\\n fv = s.feature_vector\\n product = fv.dot(self.params.T)[0, 0]\\n return s.score(lmwt=self.lmwt) + product\",\n \"def computeF1_macro(confusion_matrix, matching, num_clusters):\\r\\n # Permute the matrix columns\\r\\n permuted_confusion_matrix = np.zeros([num_clusters, num_clusters])\\r\\n for cluster in range(num_clusters):\\r\\n matched_cluster = matching[cluster]\\r\\n permuted_confusion_matrix[:, cluster] = confusion_matrix[:, matched_cluster]\\r\\n# Compute the F1 score for every cluster\\r\\n F1_score = 0\\r\\n for cluster in range(num_clusters):\\r\\n TP = permuted_confusion_matrix[cluster,cluster]\\r\\n FP = np.sum(permuted_confusion_matrix[:,cluster]) - TP\\r\\n FN = np.sum(permuted_confusion_matrix[cluster,:]) - TP\\r\\n precision = TP/(TP + FP)\\r\\n recall = TP/(TP + FN)\\r\\n f1 = stats.hmean([precision,recall])\\r\\n F1_score += f1\\r\\n F1_score /= num_clusters\\r\\n return F1_score\",\n \"def _cal_score(self, primary_category_label, secondary_category_label, actual_category_label, max_level):\\n primary_categories = self._get_categories(primary_category_label)\\n if not secondary_category_label:\\n secondary_categories = None\\n else:\\n secondary_categories = self._get_categories(secondary_category_label)\\n actual_categories = self._get_categories(actual_category_label)\\n total_score = 0\\n ignored_primary = False\\n ignored_secondary = False\\n for i in range(0, max_level + 1):\\n if primary_categories and i < len(primary_categories):\\n pv = primary_categories[i]\\n else:\\n pv = None\\n if actual_categories and i < len(actual_categories):\\n av = actual_categories[i]\\n else:\\n av = None\\n if secondary_categories and i < len(secondary_categories):\\n sv = secondary_categories[i]\\n else:\\n sv = None\\n primary_equal = pv == av\\n secondary_equal = (secondary_categories is not None) and sv == av\\n if not primary_equal:\\n ignored_primary = True\\n if not secondary_equal:\\n ignored_secondary = True\\n\\n if not ignored_primary:\\n total_score += self.level_scores[i]\\n\\n if ignored_primary and (not ignored_secondary):\\n total_score += 0.5 * self.level_scores[i]\\n\\n return total_score\",\n \"def _rouge_l_score(pred: Sequence[str], target: Sequence[str]) ->Dict[str, Tensor]:\\n pred_len, target_len = len(pred), len(target)\\n if 0 in (pred_len, target_len):\\n return dict(precision=tensor(0.0), recall=tensor(0.0), fmeasure=tensor(0.0))\\n lcs: int = _lcs(pred, target)\\n return _compute_metrics(lcs, pred_len, target_len)\",\n \"def score(self, input_fn=None, steps=None):\\n return np.sum(\\n self.evaluate(\\n input_fn=input_fn, steps=steps)[KMeansClustering.SCORES])\",\n \"def stats(detections, faces):\\n vp, fp, fn, vn = 0, 0, 0, 0\\n max_label = np.max(faces[:, 0])\\n for i in range(max_label + 1):\\n detections_i = get_label_with_index(detections, i)\\n faces_i = get_label_with_index(faces, i)\\n local_vp = 0\\n for face in faces_i:\\n found = False\\n for detection in detections_i:\\n if intersection_ratio(face, detection) >= 0.5:\\n found = True\\n break\\n if found:\\n vp += 1\\n local_vp += 1\\n else:\\n fn += 1\\n fp += len(detections_i) - local_vp\\n\\n precision = vp / (vp + fp)\\n rappel = vp / (vp + fn)\\n f_score = 2 * ((precision * rappel) / (precision + rappel))\\n\\n return precision, rappel, f_score\",\n \"def calculate_performance(scorecard):\\n \\n scorecard_array = numpy.asarray(scorecard)\\n performance = scorecard_array.sum() / scorecard_array.size\\n\\n return performance\",\n \"def calc_score(score):\\n if not score:\\n return 0\\n dbot_score = 1\\n if score >= 95:\\n dbot_score = 3\\n elif score >= 75:\\n dbot_score = 2\\n return dbot_score\",\n \"def t_score(colloc_count, c_pattern, c_lw, n):\\r\\n score = (colloc_count - (c_pattern * c_lw) / n) / (sqrt(colloc_count))\\r\\n return score\",\n \"def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\\\"malaria\\\", confusion_matrix_title=\\\"\\\"):\\n # demonstration of calculating metrics for a neural network model using sklearn\\n if not binary_classifcation:\\n # For multiclass classification.\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n precision = precision_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n recall = recall_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n f1 = f1_score(actual_labels, preds_labels, average=\\\"macro\\\")\\n print('Accuracy: %f' % accuracy)\\n print('Precision: %f' % precision)\\n print('Recall: %f' % recall)\\n print('F1 score: %f' % f1)\\n\\n else:\\n accuracy = accuracy_score(actual_labels, preds_labels)\\n print('Accuracy: %f' % accuracy)\\n # # precision tp / (tp + fp)\\n precision = precision_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Precision: %f' % precision)\\n # recall: tp / (tp + fn)\\n recall = recall_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('Recall: %f' % recall)\\n # f1: 2 tp / (2 tp + fp + fn)\\n f1 = f1_score(actual_labels, preds_labels, pos_label=pos_label)\\n print('F1 score: %f' % f1)\\n # ROC AUC\\n # auc = roc_auc_score(test_labels, basic_cnn_preds_labels)\\n # print('ROC AUC: %f' % auc)\\n\\n # confusion matrix\\n disp = plot_confusion_matrix(y_true=actual_labels, y_pred=preds_labels,\\n display_labels=list(np.unique(actual_labels)),\\n cmap=plt.cm.Blues,\\n normalize=None)\\n disp.ax_.set_title(confusion_matrix_title)\\n plt.show()\\n matrix = confusion_matrix(actual_labels, preds_labels)\\n print(matrix)\\n # if plot_confusion_matrix:\\n # show_confusion_matrix(matrix=matrix, labels=list(np.unique(actual_labels)))\",\n \"def f1_score(self):\\n self.overall_f1_score = f1_score(\\n self.y_true, self.y_pred, average = self.average_type).round(self.digits_count_fp)\\n self.classes_f1_score = f1_score(\\n self.y_true, self.y_pred, average = None).round(self.digits_count_fp)\",\n \"def compute_scores(self):\\n if self.num_classes == 2:\\n score_1 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold=0.5,\\n )[1]\\n\\n score_2 = self.competition_metric(\\n helmet_threshold=0.5,\\n impact_threshold_ratio=0.5,\\n )[1]\\n\\n score_3 = self.competition_metric(\\n impact_threshold=0.5,\\n )[1]\\n else:\\n score_1 = self.detection_metric(threshold=0.1)\\n score_2 = self.detection_metric(threshold=0.25)\\n score_3 = self.detection_metric(threshold=0.5)\\n\\n return score_1, score_2, score_3\",\n \"def _calculate_score(lsh, minhash, total_num_events):\\n neighbours = lsh.query(minhash)\\n return float(len(neighbours)) / float(total_num_events)\",\n \"def f1_score(model_id, test_set_id, rubric_id):\\n result = {'true_positive': 0, 'false_positive': 0, 'true_negative': 0, 'false_negative': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_result(model_id, test_set_id, rubric_id)\\n\\n for key in rubrication_result:\\n if rubrication_result[key] == answers[key]:\\n if rubrication_result[key] == 1:\\n result['true_positive'] += 1\\n else:\\n result['true_negative'] += 1\\n else:\\n if rubrication_result[key] == 1:\\n result['false_positive'] += 1\\n else:\\n result['false_negative'] += 1\\n if (result['true_positive'] + result['false_positive']) > 0:\\n result['precision'] = result['true_positive'] / (result['true_positive'] + result['false_positive'])\\n else:\\n result['precision'] = 0\\n if (result['true_positive'] + result['false_negative']) > 0:\\n result['recall'] = result['true_positive'] / (result['true_positive'] + result['false_negative'])\\n else:\\n result['recall'] = 0\\n if (result['precision'] + result['recall']) > 0:\\n result['f1'] = 2 * result['precision'] * result['recall'] / (result['precision'] + result['recall'])\\n else:\\n result['f1'] = 0\\n return result\",\n \"def cv_score(clf, x, y, score_func):\\r\\n result = 0\\r\\n nfold = 5\\r\\n for train, test in KFold(y.size, nfold): # split data into train/test groups, 5 times\\r\\n clf.fit(x[train], y[train]) # fit\\r\\n result += score_func(clf, x[test], y[test]) # evaluate score function on held-out data\\r\\n return result / nfold # average\\r\",\n \"def f_measure(precision, recall, beta=config.F_MEASURE_BETA):\\n if precision + recall <= 0:\\n return 0.\\n beta_sq = beta ** 2\\n return (1 + beta_sq) * precision * recall / (beta_sq * precision + recall)\",\n \"def _calculate_score_with_threshold(self):\\n\\n clue_number = 0\\n positive_score, negative_score = 0, 0\\n negative_number = 0\\n total_score = 0\\n\\n # find largest negative score\\n largest_negative_score = -1.\\n for ix, (card, score) in enumerate(self.sorted_card_score_pairs):\\n # find maximum score of negative word\\n if card.color not in [self.team, \\\"DOUBLE\\\"]:\\n largest_negative_score = score\\n break\\n\\n # add scores higher than threshold + largest negative score to positive_score\\n for card, score in self.sorted_card_score_pairs:\\n if (score > (self.delta+largest_negative_score)\\n and card.color in [self.team, \\\"DOUBLE\\\"]):\\n clue_number += 1\\n positive_score += score\\n elif card.color not in [self.team, \\\"DOUBLE\\\"]:\\n negative_score += score\\n negative_number += 1\\n else:\\n continue\\n\\n if not self.penalize_negative:\\n self.logger.info(\\\"negative score set to 0.\\\")\\n negative_score = 0\\n\\n # if threshold(delta) is large, there will be no clues.\\n # try to give at least one clue\\n # select the positive card with score larger than largest_negative_score.\\n if clue_number == 0:\\n self.logger.debug(\\\"clue number: 0.\\\")\\n for card, score in self.sorted_card_score_pairs:\\n if card.color in [self.team, \\\"DOUBLE\\\"]:\\n positive_score = score\\n clue_number += 1\\n self.cropped_threshold = score - largest_negative_score\\n else:\\n positive_score = 0\\n break\\n\\n if self.normalize_negative:\\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score / negative_number\\n else:\\n total_score = (1-self.alpha) * positive_score - self.alpha * negative_score\\n self.logger.debug(\\\"word: {}, positive_score: {}, negative_score: {}, total_score: {}\\\".format(self.clue, positive_score, negative_score, total_score))\\n return total_score, clue_number\",\n \"def f1_score(precision, recall):\\n if precision + recall == 0:\\n return 0\\n return 2 * precision * recall / (precision + recall)\",\n \"def calculate_precinct_score(pt, dstrct):\\n return pt.F(dstrct)\",\n \"def getScore(self):\\n tempscore = 1000 - 0.01*self.timeDriving \\n tempscore -= 0.1*getDist(self.maze.checkpoints[self.checkpoint].getMid(),self.pos)\\n tempscore += self.checkpoint *1000\\n tempscore += self.laps * 1000 * len(self.maze.checkpoints)\\n return tempscore\",\n \"def score_fn(self):\\n raise NotImplementedError()\",\n \"def get_score(snack_data, percentage_data, snack, snack_query, protein_query, carb_query, fat_query):\\n\\tstart_time = time.time()\\n\\n\\t#Load necessary data\\n\\t\\\"\\\"\\\"\\twith open ('../../../Data/percentagesDict.pickle', 'rb') as f:\\n\\t\\tpercentage_data = pickle.load(f)\\n\\n\\twith open ('../../../Data/FINAL_snacks_data.pickle', 'rb') as f:\\n\\t\\tsnack_data = pickle.load(f)\\\"\\\"\\\"\\n\\n\\t#Set constants\\n\\tLOW_FAT = .3\\n\\tHIGH_FAT = .6\\n\\tLOW_CARB = .1\\n\\tHIGH_CARB = .2\\n\\tLOW_PRO = .2\\n\\tHIGH_PRO = .4\\n\\n\\t#Convert macro percentages to 'high', 'med', 'low' categories\\n\\tfat = percentage_data[snack]['fat']\\n\\tprotein = percentage_data[snack]['protein']\\n\\tcarb = percentage_data[snack]['carb']\\n\\n\\tif fat > HIGH_FAT:\\n\\t\\tfat_content = 'high'\\n\\telif fat < LOW_FAT:\\n\\t\\tfat_content = 'low'\\n\\telse:\\n\\t\\tfat_content = 'med'\\n\\n\\tif protein > HIGH_PRO:\\n\\t\\tprotein_content = 'high'\\n\\telif protein < LOW_PRO:\\n\\t\\tprotein_content = 'low'\\n\\telse:\\n\\t\\tprotein_content = 'med'\\n\\n\\tif carb > HIGH_CARB:\\n\\t\\tcarb_content = 'high'\\n\\telif carb < LOW_CARB:\\n\\t\\tcarb_content = 'low'\\n\\telse:\\n\\t\\tcarb_content = 'med'\\n\\n\\t#Set x values\\n\\tx1 = fat_query == fat_content\\n\\tx2 = carb_query == carb_content\\n\\tx3 = protein_query == protein_content\\n\\tx4 = cooccur(snack_data, snack, snack_query) \\n\\tx5 = snack_data[snack]['rating']\\n\\n\\tw1 = 1\\n\\tw2 = 1\\n\\tw3 = 1\\n\\tw4 = 1\\n\\tw5 = 1\\n\\t\\n\\t#print('x1: {}, x2: {}, x3: {}, x4: {}, x5: {}'.format(x1, x2, x3, x4, x5))\\n\\t#print(\\\"get_score() time: --- %s seconds ---\\\" % (time.time() - start_time))\\n\\n\\n\\treturn w1*x1 + w2*x2 + w3*x3 + w4*x4 + w5*x5\",\n \"def score(self):\",\n \"def stats_f1score_per_class(cm):\\n # defined as 2 * recall * prec / recall + prec\\n sums = (np.sum(cm, axis=1) + np.sum(cm, axis=0))\\n mask = (sums>0)\\n sums[sums==0] = 1\\n f1score_per_class = 2 * np.diag(cm) / sums\\n f1score_per_class[np.logical_not(mask)] = -1\\n average_f1_score = f1score_per_class[mask].mean()\\n return average_f1_score, f1score_per_class\",\n \"def calculate_score(truck, job):\\n score = 0\\n score += W1 * calculate_distance(job.source_long, job.source_lat, truck.current_long, truck.current_lat)\\n print(score)\\n score += W2 * calculate_distance(job.destination_long, job.destination_lat, truck.base_long, truck.base_lat)\\n print(score)\\n score += W3 * job.price\\n print(score)\\n score += W4 * job.price / job.getDistance()\\n print(score)\\n\\n return score\",\n \"def measureSJF(p):\\r\\n\\treturn measureFCFS(msort(p))\",\n \"def bestF(score_matrix, gold_lex):\\n np.seterr(divide='ignore', invalid='ignore') # get nans instead of division by zero\\n best_f = 0\\n best_th = 0\\n\\n for th in np.linspace(0, 1, 101): # threshold\\n lex = (score_matrix >= th)\\n p = np.sum(lex * (lex == gold_lex)) / np.sum(lex)\\n r = np.sum(lex * (lex == gold_lex)) / np.sum(gold_lex)\\n f = 2 * (p * r) / (p + r)\\n\\n if f > best_f:\\n best_f = f\\n best_th = th\\n\\n return best_f, best_th\",\n \"def generateScore(self):\\n totalFreq = self.lazySum(key=None)\\n for file in self._candidate_files:\\n filename = os.path.basename(file)\\n score_file = os.path.join(self._score_dir, filename)\\n with open(score_file, 'w') as ofd:\\n with open(file) as ifd:\\n for line in ifd:\\n words = line.strip().split('\\\\t')\\n if len(words) < 2 or any(map(lambda word:len(word)<2, words)):\\n continue\\n\\n XFreq = self.lazySum(words[0])\\n YFreq = self.lazySum(words[1])\\n XYFreq = self.lazySum(line.strip())\\n # frequences filter\\n #if XYFreq < 2 or XYFreq > 24:\\n # continue\\n if YFreq == 0 or XFreq == 0 or XYFreq == 0:\\n # because when generating grams, we last last words' frequency\\n continue\\n PX = XFreq * 1.0 / totalFreq\\n PY = YFreq * 1.0 / totalFreq\\n PXY = XYFreq * 1.0 / totalFreq\\n score = math.log(PXY/PX/PY, 2) * XYFreq\\n #print \\\"Freq:\\\", XFreq, YFreq, XYFreq\\n result = \\\"{0}\\\\t{1:.2f}\\\\n\\\".format(line.strip(), score)\\n ofd.write(result)\",\n \"def compute_f_score(alpha, true_positves, false_positives, false_negatives):\\n num = true_positves\\n den = np.float64(alpha * (true_positves + false_positives) +\\\\\\n (1 - alpha) * (true_positves + false_negatives))\\n with np.errstate(divide='ignore', invalid='ignore'):\\n return num / den\",\n \"def fscore(self, beta=1.0):\\n return hmean_weighted(self.precision(), self.recall(), beta ** 2)\",\n \"def _compute_score(self):\\n\\n sgml_path = str(self.sgml_file.name)\\n text_path = sgml_path.replace('.sgm', '.txt')\\n ref_path = 'testsets/wmt18.ende.ref.txt'\\n\\n from sacrebleu import process_to_text, corpus_bleu\\n from pathlib import Path\\n\\n if not Path(text_path).exists():\\n process_to_text(sgml_path, text_path)\\n\\n hyp_stream = [x for x in open(text_path, encoding='utf-8')]\\n ref_stream = [r for r in open(ref_path, encoding='utf-8')]\\n\\n bleu = corpus_bleu(hyp_stream, [ref_stream])\\n\\n self.score = bleu.score\\n self.save()\",\n \"def get_f1score(conf_matrix1, conf_matrix2, conf_matrix3):\\r\\n p = get_precision(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n r = get_recall(conf_matrix1, conf_matrix2, conf_matrix3)\\r\\n\\r\\n if p + r > 0:\\r\\n return 2 * p * r / (p + r)\\r\\n else:\\r\\n return 0\",\n \"def score(self) -> FAIRResultCommonScore:\\n return self._score\",\n \"def calc_fcts(self):\\n flow_fcts = {}\\n print \\\"Computing FCTS:\\\"\\n for flowID, pkts in self.flow_pkts.items():\\n fct = (pkts[-1][0] - pkts[0][0])*1e-6\\n flow_fcts[flowID] = fct \\n print '\\\\tflow {:>3} FCT = {:<8.2f} ms'.format(flowID, fct)\\n avg_fct = np.average(flow_fcts.values())\\n std_fct = np.std(flow_fcts.values())\\n print 'Average FCT = {:>8.3f} +/- {:<8.3f} ms'.format(avg_fct, std_fct)\",\n \"def cal_F1(loader, model):\\n correct = 0\\n total = 0\\n model.eval()\\n cof_mat = np.zeros ((4,4))\\n Ns = np.zeros(4)\\n ns = np.zeros(4)\\n for data, labels in loader:\\n data_batch, label_batch = data.to(device), labels.to(device)\\n outputs = F.softmax(model(data_batch), dim=1)\\n predicted = outputs.max(1, keepdim=True)[1]\\n total += label_batch.size(0)\\n correct += predicted.eq(label_batch.view_as(predicted)).sum().item()\\n acc = label_batch.view_as(predicted)\\n for (a,p) in zip(acc, predicted):\\n cof_mat[a][p] += 1\\n Ns[a] += 1\\n ns[p] += 1\\n F1 = 0.0\\n for i in range(len(Ns)):\\n tempF = cof_mat[i][i]*2.0 /(Ns[i] + ns[i])\\n F1 = F1+ tempF\\n print('F1'+str(i)+':',tempF)\\n F1 = F1/4.0\\n print('cofmat',cof_mat)\\n return 100 * correct / total, F1\",\n \"def disp_score():\",\n \"def compute(self, idx, input_scores, input_names):\\n title = self._legends[idx] if self._legends is not None else None\\n headers = [\\\"\\\" or title, \\\"Dev. %s\\\" % input_names[0]]\\n if self._eval and input_scores[1] is not None:\\n headers.append(\\\"eval % s\\\" % input_names[1])\\n if self._criterion == \\\"rr\\\":\\n rr = bob.measure.recognition_rate(input_scores[0], self._thres[idx])\\n dev_rr = \\\"%.1f%%\\\" % (100 * rr)\\n raws = [[\\\"RR\\\", dev_rr]]\\n if self._eval and input_scores[1] is not None:\\n rr = bob.measure.recognition_rate(\\n input_scores[1], self._thres[idx]\\n )\\n eval_rr = \\\"%.1f%%\\\" % (100 * rr)\\n raws[0].append(eval_rr)\\n click.echo(\\n tabulate(raws, headers, self._tablefmt), file=self.log_file\\n )\\n elif self._criterion == \\\"mindcf\\\":\\n if \\\"cost\\\" in self._ctx.meta:\\n cost = self._ctx.meta.get(\\\"cost\\\", 0.99)\\n threshold = (\\n bob.measure.min_weighted_error_rate_threshold(\\n input_scores[0][0], input_scores[0][1], cost\\n )\\n if self._thres is None\\n else self._thres[idx]\\n )\\n if self._thres is None:\\n click.echo(\\n \\\"[minDCF - Cost:%f] Threshold on Development set `%s`: %e\\\"\\n % (cost, input_names[0], threshold),\\n file=self.log_file,\\n )\\n else:\\n click.echo(\\n \\\"[minDCF] User defined Threshold: %e\\\" % threshold,\\n file=self.log_file,\\n )\\n # apply threshold to development set\\n far, frr = bob.measure.farfrr(\\n input_scores[0][0], input_scores[0][1], threshold\\n )\\n dev_far_str = \\\"%.1f%%\\\" % (100 * far)\\n dev_frr_str = \\\"%.1f%%\\\" % (100 * frr)\\n dev_mindcf_str = \\\"%.1f%%\\\" % (\\n (cost * far + (1 - cost) * frr) * 100.0\\n )\\n raws = [\\n [\\\"FAR\\\", dev_far_str],\\n [\\\"FRR\\\", dev_frr_str],\\n [\\\"minDCF\\\", dev_mindcf_str],\\n ]\\n if self._eval and input_scores[1] is not None:\\n # apply threshold to development set\\n far, frr = bob.measure.farfrr(\\n input_scores[1][0], input_scores[1][1], threshold\\n )\\n eval_far_str = \\\"%.1f%%\\\" % (100 * far)\\n eval_frr_str = \\\"%.1f%%\\\" % (100 * frr)\\n eval_mindcf_str = \\\"%.1f%%\\\" % (\\n (cost * far + (1 - cost) * frr) * 100.0\\n )\\n raws[0].append(eval_far_str)\\n raws[1].append(eval_frr_str)\\n raws[2].append(eval_mindcf_str)\\n click.echo(\\n tabulate(raws, headers, self._tablefmt), file=self.log_file\\n )\\n elif self._criterion == \\\"cllr\\\":\\n cllr = bob.measure.calibration.cllr(\\n input_scores[0][0], input_scores[0][1]\\n )\\n min_cllr = bob.measure.calibration.min_cllr(\\n input_scores[0][0], input_scores[0][1]\\n )\\n dev_cllr_str = \\\"%.1f%%\\\" % cllr\\n dev_min_cllr_str = \\\"%.1f%%\\\" % min_cllr\\n raws = [[\\\"Cllr\\\", dev_cllr_str], [\\\"minCllr\\\", dev_min_cllr_str]]\\n if self._eval and input_scores[1] is not None:\\n cllr = bob.measure.calibration.cllr(\\n input_scores[1][0], input_scores[1][1]\\n )\\n min_cllr = bob.measure.calibration.min_cllr(\\n input_scores[1][0], input_scores[1][1]\\n )\\n eval_cllr_str = \\\"%.1f%%\\\" % cllr\\n eval_min_cllr_str = \\\"%.1f%%\\\" % min_cllr\\n raws[0].append(eval_cllr_str)\\n raws[1].append(eval_min_cllr_str)\\n click.echo(\\n tabulate(raws, headers, self._tablefmt), file=self.log_file\\n )\\n else:\\n title = self._legends[idx] if self._legends is not None else None\\n all_metrics = self._get_all_metrics(idx, input_scores, input_names)\\n headers = [\\\" \\\" or title, \\\"Development\\\"]\\n rows = [\\n [self.names[0], all_metrics[0][0]],\\n [self.names[1], all_metrics[0][1]],\\n [self.names[2], all_metrics[0][2]],\\n [self.names[3], all_metrics[0][3]],\\n [self.names[4], all_metrics[0][4]],\\n [self.names[5], all_metrics[0][5]],\\n ]\\n\\n if self._eval:\\n # computes statistics for the eval set based on the threshold a\\n # priori\\n headers.append(\\\"Evaluation\\\")\\n rows[0].append(all_metrics[1][0])\\n rows[1].append(all_metrics[1][1])\\n rows[2].append(all_metrics[1][2])\\n rows[3].append(all_metrics[1][3])\\n rows[4].append(all_metrics[1][4])\\n rows[5].append(all_metrics[1][5])\\n\\n click.echo(\\n tabulate(rows, headers, self._tablefmt), file=self.log_file\\n )\",\n \"def calculate_score(self):\\n try:\\n self.score = self.__total_comment_score / float(self.num_comments)\\n except ZeroDivisionError:\\n self.score = float(0)\",\n \"def costMeasure(self, map):\\n\\n if self.activeCostMeasure == 0:\\n return self.faceMeans(map).faceMeanDiff\\n elif self.activeCostMeasure == 1:\\n return self.faceMeans(map).faceHomogeneity\\n elif self.activeCostMeasure == 2:\\n return self.faceMeans(map).faceTTest\\n elif self.activeCostMeasure == 3:\\n def brightness(dart, fm = self.faceMeans(map)):\\n return max(vigra.norm(fm[dart.leftFaceLabel()]),\\n vigra.norm(fm[dart.rightFaceLabel()]))\\n return brightness\\n elif self.activeCostMeasure == 4:\\n return map.wsStats.dartPassValue\\n elif self.activeCostMeasure == 5:\\n return map.wsStats.dynamics\\n elif self.activeCostMeasure == 6:\\n return self.edgeGradients(map).dartMin\\n elif self.activeCostMeasure == 7:\\n return self.edgeGradients(map).average\\n elif self.activeCostMeasure == 8:\\n return self.edgeGradients(map, True).quantile(0.5)\\n elif self.activeCostMeasure == 9:\\n return self.edgeGradients(map).max\\n elif self.activeCostMeasure == 10:\\n return statistics.mergedIsoperimetricQuotient\\n elif self.activeCostMeasure == 11:\\n return statistics.mergedContourLength\\n else:\\n raise RuntimeError(\\\"Wrong cost measure (%s)\\\" % self.activeCostMeasure)\",\n \"def get_f1(self,common_len,RTSummary,SystemSummary):\\n recall = self.get_recall(common_len,RTSummary)\\n precision = self.get_precision(common_len,SystemSummary)\\n if precision<=0 or recall <=0:\\n return 0.0\\n else:\\n return ((2 * recall * precision)/(recall + precision))\",\n \"def measure(self, X2, X3, start_index): \\n \\n power = self.power\\n X2 = np.array(X2)\\n X3 = np.array(X3)\\n if len(X2) == 0:\\n score = 0\\n else:\\n X2 = np.fft.fft(X2);\\n X3 = np.fft.fft(X3)\\n score = np.linalg.norm(X2 - X3, ord = power)/len(X3)\\n self.decision_scores_.append((start_index, score))\\n return score\",\n \"def get_score(self, solution: np.array) -> float:\\n pass\",\n \"def computeOverallScore(self,m):\\n \\n def _computeOverallScore(scalars):\\n \\\"\\\"\\\"Given a netCDF4 group of scalars, blend them into an overall score\\\"\\\"\\\"\\n scores = {}\\n variables = [v for v in scalars.variables.keys() if \\\"Score\\\" in v and \\\"Overall\\\" not in v]\\n for region in self.regions:\\n overall_score = 0.\\n sum_of_weights = 0.\\n for v in variables:\\n if region not in v: continue\\n score = v.replace(region,\\\"\\\").strip()\\n weight = 1.\\n if self.weight.has_key(score): weight = self.weight[score]\\n overall_score += weight*scalars.variables[v][...]\\n sum_of_weights += weight\\n overall_score /= max(sum_of_weights,1e-12)\\n scores[\\\"Overall Score %s\\\" % region] = overall_score\\n return scores\\n\\n fname = os.path.join(self.output_path,\\\"%s_%s.nc\\\" % (self.name,m.name))\\n if not os.path.isfile(fname): return\\n with Dataset(fname,mode=\\\"r+\\\") as dataset:\\n datasets = [dataset.groups[grp] for grp in dataset.groups if \\\"scalars\\\" not in grp]\\n groups = [grp for grp in dataset.groups if \\\"scalars\\\" not in grp]\\n datasets.append(dataset)\\n groups .append(None)\\n for dset,grp in zip(datasets,groups):\\n if \\\"scalars\\\" in dset.groups:\\n scalars = dset.groups[\\\"scalars\\\"]\\n score = _computeOverallScore(scalars)\\n for key in score.keys():\\n if key in scalars.variables:\\n scalars.variables[key][0] = score[key]\\n else:\\n Variable(data=score[key],name=key,unit=\\\"1\\\").toNetCDF4(dataset,group=grp)\",\n \"def compute_performance(cm):\\n\\n tp = np.diagonal(cm).astype(np.float)\\n tpfp = np.sum(cm, axis=0).astype(np.float) # sum of each col\\n tpfn = np.sum(cm, axis=1).astype(np.float) # sum of each row\\n acc = np.sum(tp) / np.sum(cm)\\n precision = tp / tpfp\\n recall = tp / tpfn\\n f1 = (2 * precision * recall) / (precision + recall)\\n mf1 = np.mean(f1)\\n\\n total = np.sum(cm)\\n n_each_class = tpfn\\n\\n return total, n_each_class, acc, mf1, precision, recall, f1\",\n \"def f2_score(self, y_true=None, y_pred=None, labels=None, average=\\\"macro\\\", decimal=None, **kwargs):\\n y_true, y_pred, binary, representor, decimal = self.get_processed_data(y_true, y_pred, decimal)\\n matrix, imap, imap_count = cu.calculate_confusion_matrix(y_true, y_pred, labels, normalize=None)\\n metrics = cu.calculate_single_label_metric(matrix, imap, imap_count)\\n\\n list_f2 = np.array([item[\\\"f2\\\"] for item in metrics.values()])\\n list_weights = np.array([item[\\\"n_true\\\"] for item in metrics.values()])\\n\\n if average == \\\"micro\\\":\\n tp_global = np.sum(np.diag(matrix))\\n fp_global = fn_global = np.sum(matrix) - tp_global\\n precision = tp_global / (tp_global + fp_global)\\n recall = tp_global / (tp_global + fn_global)\\n f2 = (5 * precision * recall) / (4 * precision + recall)\\n elif average == \\\"macro\\\":\\n f2 = np.mean(list_f2)\\n elif average == \\\"weighted\\\":\\n f2 = np.dot(list_weights, list_f2) / np.sum(list_weights)\\n else:\\n f2 = dict([(label, np.round(item[\\\"f2\\\"], decimal)) for label, item in metrics.items()])\\n return f2 if type(f2) == dict else np.round(f2, decimal)\",\n \"def _f_p_r_lcs(llcs, m, n):\\n r_lcs = llcs / m\\n p_lcs = llcs / n\\n beta = p_lcs / (r_lcs + 1e-12)\\n num = (1 + (beta**2)) * r_lcs * p_lcs\\n denom = r_lcs + ((beta**2) * p_lcs)\\n f_lcs = num / (denom + 1e-12)\\n return f_lcs, p_lcs, r_lcs\",\n \"def get_score(self):\\n files_flare = self.generate_flare_set()\\n files_non_flare = self.generate_non_flare_set()\\n timeseries = []\\n y = []\\n scores = {}\\n column_mapping = self.__get_column_mapping()\\n for col in tqdm(range(1, 25)):\\n for file in tqdm(files_flare):\\n s = Sample(\\\"FL\\\", file).get_data().iloc[:, col].values\\n y.append(self.mapping[file[0]])\\n timeseries.append(s)\\n\\n for file in tqdm(files_non_flare):\\n s = Sample(\\\"NF\\\", file).get_data().iloc[:, col].values\\n y.append(self.mapping[file[0]])\\n timeseries.append(s)\\n embed = self.get_embed_vector(timeseries)\\n\\n embed_y = KMeans(n_clusters=5).fit_predict(embed)\\n y = np.array(y).flatten()\\n scores[column_mapping[col]] = self.relevance_score(embed_y, y)\\n timeseries = []\\n y = []\\n scores_data = pd.DataFrame.from_dict(scores, orient='index', columns=['Relevance Score']).sort_values(\\n by='Relevance Score', ascending=False)\\n return scores_data\",\n \"def calc_intersection_true_data_baselines_data_cnt():\\n# final_sen_scores = linux_base_path + \\\"/final_sen_scores/\\\"\\n final_sen_scores = base_path + \\\"\\\\\\\\final_sen_scores\\\\\\\\\\\"\\n top_k_docs_values = [50]\\n lambda_f = \\\"1\\\"\\n claim_sen_true_relevance_dict = read_pickle(\\\"claim_sen_relevance_dict_\\\"+curr_source)\\n claims_dict = read_pickle(\\\"claim_dict\\\")\\n intersection_count_avg_all_claims =0\\n exclude = set(string.punctuation)\\n \\n for k_val in top_k_docs_values:\\n intersection_count = 0\\n for alpha in range(10,11,1): #change just for test!\\n for beta in range(0,1,1):\\n (alpha_f,beta_f) = turn_to_float([alpha,beta])\\n curr_baseline_final_sen_score_dict = read_pickle(final_sen_scores+\\\"clm_num_key_final_ranked_list_sen_alpha_\\\"+str(alpha_f)+\\\"_beta_\\\"+str(beta_f)+\\\"_top_k_docs_\\\"+str(k_val)+\\\"_lambda_\\\"+str(lambda_f)+\\\"_sorted\\\")\\n for clm in curr_baseline_final_sen_score_dict.keys():\\n curr_clm_baseline_set = set()\\n curr_true_relevance_set = set()\\n for (sen,score) in curr_baseline_final_sen_score_dict[clm]:\\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\\n sen_no_space = sen_no_punc.replace(\\\" \\\",\\\"\\\")\\n curr_clm_baseline_set.add(sen_no_space)\\n for (sen,score) in claim_sen_true_relevance_dict[claims_dict[clm]]:\\n sen_no_punc = ''.join(ch for ch in sen if ch not in exclude)\\n sen_no_space = sen_no_punc.replace(\\\" \\\",\\\"\\\")\\n curr_true_relevance_set.add(sen_no_space) \\n intersection_count += len(curr_clm_baseline_set.intersection(curr_true_relevance_set))\\n intersection_count_avg_all_claims += float(float(intersection_count)/float(110))\\n intersection_count_avg_all_claims = float(float(intersection_count_avg_all_claims)/float(len(curr_baseline_final_sen_score_dict.keys())))\\n print \\\"intersection_count_avg_all_claims:\\\"+str(intersection_count_avg_all_claims)\",\n \"def calc_score(allcourses, student_list, chambers):\\n\\n\\t# start-score of a valid schedule\\n\\tpoints = 1000\\n\\tallcoursespoints = []\\n\\troomlocks_per_day = 28\\n\\n\\t#* create groups and dict to keep up the days per activity *#\\n\\n\\t# iterate over courses\\n\\tfor course in allcourses:\\n\\n\\t\\tcoursepoints = 0\\n\\n\\t\\t# if seminar(s) exist\\n\\t\\tif course.seminars > 0:\\n\\n\\t\\t\\t# create list with amount of seminar-groups\\n\\t\\t\\tgroups = list(range(1, int(course.seminars) + 1))\\n\\n\\t\\t# if practical exist\\n\\t\\telif course.practicals > 0:\\n\\n\\t\\t\\t# create list with amount of practical-groups\\n\\t\\t\\tgroups = list(range(1, int(course.practicals) + 1))\\n\\n\\t\\t# otherwise only one group (lecture)\\n\\t\\telse:\\n\\t\\t\\tgroups = [1]\\n\\n\\t\\t# create dict with groupnumber as key, [days] as values\\n\\t\\tdayActivity = {k: [] for k in groups}\\n\\n\\t\\t#* subtract points based on activities per day *#\\n\\n\\t\\t# iterate over activities per course\\n\\t\\tfor activity in course.activities:\\n\\n\\t\\t\\t# determine day\\n\\t\\t\\tday = int(activity[0] / roomlocks_per_day)\\n\\n\\t\\t\\t# if activity = lecture\\n\\t\\t\\tif activity[2] == 0:\\n\\n\\t\\t\\t\\t# add day to list linked to lecture\\n\\t\\t\\t\\tfor group in groups:\\n\\t\\t\\t\\t\\tdayActivity[group].append(day)\\n\\n\\t\\t\\t# for seminars and practicals\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\t# add day to list linked to group\\n\\t\\t\\t\\tdayActivity[activity[2]].append(day)\\n\\n\\t\\t# for each group\\n\\t\\tfor group in groups:\\n\\n\\t\\t\\t# for each working day\\n\\t\\t\\tfor day in range(0, 5):\\n\\n\\t\\t\\t\\t# count how many of the same activities a day\\n\\t\\t\\t\\tday_occurance = dayActivity[group].count(day)\\n\\n\\t\\t\\t\\t# if more often than 1\\n\\t\\t\\t\\tif day_occurance > 1:\\n\\n\\t\\t\\t\\t\\t# substract points\\n\\t\\t\\t\\t\\tpoints -= ((day_occurance - 1) * 10)\\n\\t\\t\\t\\t\\tcoursepoints -= ((day_occurance - 1) * 10)\\n\\n\\t\\t#* add points for spreading of activities over week *#\\n\\n\\t\\t# iterate over groups\\n\\t\\tfor group in groups:\\n\\n\\t\\t\\t# when 2 activities in week\\n\\t\\t\\tif (len(dayActivity[group]) == 2):\\n\\n\\t\\t\\t\\t# add points if they are spread (mo- thu, mo-fri)\\n\\t\\t\\t\\tif (abs(dayActivity[group][0] - dayActivity[group][1]) >= 3):\\n\\t\\t\\t\\t\\tpoints += 20\\n\\t\\t\\t\\t\\tcoursepoints += 20\\n\\n\\t\\t\\t# when 3 activities in the week\\n\\t\\t\\tif (len(dayActivity[group]) == 3):\\n\\n\\t\\t\\t\\t# add points if spread (mo-we-fr)\\n\\t\\t\\t\\tif 0 in dayActivity[group] and 2 in dayActivity[group] and 4 in dayActivity[group]:\\n\\t\\t\\t\\t\\tpoints += 20\\n\\t\\t\\t\\t\\tcoursepoints += 20\\n\\n\\t\\t\\t# if 4 activities in the week\\n\\t\\t\\tif (len(dayActivity[group]) == 4):\\n\\n\\t\\t\\t\\t# add points if spread (mo-tu-th-fr)\\n\\t\\t\\t\\tif 0 in dayActivity[group] and 1 in dayActivity[group] and 3 in dayActivity[group] and 4 in dayActivity[group]:\\n\\t\\t\\t\\t\\tpoints += 20\\n\\t\\t\\t\\t\\tcoursepoints += 20\\n\\n\\t\\t# for each activity of a course\\n\\t\\tfor activity in course.activities:\\n\\n\\t\\t\\t# substract room and timelock\\n\\t\\t\\troom, timelock = translate_roomlock(activity[0])\\n\\n\\t\\t\\t# for lectures\\n\\t\\t\\tif activity[2] == 0:\\n\\n\\t\\t\\t\\t# if too many students for room\\n\\t\\t\\t\\tif int(chambers[room].capacity) < course.students:\\n\\n\\t\\t\\t\\t\\t# substract points\\n\\t\\t\\t\\t\\tmaluspoints = course.students - int(chambers[room].capacity)\\n\\t\\t\\t\\t\\tpoints -= maluspoints\\n\\t\\t\\t\\t\\tcoursepoints -= maluspoints\\n\\n\\t\\t\\t# for practical/seminars\\n\\t\\t\\telse:\\n\\n\\t\\t\\t\\t# if seminar\\n\\t\\t\\t\\tif course.seminars > 0:\\n\\n\\t\\t\\t\\t\\t# and too many students fro room, substract points\\n\\t\\t\\t\\t\\tif int(chambers[room].capacity) < course.maxstudentssem:\\n\\n\\t\\t\\t\\t\\t\\t# substract points\\n\\t\\t\\t\\t\\t\\tmaluspoints = course.maxstudentssem - int(chambers[room].capacity)\\n\\t\\t\\t\\t\\t\\tpoints -= maluspoints\\n\\t\\t\\t\\t\\t\\tcoursepoints -= maluspoints\\n\\n\\t\\t\\t\\t# if practical\\n\\t\\t\\t\\telse:\\n\\n\\t\\t\\t\\t\\t# and too many students from room, substract points\\n\\t\\t\\t\\t\\tif int(chambers[room].capacity) < course.maxstudentsprac:\\n\\t\\t\\t\\t\\t\\tmaluspoints = course.maxstudentsprac - int(chambers[room].capacity)\\n\\t\\t\\t\\t\\t\\tpoints -= maluspoints\\n\\t\\t\\t\\t\\t\\tcoursepoints -= maluspoints\\n\\n\\t\\t# add points of allcourses\\n\\t\\tallcoursespoints.append([course.name, coursepoints])\\n\\n\\t#* substract points when 2 courses on same time *#\\n\\n\\t# for all students\\n\\tfor student in student_list:\\n\\n\\t\\t# create empty list\\n\\t\\ttimelocks_student = []\\n\\n\\t\\t# for each activity in schedule\\n\\t\\tfor activity in student.schedule:\\n\\n\\t\\t\\t# if roomlock is occupied substract points\\n\\t\\t\\tif activity[0] in timelocks_student:\\n\\t\\t\\t\\tpoints -= 1\\n\\t\\t\\t\\tcoursepoints -= 1\\n\\n\\t\\t\\t# add roomlock to list\\n\\t\\t\\ttimelocks_student.append(activity[0])\\n\\n\\treturn points\",\n \"def calculate_LC(read):\\n k_values = []\\n for i in range(1,len(read)+1):\\n k_values.append(i)\\n observed_kmers = []\\n for i in k_values:\\n observed_kmers.append((count_kmers_observed(read, i)))\\n possible_kmers = []\\n for i in k_values:\\n possible_kmers.append(count_kmers_possible(read, i))\\n df = pd.DataFrame(list(zip(k_values, observed_kmers, possible_kmers)), columns = ['k','observed kmers','possible kmers'])\\n df.at['Total', 'observed kmers'] = df['observed kmers'].sum()\\n df.at['Total', 'possible kmers'] = df['possible kmers'].sum()\\n x = int(df.at['Total', 'observed kmers'])\\n y = int(df.at['Total', 'possible kmers'])\\n LC = (x/y)\\n return(LC)\",\n \"def _f1_score_(prediction, ground_truth):\\n prediction_tokens = _normalize_answer(prediction).split()\\n ground_truth_tokens = _normalize_answer(ground_truth).split()\\n common = Counter(prediction_tokens) & Counter(ground_truth_tokens)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(prediction_tokens)\\n recall = 1.0 * num_same / len(ground_truth_tokens)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def scoring(self):\\n pass\",\n \"def _f_p_r_lcs(llcs, m, n):\\n r_lcs = llcs / m\\n p_lcs = llcs / n\\n beta = p_lcs / (r_lcs + 1e-12)\\n num = (1 + (beta ** 2)) * r_lcs * p_lcs\\n denom = r_lcs + ((beta ** 2) * p_lcs)\\n f_lcs = num / (denom + 1e-12)\\n return f_lcs, p_lcs, r_lcs\",\n \"def get_score(self, int_img):\\n score = 0\\n if self.type == FeatureType.TWO_VERTICAL:\\n first = ii.sum_region(int_img, self.top_left, (self.top_left[0] + self.width, int(self.top_left[1] + self.height / 2)))\\n second = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 2)), self.bottom_right)\\n score = first - second\\n elif self.type == FeatureType.TWO_HORIZONTAL:\\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 2), self.top_left[1] + self.height))\\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), self.top_left[1]), self.bottom_right)\\n score = first - second\\n elif self.type == FeatureType.THREE_HORIZONTAL:\\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 3), self.top_left[1] + self.height))\\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 3), self.top_left[1]), (int(self.top_left[0] + 2 * self.width / 3), self.top_left[1] + self.height))\\n third = ii.sum_region(int_img, (int(self.top_left[0] + 2 * self.width / 3), self.top_left[1]), self.bottom_right)\\n score = first - second + third\\n elif self.type == FeatureType.THREE_VERTICAL:\\n first = ii.sum_region(int_img, self.top_left, (self.bottom_right[0], int(self.top_left[1] + self.height / 3)))\\n second = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 3)), (self.bottom_right[0], int(self.top_left[1] + 2 * self.height / 3)))\\n third = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + 2 * self.height / 3)), self.bottom_right)\\n score = first - second + third\\n elif self.type == FeatureType.FOUR:\\n # top left area\\n first = ii.sum_region(int_img, self.top_left, (int(self.top_left[0] + self.width / 2), int(self.top_left[1] + self.height / 2)))\\n # top right area\\n second = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), self.top_left[1]), (self.bottom_right[0], int(self.top_left[1] + self.height / 2)))\\n # bottom left area\\n third = ii.sum_region(int_img, (self.top_left[0], int(self.top_left[1] + self.height / 2)), (int(self.top_left[0] + self.width / 2), self.bottom_right[1]))\\n # bottom right area\\n fourth = ii.sum_region(int_img, (int(self.top_left[0] + self.width / 2), int(self.top_left[1] + self.height / 2)), self.bottom_right)\\n score = first - second - third + fourth\\n return score\",\n \"def get_score(score_map, test_result):\\n if test_result < score_map[20]:\\n return int((test_result / score_map[20]) * 20)\\n elif test_result < score_map[40]:\\n return int(20 + (test_result - score_map[20]) / (score_map[40] - score_map[20]) * 20)\\n elif test_result < score_map[60]:\\n return int(40 + (test_result - score_map[40]) / (score_map[60] - score_map[40]) * 20)\\n elif test_result < score_map[85]:\\n return int(60 + (test_result - score_map[60]) / (score_map[85] - score_map[60]) * 20)\\n elif test_result < score_map[100]:\\n return int(85 + (test_result - score_map[85]) / (score_map[100] - score_map[85]) * 20)\\n else:\\n return 100\",\n \"def performance_metric(y_true, y_pred):\\n f1_arr = []\\n for i in range(np.shape(y_pred)[1]):\\n f1 = f1_score(np.array(y_true)[:, i], y_pred[:, i], average='weighted')\\n f1_arr.append(f1)\\n \\n score = np.mean(f1_arr)\\n return score\",\n \"def compute_score_fast(verbose=1):\\n res = []\\n\\n batch = math.ceil(len(train) / LINEAR_ASSIGNMENT_SEGMENT_SIZE)\\n for start in range(0, len(train), batch):\\n end = min(len(train), start + batch)\\n train_batch = train[start:end]\\n\\n features = branch_model.predict_generator(FeatureGen(train_batch, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = head_model.predict_generator(ScoreGen(features, verbose=verbose), max_queue_size=12, workers=6, verbose=0)\\n score = score_reshape(score, features)\\n\\n res.append(score)\\n\\n return res\",\n \"def raw_score(self,X,Y):\\n return self.rf.score(X,Y)\",\n \"def F1_score(y, model):\\n\\tp = precision(y, model)\\n\\tr = recall(y, model)\\n\\tf = 2*((p*r)/(p+r))\\n\\treturn f\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72489244","0.6807921","0.67379725","0.653737","0.619838","0.6129479","0.6101997","0.60964715","0.6069985","0.60437524","0.59976935","0.5977477","0.59438634","0.5916483","0.5908706","0.5908706","0.5908706","0.5908706","0.58445996","0.5814258","0.58096695","0.5808006","0.5789469","0.5777053","0.5772738","0.5771688","0.57694817","0.57658225","0.5761225","0.5759599","0.5756037","0.5745026","0.5737649","0.5736424","0.5735747","0.5735149","0.57262456","0.57109207","0.5708741","0.5691567","0.5690995","0.56850684","0.56810945","0.5680652","0.56800556","0.567768","0.5674526","0.56567353","0.56464446","0.5645631","0.5644437","0.56255865","0.5612703","0.5606994","0.56012183","0.55929834","0.5591829","0.55909085","0.5579645","0.55601496","0.5559203","0.5543454","0.55425966","0.553899","0.55358726","0.5529778","0.5527339","0.5513912","0.5513192","0.5508379","0.55081517","0.5504281","0.5496383","0.5496076","0.54715866","0.5469263","0.5466352","0.5463061","0.54569733","0.54561263","0.54524","0.5446877","0.5443985","0.54435253","0.54388344","0.54358274","0.54354167","0.54132086","0.54022217","0.5401954","0.5399136","0.5396314","0.5394787","0.5384555","0.53845006","0.5382755","0.53815645","0.5377422","0.5371867","0.5370101"],"string":"[\n \"0.72489244\",\n \"0.6807921\",\n \"0.67379725\",\n \"0.653737\",\n \"0.619838\",\n \"0.6129479\",\n \"0.6101997\",\n \"0.60964715\",\n \"0.6069985\",\n \"0.60437524\",\n \"0.59976935\",\n \"0.5977477\",\n \"0.59438634\",\n \"0.5916483\",\n \"0.5908706\",\n \"0.5908706\",\n \"0.5908706\",\n \"0.5908706\",\n \"0.58445996\",\n \"0.5814258\",\n \"0.58096695\",\n \"0.5808006\",\n \"0.5789469\",\n \"0.5777053\",\n \"0.5772738\",\n \"0.5771688\",\n \"0.57694817\",\n \"0.57658225\",\n \"0.5761225\",\n \"0.5759599\",\n \"0.5756037\",\n \"0.5745026\",\n \"0.5737649\",\n \"0.5736424\",\n \"0.5735747\",\n \"0.5735149\",\n \"0.57262456\",\n \"0.57109207\",\n \"0.5708741\",\n \"0.5691567\",\n \"0.5690995\",\n \"0.56850684\",\n \"0.56810945\",\n \"0.5680652\",\n \"0.56800556\",\n \"0.567768\",\n \"0.5674526\",\n \"0.56567353\",\n \"0.56464446\",\n \"0.5645631\",\n \"0.5644437\",\n \"0.56255865\",\n \"0.5612703\",\n \"0.5606994\",\n \"0.56012183\",\n \"0.55929834\",\n \"0.5591829\",\n \"0.55909085\",\n \"0.5579645\",\n \"0.55601496\",\n \"0.5559203\",\n \"0.5543454\",\n \"0.55425966\",\n \"0.553899\",\n \"0.55358726\",\n \"0.5529778\",\n \"0.5527339\",\n \"0.5513912\",\n \"0.5513192\",\n \"0.5508379\",\n \"0.55081517\",\n \"0.5504281\",\n \"0.5496383\",\n \"0.5496076\",\n \"0.54715866\",\n \"0.5469263\",\n \"0.5466352\",\n \"0.5463061\",\n \"0.54569733\",\n \"0.54561263\",\n \"0.54524\",\n \"0.5446877\",\n \"0.5443985\",\n \"0.54435253\",\n \"0.54388344\",\n \"0.54358274\",\n \"0.54354167\",\n \"0.54132086\",\n \"0.54022217\",\n \"0.5401954\",\n \"0.5399136\",\n \"0.5396314\",\n \"0.5394787\",\n \"0.5384555\",\n \"0.53845006\",\n \"0.5382755\",\n \"0.53815645\",\n \"0.5377422\",\n \"0.5371867\",\n \"0.5370101\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5989499"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":85176,"cells":{"query":{"kind":"string","value":"Lists all files in a folder that match the clipping.json format."},"document":{"kind":"string","value":"def _listdir(folder):\n\tfilePattern = r\"^\\d{4}\\-(0?[1-9]|1[012])\\-(0?[1-9]|[12][0-9]|3[01])\\-clipping\\-[\\d]*\\.json$\"\n\tfilenames = [f for f in os.listdir(folder) if re.match(filePattern, f)]\n\treturn filenames"},"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 json_files_from_folder(folder: str) -> list:\n\n files = []\n for file_name in os.listdir(folder):\n splitted_filename = file_name.split(\".\")\n if splitted_filename[-1] == \"json\":\n files.append(file_name)\n return files","def list_files(path):\n return list(sorted([f for f in os.listdir(path=path) if\n f.endswith('.json')]))","def json_fpaths() -> [str]:\n return glob.glob(f\"{RECIPES_DIRPATH}/*.json\")","def getFiles(folderToProcess,filter):\n\n print(f\"Parsing {folderToProcess} for {filter} files\")\n\n if debug:\n for path in Path(folderToProcess).rglob(filter):\n print(f\"Found {path}\")\n\n all_files = [str(x) for x in Path(folderToProcess).rglob(filter)] \n\n return all_files","def list_source_files(\n data_json: str,\n root_dir: str,\n show_tested_files: str,\n output_file: str = None\n) -> None:\n tested_files_filter = ShowTestedFilesOption.UNSPECIFIED\n if show_tested_files == 'all':\n tested_files_filter = ShowTestedFilesOption.ALL_TESTED\n if show_tested_files == 'some':\n tested_files_filter = ShowTestedFilesOption.ANY_TESTED\n if show_tested_files == 'none':\n tested_files_filter = ShowTestedFilesOption.NOT_TESTED\n\n invocation = cli_list_source_files_datatypes.ListSourceFilesInvocation(\n data_json,\n root_dir,\n tested_files_filter\n )\n result = cli_list_source_files.process_list_source_files(invocation)\n output_lines = (\n cli_list_source_files.format_list_source_files(invocation, result))\n\n _write_output(output_lines, output_file)","def get_paths(input_folder):\n list_files = []\n conll_folder = glob.glob(input_folder + '/*.json')\n \n for filename in conll_folder:\n list_files.append(filename)\n\n return list_files","def ls_json(directory):\n return_list = [\n f for f in os.listdir(directory) if f.endswith(\".json.gz\")\n ]\n return_list.sort()\n return return_list","def get_all_json_files_in_dir(dirpath):\n files = []\n for file in os.listdir(dirpath):\n if file.endswith('.json'):\n files.append(os.path.join(dirpath, file))\n return files","def check_file_list(any_format,ignore_warnings=True, warnings=[]):\n import os\n from glob import glob\n folders = [any_format]\n if os.is_file(any_format):\n with open(any_format) as f: folders = [_f for _f in f]\n if any_format[-1]==\"*\": folders = list(glob(any_format))\n valid_folders = []\n for f in folders:\n c = context.folder_context(f)\n if not c.meta_key[\"valid\"]: warnings.append(f)\n else: valid_folders.append(c.meta_key)\n \n #list the goods and the bads by simply listing the info for the folder but then say warnings in tabs if req\n \n if ignore_warnings == False and len(warnings) > 0:\n #some folders cannot be processed. Do you want to continue(y) or quit(n)?\n pass\n \n return valid_folders","def list_all_files(dir):\n\n result = []\n for root, _, filenames in os.walk(dir):\n for name in filenames:\n filename, ext = os.path.splitext(name)\n if ext == '.cs' or ext == '.xaml':\n result.append(os.path.join(root, name))\n return result","def getFiles(directory, showName, extension):\n os.chdir(directory)\n \n list = []\n \n for file in glob.glob(\"*\"+showName+\"*.\"+extension):\n list.append(file)\n \n return list","def _filter_files(file_dir: Union[str, Path], is_viya4: Optional[bool] = False) -> list:\n file_names = []\n file_names.extend(sorted(Path(file_dir).glob(\"*.json\")))\n if is_viya4:\n file_names.extend(sorted(Path(file_dir).glob(\"score_*.py\")))\n file_names.extend(sorted(Path(file_dir).glob(\"*.pickle\")))\n # Include H2O.ai MOJO files\n file_names.extend(sorted(Path(file_dir).glob(\"*.mojo\")))\n if file_names:\n return file_names\n else:\n raise FileNotFoundError(\n \"No valid model files were found in the provided file directory.\"\n )","def file_parser(folder, pattern = '.json'):\n path = os.getcwd()\n path_to_folder = os.path.join(path, folder)\n files = []\n jsons = []\n # r=root, d=directories, f = files\n for r, d, f in os.walk(path_to_folder):\n for file in f:\n if pattern in file:\n files.append(os.path.join(r, file))\n jsons.append(file)\n\n return((files,jsons))","def ReadFolder(folder: str) -> List[str]:\n\n onlyfiles = [f for f in listdir(folder) if isfile(join(folder, f))]\n \n return onlyfiles","def getResources(self, folder):\n\n #-------------------- \n # Get the resource JSON\n #-------------------- \n folder += \"/resources\"\n resources = self.__getJson(folder)\n #print(\"%s %s\"%(, folder))\n #print(\" Got resources: '%s'\"%(str(resources)))\n\n\n\n #-------------------- \n # Filter the JSONs\n #-------------------- \n resourceNames = []\n for r in resources:\n if 'label' in r:\n resourceNames.append(r['label'])\n #print(\"FOUND RESOURCE ('%s') : %s\"%(folder, r['label']))\n elif 'Name' in r:\n resourceNames.append(r['Name'])\n #print(\"FOUND RESOURCE ('%s') : %s\"%(folder, r['Name']))\n\n return resourceNames","def load_json_files(path: Path) -> list[Any]:\n return [load_json(p) for p in path.glob('*.json')]","def list_files():\n files = []\n for filename in os.listdir(UPLOAD_FOLDER):\n path = os.path.join(UPLOAD_FOLDER, filename)\n if os.path.isfile(path):\n files.append(filename)\n return jsonify({'List of Files: ': files})","def list_files():\n try:\n return jsonify(os.listdir(env(\"FILES_DIRECTORY\"))), 200\n except:\n return {\"msg\": \"Não há arquivos a serem listados.\"}, 404","def test_files(self, location):\n for filename in os.listdir(location):\n with open(location + '/' + filename) as json_file:\n data = json.load(json_file)\n self.test_data(data)","def getAllVCFs(inputFolder):\n listOfFiles = []\n numErrors = 0\n for folder in os.listdir(inputFolder): #Loop through all folders\n # print(folder)\n try: # using a try-xcept block to avoid errors with other files \n # not following this structure\n # TODO: make this cleaner\n vcfLoc = os.path.join(inputFolder, os.path.join(folder, \"pilon/\"))\n # print(vcfLoc)\n for potentialFile in os.listdir(vcfLoc):\n # print(potentialFile)\n if(potentialFile.endswith(\".vcf.gz\")):\n listOfFiles.append(os.path.join(vcfLoc, potentialFile))\n except:\n # print(\"error at \" + folder)\n numErrors += 1\n print(numErrors)\n return listOfFiles","def get_drawings(folder):\n # case insensitive in windows system, so \"dwg\" is ok\n return sorted(Path(folder).glob('**/*.dwg'))","def listFiles(self):\n pass","def list_files():\n files = []\n for filename in os.listdir(UPLOAD_DIRECTORY):\n path = os.path.join(UPLOAD_DIRECTORY, filename)\n if os.path.isfile(path):\n files.append(filename)\n return jsonify(files)","def ls(self):\n files = self.drive.files().list().execute().get(\"files\", [])\n for f in files:\n print(f[\"name\"], f[\"mimeType\"])","def folder(fpath):\n file_paths = glob.glob(fpath + '/*.dat')\n return list(file_paths)","def parse_folder(self, path):\n\n data = []\n for filename in os.listdir(path):\n data.append(self.parse_file(os.path.join(path, filename), filename))\n return data","def scan_folder(folder):\n LOGGER.debug(\"Scanning folder: %s\", folder)\n for file in os.listdir(folder):\n if file.endswith(\".csv\"):\n yield os.path.join(folder, file)","def read_all_data_from_folder(path):\n data = []\n\n # Loop through all files recursively\n for foldername, subfolders, filenames in os.walk(path):\n\n # Loop though each file\n for filename in filenames:\n name, ext = os.path.splitext(filename)\n\n filepath = os.path.join(foldername, filename)\n if ext == '.json':\n with open(filepath, \"r\") as f:\n data.append(json.load(f, preserve_order=False))\n elif ext == '.pkl':\n with open(filepath, \"rb\") as f:\n data.append(pickle.load(f))\n\n return data","def filterCollections(path, context):\n filteredObj = []\n for obj in os.listdir(path):\n if os.path.splitext(obj)[-1] == '.json':\n if obj.split('_', 1)[0] == context:\n filteredObj.append(obj.encode('utf8'))\n baseC = context + '_baseCollection.json'\n filteredObj = sorted(filteredObj, key=str.lower)\n filteredObj.insert(0, filteredObj.pop(filteredObj.index(baseC)))\n return filteredObj","def list_filenames(folder):\n full = glob.glob(os.path.join(_get_path(folder), '*'))\n ignore = ['Icon',]\n return [os.path.basename(f.strip()) for f in full if os.path.basename(f.strip()) not in ignore]","def get_messages_backup_files(dirpath):\n msg_files = []\n for subdirpath, dirnames, filenames in os.walk(dirpath):\n for filename in filenames:\n if re.search(r\"\\d{4}-\\d{2}-\\d{2}\\.json\", filename):\n msg_files.append(os.path.join(subdirpath, filename))\n return msg_files","def fmt_folder(folder):\n result = []\n\n folder_dir = localizer_config.get_src_path(folder)\n if not os.path.isdir(folder_dir):\n localizer_log.error(\"folder \" + folder + ' not exist. Abort.')\n\n experiments = [x for x in os.listdir(folder_dir)\n if os.path.isdir(os.path.join(folder_dir, x))]\n\n list_size = len(kpi_info.kpi_list)\n import util.runtime as runtime\n for exp_name in experiments:\n exp = runtime.find_exp_by_name(exp_name)\n if not exp:\n localizer_log.warning(\"Experiment {exp} not found\"\n .format(exp=exp_name))\n continue\n exp_dir = os.path.join(folder_dir, exp_name)\n files = [x for x in os.listdir(exp_dir) if x.endswith('.txt')]\n timeset = [int(filename.strip().replace('.txt', ''))\n for filename in files]\n\n for t in sorted(timeset):\n lst = [0 for i in range(list_size)]\n with open(os.path.join(exp_dir, str(t) + '.txt')) as f:\n for l in f:\n idx = kpi_info.get_index(l.strip())\n lst[idx] = 1\n result.append(PredData(exp, str(t), lst))\n\n return result","def list_and_filter(self, pattern, root_path):\n for path, dirs, files in os.walk(os.path.abspath(root_path)):\n for filename in fnmatch.filter(files, pattern):\n yield os.path.join(path, filename)","def findMayaFiles(directory):\n\n pass","def get_config_files(self):\n self.clear_lists()\n print self.abs_directory\n for file in os.listdir(self.abs_directory):\n print file\n if file.endswith('.json') and \"qemii\" in file:\n self.txt_files.append(file)","def list_dir(self, path):","def read_files(events_path):\r\n\r\n # Generate list of all event files in directory\r\n p = Path(events_path).glob(\"*.json\")\r\n # Check if each item in list is not directory\r\n events_list = [x for x in p if x.is_file()]\r\n return events_list","def list_files_in_given_folder(path_to_folder):\r\n file_names_list = []\r\n for file_name in glob.glob(path_to_folder+\"/*\"):\r\n file_names_list.append(file_name)\r\n assert file_names_list != [], \"failed to populate folder\"+path_to_folder\r\n return file_names_list","def filter_corpus():\n result = []\n for f in glob.glob(f\"{DATA_DIR}/COP*.json\"):\n with open(f, \"r\") as infile:\n data = json.load(infile)\n articles = flatten(data)\n result.append(articles)\n\n with open(f\"{DATA_DIR}/filtered_data.json\", \"w\", encoding='utf-8') as f:\n json.dump(result, f, indent=2)","def ls(self, folder_id: int = -1) -> list:\n print('ls', folder_id)\n if folder_id == -1:\n folder_id = self.default_dir\n url = 'https://webapi.115.com/files?aid=1&cid={}&o=user_ptime&asc=0&offset=0&show_dir=1&limit=115&code=&scid=' \\\n '&snap=0&natsort=1&custom_order=2&source=&format=json&type=&star=&is_q=&is_share='.format(folder_id)\n result = self.s.get(url, headers={'Referer': referer['115'].format(self.default_dir)}).json()\n if result['errNo'] == 0:\n data = result['data']\n return data","async def glob(self):\n # get the path string up to the wildcards\n try:\n pi1 = self._path.index(\"*\")\n except ValueError:\n pi1 = len(self._path)\n try:\n pi2 = self._path.index(\"?\")\n except ValueError:\n pi2 = len(self._path)\n pi = min(pi1, pi2)\n # using the prefix will cut down on the search space\n prefix = self._path[:pi]\n # get the wildcard\n wildcard = self._path[pi:]\n # set up the paginator\n paginator = self._conn_obj.conn.get_paginator(\"list_objects_v2\")\n parameters = {\n 'Bucket': self._bucket,\n 'Prefix': prefix\n }\n page_iterator = paginator.paginate(**parameters)\n files = []\n async for page in page_iterator:\n for item in page.get('Contents', []):\n fname = item['Key']\n # check that it matches against wildcard\n if fnmatch(fname, wildcard):\n files.append(item['Key'])\n return files","def clist() -> None:\n files = os.listdir(os.path.join(os.getcwd(), \"apis\"))\n files.remove(\"__init__.py\")\n files = [f.replace(\".py\", \"\") for f in files]\n print(files)","def get_all(folder, filter_funs = []) :\n\n def apply_funs(x, funs) :\n \"\"\"Applies the filter functions.\"\"\"\n res = True\n for f in funs :\n res = f(x)\n if not res :\n break\n return res\n \n final = {}\n files = listdir(folder)\n print(\"Loading Spectras\")\n for f in files :\n try :\n spectra = Spectra(folder + \"/\" + f)\n print(\".\", end=\"\")\n except:\n continue\n if spectra == None :\n continue\n if not apply_funs(spectra, filter_funs) :\n continue\n pot_spectra = final.get(spectra.database_id, None)\n if not pot_spectra :\n final[spectra.database_id] = [deepcopy(spectra)]\n else :\n pot_spectra.append(deepcopy(spectra))\n return final","def index_viewer():\n\n path = 'C:\\Users\\Jamie\\PycharmProjects\\ReciPy'\n for item in os.listdir(path):\n if item.endswith(\".txt\"):\n print item","def list_files(file, folder, extension = '*.evtx'):\r\n if file:\r\n return [file]\r\n elif folder:\r\n return [ y for x in os.walk(folder) for y in glob(os.path.join(x[0], extension))]\r\n else:\r\n return []","def list_phonebooks(path=\".\"):\n files = os.listdir(path)\n for file in files:\n if file.endswith(EXTENSION):\n print file","def get_files(filedir):\n inputfiles = sorted(glob.glob(os.path.normcase(filedir+\"/\")+\"*.json\"))\n return inputfiles","def view(args):\n print(\"List of all available phonebooks:\")\n for file in glob.glob(\"*.ph\"):\n print(file)","def boxSearch(client):\n\tfiles = []\n\titems_iter = client.folder(folder_id=0).get_items(limit=100, offset=0)\n\tfor x in items_iter:\n\t\tfiles.append(x)\n\treturn files","def ls(path, filter=None):","def filelisting(directory, suffix = 'tcx'):\n files = []\n for f in os.listdir(directory):\n fullpath = os.path.join(directory, f)\n if os.path.isfile(fullpath) and f.endswith(suffix):\n files.append(fullpath)\n return files","def _list_files(folder, pattern):\n for root, folders, files in os.walk(folder):\n for filename in files:\n if fnmatch.fnmatch(filename, pattern):\n yield os.path.join(root, filename)","def _list_files(folder, pattern):\n for root, folders, files in os.walk(folder):\n for filename in files:\n if fnmatch.fnmatch(filename, pattern):\n yield os.path.join(root, filename)","def coffeescript_files():\r\n dirs = \" \".join(THEME_COFFEE_PATHS + [Env.REPO_ROOT / coffee_dir for coffee_dir in COFFEE_DIRS])\r\n return cmd('find', dirs, '-type f', '-name \\\"*.coffee\\\"')","def list_files(directory, suffix='.nc'):\n nc_files = []\n\n dir_files = os.listdir(directory)\n for filename in dir_files:\n file_path = os.path.join(directory, filename)\n if os.path.isdir(file_path):\n nc_files.extend(list_files(file_path))\n elif file_path.endswith(suffix):\n nc_files.append(file_path)\n\n return nc_files","def ui_backgrounds(request):\n out = createBaseResponseObject() \n path = os.path.join(settings.BASE_PATH , \"sketch_ui/static/ui/backgrounds\")\n files = os.listdir(path)\n for f in files:\n out['results'].append(f)\n \n return HttpResponse(json.dumps(out))","def get_counselor_json_files(directory):\n search_path = os.path.join(directory, '*.json')\n filenames = list(filter(\n lambda f: re.search(r'/\\d{5}.json$', f),\n glob.glob(search_path)\n ))\n\n if not filenames:\n raise RuntimeError('no input files found in {}'.format(directory))\n\n logger.info('Found %d input files', len(filenames))\n\n for filename in filenames:\n match = re.search(r'/(\\d{5}).json$', filename)\n zipcode = match.group(1)\n\n yield zipcode, filename","def get_authorization_files_in_directory(directory): # pragma: no cover\n file_list = [\n f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))\n ]\n file_list_with_full_path = []\n for file in file_list:\n if file.endswith(\".json\"):\n file_list_with_full_path.append(\n os.path.abspath(os.path.join(directory, file))\n )\n new_file_list = []\n for file in file_list_with_full_path:\n with open(file) as f:\n contents = f.read()\n account_authorization_details_cfg = json.loads(contents)\n valid_schema = check_authorization_details_schema(\n account_authorization_details_cfg\n )\n if valid_schema:\n new_file_list.append(file)\n return new_file_list","def GetFolderISOFiles(Path):\n ISOFiles = []\n for file in os.listdir(Path):\n if file[-3:] == 'iso' or file[-3:] == 'ISO':\n ISOFiles.append(Path + '/' +file)\n print(ISOFiles)\n return ISOFiles","def listoffiles(self, path):\n return os.listdir(path)","def list_offline(args):\n json_file = args.file[0]\n emojis = load_file(json_file)\n print_table(emojis)","def searchFolder(folderPath, extentions):\n\tfiles = []\n\tos.chdir(folderPath)\n\tfor ext in extentions:\n\t\tfor file in glob.glob(\"*.\"+ext):\n\t\t\tfiles.append(os.path.splitext(file)[0])\n\treturn files","def read_files_to_list(fdir, expression='*.json'):\n filelist = []\n for file in glob.glob(path.join(fdir, expression)):\n filelist.append(file)\n return filelist","def readPlayerImageFiles(self):\n currentPath = os.path.dirname(os.path.abspath(__file__))\n listOfFileNames=[]\n for i in os.listdir(currentPath):\n if re.match(\"player\\_\\d+\",i): #i.endswith(\".gif\")\n listOfFileNames.append(currentPath+'/'+i)\n return listOfFileNames","def get_samples_file(foldername, filter=None):\n samples = []\n for file in os.listdir(foldername):\n if filter and file.find(filter) == -1:\n continue\n for sample in sfile(foldername + '/' + file, None).get_samples():\n samples.append(sample)\n return samples","def get_nifty_list(root_dir, name=\"\"):\n \n file_list = glob(root_dir + \"/**/*.nii.gz\", recursive=True)\n file_list = sorted([file for file in file_list if name in file])\n return file_list","def sel_files(dpath):\n sel_files = []\n for root, _, files in os.walk(dpath):\n for fname in files:\n if not fname.endswith('.json'): # skip non-json files\n continue\n fpath = os.path.join(root, fname)\n sel_files.append(fpath)\n return sel_files","def scan_directories(data_dir, file_filter):\n\n root = os.walk(data_dir)\n\n print('Scanning for files...')\n output = []\n\n for directory in root:\n\n files = directory[2]\n\n # Valid dataset contains video files of both halves and an accompanying label\n if file_filter(files):\n output.append(directory[0])\n\n print('Done')\n\n return output","def list_type_in_dir(path, extension):\n path, extension = check_args(path, extension)\n files = os.listdir(path)\n file_list = [os.path.join(path, f)\n for f in fnmatch.filter(files, '*' + extension)]\n\n return file_list","def find_files(path: str) -> List[str]:\n files = sorted(list(glob.glob(os.path.join(path, \"*.wav\"))))\n\n print(\"files: %d files found\" % len(files))\n return files","def getimagelist(folder):\n imagefolder = Path(folder) \n imagelist = imagefolder.glob(\"**/*.png\") \n return list(imagelist)","def cached_files():\n for (dir_path, _dir_names, file_names) in os.walk(CACHE):\n for file_name in file_names:\n if is_json_file(file_name):\n yield os.path.join(dir_path, file_name)","def get_file_list(folder):\n\tfilelist = []\n\tfor file in os.listdir(folder):\n\t\tif file.endswith('.png'):\n\t\t\tfilelist.append(file)\n\treturn filelist","def scan_fixtures(path):\n results = list()\n for root, dirs, files in os.walk(path):\n relative_path = root.replace(path + \"/\", \"\")\n if relative_path.startswith(\"static\") or relative_path.startswith(\"theme\"):\n continue\n\n for f in files:\n if not f.endswith(\".json\"):\n continue\n\n app_name = os.path.basename(os.path.dirname(relative_path))\n\n results.append((app_name, f, relative_path))\n\n return results","def files_in_folder(folder):\n files = []\n for f in glob.glob(folder):\n if os.path.isdir(f):\n files.extend(files_in_folder(f + os.sep + \"**\"))\n else:\n files.append(f)\n return files","def get_all_files(path, valid_suffix):\n files = []\n for suffix in valid_suffix:\n files.extend(glob.glob(path + \"*/**/*\" + suffix, recursive=True))\n return files","def _read_directory(self):\n self._filenames = glob.glob(self._directory + \"/*.project\")","def process_files(file_location, day):\n # construct file path\n file_dir = PREFIX+file_location\n file_pattern = file_dir+'lz_'+day+'*_raw.root'\n # print(file_pattern)\n file_list = glob.glob(file_pattern)\n print(\"There are %s MC files in the requested directory (%s).\" %(len(file_list), file_dir))\n file_names = []\n for f in file_list:\n file_name_only = f.split('/')\n file_names.append(file_name_only[-1])\n return file_names","def scan_dir(self, directory=\".\"):\n for root, dirs, files in os.walk(directory, topdown=False):\n for name in files:\n for filetype in self.allowed_file_types:\n if name.split(\".\")[-1] == filetype:\n self.song_list.append(os.path.join(root, name))","def read_all_files():\n paths = get_all_recording_paths()\n\n return read_by_paths(paths)","def ListFolder(self, path): # real signature unknown; restored from __doc__\n pass","def find_files(folder, max_title, filename_contains='', filename_extension=''):\n\n info = f'Checking {os.path.basename(folder)} folder for configuration files'\n print(info, end =\" \") \n\n # check if ssave_path folder exist\n check_valid_path(folder)\n \n # list to save configuration data files\n files_lst = []\n\n # going through all directories inside folder to find configuration data\n for root, _, files in os.walk(folder):\n for file in files:\n # filename contains filename_contains atr but not hidden file\n if re.search(filename_contains, file) and not re.search('^~\\$.+', file):\n file_path = os.path.normpath(os.path.join(root, file))\n if filename_extension and file.endswith(filename_extension):\n files_lst.append(file_path)\n # when file extension flag is None and file name doesn't contain extension (.7zip, .exe, .log, .3g2)\n elif filename_extension is None and not re.search('.+\\.(\\d)?[A-Za-z]+(\\d)?$', file):\n files_lst.append(file_path)\n elif filename_extension=='':\n files_lst.append(file_path)\n\n\n if len(files_lst) == 0:\n status_info('no data', max_title, len(info))\n else:\n status_info('ok', max_title, len(info)) \n return files_lst","def get_all_metrics(dir):\r\n file_lst = os.listdir(dir)\r\n file_lst = list(filter(lambda x: re.findall(r'\\.csv$',x), file_lst))\r\n return file_lst","def list_file(self, path: str) -> List[FileName]:\n current_file = self.file_exists(path)\n if current_file is None:\n raise FileNotExistException(\n \"Path doesn't exist. Can't list non-existent path\"\n )\n if current_file.file_type != GOOGLE_FOLDER_TYPE:\n raise NotAFolderException(\"file_nod has to be a folder to list contents\")\n if current_file.children is None:\n raise NotAFolderException(\"file_nod has to be a folder to list contents\")\n if len(current_file.children) == 0:\n return []\n return [\n child_file.file_name for child_file in list(current_file.children.values())\n ]","def find_files(directory, pattern='**/*.wav'):\n return glob(os.path.join(directory, pattern), recursive=True)","def ReadRecipesFromDirectory(self, path: str) -> None:\n for file_path in glob.glob(os.path.join(path, '*.json')):\n self.ReadRecipeFromFile(file_path)","def list_directory(path):\n files = []\n for f in listdir(path):\n if isfile(join(path, f)) and f.endswith('.mp3'):\n files.append(f)\n return files","def get_files_to_be_indexed(self):\n\t\tfiles = self.get_all_files()\n\t\tfiles_list = []\n\t\tfor name in files:\n\t\t\tif(name.split('.')[-1] in self.accepted_formats and os.stat(os.path.join(self.root, name)).st_size < 5000000):\n\t\t\t\tfiles_list.append(os.path.join(self.root, name))\n\t\treturn files_list[0:-1]","def collect_files(path, audio_files):\n\n for entry in os.scandir(path):\n if entry.is_dir():\n collect_files(entry.path, audio_files)\n if entry.is_file() and (entry.path.endswith(\".flac\") or entry.path.endswith(\".wav\")):\n audio_files.append(entry.path)","def filterAll(media_list_file, in_movie_dir, out_movie_dir):\n with open(media_list_file) as f:\n names = json.load(f)\n\n count_tweets = []\n count_kept_tweets = []\n for name in names:\n with open(\"{}/{}.json\".format(in_movie_dir, name)) as f:\n tweets = json.load(f)\n kept_tweets = [t for t in tweets.values() if keep(t)]\n print(\"total = {}\\tkeep = {}\\tName = {}\".format(\n len(tweets), len(kept_tweets), name))\n count_tweets.append(len(tweets))\n count_kept_tweets.append(len(kept_tweets))\n with open(\"{}/{}.json\".format(out_movie_dir, name), \"w\") as f:\n json.dump(kept_tweets, f)\n print(\"Mean tweets = {}\".format(np.mean(count_tweets)))\n print(\"Mean kept tweets = {}\".format(np.mean(count_kept_tweets)))\n print(\"Mean fraction kept tweets = {}\".format(\n np.mean(count_kept_tweets) / np.mean(count_tweets)))","def _listfiles(dirname):\n for root, dirs, files in os.walk(dirname):\n fkey = os.path.basename(root)\n f = []\n for name in files:\n key = os.path.splitext(name)[0]\n listfilters[key] = os.path.join(root, name)\n f.append(key)\n if f:\n showfilters[fkey] = f","def list_files(folder, number_of_files=None):\n paths = glob.glob(folder + \"/*.gz\")\n\n if number_of_files is None:\n return paths\n else:\n return paths[:number_of_files]","def detectFiles(self, input):\n output = []\n if os.path.isfile(input):\n output.append(input)\n else:\n input = os.path.join(input, '*') if os.path.isdir(input) else input\n for file in glob.glob(input):\n output.append(file)\n return output","def get_bibfiles(folder: str) -> t.List[str]:\n full_pathname = os.path.normpath(os.path.abspath(folder))\n bib_files = []\n for f in os.listdir(full_pathname):\n fullname = os.path.join(full_pathname, f)\n if f.endswith(\".bib\") and os.path.isfile(fullname):\n logging.debug(f'get bibfile \"{f}\" from directory \"{full_pathname}\"')\n bib_files.append(fullname)\n return bib_files","def get_list_of_files_in_folder(\n self, folder_name: str, limit: int = 1\n ) -> List[str]:\n\n files = []\n if os.path.isdir(folder_name):\n # Get list of only html files from folder:\n files = [file for file in os.listdir(folder_name) if file.endswith(\".html\")]\n\n if len(files) < limit: # short dialogs\n return []\n\n # Descending sort to consider message order:\n files = sorted(\n files,\n key=lambda x: int(re.search(r\"messages(\\d+)\\.html\", x).group(1)),\n reverse=True,\n )\n else:\n print(f\"No such directory: {folder_name}\")\n return files","def get_card_files(card_dir: str = \"./cards\") -> List[Path]:\n p: Path = Path(card_dir)\n return list(p.glob('**/*.yaml'))","def list(self):\n objectpath = os.path.join(self.rootpath, self.OBJECTPATH)\n for root, dirs, files in os.walk(objectpath, topdown=False):\n for name in files:\n print(os.path.join(root, name))","def listFiles(self):\n current_month = NoaaCycle.last_month()\n # 2do archive contain extra path: data/noaa/metar/2011-* ; better is 2011-*\n dir_regex = os.path.join(self.download_dir, \"%s-*\" % current_month)\n self.archive_name = os.path.join(self.download_dir, current_month)\n return glob.glob(dir_regex)","def get_paths(input_folder: str) -> list[str]:\n\n return [f for f in os.listdir(input_folder) if f[-4:] == '.txt' and f[:3] != 'top']","def main():\n\n parser = argparse.ArgumentParser()\n parser.add_argument(\"folder\")\n args = parser.parse_args()\n \n print(\"\")\n print(\"Smart Listing:\", args.folder.replace(\"/\", \" >\"))\n print(\"\")\n for seq, frange in parsefilenames(os.listdir(args.folder)):\n print(len(frange), seq, frange)"],"string":"[\n \"def json_files_from_folder(folder: str) -> list:\\n\\n files = []\\n for file_name in os.listdir(folder):\\n splitted_filename = file_name.split(\\\".\\\")\\n if splitted_filename[-1] == \\\"json\\\":\\n files.append(file_name)\\n return files\",\n \"def list_files(path):\\n return list(sorted([f for f in os.listdir(path=path) if\\n f.endswith('.json')]))\",\n \"def json_fpaths() -> [str]:\\n return glob.glob(f\\\"{RECIPES_DIRPATH}/*.json\\\")\",\n \"def getFiles(folderToProcess,filter):\\n\\n print(f\\\"Parsing {folderToProcess} for {filter} files\\\")\\n\\n if debug:\\n for path in Path(folderToProcess).rglob(filter):\\n print(f\\\"Found {path}\\\")\\n\\n all_files = [str(x) for x in Path(folderToProcess).rglob(filter)] \\n\\n return all_files\",\n \"def list_source_files(\\n data_json: str,\\n root_dir: str,\\n show_tested_files: str,\\n output_file: str = None\\n) -> None:\\n tested_files_filter = ShowTestedFilesOption.UNSPECIFIED\\n if show_tested_files == 'all':\\n tested_files_filter = ShowTestedFilesOption.ALL_TESTED\\n if show_tested_files == 'some':\\n tested_files_filter = ShowTestedFilesOption.ANY_TESTED\\n if show_tested_files == 'none':\\n tested_files_filter = ShowTestedFilesOption.NOT_TESTED\\n\\n invocation = cli_list_source_files_datatypes.ListSourceFilesInvocation(\\n data_json,\\n root_dir,\\n tested_files_filter\\n )\\n result = cli_list_source_files.process_list_source_files(invocation)\\n output_lines = (\\n cli_list_source_files.format_list_source_files(invocation, result))\\n\\n _write_output(output_lines, output_file)\",\n \"def get_paths(input_folder):\\n list_files = []\\n conll_folder = glob.glob(input_folder + '/*.json')\\n \\n for filename in conll_folder:\\n list_files.append(filename)\\n\\n return list_files\",\n \"def ls_json(directory):\\n return_list = [\\n f for f in os.listdir(directory) if f.endswith(\\\".json.gz\\\")\\n ]\\n return_list.sort()\\n return return_list\",\n \"def get_all_json_files_in_dir(dirpath):\\n files = []\\n for file in os.listdir(dirpath):\\n if file.endswith('.json'):\\n files.append(os.path.join(dirpath, file))\\n return files\",\n \"def check_file_list(any_format,ignore_warnings=True, warnings=[]):\\n import os\\n from glob import glob\\n folders = [any_format]\\n if os.is_file(any_format):\\n with open(any_format) as f: folders = [_f for _f in f]\\n if any_format[-1]==\\\"*\\\": folders = list(glob(any_format))\\n valid_folders = []\\n for f in folders:\\n c = context.folder_context(f)\\n if not c.meta_key[\\\"valid\\\"]: warnings.append(f)\\n else: valid_folders.append(c.meta_key)\\n \\n #list the goods and the bads by simply listing the info for the folder but then say warnings in tabs if req\\n \\n if ignore_warnings == False and len(warnings) > 0:\\n #some folders cannot be processed. Do you want to continue(y) or quit(n)?\\n pass\\n \\n return valid_folders\",\n \"def list_all_files(dir):\\n\\n result = []\\n for root, _, filenames in os.walk(dir):\\n for name in filenames:\\n filename, ext = os.path.splitext(name)\\n if ext == '.cs' or ext == '.xaml':\\n result.append(os.path.join(root, name))\\n return result\",\n \"def getFiles(directory, showName, extension):\\n os.chdir(directory)\\n \\n list = []\\n \\n for file in glob.glob(\\\"*\\\"+showName+\\\"*.\\\"+extension):\\n list.append(file)\\n \\n return list\",\n \"def _filter_files(file_dir: Union[str, Path], is_viya4: Optional[bool] = False) -> list:\\n file_names = []\\n file_names.extend(sorted(Path(file_dir).glob(\\\"*.json\\\")))\\n if is_viya4:\\n file_names.extend(sorted(Path(file_dir).glob(\\\"score_*.py\\\")))\\n file_names.extend(sorted(Path(file_dir).glob(\\\"*.pickle\\\")))\\n # Include H2O.ai MOJO files\\n file_names.extend(sorted(Path(file_dir).glob(\\\"*.mojo\\\")))\\n if file_names:\\n return file_names\\n else:\\n raise FileNotFoundError(\\n \\\"No valid model files were found in the provided file directory.\\\"\\n )\",\n \"def file_parser(folder, pattern = '.json'):\\n path = os.getcwd()\\n path_to_folder = os.path.join(path, folder)\\n files = []\\n jsons = []\\n # r=root, d=directories, f = files\\n for r, d, f in os.walk(path_to_folder):\\n for file in f:\\n if pattern in file:\\n files.append(os.path.join(r, file))\\n jsons.append(file)\\n\\n return((files,jsons))\",\n \"def ReadFolder(folder: str) -> List[str]:\\n\\n onlyfiles = [f for f in listdir(folder) if isfile(join(folder, f))]\\n \\n return onlyfiles\",\n \"def getResources(self, folder):\\n\\n #-------------------- \\n # Get the resource JSON\\n #-------------------- \\n folder += \\\"/resources\\\"\\n resources = self.__getJson(folder)\\n #print(\\\"%s %s\\\"%(, folder))\\n #print(\\\" Got resources: '%s'\\\"%(str(resources)))\\n\\n\\n\\n #-------------------- \\n # Filter the JSONs\\n #-------------------- \\n resourceNames = []\\n for r in resources:\\n if 'label' in r:\\n resourceNames.append(r['label'])\\n #print(\\\"FOUND RESOURCE ('%s') : %s\\\"%(folder, r['label']))\\n elif 'Name' in r:\\n resourceNames.append(r['Name'])\\n #print(\\\"FOUND RESOURCE ('%s') : %s\\\"%(folder, r['Name']))\\n\\n return resourceNames\",\n \"def load_json_files(path: Path) -> list[Any]:\\n return [load_json(p) for p in path.glob('*.json')]\",\n \"def list_files():\\n files = []\\n for filename in os.listdir(UPLOAD_FOLDER):\\n path = os.path.join(UPLOAD_FOLDER, filename)\\n if os.path.isfile(path):\\n files.append(filename)\\n return jsonify({'List of Files: ': files})\",\n \"def list_files():\\n try:\\n return jsonify(os.listdir(env(\\\"FILES_DIRECTORY\\\"))), 200\\n except:\\n return {\\\"msg\\\": \\\"Não há arquivos a serem listados.\\\"}, 404\",\n \"def test_files(self, location):\\n for filename in os.listdir(location):\\n with open(location + '/' + filename) as json_file:\\n data = json.load(json_file)\\n self.test_data(data)\",\n \"def getAllVCFs(inputFolder):\\n listOfFiles = []\\n numErrors = 0\\n for folder in os.listdir(inputFolder): #Loop through all folders\\n # print(folder)\\n try: # using a try-xcept block to avoid errors with other files \\n # not following this structure\\n # TODO: make this cleaner\\n vcfLoc = os.path.join(inputFolder, os.path.join(folder, \\\"pilon/\\\"))\\n # print(vcfLoc)\\n for potentialFile in os.listdir(vcfLoc):\\n # print(potentialFile)\\n if(potentialFile.endswith(\\\".vcf.gz\\\")):\\n listOfFiles.append(os.path.join(vcfLoc, potentialFile))\\n except:\\n # print(\\\"error at \\\" + folder)\\n numErrors += 1\\n print(numErrors)\\n return listOfFiles\",\n \"def get_drawings(folder):\\n # case insensitive in windows system, so \\\"dwg\\\" is ok\\n return sorted(Path(folder).glob('**/*.dwg'))\",\n \"def listFiles(self):\\n pass\",\n \"def list_files():\\n files = []\\n for filename in os.listdir(UPLOAD_DIRECTORY):\\n path = os.path.join(UPLOAD_DIRECTORY, filename)\\n if os.path.isfile(path):\\n files.append(filename)\\n return jsonify(files)\",\n \"def ls(self):\\n files = self.drive.files().list().execute().get(\\\"files\\\", [])\\n for f in files:\\n print(f[\\\"name\\\"], f[\\\"mimeType\\\"])\",\n \"def folder(fpath):\\n file_paths = glob.glob(fpath + '/*.dat')\\n return list(file_paths)\",\n \"def parse_folder(self, path):\\n\\n data = []\\n for filename in os.listdir(path):\\n data.append(self.parse_file(os.path.join(path, filename), filename))\\n return data\",\n \"def scan_folder(folder):\\n LOGGER.debug(\\\"Scanning folder: %s\\\", folder)\\n for file in os.listdir(folder):\\n if file.endswith(\\\".csv\\\"):\\n yield os.path.join(folder, file)\",\n \"def read_all_data_from_folder(path):\\n data = []\\n\\n # Loop through all files recursively\\n for foldername, subfolders, filenames in os.walk(path):\\n\\n # Loop though each file\\n for filename in filenames:\\n name, ext = os.path.splitext(filename)\\n\\n filepath = os.path.join(foldername, filename)\\n if ext == '.json':\\n with open(filepath, \\\"r\\\") as f:\\n data.append(json.load(f, preserve_order=False))\\n elif ext == '.pkl':\\n with open(filepath, \\\"rb\\\") as f:\\n data.append(pickle.load(f))\\n\\n return data\",\n \"def filterCollections(path, context):\\n filteredObj = []\\n for obj in os.listdir(path):\\n if os.path.splitext(obj)[-1] == '.json':\\n if obj.split('_', 1)[0] == context:\\n filteredObj.append(obj.encode('utf8'))\\n baseC = context + '_baseCollection.json'\\n filteredObj = sorted(filteredObj, key=str.lower)\\n filteredObj.insert(0, filteredObj.pop(filteredObj.index(baseC)))\\n return filteredObj\",\n \"def list_filenames(folder):\\n full = glob.glob(os.path.join(_get_path(folder), '*'))\\n ignore = ['Icon',]\\n return [os.path.basename(f.strip()) for f in full if os.path.basename(f.strip()) not in ignore]\",\n \"def get_messages_backup_files(dirpath):\\n msg_files = []\\n for subdirpath, dirnames, filenames in os.walk(dirpath):\\n for filename in filenames:\\n if re.search(r\\\"\\\\d{4}-\\\\d{2}-\\\\d{2}\\\\.json\\\", filename):\\n msg_files.append(os.path.join(subdirpath, filename))\\n return msg_files\",\n \"def fmt_folder(folder):\\n result = []\\n\\n folder_dir = localizer_config.get_src_path(folder)\\n if not os.path.isdir(folder_dir):\\n localizer_log.error(\\\"folder \\\" + folder + ' not exist. Abort.')\\n\\n experiments = [x for x in os.listdir(folder_dir)\\n if os.path.isdir(os.path.join(folder_dir, x))]\\n\\n list_size = len(kpi_info.kpi_list)\\n import util.runtime as runtime\\n for exp_name in experiments:\\n exp = runtime.find_exp_by_name(exp_name)\\n if not exp:\\n localizer_log.warning(\\\"Experiment {exp} not found\\\"\\n .format(exp=exp_name))\\n continue\\n exp_dir = os.path.join(folder_dir, exp_name)\\n files = [x for x in os.listdir(exp_dir) if x.endswith('.txt')]\\n timeset = [int(filename.strip().replace('.txt', ''))\\n for filename in files]\\n\\n for t in sorted(timeset):\\n lst = [0 for i in range(list_size)]\\n with open(os.path.join(exp_dir, str(t) + '.txt')) as f:\\n for l in f:\\n idx = kpi_info.get_index(l.strip())\\n lst[idx] = 1\\n result.append(PredData(exp, str(t), lst))\\n\\n return result\",\n \"def list_and_filter(self, pattern, root_path):\\n for path, dirs, files in os.walk(os.path.abspath(root_path)):\\n for filename in fnmatch.filter(files, pattern):\\n yield os.path.join(path, filename)\",\n \"def findMayaFiles(directory):\\n\\n pass\",\n \"def get_config_files(self):\\n self.clear_lists()\\n print self.abs_directory\\n for file in os.listdir(self.abs_directory):\\n print file\\n if file.endswith('.json') and \\\"qemii\\\" in file:\\n self.txt_files.append(file)\",\n \"def list_dir(self, path):\",\n \"def read_files(events_path):\\r\\n\\r\\n # Generate list of all event files in directory\\r\\n p = Path(events_path).glob(\\\"*.json\\\")\\r\\n # Check if each item in list is not directory\\r\\n events_list = [x for x in p if x.is_file()]\\r\\n return events_list\",\n \"def list_files_in_given_folder(path_to_folder):\\r\\n file_names_list = []\\r\\n for file_name in glob.glob(path_to_folder+\\\"/*\\\"):\\r\\n file_names_list.append(file_name)\\r\\n assert file_names_list != [], \\\"failed to populate folder\\\"+path_to_folder\\r\\n return file_names_list\",\n \"def filter_corpus():\\n result = []\\n for f in glob.glob(f\\\"{DATA_DIR}/COP*.json\\\"):\\n with open(f, \\\"r\\\") as infile:\\n data = json.load(infile)\\n articles = flatten(data)\\n result.append(articles)\\n\\n with open(f\\\"{DATA_DIR}/filtered_data.json\\\", \\\"w\\\", encoding='utf-8') as f:\\n json.dump(result, f, indent=2)\",\n \"def ls(self, folder_id: int = -1) -> list:\\n print('ls', folder_id)\\n if folder_id == -1:\\n folder_id = self.default_dir\\n url = 'https://webapi.115.com/files?aid=1&cid={}&o=user_ptime&asc=0&offset=0&show_dir=1&limit=115&code=&scid=' \\\\\\n '&snap=0&natsort=1&custom_order=2&source=&format=json&type=&star=&is_q=&is_share='.format(folder_id)\\n result = self.s.get(url, headers={'Referer': referer['115'].format(self.default_dir)}).json()\\n if result['errNo'] == 0:\\n data = result['data']\\n return data\",\n \"async def glob(self):\\n # get the path string up to the wildcards\\n try:\\n pi1 = self._path.index(\\\"*\\\")\\n except ValueError:\\n pi1 = len(self._path)\\n try:\\n pi2 = self._path.index(\\\"?\\\")\\n except ValueError:\\n pi2 = len(self._path)\\n pi = min(pi1, pi2)\\n # using the prefix will cut down on the search space\\n prefix = self._path[:pi]\\n # get the wildcard\\n wildcard = self._path[pi:]\\n # set up the paginator\\n paginator = self._conn_obj.conn.get_paginator(\\\"list_objects_v2\\\")\\n parameters = {\\n 'Bucket': self._bucket,\\n 'Prefix': prefix\\n }\\n page_iterator = paginator.paginate(**parameters)\\n files = []\\n async for page in page_iterator:\\n for item in page.get('Contents', []):\\n fname = item['Key']\\n # check that it matches against wildcard\\n if fnmatch(fname, wildcard):\\n files.append(item['Key'])\\n return files\",\n \"def clist() -> None:\\n files = os.listdir(os.path.join(os.getcwd(), \\\"apis\\\"))\\n files.remove(\\\"__init__.py\\\")\\n files = [f.replace(\\\".py\\\", \\\"\\\") for f in files]\\n print(files)\",\n \"def get_all(folder, filter_funs = []) :\\n\\n def apply_funs(x, funs) :\\n \\\"\\\"\\\"Applies the filter functions.\\\"\\\"\\\"\\n res = True\\n for f in funs :\\n res = f(x)\\n if not res :\\n break\\n return res\\n \\n final = {}\\n files = listdir(folder)\\n print(\\\"Loading Spectras\\\")\\n for f in files :\\n try :\\n spectra = Spectra(folder + \\\"/\\\" + f)\\n print(\\\".\\\", end=\\\"\\\")\\n except:\\n continue\\n if spectra == None :\\n continue\\n if not apply_funs(spectra, filter_funs) :\\n continue\\n pot_spectra = final.get(spectra.database_id, None)\\n if not pot_spectra :\\n final[spectra.database_id] = [deepcopy(spectra)]\\n else :\\n pot_spectra.append(deepcopy(spectra))\\n return final\",\n \"def index_viewer():\\n\\n path = 'C:\\\\Users\\\\Jamie\\\\PycharmProjects\\\\ReciPy'\\n for item in os.listdir(path):\\n if item.endswith(\\\".txt\\\"):\\n print item\",\n \"def list_files(file, folder, extension = '*.evtx'):\\r\\n if file:\\r\\n return [file]\\r\\n elif folder:\\r\\n return [ y for x in os.walk(folder) for y in glob(os.path.join(x[0], extension))]\\r\\n else:\\r\\n return []\",\n \"def list_phonebooks(path=\\\".\\\"):\\n files = os.listdir(path)\\n for file in files:\\n if file.endswith(EXTENSION):\\n print file\",\n \"def get_files(filedir):\\n inputfiles = sorted(glob.glob(os.path.normcase(filedir+\\\"/\\\")+\\\"*.json\\\"))\\n return inputfiles\",\n \"def view(args):\\n print(\\\"List of all available phonebooks:\\\")\\n for file in glob.glob(\\\"*.ph\\\"):\\n print(file)\",\n \"def boxSearch(client):\\n\\tfiles = []\\n\\titems_iter = client.folder(folder_id=0).get_items(limit=100, offset=0)\\n\\tfor x in items_iter:\\n\\t\\tfiles.append(x)\\n\\treturn files\",\n \"def ls(path, filter=None):\",\n \"def filelisting(directory, suffix = 'tcx'):\\n files = []\\n for f in os.listdir(directory):\\n fullpath = os.path.join(directory, f)\\n if os.path.isfile(fullpath) and f.endswith(suffix):\\n files.append(fullpath)\\n return files\",\n \"def _list_files(folder, pattern):\\n for root, folders, files in os.walk(folder):\\n for filename in files:\\n if fnmatch.fnmatch(filename, pattern):\\n yield os.path.join(root, filename)\",\n \"def _list_files(folder, pattern):\\n for root, folders, files in os.walk(folder):\\n for filename in files:\\n if fnmatch.fnmatch(filename, pattern):\\n yield os.path.join(root, filename)\",\n \"def coffeescript_files():\\r\\n dirs = \\\" \\\".join(THEME_COFFEE_PATHS + [Env.REPO_ROOT / coffee_dir for coffee_dir in COFFEE_DIRS])\\r\\n return cmd('find', dirs, '-type f', '-name \\\\\\\"*.coffee\\\\\\\"')\",\n \"def list_files(directory, suffix='.nc'):\\n nc_files = []\\n\\n dir_files = os.listdir(directory)\\n for filename in dir_files:\\n file_path = os.path.join(directory, filename)\\n if os.path.isdir(file_path):\\n nc_files.extend(list_files(file_path))\\n elif file_path.endswith(suffix):\\n nc_files.append(file_path)\\n\\n return nc_files\",\n \"def ui_backgrounds(request):\\n out = createBaseResponseObject() \\n path = os.path.join(settings.BASE_PATH , \\\"sketch_ui/static/ui/backgrounds\\\")\\n files = os.listdir(path)\\n for f in files:\\n out['results'].append(f)\\n \\n return HttpResponse(json.dumps(out))\",\n \"def get_counselor_json_files(directory):\\n search_path = os.path.join(directory, '*.json')\\n filenames = list(filter(\\n lambda f: re.search(r'/\\\\d{5}.json$', f),\\n glob.glob(search_path)\\n ))\\n\\n if not filenames:\\n raise RuntimeError('no input files found in {}'.format(directory))\\n\\n logger.info('Found %d input files', len(filenames))\\n\\n for filename in filenames:\\n match = re.search(r'/(\\\\d{5}).json$', filename)\\n zipcode = match.group(1)\\n\\n yield zipcode, filename\",\n \"def get_authorization_files_in_directory(directory): # pragma: no cover\\n file_list = [\\n f for f in os.listdir(directory) if os.path.isfile(os.path.join(directory, f))\\n ]\\n file_list_with_full_path = []\\n for file in file_list:\\n if file.endswith(\\\".json\\\"):\\n file_list_with_full_path.append(\\n os.path.abspath(os.path.join(directory, file))\\n )\\n new_file_list = []\\n for file in file_list_with_full_path:\\n with open(file) as f:\\n contents = f.read()\\n account_authorization_details_cfg = json.loads(contents)\\n valid_schema = check_authorization_details_schema(\\n account_authorization_details_cfg\\n )\\n if valid_schema:\\n new_file_list.append(file)\\n return new_file_list\",\n \"def GetFolderISOFiles(Path):\\n ISOFiles = []\\n for file in os.listdir(Path):\\n if file[-3:] == 'iso' or file[-3:] == 'ISO':\\n ISOFiles.append(Path + '/' +file)\\n print(ISOFiles)\\n return ISOFiles\",\n \"def listoffiles(self, path):\\n return os.listdir(path)\",\n \"def list_offline(args):\\n json_file = args.file[0]\\n emojis = load_file(json_file)\\n print_table(emojis)\",\n \"def searchFolder(folderPath, extentions):\\n\\tfiles = []\\n\\tos.chdir(folderPath)\\n\\tfor ext in extentions:\\n\\t\\tfor file in glob.glob(\\\"*.\\\"+ext):\\n\\t\\t\\tfiles.append(os.path.splitext(file)[0])\\n\\treturn files\",\n \"def read_files_to_list(fdir, expression='*.json'):\\n filelist = []\\n for file in glob.glob(path.join(fdir, expression)):\\n filelist.append(file)\\n return filelist\",\n \"def readPlayerImageFiles(self):\\n currentPath = os.path.dirname(os.path.abspath(__file__))\\n listOfFileNames=[]\\n for i in os.listdir(currentPath):\\n if re.match(\\\"player\\\\_\\\\d+\\\",i): #i.endswith(\\\".gif\\\")\\n listOfFileNames.append(currentPath+'/'+i)\\n return listOfFileNames\",\n \"def get_samples_file(foldername, filter=None):\\n samples = []\\n for file in os.listdir(foldername):\\n if filter and file.find(filter) == -1:\\n continue\\n for sample in sfile(foldername + '/' + file, None).get_samples():\\n samples.append(sample)\\n return samples\",\n \"def get_nifty_list(root_dir, name=\\\"\\\"):\\n \\n file_list = glob(root_dir + \\\"/**/*.nii.gz\\\", recursive=True)\\n file_list = sorted([file for file in file_list if name in file])\\n return file_list\",\n \"def sel_files(dpath):\\n sel_files = []\\n for root, _, files in os.walk(dpath):\\n for fname in files:\\n if not fname.endswith('.json'): # skip non-json files\\n continue\\n fpath = os.path.join(root, fname)\\n sel_files.append(fpath)\\n return sel_files\",\n \"def scan_directories(data_dir, file_filter):\\n\\n root = os.walk(data_dir)\\n\\n print('Scanning for files...')\\n output = []\\n\\n for directory in root:\\n\\n files = directory[2]\\n\\n # Valid dataset contains video files of both halves and an accompanying label\\n if file_filter(files):\\n output.append(directory[0])\\n\\n print('Done')\\n\\n return output\",\n \"def list_type_in_dir(path, extension):\\n path, extension = check_args(path, extension)\\n files = os.listdir(path)\\n file_list = [os.path.join(path, f)\\n for f in fnmatch.filter(files, '*' + extension)]\\n\\n return file_list\",\n \"def find_files(path: str) -> List[str]:\\n files = sorted(list(glob.glob(os.path.join(path, \\\"*.wav\\\"))))\\n\\n print(\\\"files: %d files found\\\" % len(files))\\n return files\",\n \"def getimagelist(folder):\\n imagefolder = Path(folder) \\n imagelist = imagefolder.glob(\\\"**/*.png\\\") \\n return list(imagelist)\",\n \"def cached_files():\\n for (dir_path, _dir_names, file_names) in os.walk(CACHE):\\n for file_name in file_names:\\n if is_json_file(file_name):\\n yield os.path.join(dir_path, file_name)\",\n \"def get_file_list(folder):\\n\\tfilelist = []\\n\\tfor file in os.listdir(folder):\\n\\t\\tif file.endswith('.png'):\\n\\t\\t\\tfilelist.append(file)\\n\\treturn filelist\",\n \"def scan_fixtures(path):\\n results = list()\\n for root, dirs, files in os.walk(path):\\n relative_path = root.replace(path + \\\"/\\\", \\\"\\\")\\n if relative_path.startswith(\\\"static\\\") or relative_path.startswith(\\\"theme\\\"):\\n continue\\n\\n for f in files:\\n if not f.endswith(\\\".json\\\"):\\n continue\\n\\n app_name = os.path.basename(os.path.dirname(relative_path))\\n\\n results.append((app_name, f, relative_path))\\n\\n return results\",\n \"def files_in_folder(folder):\\n files = []\\n for f in glob.glob(folder):\\n if os.path.isdir(f):\\n files.extend(files_in_folder(f + os.sep + \\\"**\\\"))\\n else:\\n files.append(f)\\n return files\",\n \"def get_all_files(path, valid_suffix):\\n files = []\\n for suffix in valid_suffix:\\n files.extend(glob.glob(path + \\\"*/**/*\\\" + suffix, recursive=True))\\n return files\",\n \"def _read_directory(self):\\n self._filenames = glob.glob(self._directory + \\\"/*.project\\\")\",\n \"def process_files(file_location, day):\\n # construct file path\\n file_dir = PREFIX+file_location\\n file_pattern = file_dir+'lz_'+day+'*_raw.root'\\n # print(file_pattern)\\n file_list = glob.glob(file_pattern)\\n print(\\\"There are %s MC files in the requested directory (%s).\\\" %(len(file_list), file_dir))\\n file_names = []\\n for f in file_list:\\n file_name_only = f.split('/')\\n file_names.append(file_name_only[-1])\\n return file_names\",\n \"def scan_dir(self, directory=\\\".\\\"):\\n for root, dirs, files in os.walk(directory, topdown=False):\\n for name in files:\\n for filetype in self.allowed_file_types:\\n if name.split(\\\".\\\")[-1] == filetype:\\n self.song_list.append(os.path.join(root, name))\",\n \"def read_all_files():\\n paths = get_all_recording_paths()\\n\\n return read_by_paths(paths)\",\n \"def ListFolder(self, path): # real signature unknown; restored from __doc__\\n pass\",\n \"def find_files(folder, max_title, filename_contains='', filename_extension=''):\\n\\n info = f'Checking {os.path.basename(folder)} folder for configuration files'\\n print(info, end =\\\" \\\") \\n\\n # check if ssave_path folder exist\\n check_valid_path(folder)\\n \\n # list to save configuration data files\\n files_lst = []\\n\\n # going through all directories inside folder to find configuration data\\n for root, _, files in os.walk(folder):\\n for file in files:\\n # filename contains filename_contains atr but not hidden file\\n if re.search(filename_contains, file) and not re.search('^~\\\\$.+', file):\\n file_path = os.path.normpath(os.path.join(root, file))\\n if filename_extension and file.endswith(filename_extension):\\n files_lst.append(file_path)\\n # when file extension flag is None and file name doesn't contain extension (.7zip, .exe, .log, .3g2)\\n elif filename_extension is None and not re.search('.+\\\\.(\\\\d)?[A-Za-z]+(\\\\d)?$', file):\\n files_lst.append(file_path)\\n elif filename_extension=='':\\n files_lst.append(file_path)\\n\\n\\n if len(files_lst) == 0:\\n status_info('no data', max_title, len(info))\\n else:\\n status_info('ok', max_title, len(info)) \\n return files_lst\",\n \"def get_all_metrics(dir):\\r\\n file_lst = os.listdir(dir)\\r\\n file_lst = list(filter(lambda x: re.findall(r'\\\\.csv$',x), file_lst))\\r\\n return file_lst\",\n \"def list_file(self, path: str) -> List[FileName]:\\n current_file = self.file_exists(path)\\n if current_file is None:\\n raise FileNotExistException(\\n \\\"Path doesn't exist. Can't list non-existent path\\\"\\n )\\n if current_file.file_type != GOOGLE_FOLDER_TYPE:\\n raise NotAFolderException(\\\"file_nod has to be a folder to list contents\\\")\\n if current_file.children is None:\\n raise NotAFolderException(\\\"file_nod has to be a folder to list contents\\\")\\n if len(current_file.children) == 0:\\n return []\\n return [\\n child_file.file_name for child_file in list(current_file.children.values())\\n ]\",\n \"def find_files(directory, pattern='**/*.wav'):\\n return glob(os.path.join(directory, pattern), recursive=True)\",\n \"def ReadRecipesFromDirectory(self, path: str) -> None:\\n for file_path in glob.glob(os.path.join(path, '*.json')):\\n self.ReadRecipeFromFile(file_path)\",\n \"def list_directory(path):\\n files = []\\n for f in listdir(path):\\n if isfile(join(path, f)) and f.endswith('.mp3'):\\n files.append(f)\\n return files\",\n \"def get_files_to_be_indexed(self):\\n\\t\\tfiles = self.get_all_files()\\n\\t\\tfiles_list = []\\n\\t\\tfor name in files:\\n\\t\\t\\tif(name.split('.')[-1] in self.accepted_formats and os.stat(os.path.join(self.root, name)).st_size < 5000000):\\n\\t\\t\\t\\tfiles_list.append(os.path.join(self.root, name))\\n\\t\\treturn files_list[0:-1]\",\n \"def collect_files(path, audio_files):\\n\\n for entry in os.scandir(path):\\n if entry.is_dir():\\n collect_files(entry.path, audio_files)\\n if entry.is_file() and (entry.path.endswith(\\\".flac\\\") or entry.path.endswith(\\\".wav\\\")):\\n audio_files.append(entry.path)\",\n \"def filterAll(media_list_file, in_movie_dir, out_movie_dir):\\n with open(media_list_file) as f:\\n names = json.load(f)\\n\\n count_tweets = []\\n count_kept_tweets = []\\n for name in names:\\n with open(\\\"{}/{}.json\\\".format(in_movie_dir, name)) as f:\\n tweets = json.load(f)\\n kept_tweets = [t for t in tweets.values() if keep(t)]\\n print(\\\"total = {}\\\\tkeep = {}\\\\tName = {}\\\".format(\\n len(tweets), len(kept_tweets), name))\\n count_tweets.append(len(tweets))\\n count_kept_tweets.append(len(kept_tweets))\\n with open(\\\"{}/{}.json\\\".format(out_movie_dir, name), \\\"w\\\") as f:\\n json.dump(kept_tweets, f)\\n print(\\\"Mean tweets = {}\\\".format(np.mean(count_tweets)))\\n print(\\\"Mean kept tweets = {}\\\".format(np.mean(count_kept_tweets)))\\n print(\\\"Mean fraction kept tweets = {}\\\".format(\\n np.mean(count_kept_tweets) / np.mean(count_tweets)))\",\n \"def _listfiles(dirname):\\n for root, dirs, files in os.walk(dirname):\\n fkey = os.path.basename(root)\\n f = []\\n for name in files:\\n key = os.path.splitext(name)[0]\\n listfilters[key] = os.path.join(root, name)\\n f.append(key)\\n if f:\\n showfilters[fkey] = f\",\n \"def list_files(folder, number_of_files=None):\\n paths = glob.glob(folder + \\\"/*.gz\\\")\\n\\n if number_of_files is None:\\n return paths\\n else:\\n return paths[:number_of_files]\",\n \"def detectFiles(self, input):\\n output = []\\n if os.path.isfile(input):\\n output.append(input)\\n else:\\n input = os.path.join(input, '*') if os.path.isdir(input) else input\\n for file in glob.glob(input):\\n output.append(file)\\n return output\",\n \"def get_bibfiles(folder: str) -> t.List[str]:\\n full_pathname = os.path.normpath(os.path.abspath(folder))\\n bib_files = []\\n for f in os.listdir(full_pathname):\\n fullname = os.path.join(full_pathname, f)\\n if f.endswith(\\\".bib\\\") and os.path.isfile(fullname):\\n logging.debug(f'get bibfile \\\"{f}\\\" from directory \\\"{full_pathname}\\\"')\\n bib_files.append(fullname)\\n return bib_files\",\n \"def get_list_of_files_in_folder(\\n self, folder_name: str, limit: int = 1\\n ) -> List[str]:\\n\\n files = []\\n if os.path.isdir(folder_name):\\n # Get list of only html files from folder:\\n files = [file for file in os.listdir(folder_name) if file.endswith(\\\".html\\\")]\\n\\n if len(files) < limit: # short dialogs\\n return []\\n\\n # Descending sort to consider message order:\\n files = sorted(\\n files,\\n key=lambda x: int(re.search(r\\\"messages(\\\\d+)\\\\.html\\\", x).group(1)),\\n reverse=True,\\n )\\n else:\\n print(f\\\"No such directory: {folder_name}\\\")\\n return files\",\n \"def get_card_files(card_dir: str = \\\"./cards\\\") -> List[Path]:\\n p: Path = Path(card_dir)\\n return list(p.glob('**/*.yaml'))\",\n \"def list(self):\\n objectpath = os.path.join(self.rootpath, self.OBJECTPATH)\\n for root, dirs, files in os.walk(objectpath, topdown=False):\\n for name in files:\\n print(os.path.join(root, name))\",\n \"def listFiles(self):\\n current_month = NoaaCycle.last_month()\\n # 2do archive contain extra path: data/noaa/metar/2011-* ; better is 2011-*\\n dir_regex = os.path.join(self.download_dir, \\\"%s-*\\\" % current_month)\\n self.archive_name = os.path.join(self.download_dir, current_month)\\n return glob.glob(dir_regex)\",\n \"def get_paths(input_folder: str) -> list[str]:\\n\\n return [f for f in os.listdir(input_folder) if f[-4:] == '.txt' and f[:3] != 'top']\",\n \"def main():\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"folder\\\")\\n args = parser.parse_args()\\n \\n print(\\\"\\\")\\n print(\\\"Smart Listing:\\\", args.folder.replace(\\\"/\\\", \\\" >\\\"))\\n print(\\\"\\\")\\n for seq, frange in parsefilenames(os.listdir(args.folder)):\\n print(len(frange), seq, frange)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66877824","0.60839224","0.5914875","0.5865345","0.5820445","0.58006823","0.5798163","0.5783536","0.5780574","0.57754827","0.5738916","0.5717606","0.5713355","0.56997764","0.5660107","0.56417465","0.5632708","0.56137383","0.5609525","0.55692714","0.5567126","0.5533458","0.5533408","0.5528626","0.55161154","0.5513673","0.5506482","0.5489303","0.54867125","0.5484834","0.548242","0.54811954","0.5435431","0.54229957","0.5418196","0.54132414","0.5406518","0.53742754","0.5369675","0.53643215","0.5357356","0.53486466","0.5340245","0.5339698","0.53391564","0.5330479","0.5327579","0.5322187","0.5321568","0.53174007","0.531069","0.5306024","0.5306024","0.5286194","0.52852637","0.5281248","0.5276332","0.52730954","0.52508724","0.5247736","0.524429","0.5238882","0.52360666","0.52352494","0.5235192","0.5216972","0.5216466","0.52056926","0.5204863","0.52030104","0.5194949","0.51933515","0.5193342","0.5187041","0.51867056","0.51826394","0.5161834","0.51537216","0.51535875","0.5148624","0.51432693","0.5139555","0.5126479","0.51243794","0.5120903","0.51199996","0.51175046","0.5110943","0.51103514","0.51076776","0.5105731","0.510376","0.5102827","0.5098096","0.50967056","0.5095885","0.5095657","0.5094171","0.5089996","0.5087442"],"string":"[\n \"0.66877824\",\n \"0.60839224\",\n \"0.5914875\",\n \"0.5865345\",\n \"0.5820445\",\n \"0.58006823\",\n \"0.5798163\",\n \"0.5783536\",\n \"0.5780574\",\n \"0.57754827\",\n \"0.5738916\",\n \"0.5717606\",\n \"0.5713355\",\n \"0.56997764\",\n \"0.5660107\",\n \"0.56417465\",\n \"0.5632708\",\n \"0.56137383\",\n \"0.5609525\",\n \"0.55692714\",\n \"0.5567126\",\n \"0.5533458\",\n \"0.5533408\",\n \"0.5528626\",\n \"0.55161154\",\n \"0.5513673\",\n \"0.5506482\",\n \"0.5489303\",\n \"0.54867125\",\n \"0.5484834\",\n \"0.548242\",\n \"0.54811954\",\n \"0.5435431\",\n \"0.54229957\",\n \"0.5418196\",\n \"0.54132414\",\n \"0.5406518\",\n \"0.53742754\",\n \"0.5369675\",\n \"0.53643215\",\n \"0.5357356\",\n \"0.53486466\",\n \"0.5340245\",\n \"0.5339698\",\n \"0.53391564\",\n \"0.5330479\",\n \"0.5327579\",\n \"0.5322187\",\n \"0.5321568\",\n \"0.53174007\",\n \"0.531069\",\n \"0.5306024\",\n \"0.5306024\",\n \"0.5286194\",\n \"0.52852637\",\n \"0.5281248\",\n \"0.5276332\",\n \"0.52730954\",\n \"0.52508724\",\n \"0.5247736\",\n \"0.524429\",\n \"0.5238882\",\n \"0.52360666\",\n \"0.52352494\",\n \"0.5235192\",\n \"0.5216972\",\n \"0.5216466\",\n \"0.52056926\",\n \"0.5204863\",\n \"0.52030104\",\n \"0.5194949\",\n \"0.51933515\",\n \"0.5193342\",\n \"0.5187041\",\n \"0.51867056\",\n \"0.51826394\",\n \"0.5161834\",\n \"0.51537216\",\n \"0.51535875\",\n \"0.5148624\",\n \"0.51432693\",\n \"0.5139555\",\n \"0.5126479\",\n \"0.51243794\",\n \"0.5120903\",\n \"0.51199996\",\n \"0.51175046\",\n \"0.5110943\",\n \"0.51103514\",\n \"0.51076776\",\n \"0.5105731\",\n \"0.510376\",\n \"0.5102827\",\n \"0.5098096\",\n \"0.50967056\",\n \"0.5095885\",\n \"0.5095657\",\n \"0.5094171\",\n \"0.5089996\",\n \"0.5087442\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7092136"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85177,"cells":{"query":{"kind":"string","value":"To handle exceptions. Some .jsons may not have the same keys."},"document":{"kind":"string","value":"def _get_clipping_value(clipping, key):\n\tif key in clipping:\n\t\treturn clipping[key]\n\treturn \"N/A\""},"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 assert_json_failure_response_is_username_collision(self, response):\r\n self.assertEqual(400, response.status_code)\r\n payload = json.loads(response.content)\r\n self.assertFalse(payload.get('success'))\r\n self.assertIn('already exists', payload.get('value'))","def check_repeated_keys(text,verbose=False):\n\textra_msg = \"either fix the repeated keys or check for JSON problems.\"\n\ttext_json = jsonify(text)\n\ttry: _ = json.loads(text_json,object_pairs_hook=SafeDictHook)\n\texcept Exception as e: \n\t\t# if we get a type error we are probably on python < 2.7\n\t\t# ... where json lacks the hook so we just give a warning and pass\n\t\tif type(e)==TypeError:\n\t\t\tprint('warning','JSON encountered a type error which suggests an old version '\n\t\t\t\t'(possibly python 2.6) so we will pass. beware repeated keys or downstream '\n\t\t\t\t'dictionary errors')\n\t\t\treturn True\n\t\tprint('error','found repeated keys (or JSON encoding error). '+extra_msg)\n\t\tif verbose: \n\t\t\ttext_with_linenos = '\\n'.join(['[DEBUG]%s|%s'%(str(ll).rjust(4),l) \n\t\t\t\tfor ll,l in enumerate(text_json.splitlines())])\n\t\t\tprint('warning','the following string has a JSON problem:\\n'+text_with_linenos)\n\t\t\tprint('exception','exception is %s'%e)\n\t\t\tprint('note',controlmsg['json'])\n\t\treturn False\n\treturn True","def test_dict_keys_duplicate(self):\n assert (\n orjson.dumps({\"1\": True, 1: False}, option=orjson.OPT_NON_STR_KEYS)\n == b'{\"1\":true,\"1\":false}'\n )","def item6():\n try:\n # Do something\n pass\n except:\n # Handle exception\n pass\n else:\n # Runs when there are no exceptions\n pass\n finally:\n # Always runs after try\n pass\n\n handle = open('random_data.txt', 'w', encoding='utf-8')\n handle.write('success\\nand\\nnew\\nlines')\n handle.close()\n\n '''\n handle2 = open('random_data4.txt') # Raise IOError\n \n try:\n data = handle2.read() # Raise UnicodeDecodeError\n finally:\n handle2.close()\n '''\n\n import json\n\n def load_json_key(data, key):\n try:\n result_dict = json.loads(data) # Raise ValueError\n except ValueError as e:\n raise KeyError from e\n else:\n return result_dict[key] # Raise KeyError\n\n try:\n load_json_key('{\"foo\": bad payload', 'foo')\n except KeyError:\n print('Saw KeyError')\n\n try:\n load_json_key('{\"foo\": \"bar\"}', 'stuff')\n except KeyError:\n print('Saw KeyError')\n\n print(load_json_key('{\"foo\": \"bar\"}', 'foo'))\n\n def divide_json(path):\n handle = open(path, 'r+') # IOError\n try:\n data = handle.read() # UnicodeDecodeError\n op = json.loads(data) # ValueError\n value = op['numerator'] / op['denominator'] # ZeroDivisionError\n except ZeroDivisionError:\n return None\n else:\n op['result'] = value\n result = json.dumps(op)\n handle.seek(0)\n handle.write(result) # IOError\n return value\n finally:\n handle.close() # Always runs\n\n temp_path = 'random_data.json'\n with open(temp_path, 'w') as handle:\n handle.write('{\"numerator\": 1, \"denominator\": 10}')\n\n print(divide_json(temp_path))","def _CheckJson(input_api, output_api):\n for affected_file in input_api.AffectedFiles(include_deletes=False):\n filename = affected_file.AbsoluteLocalPath()\n if os.path.splitext(filename)[1] != '.json':\n continue\n try:\n input_api.json.load(open(filename))\n except ValueError:\n return [output_api.PresubmitError('Error parsing JSON in %s!' % filename)]\n return []","def handle_missing_objects(exc):\n return jsonify(dict(\n message=str(exc)\n )), exc.code","def test_detect_duplicate_upload_items(duplicate_items: List[JSONDict]) -> None:\n\n with pytest.raises(ValidationError) as e:\n invalid_collection = UploadCollection(items=duplicate_items) # noqa: F841\n\n assert e.value.errors() == [\n {\n \"loc\": (\"items\",),\n \"msg\": \"Duplicate item guids detected: ['http://www.crimsonhexagon.com/post1']\",\n \"type\": \"value_error\",\n }\n ]","def test_tap_config_json_validation_retry_with_invalid_config_and_then_fix(self):\n self._assert_retry_validation_of_json_file(config=self.invalid_json_file,\n properties=self.valid_json_file,\n state=self.valid_json_file)","def test_read_json(self, magic_0, magic_1):\n expected = {\n 'key_1': [1, 2, 3, 4, 5],\n 'key_2': ['a', 'b', 'c', 'd', 'e']\n }\n result = helpers.read_json(r\"path\")\n self.assertEqual(expected, result)","def _check_errors(self, json_loaded):\n\n content = json_loaded\n try:\n m = content[u'error'][u'message']\n c = content[u'error'][u'code']\n out= \"API Error code: {}\\nError message: {}\".format(c, m)\n raise InvalidQueryException(self.name, out)\n except KeyError:\n pass","def test_tap_config_json_validation_retry_with_invalid_properties_and_then_fix(self):\n self._assert_retry_validation_of_json_file(config=self.valid_json_file,\n properties=self.invalid_json_file,\n state=self.valid_json_file)","def test_jfpv1_json_load_error(self):\n with self.assertRaises(JSONLoad):\n create('{\"foo\": bar}', hash_function=hash_functions.SHA256, version=1)","def _import(self, data):\n if isinstance(data, dict):\n if len(data):\n for key in data:\n if data.get(key) is not None:\n if not self.set(key, data.get(key)):\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))","def test_badFormat(self):\n with open(os.path.join(self.directory, \"service2.json\"), \"w\") as f:\n f.write(\"this is not json\")\n self.pump()\n self.assertNodesEqual(knownNodes(self.disco, \"service2\", \"staging\"), [])","def test_load_unsupported_type(self):\n expected = {\n \"name\": \"Kevin\",\n \"age\": 21,\n \"pet\": {\n \"name\": \"Trippy Jack\",\n \"age\": 20762,\n \"__type__\": \"hyperdimensional.hamster\"\n }\n }\n with open('tests/unsupported_type.json', 'r') as json_file:\n self.assertEqual(expected, morejson.load(json_file))","def validate_json(self):\n pass","def invalid_item(upload_items: List[JSONDict]) -> JSONDict:\n altered = upload_items[0]\n altered[\"language\"] = \"engl\"\n altered[\"date\"] = \"02-2031-01\"\n altered[\"url\"] = \"incorrect.com\"\n return altered","def test_schema_invalid_json(self):\n schema_0_input = schema_nested_2_invalid_JSON\n\n # if you uncomment this line:\n # schema_0_input = schema_nested_2\n # this will fail the test: Failed: DID NOT RAISE <class 'simplejson.scanner.JSONDecodeError'>\n # because this is a valid schema\n\n with pytest.raises(simplejson.scanner.JSONDecodeError):\n msg = singer.parse_message(schema_0_input)","def test_get_json_data_throw_not_found_error(self):\n response = self.app.test_client().get('/test/get_json_data/99999')\n self.assertEqual(response.json['status'], 'failure')\n self.assertEqual(response.json['error'], 'Test not found')","def test_tap_config_json_validation_retry_with_invalid_state_and_then_fix(self):\n self._assert_retry_validation_of_json_file(config=self.valid_json_file,\n properties=self.valid_json_file,\n state=self.invalid_json_file)","def assertJSONError(self, response, exception):\n # first of all, try to find the exception\n full_exception_name = exception + 'Exception'\n exception_cls = getattr(exceptions, full_exception_name)\n self.assertStatus(response, exception_cls.status)\n\n expected = {'code': exception,\n 'message': exception_cls.message}\n self.assertJSON(response, expected)\n return","def merge_multiple_json(path):\n import glob\n\n result = {}\n file_names = glob.glob(path + '/*.json')\n\n for file_name in file_names:\n with open(file_name,'r') as f:\n data = json.load(f)\n if type(data) is dict: result[file_name.replace('.json','')] = data\n else: print 'fake_data in %s is invalid, pls check !!!' % file_name\n\n return result","def test_loads_a_non_object_json_file(self):\n from test.resources import simple_json\n self.assertEqual(simple_json._data, 'test')","def test_restore_with_invalid_bucket_config_json(self):\n gen = BlobGenerator(\"ent-backup_1\", \"ent-backup-\", self.value_size, end=self.num_items)\n self._load_all_buckets(self.master, gen, \"create\", 0)\n self.backup_create()\n self._take_n_backups(n=self.backupset.number_of_backups)\n status, output, message = self.backup_list()\n error_msg = \"Error merging data: Unable to read bucket settings because bucket-config.json is corrupt\"\n if not status:\n self.fail(message)\n backup_count = 0\n for line in output:\n if re.search(\"\\d{4}-\\d{2}-\\d{2}T\\d{2}_\\d{2}_\\d{2}.\\d+-\\d{2}_\\d{2}\", line):\n backup_name = re.search(\"\\d{4}-\\d{2}-\\d{2}T\\d{2}_\\d{2}_\\d{2}.\\d+-\\d{2}_\\d{2}\",\n line).group()\n if backup_name in self.backups:\n backup_count += 1\n self.log.info(\"{0} matched in list command output\".format(backup_name))\n backup_bucket_config_path = self.backupset.directory + \"/backup\" + \\\n \"/\" + self.backups[self.backupset.number_of_backups - 1] + \\\n \"/\" + self.buckets[0].name + \"-*\" \\\n \"/bucket-config.json\"\n remote_client = RemoteMachineShellConnection(self.backupset.backup_host)\n self.log.info(\"Remove } in bucket-config.json to make it invalid json \")\n remote_client.execute_command(\"sed -i 's/}//' %s \" % backup_bucket_config_path)\n self.log.info(\"Start to merge backup\")\n self.backupset.start = randrange(1, self.backupset.number_of_backups)\n self.backupset.end = randrange(self.backupset.start + 1,\n self.backupset.number_of_backups + 1)\n result, output, _ = self.backup_merge()\n if result:\n self.log.info(\"Here is the output from command %s \" % output[0])\n if not self._check_output(error_msg, output):\n self.fail(\"read bucket config should fail since bucket-config.json is invalid\")\n remote_client.disconnect()","def test_lti20_bad_json(self):\r\n for error_inputs, error_message in self.BAD_JSON_INPUTS:\r\n for einput in error_inputs:\r\n with self.assertRaisesRegexp(LTIError, error_message):\r\n self.xmodule.parse_lti_2_0_result_json(einput)","def test_circular_dict(self):\n obj = {}\n obj[\"obj\"] = obj\n with self.assertRaises(orjson.JSONEncodeError):\n orjson.dumps(obj)","def check_json_file(file_name: str, excel_file: str, sheet_name: str) -> list:\n try:\n with open(file_name) as json_file:\n data = json.load(json_file)\n return data\n except FileNotFoundError:\n period_index = excel_file.index(\".\")\n json_file_name = excel_file[:period_index] + \".json\"\n write_json_file(json_file_name, convert_excel_file(excel_file, sheet_name))\n return check_json_file(file_name, excel_file, sheet_name)","def validate_json() -> bool:\n with Path(ROOT_DIR, \"seals\", \"seals.json\").open() as f:\n seals = json.load(f)\n\n seals_in_json = [k for k, v in seals.items() if v[\"has_seal\"]]\n\n seals = [\n x.split(\"/\")[-1][:-4] for x in glob.glob(f\"{ROOT_DIR}/seals/orig/*\")\n ]\n missing_seals = sorted(list(set(seals_in_json) ^ set(seals)))\n if not missing_seals:\n return True\n\n raise Exception(f\"Missing entry for: {' '.join(missing_seals)}\")","def test_throws_item_missing_key(self):\n with pytest.raises(marshmallow.ValidationError):\n Item.Schema().loads(json.dumps(item_missing_key))","def compare_json(js1, js2):\n return js1.items() <= js2.items()","def test_conflict(self):\n self._error_test(fitbit_exceptions.HTTPConflict)","def test_load_json_file_not_found_error() -> None:\n fname = \"invalid_file.json\"\n\n assert load_json(fname) == {}\n assert load_json(fname, default=\"\") == \"\"\n assert load_json_object(fname) == {}\n assert load_json_object(fname, default={\"Hi\": \"Peter\"}) == {\"Hi\": \"Peter\"}\n assert load_json_array(fname) == []\n assert load_json_array(fname, default=[\"Hi\"]) == [\"Hi\"]","def handle_missing_duplicate_headers(self, expected_fields, bucket_name, error_filename):\n missing_headers = [cell for cell, count in expected_fields.items() if count == 0]\n duplicated_headers = [cell for cell, count in expected_fields.items() if count > 1]\n\n if missing_headers or duplicated_headers:\n self.write_missing_duplicated_headers(\n missing_headers, duplicated_headers, bucket_name,\n error_filename\n )\n raise_missing_duplicated_exception(missing_headers, duplicated_headers)","def test_deserialization_error():\n\n tree = MerkleTree()\n\n with pytest.raises(json.JSONDecodeError):\n tree.encryptObjectFromFile(\n os.path.join(os.path.dirname(__file__),\n 'objects/bad.json')\n )","def test_save_method(self):\n prev_all_objs = storage.all()\n\n obj = BaseModel()\n key = \"{}.{}\".format(type(obj).__name__, obj.id)\n\n self.assertIn(key, prev_all_objs.keys())\n try:\n\n with open('file.json', mode='r', encoding='utf-8') as file:\n dict_loaded = json.load(file)\n\n self.assertIs(type(dict_loaded), dict)\n self.assertNotIn(key, dict_loaded.keys())\n\n storage.save()\n except FileNotFoundError:\n pass\n try:\n\n with open('file.json', mode='r', encoding='utf-8') as file:\n dict_loaded = json.load(file)\n\n self.assertIs(type(dict_loaded), dict)\n self.assertIn(key, dict_loaded.keys())\n except FileNotFoundError:\n pass","def test_save_json_with_invalid_step(temp_dir):\n data = json.dumps({\"k\": \"v\", \"list\": [1, 2, 3]})\n\n with pytest.raises(ValueError):\n save_json(temp_dir, data, step={\"invalid\": \"dict\"})","def test_json_exceptions(self, error, input_file_path: str, msg: str):\n with pytest.raises(error) as context:\n with open(attach_path(input_file_path), 'r') as input_file:\n str(read_json(input_file.read()))\n assert str(context.value) == msg","def test_get_users_from_invalid_json():\n with pytest.raises(ValueError):\n Users.from_json(file_path='{0}/json_input/invalid.json'.format(os.path.dirname(os.path.abspath(__file__))))","def test_valid_json():\n invalid_json = False\n for filename in os.listdir(\"../networking\"):\n if filename.endswith(\".cfn.json\"):\n print(\"Validating json file: %s\" % filename)\n with open(f\"../networking/{filename}\", encoding=\"utf-8\") as f:\n try:\n json.load(f)\n print(\"SUCCESS: Valid json.\")\n except ValueError as e:\n print(\"ERROR: Invalid json: %s\" % e)\n invalid_json = True\n\n assert not invalid_json","def test_invalid_data(self):\n\n json_data = {\n \"input\" : {\n 'version': 'BAD',\n 'files': {'input_a': [self.source_file.id]},\n 'json': {}\n },\n \"job_type_id\" : self.job_type1.pk,\n \"configuration\" : self.configuration\n }\n\n url = '/%s/jobs/' % self.api\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.content)","def test_response_json(self):\n response = self.client.search()\n self.assertTrue(isinstance(response.json, dict))\n\n\n # with invalid json\n from rubber import settings\n settings.RUBBER_MOCK_HTTP_RESPONSE = \"\"\";;;\"\"\"\n \n response = self.client.search()\n self.assertIsNone(response.json)","def test_json(self):\n\n cases_dir = pathlib.Path(__file__).parent / 'cases'\n\n asn_strs = {\n asn_path.stem: asn_path.read_text()\n for asn_path in cases_dir.glob('*.asn')\n }\n json_strs = {\n json_path.stem: json_path.read_text()\n for json_path in cases_dir.glob('*.json')\n }\n\n assert set(asn_strs.keys()) == set(json_strs.keys())\n assert len(asn_strs) > 0\n\n for key in asn_strs:\n with self.subTest(key=key):\n res_json = asn1vnparser.parse_asn1_value_assignment(\n asn_strs[key], as_json=True)\n res_py = json.loads(res_json)\n self.maxDiff = None\n self.assertEqual(res_py, json.loads(json_strs[key]))","def test_load_from_file_to_dict_key_length(self):\n self.assertEqual(len(self.loaded_json_dict), 3)","def test_json_error(self):\n with self.assertRaises(AttributeError):\n FileStorage.__objects\n FileStorage.__File_Path","def test_dictionary(self):\n self.assertIsInstance(self.test1json, dict)","def test_target_config_raises_exception_if_not_valid_json_after_retries(self):\n invalid_file_contents = ['', 'foo', '{\"foo\": 1']\n\n for invalid_content in invalid_file_contents:\n with open(self.invalid_json_file, 'w', encoding='utf-8') as invalid_file:\n invalid_file.write(invalid_content)\n\n with self.assertRaises(commands.RunCommandException) as command_exception:\n self._assert_target_config(config=self.invalid_json_file)\n\n self.assertEqual(f'Invalid json file for config: {self.invalid_json_file}',\n str(command_exception.exception))","def test_invalid_json_batch(self):\n req = '[{\"jsonrpc\": \"2.0\", \"method\": \"sum\", \"params\": [1,2,4], \"id\": \"1\"},{\"jsonrpc\": \"2.0\", \"method\"]'\n resp = '{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"ParseError: Parse error\"}, \"id\": null}'\n status = 500\n r_status, r_resp = self.exec_handler(req)\n self.assertEqual(r_status, status)\n self.assertEqual(simplejson.loads(r_resp), simplejson.loads(resp))","def test_duplicated_entries() -> None:\n r4.from_raw('{\"resourceType\":\"DomainResource\"}')\n with pytest.raises(pydantic.ValidationError):\n r4.from_raw(\n '{\"resourceType\":\"DomainResource\", \"resourceType\":\"DomainResource\"}'\n )","def test_data_parse_invalid_json(self):\n lines = ['{\"a\": \"val\" \"b\": \"val2\"}']\n self.assertRaises(TypeError, parser._parse_data, lines)","def test_validate_file_extension_json(self):\n data_locations = open(self.test_dir + 'mannheim_short.json',\n encoding='utf-8')\n data_locations_false = open(self.test_dir + 'contacts.csv',\n encoding='utf-8')\n a = validate_file_extension_json(data_locations)\n self.assertEqual(a, None)\n with self.assertRaises(ValidationError) as context:\n validate_file_extension_json(data_locations_false)\n data_locations.close()\n data_locations_false.close()\n self.assertTrue(\"Kein gültiges JSON-File\" or \"No valid JSON file\" in\n str(context.exception))","def test_request_err_json(self, method, m_requests):\n # Dummies for K8s API URL and `requests` session.\n url = 'http://examples.com/'\n client = k8s.requests.Session()\n\n # Construct a response with a corrupt JSON string.\n corrupt_json = \"{this is not valid] json;\"\n m_requests.request(\n method,\n url,\n text=corrupt_json,\n status_code=200,\n )\n\n # Test function must not return a response but indicate an error.\n ret = k8s.request(client, method, url, None, None)\n assert ret == ({}, True)","def test_composite_1():\n datadir, _ = os.path.split(__file__)\n datapath = os.path.join(datadir, 'testdata', 'data1.json')\n with open(datapath) as f:\n rawjson = f.read()\n data_i = json.loads(rawjson, object_pairs_hook=Item)\n data_o = json.loads(rawjson, object_pairs_hook=OrderedDict)\n for x, y in zip(data_i, data_o):\n assert list(x.keys()) == list(y.keys())\n assert list(x.values()) == list(y.values())","def test_detect_duplicate_train_items(duplicate_train_items: List[JSONDict]) -> None:\n\n with pytest.raises(ValidationError) as e:\n invalid_collection = TrainCollection(items=duplicate_train_items) # noqa: F841\n\n assert e.value.errors() == [\n {\n \"loc\": (\"items\",),\n \"msg\": \"Duplicate item urls detected: ['http://www.crimsonhexagon.com/post1']\",\n \"type\": \"value_error\",\n }\n ]","def test_json(self, input_file_path: str, answer_file_path: List[Dict]):\n with open(attach_path(input_file_path), 'r') as input_file:\n with open(attach_path(answer_file_path), 'r') as answer_file:\n assert str(read_json(input_file.read().strip())) == answer_file.read().strip()","def _check_json(json_data: Any, clean: bool) -> Any:\n try:\n json.loads(json_data)\n except ValueError:\n return \"unknown\" if clean else False\n return \"success\" if clean else True","def test_to_json_file_non_dict(self):\n\n output_file = \"this_file_is_a_ghost\"\n File(output_file).delete()\n\n self.assertRaises(TypeError, lambda: Dict(1).to_json_file(output_file))\n self.assertRaises(TypeError, lambda: Dict(\"100\").to_json_file(output_file))\n self.assertRaises(\n TypeError, lambda: Dict(\"{'hello': 'world'}\").to_json_file(output_file)\n )\n\n File(output_file).delete()","def test_verifies_token_file_contains_json(self):\n\n with open(self.sample_token_file, 'w',\n encoding=\"utf8\", errors=\"surrogateescape\") as stf_h:\n stf_h.write(\"Bad JSON\")\n\n with self.assertRaises(json.decoder.JSONDecodeError):\n badgr = BadgrLite(token_filename=self.sample_token_file)\n badgr.load_token()","def _validate_json(self):\n # Do we find valid json?\n try:\n with open(self.batch_json_path, \"rb\") as fd:\n batch_json = json.loads(fd.read())\n\n except Exception as err:\n raise\n self.message(\n \"[-] Error reading JSON batch file '%s' : '%s'\" %\n (self.batch_json_path, err))\n return False\n\n # Does the json represent a dictionary of the expected form?\n if not isinstance(batch_json, types.DictionaryType):\n self.message(\n \"[-] JSON batch file '%s' deserialises to unexpected object type '%s'\" %\n (self.batch_json_path, type(batch_json)))\n return False\n\n # If it is a dictionary does it have the expected characteristics?\n for endpoint, sys_info in batch_json.items():\n\n # Endpoint should be a hostname, IP or some other string\n # identifier, difficult to validate much beyond 'string'\n if type(endpoint) not in [types.StringType, types.UnicodeType]:\n self.message(\n \"[-] Element within JSON batch file '%s' conatins unexpected object type for an endpoint element '%s'. %s : %s\" %\n (self.batch_json_path, type(endpoint), endpoint, sys_info))\n return False\n\n # Does the sys_info dict contain the expected keys?\n if set(sys_info.keys()).symmetric_difference(\n set(self.json_batch_template)):\n self.message(\n \"[-] Unexpected sys_info structure within JSON batch file %s, expected keys '%s' %s : %s\" %\n (self.batch_json_path, self.json_batch_template, endpoint, sys_info))\n return False\n\n # Create a psuedononymised hash of the uuid using MAC addr as salt\n mac_repr = \"0x\" + sys_info[\"mac_addr\"].lower().replace(\":\", \"\")\n sys_info[\"hashed_uuid\"] = hashlib.sha256(\n mac_repr + sys_info[\"sys_uuid\"]).hexdigest()\n\n # Remove both the real sys_uuid and the mac_addr from the structure so they do not get submitted to the API\n # and remain confidential to the submitter\n del sys_info[\"sys_uuid\"]\n del sys_info[\"mac_addr\"]\n\n # Set the read in json structure as the structure of system data to\n # walk and send to the API\n self.endpoints_to_check = batch_json\n\n self.message(\"[+] Batch JSON file validated\")\n return True","def test_wrong_upload_item(invalid_item: JSONDict) -> None:\n\n with pytest.raises(ValidationError) as e:\n invalid = UploadItem(**invalid_item) # noqa: F841\n assert e.value.errors() == [\n {\n \"ctx\": {\"limit_value\": 2},\n \"loc\": (\"language\",),\n \"msg\": \"ensure this value has at most 2 characters\",\n \"type\": \"value_error.any_str.max_length\",\n },\n {\n \"loc\": (\"date\",),\n \"msg\": \"Could not validate format '02-2031-01'. Must be YYYY-MM-DD or iso-formatted time stamp\",\n \"type\": \"value_error\",\n },\n {\n \"loc\": (\"url\",),\n \"msg\": \"invalid or missing URL scheme\",\n \"type\": \"value_error.url.scheme\",\n },\n ]","def noop_merge(output_json, jsons_to_merge):\n if len(jsons_to_merge) > 1:\n print('Multiple JSONs provided: %s' % (','.join(jsons_to_merge)),\n file=sys.stderr)\n return 1\n if jsons_to_merge:\n shutil.copyfile(jsons_to_merge[0], output_json)\n else:\n with open(output_json, 'w') as f:\n json.dump({}, f)\n return 0","def test_list_3(self):\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\n jdic = json.loads('[{\"test1\":3, \"test2\":4},{\"test1\":3, \"test2\":4}]')\n self.assertFalse(check_json_array(jdic, jobj))","def test_WronJSONFormat():\n\n tree = MerkleTree()\n\n with pytest.raises(WrongJSONFormat):\n tree.encryptFilePerObject(\n os.path.join(os.path.dirname(__file__),\n 'objects/sample.json')\n )","def get_er_exceptions():\n express_route_exceptions_lst = []\n try:\n for i in get_data():\n if i['expressRoute'] is False:\n express_route_exceptions_lst.append(i)\n express_route_exceptions_dic = {'expressRoutesExceptions': express_route_exceptions_lst}\n return get_json(express_route_exceptions_dic)\n except ValueError as e:\n print(e)","def compare_json(json1, json2):\r\n return JsonType.eq(json1, json2)","def raise_best_exception(self, json_response):\n exceptions = {\n 206: CannotParseError,\n 400: BadRequestError,\n 401: NotAuthorizedError,\n 403: ForbiddenError,\n 404: NotFoundError,\n 500: ServerError,\n 503: UnavailableError,\n }\n try:\n err = json_response['response']['error']\n raise exceptions[err['code']](err['code'],err['message'])\n except IndexError:\n raise UnexpectedError('','Unexpected error.')","def test_load_bad_datetime_arg(self):\n expected = {\n \"release_day\": 2,\n \"closing_date\": {\n \"bad_arg\": 12,\n \"month\": 10,\n \"year\": 2013,\n \"day\": 18,\n \"__type__\": \"datetime.date\"\n }\n }\n with open('tests/bad_datetime_arg.json', 'r') as json_file:\n self.assertEqual(expected, morejson.load(json_file))","def existing_key_fail(self, data, new_data):\n message = 'exists'\n rv = self.add_success(data)\n assert not in_response(rv, message)\n self.add_fail(data, message)\n rv = self.add_success(new_data)\n assert not in_response(rv, message)\n self.update_fail(data, message)\n assert self.verify_object(new_data)","def is_valid_json(j):\n try:\n json.dumps(j)\n return True\n except json.JSONDecodeError:\n print(\"not valid json\")\n return False","def is_empty_json(json_object):\n try:\n obj = json.load(json_object)\n except:\n obj = json.dumps(json_object)\n print(TypeError.message)\n return len(obj) == 0","def sanitise_json_error(error_dict):\n ret = copy.copy(error_dict)\n chop = len(JSON_ERROR)\n ret['detail'] = ret['detail'][:chop]\n return ret","def test_unique_item_properties_failed(self):\n check_value = [{\"a\": 1, \"b\": 3}, {\"a\": 1, \"b\": 2}]\n\n with pytest.raises(AssertionError):\n unique_item_properties(check_value, \"a\")","def test_service_api_predict_missing_keys(service_app):\n tmp_data = copy.deepcopy(data[:1])\n tmp_data[0].pop('x1')\n\n response = service_app.post('/predict',\n data=json.dumps(tmp_data),\n content_type='application/json')\n assert response.headers['Content-Type'] == 'application/json'\n assert response.status_code == 400\n assert json.loads(response.data) == {'error': \"'x1' is a required property in items -> required\"}","def test_load_json_value_data(tmp_path: Path) -> None:\n fname = tmp_path / \"test5.json\"\n with open(fname, \"w\", encoding=\"utf8\") as handle:\n handle.write('\"two\"')\n\n assert load_json(fname) == \"two\"\n with pytest.raises(\n HomeAssistantError, match=\"Expected JSON to be parsed as a dict\"\n ):\n load_json_object(fname)\n with pytest.raises(\n HomeAssistantError, match=\"Expected JSON to be parsed as a list\"\n ):\n load_json_array(fname)","def test_invalid_json_dumpling(self):\n with pytest.raises(InvalidDumpling):\n validate_dumpling(\"{'invalid_single_quotes': 'value'}\")","def test_unknown_by_content_type(self):\n request = FakeRequest('/hiihoo.json', 'hiihootype')\n response = datamapper.format(request, {'a': 1})\n self.assertEquals(json.loads(response.content), {'a': 1})\n self.assertEquals(response['Content-Type'], 'application/json; charset=utf-8')","def _protected_from_json(_json, client_api, dataset=None):\n try:\n item = Item.from_json(_json=_json,\n client_api=client_api,\n dataset=dataset)\n status = True\n except Exception:\n item = traceback.format_exc()\n status = False\n return status, item","def test_keyerror(self):\n try:\n self.db['foo']\n except KeyError, e:\n assert \"no key 'foo' in database <SequenceFileDB\" in str(e), str(e)","def test_error_no_json(self, app, data_queues, metricsmock):\n res = self._call(app, \"\\xae\", method=\"post\", status=400)\n detail = \"JSONDecodeError('Expecting value: line 1 column 1 (char 0)')\"\n self.check_response(data_queues, res, \"parse_error\", details={\"decode\": detail})\n metricsmock.assert_incr_once(\n self.metric_type + \".request\", tags=[self.metric_path, \"key:test\"]\n )","def test_empty_json(self):\n json_data = '{ }'\n json_flattened = json_flatten(json_data)\n self.assertEqual(json.loads(json_flattened), json.loads('{ }'))","def test_get_single_different(single_bucket): # pylint: disable=redefined-outer-name\n with pytest.raises(KeyError):\n single_bucket.get(\"key 2\")","def conflict():\n return HttpError(409)","def test_invalid_json(self):\n req = '{\"jsonrpc\": \"2.0\", \"method\": \"foobar, \"params\": \"bar\", \"baz]'\n resp = '{\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"ParseError: Parse error\"}, \"id\": null}'\n status = 500\n r_status, r_resp = self.exec_handler(req)\n self.assertEqual(r_status, status)\n self.assertEqual(simplejson.loads(r_resp), simplejson.loads(resp))","def missing_data(self, data):\n missing_fields = []\n for key in data:\n if not key in request.json:\n missing_fields.append(key)\n if missing_fields:\n message = 'Missing ' + ', '.join(missing_fields)\n return self.bad_request(message)\n return None","def _reject_invalid_json(val: Any) -> None:\n raise ValueError(f\"Invalid JSON value: {val!r}\")","def test_no_such_key():\n test = [{'key': 'val1'}, ['missing']]\n t_result = fetch_data_by_keys(*test)\n assert not is_successful(t_result)\n assert 'missing' in str(t_result.failure())","def test_load_bad_data(tmp_path: Path) -> None:\n fname = tmp_path / \"test5.json\"\n with open(fname, \"w\") as fh:\n fh.write(TEST_BAD_SERIALIED)\n with pytest.raises(HomeAssistantError):\n load_json(fname)","def check_all_same_keys(dict_list, name):\n if len(dict_list) == 0:\n return\n keys = dict_list[0].keys()\n for dct in dict_list:\n if keys != dct.keys():\n raise DGLError('Expect all {} to have the same set of keys, but got'\n ' {} and {}.'.format(name, keys, dct.keys()))","def compare_json(test_name): # , json_object, filters):\n baseline_json = None\n result_json = None\n try:\n with open(robot_dir + \"/output/baseline/{}.json\".format(test_name.replace(' ', ''))) as baseline_file:\n try:\n with open(robot_dir + \"/output/results/{}.json\".format(test_name.replace(' ', ''))) as result_file:\n baseline_json = json.load(baseline_file)\n result_json = json.load(result_file)\n except:\n print(\"Failed to open the results json\")\n except:\n print(\"Failed to open the baseline json\")\n return False\n return ordered(baseline_json) == ordered(result_json)","def _loadJson(self, file):\n # TODO : Is it paranoid checking?\n if os.path.isfile(file):\n try:\n with open(file, 'r') as f:\n data = json.load(f)\n return data\n except ValueError:\n msg = \"Corrupted JSON file => %s\" % file\n # logger.error(msg)\n self._exception(200, msg)\n # return -2 # code for corrupted json file\n else:\n msg = \"File cannot be found => %s\" % file\n self._exception(201, msg)","def test_unique_upload_items(upload_items: List[JSONDict]) -> None:\n validated = UploadCollection(items=upload_items)\n assert validated.dict() == upload_items","def keyError():\n d = {}\n d['cat']","def test_simplef(self):\n samp1 = JObject(keys = ['status', 'result'])\n j = json.loads('{\"status\": \"success\", \"resultd\": \"yes\"}')\n self.assertFalse(check_json_object(j, samp1))","def check_for_dict(check):","def check_job_json(job_info):\n job_type_list = [job_type.value for _, job_type in JobType.__members__.items()]\n if 'source_id' not in job_info:\n raise ValueError(\"Json string Errors, key:source_id not found.\")\n if 'job_id' not in job_info:\n raise ValueError(\"Json string Errors, key:job_id not found.\")\n if 'job_type' not in job_info or not job_info['job_type']:\n raise ValueError(\"Json string Errors, key:job_type not found.\")\n if job_info['job_type'] not in job_type_list:\n raise ValueError(\"Invalid job type: {}.\".format(job_info['job_type']))\n if 'job_content' not in job_info:\n raise ValueError(\"Json string Errors, key:job_content not found.\")","def test_dupe_keys():\n assert_raises(voluptuous.SchemaError, Schema,\n {Required(\"id\"): str, Required(\"id\"): int})\n assert_raises(voluptuous.SchemaError, Schema,\n {Required(\"id\"): str, \"id\": str})\n assert_raises(voluptuous.SchemaError, Schema,\n {voluptuous.Optional(\"id\"): str, Required(\"id\"): int})","def test_json_reader_file_keys(process_data):\n data = process_data(file_name_or_type='scooter_data.json')\n for scooter in data:\n names_keys = list(scooter.keys())\n assert names_keys == ['id', 'name', 'vin_number',\n 'electric_scooter', 'color',\n 'city', 'usage', 'cost_usd',\n 'total_years_of_use']","def test_bad_valuetype():\n test = [{'key': {'key1': 'val'}}, ['key']]\n t_result = fetch_data_by_keys(*test)\n assert not is_successful(t_result)\n assert 'Bad data found' in str(t_result.failure())","async def _handle_response(response: ClientResponse) -> Dict:\n content = await response.json(encoding='utf-8', loads=loads)\n if response.status != 200:\n for member in JmRpcErrorType:\n if content['message'] != member.value:\n continue\n raise JmRpcError(response.status, content)\n response.raise_for_status()\n return content","def test_non_existent_file(self):\n remove('Rectangle.json')\n self.assertEqual(self.r1.load_from_file(), [])","def test_correct_upload_item(upload_items: List[JSONDict]) -> None:\n validated = UploadItem(**upload_items[0])\n assert validated.dict() == upload_items[0]","def _reject_invalid_json(val):\n raise ValueError(f\"Invalid JSON value: {val!r}\")"],"string":"[\n \"def assert_json_failure_response_is_username_collision(self, response):\\r\\n self.assertEqual(400, response.status_code)\\r\\n payload = json.loads(response.content)\\r\\n self.assertFalse(payload.get('success'))\\r\\n self.assertIn('already exists', payload.get('value'))\",\n \"def check_repeated_keys(text,verbose=False):\\n\\textra_msg = \\\"either fix the repeated keys or check for JSON problems.\\\"\\n\\ttext_json = jsonify(text)\\n\\ttry: _ = json.loads(text_json,object_pairs_hook=SafeDictHook)\\n\\texcept Exception as e: \\n\\t\\t# if we get a type error we are probably on python < 2.7\\n\\t\\t# ... where json lacks the hook so we just give a warning and pass\\n\\t\\tif type(e)==TypeError:\\n\\t\\t\\tprint('warning','JSON encountered a type error which suggests an old version '\\n\\t\\t\\t\\t'(possibly python 2.6) so we will pass. beware repeated keys or downstream '\\n\\t\\t\\t\\t'dictionary errors')\\n\\t\\t\\treturn True\\n\\t\\tprint('error','found repeated keys (or JSON encoding error). '+extra_msg)\\n\\t\\tif verbose: \\n\\t\\t\\ttext_with_linenos = '\\\\n'.join(['[DEBUG]%s|%s'%(str(ll).rjust(4),l) \\n\\t\\t\\t\\tfor ll,l in enumerate(text_json.splitlines())])\\n\\t\\t\\tprint('warning','the following string has a JSON problem:\\\\n'+text_with_linenos)\\n\\t\\t\\tprint('exception','exception is %s'%e)\\n\\t\\t\\tprint('note',controlmsg['json'])\\n\\t\\treturn False\\n\\treturn True\",\n \"def test_dict_keys_duplicate(self):\\n assert (\\n orjson.dumps({\\\"1\\\": True, 1: False}, option=orjson.OPT_NON_STR_KEYS)\\n == b'{\\\"1\\\":true,\\\"1\\\":false}'\\n )\",\n \"def item6():\\n try:\\n # Do something\\n pass\\n except:\\n # Handle exception\\n pass\\n else:\\n # Runs when there are no exceptions\\n pass\\n finally:\\n # Always runs after try\\n pass\\n\\n handle = open('random_data.txt', 'w', encoding='utf-8')\\n handle.write('success\\\\nand\\\\nnew\\\\nlines')\\n handle.close()\\n\\n '''\\n handle2 = open('random_data4.txt') # Raise IOError\\n \\n try:\\n data = handle2.read() # Raise UnicodeDecodeError\\n finally:\\n handle2.close()\\n '''\\n\\n import json\\n\\n def load_json_key(data, key):\\n try:\\n result_dict = json.loads(data) # Raise ValueError\\n except ValueError as e:\\n raise KeyError from e\\n else:\\n return result_dict[key] # Raise KeyError\\n\\n try:\\n load_json_key('{\\\"foo\\\": bad payload', 'foo')\\n except KeyError:\\n print('Saw KeyError')\\n\\n try:\\n load_json_key('{\\\"foo\\\": \\\"bar\\\"}', 'stuff')\\n except KeyError:\\n print('Saw KeyError')\\n\\n print(load_json_key('{\\\"foo\\\": \\\"bar\\\"}', 'foo'))\\n\\n def divide_json(path):\\n handle = open(path, 'r+') # IOError\\n try:\\n data = handle.read() # UnicodeDecodeError\\n op = json.loads(data) # ValueError\\n value = op['numerator'] / op['denominator'] # ZeroDivisionError\\n except ZeroDivisionError:\\n return None\\n else:\\n op['result'] = value\\n result = json.dumps(op)\\n handle.seek(0)\\n handle.write(result) # IOError\\n return value\\n finally:\\n handle.close() # Always runs\\n\\n temp_path = 'random_data.json'\\n with open(temp_path, 'w') as handle:\\n handle.write('{\\\"numerator\\\": 1, \\\"denominator\\\": 10}')\\n\\n print(divide_json(temp_path))\",\n \"def _CheckJson(input_api, output_api):\\n for affected_file in input_api.AffectedFiles(include_deletes=False):\\n filename = affected_file.AbsoluteLocalPath()\\n if os.path.splitext(filename)[1] != '.json':\\n continue\\n try:\\n input_api.json.load(open(filename))\\n except ValueError:\\n return [output_api.PresubmitError('Error parsing JSON in %s!' % filename)]\\n return []\",\n \"def handle_missing_objects(exc):\\n return jsonify(dict(\\n message=str(exc)\\n )), exc.code\",\n \"def test_detect_duplicate_upload_items(duplicate_items: List[JSONDict]) -> None:\\n\\n with pytest.raises(ValidationError) as e:\\n invalid_collection = UploadCollection(items=duplicate_items) # noqa: F841\\n\\n assert e.value.errors() == [\\n {\\n \\\"loc\\\": (\\\"items\\\",),\\n \\\"msg\\\": \\\"Duplicate item guids detected: ['http://www.crimsonhexagon.com/post1']\\\",\\n \\\"type\\\": \\\"value_error\\\",\\n }\\n ]\",\n \"def test_tap_config_json_validation_retry_with_invalid_config_and_then_fix(self):\\n self._assert_retry_validation_of_json_file(config=self.invalid_json_file,\\n properties=self.valid_json_file,\\n state=self.valid_json_file)\",\n \"def test_read_json(self, magic_0, magic_1):\\n expected = {\\n 'key_1': [1, 2, 3, 4, 5],\\n 'key_2': ['a', 'b', 'c', 'd', 'e']\\n }\\n result = helpers.read_json(r\\\"path\\\")\\n self.assertEqual(expected, result)\",\n \"def _check_errors(self, json_loaded):\\n\\n content = json_loaded\\n try:\\n m = content[u'error'][u'message']\\n c = content[u'error'][u'code']\\n out= \\\"API Error code: {}\\\\nError message: {}\\\".format(c, m)\\n raise InvalidQueryException(self.name, out)\\n except KeyError:\\n pass\",\n \"def test_tap_config_json_validation_retry_with_invalid_properties_and_then_fix(self):\\n self._assert_retry_validation_of_json_file(config=self.valid_json_file,\\n properties=self.invalid_json_file,\\n state=self.valid_json_file)\",\n \"def test_jfpv1_json_load_error(self):\\n with self.assertRaises(JSONLoad):\\n create('{\\\"foo\\\": bar}', hash_function=hash_functions.SHA256, version=1)\",\n \"def _import(self, data):\\n if isinstance(data, dict):\\n if len(data):\\n for key in data:\\n if data.get(key) is not None:\\n if not self.set(key, data.get(key)):\\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))\",\n \"def test_badFormat(self):\\n with open(os.path.join(self.directory, \\\"service2.json\\\"), \\\"w\\\") as f:\\n f.write(\\\"this is not json\\\")\\n self.pump()\\n self.assertNodesEqual(knownNodes(self.disco, \\\"service2\\\", \\\"staging\\\"), [])\",\n \"def test_load_unsupported_type(self):\\n expected = {\\n \\\"name\\\": \\\"Kevin\\\",\\n \\\"age\\\": 21,\\n \\\"pet\\\": {\\n \\\"name\\\": \\\"Trippy Jack\\\",\\n \\\"age\\\": 20762,\\n \\\"__type__\\\": \\\"hyperdimensional.hamster\\\"\\n }\\n }\\n with open('tests/unsupported_type.json', 'r') as json_file:\\n self.assertEqual(expected, morejson.load(json_file))\",\n \"def validate_json(self):\\n pass\",\n \"def invalid_item(upload_items: List[JSONDict]) -> JSONDict:\\n altered = upload_items[0]\\n altered[\\\"language\\\"] = \\\"engl\\\"\\n altered[\\\"date\\\"] = \\\"02-2031-01\\\"\\n altered[\\\"url\\\"] = \\\"incorrect.com\\\"\\n return altered\",\n \"def test_schema_invalid_json(self):\\n schema_0_input = schema_nested_2_invalid_JSON\\n\\n # if you uncomment this line:\\n # schema_0_input = schema_nested_2\\n # this will fail the test: Failed: DID NOT RAISE <class 'simplejson.scanner.JSONDecodeError'>\\n # because this is a valid schema\\n\\n with pytest.raises(simplejson.scanner.JSONDecodeError):\\n msg = singer.parse_message(schema_0_input)\",\n \"def test_get_json_data_throw_not_found_error(self):\\n response = self.app.test_client().get('/test/get_json_data/99999')\\n self.assertEqual(response.json['status'], 'failure')\\n self.assertEqual(response.json['error'], 'Test not found')\",\n \"def test_tap_config_json_validation_retry_with_invalid_state_and_then_fix(self):\\n self._assert_retry_validation_of_json_file(config=self.valid_json_file,\\n properties=self.valid_json_file,\\n state=self.invalid_json_file)\",\n \"def assertJSONError(self, response, exception):\\n # first of all, try to find the exception\\n full_exception_name = exception + 'Exception'\\n exception_cls = getattr(exceptions, full_exception_name)\\n self.assertStatus(response, exception_cls.status)\\n\\n expected = {'code': exception,\\n 'message': exception_cls.message}\\n self.assertJSON(response, expected)\\n return\",\n \"def merge_multiple_json(path):\\n import glob\\n\\n result = {}\\n file_names = glob.glob(path + '/*.json')\\n\\n for file_name in file_names:\\n with open(file_name,'r') as f:\\n data = json.load(f)\\n if type(data) is dict: result[file_name.replace('.json','')] = data\\n else: print 'fake_data in %s is invalid, pls check !!!' % file_name\\n\\n return result\",\n \"def test_loads_a_non_object_json_file(self):\\n from test.resources import simple_json\\n self.assertEqual(simple_json._data, 'test')\",\n \"def test_restore_with_invalid_bucket_config_json(self):\\n gen = BlobGenerator(\\\"ent-backup_1\\\", \\\"ent-backup-\\\", self.value_size, end=self.num_items)\\n self._load_all_buckets(self.master, gen, \\\"create\\\", 0)\\n self.backup_create()\\n self._take_n_backups(n=self.backupset.number_of_backups)\\n status, output, message = self.backup_list()\\n error_msg = \\\"Error merging data: Unable to read bucket settings because bucket-config.json is corrupt\\\"\\n if not status:\\n self.fail(message)\\n backup_count = 0\\n for line in output:\\n if re.search(\\\"\\\\d{4}-\\\\d{2}-\\\\d{2}T\\\\d{2}_\\\\d{2}_\\\\d{2}.\\\\d+-\\\\d{2}_\\\\d{2}\\\", line):\\n backup_name = re.search(\\\"\\\\d{4}-\\\\d{2}-\\\\d{2}T\\\\d{2}_\\\\d{2}_\\\\d{2}.\\\\d+-\\\\d{2}_\\\\d{2}\\\",\\n line).group()\\n if backup_name in self.backups:\\n backup_count += 1\\n self.log.info(\\\"{0} matched in list command output\\\".format(backup_name))\\n backup_bucket_config_path = self.backupset.directory + \\\"/backup\\\" + \\\\\\n \\\"/\\\" + self.backups[self.backupset.number_of_backups - 1] + \\\\\\n \\\"/\\\" + self.buckets[0].name + \\\"-*\\\" \\\\\\n \\\"/bucket-config.json\\\"\\n remote_client = RemoteMachineShellConnection(self.backupset.backup_host)\\n self.log.info(\\\"Remove } in bucket-config.json to make it invalid json \\\")\\n remote_client.execute_command(\\\"sed -i 's/}//' %s \\\" % backup_bucket_config_path)\\n self.log.info(\\\"Start to merge backup\\\")\\n self.backupset.start = randrange(1, self.backupset.number_of_backups)\\n self.backupset.end = randrange(self.backupset.start + 1,\\n self.backupset.number_of_backups + 1)\\n result, output, _ = self.backup_merge()\\n if result:\\n self.log.info(\\\"Here is the output from command %s \\\" % output[0])\\n if not self._check_output(error_msg, output):\\n self.fail(\\\"read bucket config should fail since bucket-config.json is invalid\\\")\\n remote_client.disconnect()\",\n \"def test_lti20_bad_json(self):\\r\\n for error_inputs, error_message in self.BAD_JSON_INPUTS:\\r\\n for einput in error_inputs:\\r\\n with self.assertRaisesRegexp(LTIError, error_message):\\r\\n self.xmodule.parse_lti_2_0_result_json(einput)\",\n \"def test_circular_dict(self):\\n obj = {}\\n obj[\\\"obj\\\"] = obj\\n with self.assertRaises(orjson.JSONEncodeError):\\n orjson.dumps(obj)\",\n \"def check_json_file(file_name: str, excel_file: str, sheet_name: str) -> list:\\n try:\\n with open(file_name) as json_file:\\n data = json.load(json_file)\\n return data\\n except FileNotFoundError:\\n period_index = excel_file.index(\\\".\\\")\\n json_file_name = excel_file[:period_index] + \\\".json\\\"\\n write_json_file(json_file_name, convert_excel_file(excel_file, sheet_name))\\n return check_json_file(file_name, excel_file, sheet_name)\",\n \"def validate_json() -> bool:\\n with Path(ROOT_DIR, \\\"seals\\\", \\\"seals.json\\\").open() as f:\\n seals = json.load(f)\\n\\n seals_in_json = [k for k, v in seals.items() if v[\\\"has_seal\\\"]]\\n\\n seals = [\\n x.split(\\\"/\\\")[-1][:-4] for x in glob.glob(f\\\"{ROOT_DIR}/seals/orig/*\\\")\\n ]\\n missing_seals = sorted(list(set(seals_in_json) ^ set(seals)))\\n if not missing_seals:\\n return True\\n\\n raise Exception(f\\\"Missing entry for: {' '.join(missing_seals)}\\\")\",\n \"def test_throws_item_missing_key(self):\\n with pytest.raises(marshmallow.ValidationError):\\n Item.Schema().loads(json.dumps(item_missing_key))\",\n \"def compare_json(js1, js2):\\n return js1.items() <= js2.items()\",\n \"def test_conflict(self):\\n self._error_test(fitbit_exceptions.HTTPConflict)\",\n \"def test_load_json_file_not_found_error() -> None:\\n fname = \\\"invalid_file.json\\\"\\n\\n assert load_json(fname) == {}\\n assert load_json(fname, default=\\\"\\\") == \\\"\\\"\\n assert load_json_object(fname) == {}\\n assert load_json_object(fname, default={\\\"Hi\\\": \\\"Peter\\\"}) == {\\\"Hi\\\": \\\"Peter\\\"}\\n assert load_json_array(fname) == []\\n assert load_json_array(fname, default=[\\\"Hi\\\"]) == [\\\"Hi\\\"]\",\n \"def handle_missing_duplicate_headers(self, expected_fields, bucket_name, error_filename):\\n missing_headers = [cell for cell, count in expected_fields.items() if count == 0]\\n duplicated_headers = [cell for cell, count in expected_fields.items() if count > 1]\\n\\n if missing_headers or duplicated_headers:\\n self.write_missing_duplicated_headers(\\n missing_headers, duplicated_headers, bucket_name,\\n error_filename\\n )\\n raise_missing_duplicated_exception(missing_headers, duplicated_headers)\",\n \"def test_deserialization_error():\\n\\n tree = MerkleTree()\\n\\n with pytest.raises(json.JSONDecodeError):\\n tree.encryptObjectFromFile(\\n os.path.join(os.path.dirname(__file__),\\n 'objects/bad.json')\\n )\",\n \"def test_save_method(self):\\n prev_all_objs = storage.all()\\n\\n obj = BaseModel()\\n key = \\\"{}.{}\\\".format(type(obj).__name__, obj.id)\\n\\n self.assertIn(key, prev_all_objs.keys())\\n try:\\n\\n with open('file.json', mode='r', encoding='utf-8') as file:\\n dict_loaded = json.load(file)\\n\\n self.assertIs(type(dict_loaded), dict)\\n self.assertNotIn(key, dict_loaded.keys())\\n\\n storage.save()\\n except FileNotFoundError:\\n pass\\n try:\\n\\n with open('file.json', mode='r', encoding='utf-8') as file:\\n dict_loaded = json.load(file)\\n\\n self.assertIs(type(dict_loaded), dict)\\n self.assertIn(key, dict_loaded.keys())\\n except FileNotFoundError:\\n pass\",\n \"def test_save_json_with_invalid_step(temp_dir):\\n data = json.dumps({\\\"k\\\": \\\"v\\\", \\\"list\\\": [1, 2, 3]})\\n\\n with pytest.raises(ValueError):\\n save_json(temp_dir, data, step={\\\"invalid\\\": \\\"dict\\\"})\",\n \"def test_json_exceptions(self, error, input_file_path: str, msg: str):\\n with pytest.raises(error) as context:\\n with open(attach_path(input_file_path), 'r') as input_file:\\n str(read_json(input_file.read()))\\n assert str(context.value) == msg\",\n \"def test_get_users_from_invalid_json():\\n with pytest.raises(ValueError):\\n Users.from_json(file_path='{0}/json_input/invalid.json'.format(os.path.dirname(os.path.abspath(__file__))))\",\n \"def test_valid_json():\\n invalid_json = False\\n for filename in os.listdir(\\\"../networking\\\"):\\n if filename.endswith(\\\".cfn.json\\\"):\\n print(\\\"Validating json file: %s\\\" % filename)\\n with open(f\\\"../networking/{filename}\\\", encoding=\\\"utf-8\\\") as f:\\n try:\\n json.load(f)\\n print(\\\"SUCCESS: Valid json.\\\")\\n except ValueError as e:\\n print(\\\"ERROR: Invalid json: %s\\\" % e)\\n invalid_json = True\\n\\n assert not invalid_json\",\n \"def test_invalid_data(self):\\n\\n json_data = {\\n \\\"input\\\" : {\\n 'version': 'BAD',\\n 'files': {'input_a': [self.source_file.id]},\\n 'json': {}\\n },\\n \\\"job_type_id\\\" : self.job_type1.pk,\\n \\\"configuration\\\" : self.configuration\\n }\\n\\n url = '/%s/jobs/' % self.api\\n response = self.client.generic('POST', url, json.dumps(json_data), 'application/json')\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, response.content)\",\n \"def test_response_json(self):\\n response = self.client.search()\\n self.assertTrue(isinstance(response.json, dict))\\n\\n\\n # with invalid json\\n from rubber import settings\\n settings.RUBBER_MOCK_HTTP_RESPONSE = \\\"\\\"\\\";;;\\\"\\\"\\\"\\n \\n response = self.client.search()\\n self.assertIsNone(response.json)\",\n \"def test_json(self):\\n\\n cases_dir = pathlib.Path(__file__).parent / 'cases'\\n\\n asn_strs = {\\n asn_path.stem: asn_path.read_text()\\n for asn_path in cases_dir.glob('*.asn')\\n }\\n json_strs = {\\n json_path.stem: json_path.read_text()\\n for json_path in cases_dir.glob('*.json')\\n }\\n\\n assert set(asn_strs.keys()) == set(json_strs.keys())\\n assert len(asn_strs) > 0\\n\\n for key in asn_strs:\\n with self.subTest(key=key):\\n res_json = asn1vnparser.parse_asn1_value_assignment(\\n asn_strs[key], as_json=True)\\n res_py = json.loads(res_json)\\n self.maxDiff = None\\n self.assertEqual(res_py, json.loads(json_strs[key]))\",\n \"def test_load_from_file_to_dict_key_length(self):\\n self.assertEqual(len(self.loaded_json_dict), 3)\",\n \"def test_json_error(self):\\n with self.assertRaises(AttributeError):\\n FileStorage.__objects\\n FileStorage.__File_Path\",\n \"def test_dictionary(self):\\n self.assertIsInstance(self.test1json, dict)\",\n \"def test_target_config_raises_exception_if_not_valid_json_after_retries(self):\\n invalid_file_contents = ['', 'foo', '{\\\"foo\\\": 1']\\n\\n for invalid_content in invalid_file_contents:\\n with open(self.invalid_json_file, 'w', encoding='utf-8') as invalid_file:\\n invalid_file.write(invalid_content)\\n\\n with self.assertRaises(commands.RunCommandException) as command_exception:\\n self._assert_target_config(config=self.invalid_json_file)\\n\\n self.assertEqual(f'Invalid json file for config: {self.invalid_json_file}',\\n str(command_exception.exception))\",\n \"def test_invalid_json_batch(self):\\n req = '[{\\\"jsonrpc\\\": \\\"2.0\\\", \\\"method\\\": \\\"sum\\\", \\\"params\\\": [1,2,4], \\\"id\\\": \\\"1\\\"},{\\\"jsonrpc\\\": \\\"2.0\\\", \\\"method\\\"]'\\n resp = '{\\\"jsonrpc\\\": \\\"2.0\\\", \\\"error\\\": {\\\"code\\\": -32700, \\\"message\\\": \\\"ParseError: Parse error\\\"}, \\\"id\\\": null}'\\n status = 500\\n r_status, r_resp = self.exec_handler(req)\\n self.assertEqual(r_status, status)\\n self.assertEqual(simplejson.loads(r_resp), simplejson.loads(resp))\",\n \"def test_duplicated_entries() -> None:\\n r4.from_raw('{\\\"resourceType\\\":\\\"DomainResource\\\"}')\\n with pytest.raises(pydantic.ValidationError):\\n r4.from_raw(\\n '{\\\"resourceType\\\":\\\"DomainResource\\\", \\\"resourceType\\\":\\\"DomainResource\\\"}'\\n )\",\n \"def test_data_parse_invalid_json(self):\\n lines = ['{\\\"a\\\": \\\"val\\\" \\\"b\\\": \\\"val2\\\"}']\\n self.assertRaises(TypeError, parser._parse_data, lines)\",\n \"def test_validate_file_extension_json(self):\\n data_locations = open(self.test_dir + 'mannheim_short.json',\\n encoding='utf-8')\\n data_locations_false = open(self.test_dir + 'contacts.csv',\\n encoding='utf-8')\\n a = validate_file_extension_json(data_locations)\\n self.assertEqual(a, None)\\n with self.assertRaises(ValidationError) as context:\\n validate_file_extension_json(data_locations_false)\\n data_locations.close()\\n data_locations_false.close()\\n self.assertTrue(\\\"Kein gültiges JSON-File\\\" or \\\"No valid JSON file\\\" in\\n str(context.exception))\",\n \"def test_request_err_json(self, method, m_requests):\\n # Dummies for K8s API URL and `requests` session.\\n url = 'http://examples.com/'\\n client = k8s.requests.Session()\\n\\n # Construct a response with a corrupt JSON string.\\n corrupt_json = \\\"{this is not valid] json;\\\"\\n m_requests.request(\\n method,\\n url,\\n text=corrupt_json,\\n status_code=200,\\n )\\n\\n # Test function must not return a response but indicate an error.\\n ret = k8s.request(client, method, url, None, None)\\n assert ret == ({}, True)\",\n \"def test_composite_1():\\n datadir, _ = os.path.split(__file__)\\n datapath = os.path.join(datadir, 'testdata', 'data1.json')\\n with open(datapath) as f:\\n rawjson = f.read()\\n data_i = json.loads(rawjson, object_pairs_hook=Item)\\n data_o = json.loads(rawjson, object_pairs_hook=OrderedDict)\\n for x, y in zip(data_i, data_o):\\n assert list(x.keys()) == list(y.keys())\\n assert list(x.values()) == list(y.values())\",\n \"def test_detect_duplicate_train_items(duplicate_train_items: List[JSONDict]) -> None:\\n\\n with pytest.raises(ValidationError) as e:\\n invalid_collection = TrainCollection(items=duplicate_train_items) # noqa: F841\\n\\n assert e.value.errors() == [\\n {\\n \\\"loc\\\": (\\\"items\\\",),\\n \\\"msg\\\": \\\"Duplicate item urls detected: ['http://www.crimsonhexagon.com/post1']\\\",\\n \\\"type\\\": \\\"value_error\\\",\\n }\\n ]\",\n \"def test_json(self, input_file_path: str, answer_file_path: List[Dict]):\\n with open(attach_path(input_file_path), 'r') as input_file:\\n with open(attach_path(answer_file_path), 'r') as answer_file:\\n assert str(read_json(input_file.read().strip())) == answer_file.read().strip()\",\n \"def _check_json(json_data: Any, clean: bool) -> Any:\\n try:\\n json.loads(json_data)\\n except ValueError:\\n return \\\"unknown\\\" if clean else False\\n return \\\"success\\\" if clean else True\",\n \"def test_to_json_file_non_dict(self):\\n\\n output_file = \\\"this_file_is_a_ghost\\\"\\n File(output_file).delete()\\n\\n self.assertRaises(TypeError, lambda: Dict(1).to_json_file(output_file))\\n self.assertRaises(TypeError, lambda: Dict(\\\"100\\\").to_json_file(output_file))\\n self.assertRaises(\\n TypeError, lambda: Dict(\\\"{'hello': 'world'}\\\").to_json_file(output_file)\\n )\\n\\n File(output_file).delete()\",\n \"def test_verifies_token_file_contains_json(self):\\n\\n with open(self.sample_token_file, 'w',\\n encoding=\\\"utf8\\\", errors=\\\"surrogateescape\\\") as stf_h:\\n stf_h.write(\\\"Bad JSON\\\")\\n\\n with self.assertRaises(json.decoder.JSONDecodeError):\\n badgr = BadgrLite(token_filename=self.sample_token_file)\\n badgr.load_token()\",\n \"def _validate_json(self):\\n # Do we find valid json?\\n try:\\n with open(self.batch_json_path, \\\"rb\\\") as fd:\\n batch_json = json.loads(fd.read())\\n\\n except Exception as err:\\n raise\\n self.message(\\n \\\"[-] Error reading JSON batch file '%s' : '%s'\\\" %\\n (self.batch_json_path, err))\\n return False\\n\\n # Does the json represent a dictionary of the expected form?\\n if not isinstance(batch_json, types.DictionaryType):\\n self.message(\\n \\\"[-] JSON batch file '%s' deserialises to unexpected object type '%s'\\\" %\\n (self.batch_json_path, type(batch_json)))\\n return False\\n\\n # If it is a dictionary does it have the expected characteristics?\\n for endpoint, sys_info in batch_json.items():\\n\\n # Endpoint should be a hostname, IP or some other string\\n # identifier, difficult to validate much beyond 'string'\\n if type(endpoint) not in [types.StringType, types.UnicodeType]:\\n self.message(\\n \\\"[-] Element within JSON batch file '%s' conatins unexpected object type for an endpoint element '%s'. %s : %s\\\" %\\n (self.batch_json_path, type(endpoint), endpoint, sys_info))\\n return False\\n\\n # Does the sys_info dict contain the expected keys?\\n if set(sys_info.keys()).symmetric_difference(\\n set(self.json_batch_template)):\\n self.message(\\n \\\"[-] Unexpected sys_info structure within JSON batch file %s, expected keys '%s' %s : %s\\\" %\\n (self.batch_json_path, self.json_batch_template, endpoint, sys_info))\\n return False\\n\\n # Create a psuedononymised hash of the uuid using MAC addr as salt\\n mac_repr = \\\"0x\\\" + sys_info[\\\"mac_addr\\\"].lower().replace(\\\":\\\", \\\"\\\")\\n sys_info[\\\"hashed_uuid\\\"] = hashlib.sha256(\\n mac_repr + sys_info[\\\"sys_uuid\\\"]).hexdigest()\\n\\n # Remove both the real sys_uuid and the mac_addr from the structure so they do not get submitted to the API\\n # and remain confidential to the submitter\\n del sys_info[\\\"sys_uuid\\\"]\\n del sys_info[\\\"mac_addr\\\"]\\n\\n # Set the read in json structure as the structure of system data to\\n # walk and send to the API\\n self.endpoints_to_check = batch_json\\n\\n self.message(\\\"[+] Batch JSON file validated\\\")\\n return True\",\n \"def test_wrong_upload_item(invalid_item: JSONDict) -> None:\\n\\n with pytest.raises(ValidationError) as e:\\n invalid = UploadItem(**invalid_item) # noqa: F841\\n assert e.value.errors() == [\\n {\\n \\\"ctx\\\": {\\\"limit_value\\\": 2},\\n \\\"loc\\\": (\\\"language\\\",),\\n \\\"msg\\\": \\\"ensure this value has at most 2 characters\\\",\\n \\\"type\\\": \\\"value_error.any_str.max_length\\\",\\n },\\n {\\n \\\"loc\\\": (\\\"date\\\",),\\n \\\"msg\\\": \\\"Could not validate format '02-2031-01'. Must be YYYY-MM-DD or iso-formatted time stamp\\\",\\n \\\"type\\\": \\\"value_error\\\",\\n },\\n {\\n \\\"loc\\\": (\\\"url\\\",),\\n \\\"msg\\\": \\\"invalid or missing URL scheme\\\",\\n \\\"type\\\": \\\"value_error.url.scheme\\\",\\n },\\n ]\",\n \"def noop_merge(output_json, jsons_to_merge):\\n if len(jsons_to_merge) > 1:\\n print('Multiple JSONs provided: %s' % (','.join(jsons_to_merge)),\\n file=sys.stderr)\\n return 1\\n if jsons_to_merge:\\n shutil.copyfile(jsons_to_merge[0], output_json)\\n else:\\n with open(output_json, 'w') as f:\\n json.dump({}, f)\\n return 0\",\n \"def test_list_3(self):\\n jobj = JList(parent = 'some', keys = [JObject(parent = None, keys = ['test1', 'test2'])])\\n jdic = json.loads('[{\\\"test1\\\":3, \\\"test2\\\":4},{\\\"test1\\\":3, \\\"test2\\\":4}]')\\n self.assertFalse(check_json_array(jdic, jobj))\",\n \"def test_WronJSONFormat():\\n\\n tree = MerkleTree()\\n\\n with pytest.raises(WrongJSONFormat):\\n tree.encryptFilePerObject(\\n os.path.join(os.path.dirname(__file__),\\n 'objects/sample.json')\\n )\",\n \"def get_er_exceptions():\\n express_route_exceptions_lst = []\\n try:\\n for i in get_data():\\n if i['expressRoute'] is False:\\n express_route_exceptions_lst.append(i)\\n express_route_exceptions_dic = {'expressRoutesExceptions': express_route_exceptions_lst}\\n return get_json(express_route_exceptions_dic)\\n except ValueError as e:\\n print(e)\",\n \"def compare_json(json1, json2):\\r\\n return JsonType.eq(json1, json2)\",\n \"def raise_best_exception(self, json_response):\\n exceptions = {\\n 206: CannotParseError,\\n 400: BadRequestError,\\n 401: NotAuthorizedError,\\n 403: ForbiddenError,\\n 404: NotFoundError,\\n 500: ServerError,\\n 503: UnavailableError,\\n }\\n try:\\n err = json_response['response']['error']\\n raise exceptions[err['code']](err['code'],err['message'])\\n except IndexError:\\n raise UnexpectedError('','Unexpected error.')\",\n \"def test_load_bad_datetime_arg(self):\\n expected = {\\n \\\"release_day\\\": 2,\\n \\\"closing_date\\\": {\\n \\\"bad_arg\\\": 12,\\n \\\"month\\\": 10,\\n \\\"year\\\": 2013,\\n \\\"day\\\": 18,\\n \\\"__type__\\\": \\\"datetime.date\\\"\\n }\\n }\\n with open('tests/bad_datetime_arg.json', 'r') as json_file:\\n self.assertEqual(expected, morejson.load(json_file))\",\n \"def existing_key_fail(self, data, new_data):\\n message = 'exists'\\n rv = self.add_success(data)\\n assert not in_response(rv, message)\\n self.add_fail(data, message)\\n rv = self.add_success(new_data)\\n assert not in_response(rv, message)\\n self.update_fail(data, message)\\n assert self.verify_object(new_data)\",\n \"def is_valid_json(j):\\n try:\\n json.dumps(j)\\n return True\\n except json.JSONDecodeError:\\n print(\\\"not valid json\\\")\\n return False\",\n \"def is_empty_json(json_object):\\n try:\\n obj = json.load(json_object)\\n except:\\n obj = json.dumps(json_object)\\n print(TypeError.message)\\n return len(obj) == 0\",\n \"def sanitise_json_error(error_dict):\\n ret = copy.copy(error_dict)\\n chop = len(JSON_ERROR)\\n ret['detail'] = ret['detail'][:chop]\\n return ret\",\n \"def test_unique_item_properties_failed(self):\\n check_value = [{\\\"a\\\": 1, \\\"b\\\": 3}, {\\\"a\\\": 1, \\\"b\\\": 2}]\\n\\n with pytest.raises(AssertionError):\\n unique_item_properties(check_value, \\\"a\\\")\",\n \"def test_service_api_predict_missing_keys(service_app):\\n tmp_data = copy.deepcopy(data[:1])\\n tmp_data[0].pop('x1')\\n\\n response = service_app.post('/predict',\\n data=json.dumps(tmp_data),\\n content_type='application/json')\\n assert response.headers['Content-Type'] == 'application/json'\\n assert response.status_code == 400\\n assert json.loads(response.data) == {'error': \\\"'x1' is a required property in items -> required\\\"}\",\n \"def test_load_json_value_data(tmp_path: Path) -> None:\\n fname = tmp_path / \\\"test5.json\\\"\\n with open(fname, \\\"w\\\", encoding=\\\"utf8\\\") as handle:\\n handle.write('\\\"two\\\"')\\n\\n assert load_json(fname) == \\\"two\\\"\\n with pytest.raises(\\n HomeAssistantError, match=\\\"Expected JSON to be parsed as a dict\\\"\\n ):\\n load_json_object(fname)\\n with pytest.raises(\\n HomeAssistantError, match=\\\"Expected JSON to be parsed as a list\\\"\\n ):\\n load_json_array(fname)\",\n \"def test_invalid_json_dumpling(self):\\n with pytest.raises(InvalidDumpling):\\n validate_dumpling(\\\"{'invalid_single_quotes': 'value'}\\\")\",\n \"def test_unknown_by_content_type(self):\\n request = FakeRequest('/hiihoo.json', 'hiihootype')\\n response = datamapper.format(request, {'a': 1})\\n self.assertEquals(json.loads(response.content), {'a': 1})\\n self.assertEquals(response['Content-Type'], 'application/json; charset=utf-8')\",\n \"def _protected_from_json(_json, client_api, dataset=None):\\n try:\\n item = Item.from_json(_json=_json,\\n client_api=client_api,\\n dataset=dataset)\\n status = True\\n except Exception:\\n item = traceback.format_exc()\\n status = False\\n return status, item\",\n \"def test_keyerror(self):\\n try:\\n self.db['foo']\\n except KeyError, e:\\n assert \\\"no key 'foo' in database <SequenceFileDB\\\" in str(e), str(e)\",\n \"def test_error_no_json(self, app, data_queues, metricsmock):\\n res = self._call(app, \\\"\\\\xae\\\", method=\\\"post\\\", status=400)\\n detail = \\\"JSONDecodeError('Expecting value: line 1 column 1 (char 0)')\\\"\\n self.check_response(data_queues, res, \\\"parse_error\\\", details={\\\"decode\\\": detail})\\n metricsmock.assert_incr_once(\\n self.metric_type + \\\".request\\\", tags=[self.metric_path, \\\"key:test\\\"]\\n )\",\n \"def test_empty_json(self):\\n json_data = '{ }'\\n json_flattened = json_flatten(json_data)\\n self.assertEqual(json.loads(json_flattened), json.loads('{ }'))\",\n \"def test_get_single_different(single_bucket): # pylint: disable=redefined-outer-name\\n with pytest.raises(KeyError):\\n single_bucket.get(\\\"key 2\\\")\",\n \"def conflict():\\n return HttpError(409)\",\n \"def test_invalid_json(self):\\n req = '{\\\"jsonrpc\\\": \\\"2.0\\\", \\\"method\\\": \\\"foobar, \\\"params\\\": \\\"bar\\\", \\\"baz]'\\n resp = '{\\\"jsonrpc\\\": \\\"2.0\\\", \\\"error\\\": {\\\"code\\\": -32700, \\\"message\\\": \\\"ParseError: Parse error\\\"}, \\\"id\\\": null}'\\n status = 500\\n r_status, r_resp = self.exec_handler(req)\\n self.assertEqual(r_status, status)\\n self.assertEqual(simplejson.loads(r_resp), simplejson.loads(resp))\",\n \"def missing_data(self, data):\\n missing_fields = []\\n for key in data:\\n if not key in request.json:\\n missing_fields.append(key)\\n if missing_fields:\\n message = 'Missing ' + ', '.join(missing_fields)\\n return self.bad_request(message)\\n return None\",\n \"def _reject_invalid_json(val: Any) -> None:\\n raise ValueError(f\\\"Invalid JSON value: {val!r}\\\")\",\n \"def test_no_such_key():\\n test = [{'key': 'val1'}, ['missing']]\\n t_result = fetch_data_by_keys(*test)\\n assert not is_successful(t_result)\\n assert 'missing' in str(t_result.failure())\",\n \"def test_load_bad_data(tmp_path: Path) -> None:\\n fname = tmp_path / \\\"test5.json\\\"\\n with open(fname, \\\"w\\\") as fh:\\n fh.write(TEST_BAD_SERIALIED)\\n with pytest.raises(HomeAssistantError):\\n load_json(fname)\",\n \"def check_all_same_keys(dict_list, name):\\n if len(dict_list) == 0:\\n return\\n keys = dict_list[0].keys()\\n for dct in dict_list:\\n if keys != dct.keys():\\n raise DGLError('Expect all {} to have the same set of keys, but got'\\n ' {} and {}.'.format(name, keys, dct.keys()))\",\n \"def compare_json(test_name): # , json_object, filters):\\n baseline_json = None\\n result_json = None\\n try:\\n with open(robot_dir + \\\"/output/baseline/{}.json\\\".format(test_name.replace(' ', ''))) as baseline_file:\\n try:\\n with open(robot_dir + \\\"/output/results/{}.json\\\".format(test_name.replace(' ', ''))) as result_file:\\n baseline_json = json.load(baseline_file)\\n result_json = json.load(result_file)\\n except:\\n print(\\\"Failed to open the results json\\\")\\n except:\\n print(\\\"Failed to open the baseline json\\\")\\n return False\\n return ordered(baseline_json) == ordered(result_json)\",\n \"def _loadJson(self, file):\\n # TODO : Is it paranoid checking?\\n if os.path.isfile(file):\\n try:\\n with open(file, 'r') as f:\\n data = json.load(f)\\n return data\\n except ValueError:\\n msg = \\\"Corrupted JSON file => %s\\\" % file\\n # logger.error(msg)\\n self._exception(200, msg)\\n # return -2 # code for corrupted json file\\n else:\\n msg = \\\"File cannot be found => %s\\\" % file\\n self._exception(201, msg)\",\n \"def test_unique_upload_items(upload_items: List[JSONDict]) -> None:\\n validated = UploadCollection(items=upload_items)\\n assert validated.dict() == upload_items\",\n \"def keyError():\\n d = {}\\n d['cat']\",\n \"def test_simplef(self):\\n samp1 = JObject(keys = ['status', 'result'])\\n j = json.loads('{\\\"status\\\": \\\"success\\\", \\\"resultd\\\": \\\"yes\\\"}')\\n self.assertFalse(check_json_object(j, samp1))\",\n \"def check_for_dict(check):\",\n \"def check_job_json(job_info):\\n job_type_list = [job_type.value for _, job_type in JobType.__members__.items()]\\n if 'source_id' not in job_info:\\n raise ValueError(\\\"Json string Errors, key:source_id not found.\\\")\\n if 'job_id' not in job_info:\\n raise ValueError(\\\"Json string Errors, key:job_id not found.\\\")\\n if 'job_type' not in job_info or not job_info['job_type']:\\n raise ValueError(\\\"Json string Errors, key:job_type not found.\\\")\\n if job_info['job_type'] not in job_type_list:\\n raise ValueError(\\\"Invalid job type: {}.\\\".format(job_info['job_type']))\\n if 'job_content' not in job_info:\\n raise ValueError(\\\"Json string Errors, key:job_content not found.\\\")\",\n \"def test_dupe_keys():\\n assert_raises(voluptuous.SchemaError, Schema,\\n {Required(\\\"id\\\"): str, Required(\\\"id\\\"): int})\\n assert_raises(voluptuous.SchemaError, Schema,\\n {Required(\\\"id\\\"): str, \\\"id\\\": str})\\n assert_raises(voluptuous.SchemaError, Schema,\\n {voluptuous.Optional(\\\"id\\\"): str, Required(\\\"id\\\"): int})\",\n \"def test_json_reader_file_keys(process_data):\\n data = process_data(file_name_or_type='scooter_data.json')\\n for scooter in data:\\n names_keys = list(scooter.keys())\\n assert names_keys == ['id', 'name', 'vin_number',\\n 'electric_scooter', 'color',\\n 'city', 'usage', 'cost_usd',\\n 'total_years_of_use']\",\n \"def test_bad_valuetype():\\n test = [{'key': {'key1': 'val'}}, ['key']]\\n t_result = fetch_data_by_keys(*test)\\n assert not is_successful(t_result)\\n assert 'Bad data found' in str(t_result.failure())\",\n \"async def _handle_response(response: ClientResponse) -> Dict:\\n content = await response.json(encoding='utf-8', loads=loads)\\n if response.status != 200:\\n for member in JmRpcErrorType:\\n if content['message'] != member.value:\\n continue\\n raise JmRpcError(response.status, content)\\n response.raise_for_status()\\n return content\",\n \"def test_non_existent_file(self):\\n remove('Rectangle.json')\\n self.assertEqual(self.r1.load_from_file(), [])\",\n \"def test_correct_upload_item(upload_items: List[JSONDict]) -> None:\\n validated = UploadItem(**upload_items[0])\\n assert validated.dict() == upload_items[0]\",\n \"def _reject_invalid_json(val):\\n raise ValueError(f\\\"Invalid JSON value: {val!r}\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6223973","0.59830946","0.59771997","0.5899925","0.5856975","0.5799147","0.5791387","0.57734907","0.57483834","0.57410455","0.57091707","0.5696217","0.56931484","0.5691315","0.5677174","0.56699157","0.5655964","0.5650639","0.5624103","0.5604085","0.55974025","0.5597051","0.5577465","0.5566404","0.55583584","0.55497384","0.5549101","0.5540913","0.55212414","0.54976094","0.5489158","0.54839486","0.5474386","0.54613304","0.54541403","0.54503345","0.5446576","0.54421747","0.5429536","0.5426548","0.54211235","0.54179424","0.5414088","0.54094684","0.5407962","0.5397954","0.5383065","0.53783935","0.53698266","0.53659403","0.53461885","0.53408897","0.5333966","0.53333324","0.53098434","0.5301218","0.5287878","0.5286749","0.52861726","0.5285833","0.52852887","0.52772","0.5260189","0.5260066","0.52585787","0.523357","0.52232933","0.52159804","0.5214768","0.521012","0.5209362","0.52003133","0.51900816","0.5186109","0.51847357","0.51763046","0.5174612","0.51737034","0.51623416","0.51605076","0.5160468","0.5158792","0.5158644","0.5156079","0.5152765","0.51473635","0.5145869","0.5145706","0.5135056","0.5133046","0.51311696","0.51270574","0.51250654","0.51181906","0.5107895","0.51071435","0.51066405","0.5097118","0.5095688","0.50952995","0.5093318"],"string":"[\n \"0.6223973\",\n \"0.59830946\",\n \"0.59771997\",\n \"0.5899925\",\n \"0.5856975\",\n \"0.5799147\",\n \"0.5791387\",\n \"0.57734907\",\n \"0.57483834\",\n \"0.57410455\",\n \"0.57091707\",\n \"0.5696217\",\n \"0.56931484\",\n \"0.5691315\",\n \"0.5677174\",\n \"0.56699157\",\n \"0.5655964\",\n \"0.5650639\",\n \"0.5624103\",\n \"0.5604085\",\n \"0.55974025\",\n \"0.5597051\",\n \"0.5577465\",\n \"0.5566404\",\n \"0.55583584\",\n \"0.55497384\",\n \"0.5549101\",\n \"0.5540913\",\n \"0.55212414\",\n \"0.54976094\",\n \"0.5489158\",\n \"0.54839486\",\n \"0.5474386\",\n \"0.54613304\",\n \"0.54541403\",\n \"0.54503345\",\n \"0.5446576\",\n \"0.54421747\",\n \"0.5429536\",\n \"0.5426548\",\n \"0.54211235\",\n \"0.54179424\",\n \"0.5414088\",\n \"0.54094684\",\n \"0.5407962\",\n \"0.5397954\",\n \"0.5383065\",\n \"0.53783935\",\n \"0.53698266\",\n \"0.53659403\",\n \"0.53461885\",\n \"0.53408897\",\n \"0.5333966\",\n \"0.53333324\",\n \"0.53098434\",\n \"0.5301218\",\n \"0.5287878\",\n \"0.5286749\",\n \"0.52861726\",\n \"0.5285833\",\n \"0.52852887\",\n \"0.52772\",\n \"0.5260189\",\n \"0.5260066\",\n \"0.52585787\",\n \"0.523357\",\n \"0.52232933\",\n \"0.52159804\",\n \"0.5214768\",\n \"0.521012\",\n \"0.5209362\",\n \"0.52003133\",\n \"0.51900816\",\n \"0.5186109\",\n \"0.51847357\",\n \"0.51763046\",\n \"0.5174612\",\n \"0.51737034\",\n \"0.51623416\",\n \"0.51605076\",\n \"0.5160468\",\n \"0.5158792\",\n \"0.5158644\",\n \"0.5156079\",\n \"0.5152765\",\n \"0.51473635\",\n \"0.5145869\",\n \"0.5145706\",\n \"0.5135056\",\n \"0.5133046\",\n \"0.51311696\",\n \"0.51270574\",\n \"0.51250654\",\n \"0.51181906\",\n \"0.5107895\",\n \"0.51071435\",\n \"0.51066405\",\n \"0.5097118\",\n \"0.5095688\",\n \"0.50952995\",\n \"0.5093318\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85178,"cells":{"query":{"kind":"string","value":"Onetime use function. Method for rebasing .json files. Previous file versions did not include the base64 prefix."},"document":{"kind":"string","value":"def rebase_add_encoding_prefix():\n\tfilenames, clippings = load_clippings(inFolder)\n\tfor file, clip in zip(filenames, clippings):\n\t\timg = clip[\"imgEncoding\"]\n\t\tstr = \"data:image/png;base64,\"\n\t\tif str not in img:\n\t\t\tclip[\"imgEncoding\"] = str + img\n\t\t\twith open(file, \"w\") as outfile:\n\t\t\t\tjson.dump(clip, outfile)"},"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 replace_gen(self):\r\n current_path = os.path.join(self.settings.save_path, 'current.json')\r\n current_folder_path = os.path.join(self.settings.save_path, 'current')\r\n history_path = os.path.join(self.settings.save_path, 'history')\r\n archive_folder_path = os.path.join(history_path, f'gen{self.generation}')\r\n archive_path = os.path.join(archive_folder_path, 'current') # no ending allowed\r\n archive_json_path = os.path.join(archive_folder_path, 'current.json')\r\n\r\n\r\n if not os.path.exists(current_path):\r\n raise FileNotFoundError\r\n if not os.path.exists(current_folder_path):\r\n raise FileNotFoundError\r\n\r\n os.makedirs(history_path, exist_ok=True)\r\n os.makedirs(archive_folder_path)\r\n\r\n cwd = os.getcwd()\r\n shutil.make_archive(archive_path, 'zip', current_folder_path)\r\n os.chdir(cwd)\r\n shutil.rmtree(current_folder_path, onerror=_ignore_del_dir_failure)\r\n os.chdir(cwd)\r\n\r\n os.rename(current_path, archive_json_path)","def anonymize(data_dir):\n\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\n for dir_name in sorted(dirs):\n dir_path = os.path.join(root, dir_name)\n json_path = os.path.join(root, dir_name, 'data.json')\n print(json_path)\n\n with open(json_path) as f:\n data = json.load(f)\n\n data.pop('user_email')\n data.pop('user_name')\n data.pop('survey_data')\n\n with open(json_path, 'w') as f:\n json.dump(data, f)","def regenerate_json_file():\n \n # filepaths used in generating json data...\n dir_export = f\"C:\\\\Users\\\\{os.getlogin()}\\\\Downloads\"\n list_name = 'my-favourite-films.csv'\n json_output_filename = 'reviews_web_data.json'\n path_to_rootreducer = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\reducers\\\\RootReducer.js';\n path_to_json_output = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\components\\\\films\\\\{json_output_filename}'\n \n # 1) find letterboxd zip export...\n prefix = 'letterboxd'\n postfix = 'utc.zip'\n zip_file_name = \"\"\n download_folder = sorted(glob.glob(f\"{dir_export}/*.zip\"), key=os.path.getmtime)\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\n for filepath in download_folder:\n filename = filepath.split('\\\\')[-1]\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\n zip_file_name = filename\n print(f\"Found the zip export! -> {zip_file_name}\")\n break\n else:\n continue\n\n path_to_zip_file = f\"{dir_export}\\\\{zip_file_name}\" # path to zip file we downlodaded from letterboxd...\n path_to_extracted_zip = f\"{dir_export}\\\\{zip_file_name[:-4]}\" # path to extracted zip (which we are about to do)...\n\n # 2) extract zip automatically (if not done already)...\n if os.path.exists(path=path_to_zip_file):\n if not os.path.exists(path=path_to_extracted_zip):\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\n z.extractall(path_to_extracted_zip)\n print(f\"Extract complete! -> {path_to_extracted_zip}\")\n else:\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\n else:\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\n\n\n # local version of letterboxd data list\n letterboxd_list = []\n \n # 3) locate the csv file of interest\n if os.path.exists(path_to_extracted_zip): \n # open csv file...\n path_to_list = f'{path_to_extracted_zip}\\\\lists\\\\{list_name}'\n with open(path_to_list, 'r') as f:\n # csv reader object\n csv_reader = csv.reader(f)\n \n # skip header in the csv file...\n rows_to_skip = 5\n for i in range(0, rows_to_skip):\n next(csv_reader)\n \n # 4) iterate over each row (i.e. each film) in csv file...\n for csv_row in csv_reader:\n pos = csv_row[0]\n title = csv_row[1]\n year = csv_row[2]\n letterboxd_url = csv_row[3]\n letterboxd_film_id = letterboxd_url.split('/')[-1]\n genres = []\n directors = []\n duration = 0\n language = \"\"\n imdb_url = \"\"\n imdb_avg_rating = \"\"\n imdb_num_votes = \"\"\n tmdb_url = \"\"\n poster_url = \"\"\n \n # parse data from letterboxd web page... (this takes ~1.21s)\n page = session.get(url=letterboxd_url, verify=False, stream=True)\n soup = BeautifulSoup(page.content, 'html.parser')\n \n # retrieve list of genres...\n div_genres = soup.select_one('#tab-genres')\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\n if 'genre' in link['href']:\n genre = link.text.capitalize()\n if genre == 'Science-fiction':\n genre = 'Sci-fi'\n genres.append(genre)\n\n # retrieve duration\n textfooter = soup.select_one('section.col-main > p.text-footer').text\n if 'mins' in textfooter:\n minstext = textfooter.find('mins', 0, len(textfooter))\n duration = textfooter[minstext-5:minstext].strip()\n \n # retrieve the first spoken language\n div_details = soup.select_one('#tab-details')\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\n if 'language' in link['href']:\n language = link.text.capitalize()\n break\n \n # retrieve IMDB url\n footer = soup.select_one('section.col-main p.text-footer')\n url_buttons = footer.select('a.micro-button')\n for url in url_buttons:\n if 'imdb' in url.text.lower():\n # get IMDB URL\n imdb_url = url['href']\n elif 'tmdb' in url.text.lower():\n # get TMDB URL\n tmdb_url = url['href']\n if len(url_buttons) == 1:\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\n\n # retrieve avg rating on letterboxd\n # page_content_str = page.content.decode('utf-8')\n # letterboxd_avg_rating = soup.select_one('.average-rating')\n\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\n imdb_film_id = imdb_url.split('/')[-2]\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\n imdb = requests.get(url=url, verify=False)\n imdb_json = json.loads(imdb.text)\n\n # retrieve avg IMD rating\n imdb_avg_rating = imdb_json['imdbRating']\n \n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\n \n # retrieve poster from IMDB\n poster_url = imdb_json['Poster']\n if 'SX300' in poster_url:\n poster_url = poster_url.split('SX300')[0]\n \n # retrieve title from IMDB (because letterboxd parsing is shite!)\n # title = imdb_json['Title']\n \n # retrieve list of directors (because letterboxd parsing is shite!)\n directors = imdb_json['Director'].split(', ')\n \n # id of my review!\n titlev2 = Helpers.simplify_movie_title(title=title)\n review_id = f\"{titlev2}-{letterboxd_film_id}-review\"\n \n \"\"\"\n # iterate over \\\\img\\\\films\\\\\n screenshots = []\n directory_in_str = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\img\\\\films';\n for subdir, dirs, files in os.walk(directory_in_str):\n for file in files:\n # find the right directory...\n title_from_directory_storing_screenshots = subdir.split('\\\\')[-1]\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\n if titlev3 == titlev2:\n # get my screenshots...\n if 'screenshot' in file:\n screenshot = os.path.join(subdir, file)\n screenshots.append(screenshot)\n \n # use my custom poster if I put one there...\n if 'custom_poster' in file:\n poster_url = os.path.join(subdir, file)\n \"\"\"\n \n # DEBUGGING....\n print(f\" > {pos}: {title}\")\n #print(f' > Title = ({title})')\n #print(f' > IMDB url = ({imdb_url})')\n #print(f' > Language = ({language})')\n #print(f' > Duration = ({duration})')\n #print(f' > Genres = ({genres})')\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\n #print(f' > IMDB num votes = ({imdb_num_votes})')\n #print(f' > Poster = ({poster_url})')\n #print(f' > Directors = ({directors})')\n #print(f' > Tags = ({my_tags})')\n \n # append to list...\n letterboxd_list.append({\n 'letterboxdFilmId': letterboxd_film_id,\n 'imdbFilmId': imdb_film_id,\n 'letterboxdUrl': letterboxd_url,\n 'imdbUrl': imdb_url,\n 'posterUrl': poster_url,\n 'position': pos,\n 'title': title,\n 'year': year,\n 'duration': duration,\n 'language': language,\n 'imdbAvgRating': imdb_avg_rating,\n 'imdbNumVotes': imdb_num_votes,\n 'tmdbUrl': tmdb_url,\n 'directors': directors,\n 'genres': genres,\n 'reviewId': review_id\n })\n \n # clear json file first...\n open(path_to_json_output, 'w').close()\n \n # write new content...\n with open(path_to_json_output, 'w') as f:\n json.dump(letterboxd_list, f, indent=4)\n \n print(f'JSON export finished! -> {path_to_json_output}')","def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\n\n print(\"Fixing the acquisition numbers of the .json files in sourcedata.\")\n\n for old_path in raw_dir.rglob(\"*.json\"):\n\n parts_of_stem_of_old_path = old_path.stem.split(\"_\")\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\n fresh_new_stem = \"_\".join(stem_parts_with_correct_acquisition_number)\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\n old_path.replace(fresh_new_path)","def test_rotate_filenames():\n tmpdir = os.path.join(tempfile.gettempdir(), \"jade-test-tmp87alkj8ew\")\n os.makedirs(tmpdir, exist_ok=True)\n\n data = {\"A\": 1, \"B\": 2}\n json_file1 = os.path.join(tmpdir, \"a1.json\")\n dump_data(data, json_file1)\n\n json_file2 = os.path.join(tmpdir, \"a2.json\")\n dump_data(data, json_file2)\n\n rotate_filenames(tmpdir, \".json\")\n\n if os.path.exists(tmpdir):\n shutil.rmtree(tmpdir)","def minify_json(self) -> None:\n print(f\"[FileManager: INFO] Minifing file {self.path}\")\n file_data = open(self.path, \"r\", encoding=\"utf-8\").read()\n json_data = json.loads(file_data) \n json_string = json.dumps(json_data, separators=(',', \":\")) \n path = str(self.path).replace(\".json\", \"\")\n new_path = \"{0}_min.json\".format(path)\n open(new_path, \"w+\", encoding=\"utf-8\").write(json_string)","def fix_path(self):\n paths = self.data['path'].tolist()\n prefixes = [re.findall(r'[A-Z\\-0-9]+', path) for path in paths]\n prefix_good = [str(prefix[0]) + \".json\" for prefix in prefixes]\n self.data['path'] = prefix_good","def sanitize_json_files(unsanitized_json_file):\n with open(develop_baseline_dir + unsanitized_json_file) as f:\n lines = f.readlines()\n\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\n w.writelines([item for item in lines[:-1]])","def _files_from_json(self, file_json):\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\n self.compression_algorithm = 'gzip'\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()","def json_to_cache(new_json: Dict, file_name: str) -> None:\n\n json_path = os.path.join(CACHE_DIR, file_name)\n ensure_dir(json_path)\n with open(json_path, \"w\") as outfile:\n json.dump(new_json, outfile, ensure_ascii=False)","def processed_json_path(path):\n return path.replace(RAW_ASSETS_PATH, ASSETS_PATH).replace('.json', '.bin')","def process_files_json():\n # chdir into beep root\n pwd = os.getcwd()\n os.chdir(os.environ.get(\"BEEP_ROOT\", \"/\"))\n\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\n\n all_list = sorted(all_list)\n dumpfn(all_list, \"all_files.json\")\n\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\n\n new_file_index = file_id\n\n for filename in tqdm(sorted(file_list)):\n # If the file has already been renamed another entry should not be made\n if mapdf['filename'].str.contains(filename).sum() > 0:\n continue\n old_file = os.path.join(SRC_DIR, filename)\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\n shutil.copy(old_file, new_path) # copy main data file\n shutil.copy(old_file.replace(\".csv\", '_Metadata.csv'), new_path) # copy meta data file\n\n if PROJECT_NAME == 'FastCharge':\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\n elif PROJECT_NAME == 'ClosedLoopOED':\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\n else:\n raise ValueError(\"Unsupported PROJECT_NAME: {}\".format(PROJECT_NAME))\n\n df_dup = mapdf.set_index(['protocol', 'date'])\n if (protocol, date) in df_dup.index:\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\n file_id = row['fid'].iloc[0]\n protocol = row['protocol'].iloc[0]\n date = row['date'].iloc[0]\n strname = row['strname'].iloc[0]\n else:\n file_id = new_file_index\n new_file_index = new_file_index + 1\n\n new_name = \"{}_{}_{}\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \"{}.csv\".format(new_name))\n\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\n os.path.abspath(old_file),\n os.path.abspath(new_file)]],\n columns=METADATA_COLUMN_NAMES)\n mapdf = mapdf.append(new_row)\n\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\".csv\", \"_Metadata.csv\"),\n new_file.replace(\".csv\", \"_Metadata.csv\"))\n\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \"map.csv\"), index=False)\n mapdf = mapdf.reset_index(drop=True)\n os.chdir(pwd)\n return json.dumps(mapdf.to_dict(\"list\"))","def fix_jsons_in(bids_dir: Path):\n\n print(\"Finalizing task json files.\")\n\n for path in bids_dir.rglob(\"func/*_task-*.json\"):\n append_to_json_file(key=\"TaskName\", value=task_name_of(path), path_to_json=path)\n\n print(\"Appending echo times to phase difference json files.\")\n\n for path in bids_dir.rglob(\"fmap/*_phasediff.json\"):\n magnitude1_path = the_path_that_matches(pattern=\"sub-*_magnitude1.json\", in_directory=path.parent)\n magnitude2_path = the_path_that_matches(pattern=\"sub-*_magnitude2.json\", in_directory=path.parent)\n echo_time1 = value_of_key_in_json_file(\"EchoTime\", magnitude1_path)\n echo_time2 = value_of_key_in_json_file(\"EchoTime\", magnitude2_path)\n append_to_json_file(key=\"EchoTime1\", value=echo_time1, path_to_json=path)\n append_to_json_file(key=\"EchoTime2\", value=echo_time2, path_to_json=path)\n\n print(\"Setting targets of fieldmap json files.\")\n\n for path in bids_dir.rglob(\"fmap/*.json\"):\n func_dir = path.parent.parent / \"func\"\n trimmed_func_paths = [\"func/\" + func_path.name for func_path in func_dir.glob(\"*.nii\")]\n append_to_json_file(key=\"IntendedFor\", value=trimmed_func_paths, path_to_json=path)","def get_source_file_name(json_name):\n assert json_name.endswith(JSON_EXT)\n (directory, base_name) = os.path.split(json_name)\n new_directory = os.path.relpath(directory, start=CACHE)\n new_directory = os.path.join(\"/\", new_directory)\n new_base_name = base_name[:-len(JSON_EXT)]\n i = new_base_name.rfind(\"-\")\n if i != -1:\n new_base_name = new_base_name[:i] + \".\" + new_base_name[i + 1:]\n result = os.path.join(new_directory, new_base_name)\n return result","def reset_data():\n shutil.copy2(\n 'data/one_producer_many_consumers.ORIG.json',\n 'data/one_producer_many_consumers.json'\n )","def getcleanjson(self):\n dico=self.dico.copy() # shalow copie as we remove second level data in the copied\n for key in [\"basefiles\",\"grader\",\"soluce\"]:\n if key in dico:\n del dico[key]\n return str(json.dumps(dico))","def reformfile0():\n txt = \"\"\"\n {\n \"policy\": {\n \"_SS_Earnings_c\": {\"2016\": [300000],\n \"2018\": [500000],\n \"2020\": [700000]}\n }\n }\n \"\"\"\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\n rfile.write(txt + '\\n')\n rfile.close()\n # Must close and then yield for Windows platform\n yield rfile\n if os.path.isfile(rfile.name):\n try:\n os.remove(rfile.name)\n except OSError:\n pass # sometimes we can't remove a generated temporary file","def fileRenameandReplace(filename,newfilename):\n try:\n os.rename(filename,newfilename)\n logging.info(\"Json file renamed in PD path\")\n except Exception as er:\n print (\"Not able to rename the json file \")\n return False","def reformfile1():\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\n rfile.write(REFORM1_CONTENTS)\n rfile.close()\n # must close and then yield for Windows platform\n yield rfile\n if os.path.isfile(rfile.name):\n try:\n os.remove(rfile.name)\n except OSError:\n pass # sometimes we can't remove a generated temporary file","def repair_json(in_file, out_file, path_to_img):\n with open(in_file, 'rb') as f:\n data = f.readlines()\n\n # delete all \\n characters\n data = map(lambda x: x.rstrip(), data)\n\n # make one JSON object per row\n json_rows = []\n start = -1\n while True:\n try:\n start = data.index('{', start + 1)\n end = data.index('}', start)\n row = ''.join(data[start:end+1])\n row = re.sub(\"\\\"Bmp\\\"\", \"\\\"Image\\\"\", row)\n row = re.sub(\".bmp\", \".jpg\", row)\n json_rows.append(row)\n start = end\n except ValueError:\n break\n\n # join all JSON objects into one comme delimited string enclosed in square brackets\n data_join_str = \"[\" + ','.join(json_rows) + \"]\"\n\n # create JSON object\n repaired_json = json.loads(data_join_str)\n for x in repaired_json:\n f = os.path.join(path_to_img, x['Image'])\n print x['Image']\n if not os.path.isfile(f):\n repaired_json.remove(x)\n # remove out_file if it exists\n try:\n os.remove(out_file)\n except OSError:\n pass\n except IOError:\n pass\n print 'dumping...'\n with open(out_file, 'w+') as f:\n json.dump(repaired_json, f)","def get_metadata_file(self, file_in_cache):\n return re.sub(r'\\.tar$', '.json', file_in_cache)","def fix_image_dict(folder, image_dict):\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \"*.*\")\n for file_path in glob.glob(image_pattern):\n file_name = os.path.basename(file_path)\n if file_name not in image_dict:\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]","def restore_base_data():\n\n db_dirname = os.path.dirname(os.path.realpath(__file__))\n shutil.copyfile(src=os.path.join(db_dirname, 'consolemini.base.json'),\n dst=os.path.join(db_dirname, 'consolemini.test.json'))","def backeruper(file_name, file_num=0):\n\n if not os.path.exists('%s.json' % file_name):\n write_backup('%s.json' % file_name)\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\n write_backup('%s.%s.json' % (file_name, file_num))\n else:\n file_num += 1\n backeruper(file_name, file_num)","def remove_base64(examples: List[TaskType]) -> List[TaskType]:\n for eg in examples:\n if \"audio\" in eg and eg[\"audio\"].startswith(\"data:\") and \"path\" in eg:\n eg[\"audio\"] = eg[\"path\"]\n if \"video\" in eg and eg[\"video\"].startswith(\"data:\") and \"path\" in eg:\n eg[\"video\"] = eg[\"path\"]\n return examples","def test_get_pathless_raw_file_name_json(self):\n\n this_pathless_file_name = probsevere_io._get_pathless_raw_file_name(\n unix_time_sec=VALID_TIME_UNIX_SEC,\n file_extension=probsevere_io.JSON_FILE_EXTENSION)\n\n self.assertTrue(this_pathless_file_name == PATHLESS_JSON_FILE_NAME)","def fix_file(\n self,\n filepath: Path,\n output_dir: Path,\n add_unique_suffix: bool = False,\n ) -> str | Path:\n return filepath","def unpack_rename_data(self):\n for old, new in self.f_name_map.items():\n try:\n read_path = Path(os.environ[\"DATA_PATH\"]) / old\n write_path = Path(os.environ[\"DATA_PATH\"]) / new\n if \"ZIP\" in old:\n shutil.unpack_archive(read_path, write_path, \"zip\")\n else:\n shutil.unpack_archive(read_path, write_path)\n read_path.unlink() # delete original file\n except OSError:\n print(f\"Did not unpack {read_path}\")","def remove_useless_file(rootPath):\n all_file_paddle_list = get_all_paddle_file(rootPath)\n ut_file_map_new = {}\n ut_file_map = \"%s/build/ut_file_map.json\" % rootPath\n with open(ut_file_map, 'r') as load_f:\n load_dict = json.load(load_f)\n for key in load_dict:\n if key in all_file_paddle_list:\n ut_file_map_new[key] = load_dict[key]\n\n with open(\"%s/build/ut_file_map.json\" % rootPath, \"w\") as f:\n json.dump(ut_file_map_new, f, indent=4)\n print(\"remove_useless_file ut_file_map success!!\")","def main():\n\n # Set up argument parser.\n parser = argparse.ArgumentParser(\n description='Removes duplicate key-value pairs from JSON files.')\n parser.add_argument('--suffix', default='',\n help='optional suffix for output files; '\n 'if empty, files will be changed in place')\n parser.add_argument('files', nargs='+', help='input files')\n args = parser.parse_args()\n\n # Iterate over files.\n for filename in args.files:\n # Read in json using Python libraries. This eliminates duplicates.\n print('Processing ' + filename + '...')\n try:\n with codecs.open(filename, 'r', 'utf-8') as infile:\n j = json.load(infile)\n except ValueError as e:\n print('Error reading ' + filename)\n raise InputError(filename, str(e))\n\n # Built up output strings as an array to make output of delimiters easier.\n output = []\n for key in j:\n if key != '@metadata':\n output.append('\\t\"' + key + '\": \"' +\n j[key].replace('\\n', '\\\\n') + '\"')\n\n # Output results.\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\n outfile.write('{\\n')\n outfile.write(',\\n'.join(output))\n outfile.write('\\n}\\n')","def rewrite_data_files():\n return False","def newJsonFile():\n nonlocal currentFile\n currentFile = join(rootFolder, 'tweetsRaw-' + str(now()) + '.json')\n f = open(currentFile)\n f.write('[\\n')\n return f","def reformat(self):\n\t\told_path = os.path.join( self.path, self.init_str )\n\t\tnew_path = os.path.join( self.path, self.reorder() )\n\t\tos.rename(old_path,new_path)","def copy_json():\n sourcePath = 'contents/external/'\n targetPath = 'build/external/'\n for base,subdirs,files in os.walk(sourcePath):\n for file in files:\n orig = os.path.join(base, file)\n if os.path.isfile(orig) and file[-5:] == '.json':\n targetBase = os.path.join(targetPath, base[len(sourcePath):])\n dest = os.path.join(targetBase, file)\n puts(\"Checking diretory %s\" % targetBase)\n if not os.path.exists(targetBase):\n puts(yellow(\"Not found! Creating...\"))\n os.makedirs(targetBase)\n puts(\"Copying from %s to %s\" % (orig, dest))\n copyfile(orig, dest)","def setUp(self):\n if os.path.exists('file.json'):\n os.remove(\"file.json\")","def _dumpJson(self, data, file):\n name, ext = os.path.splitext(file)\n tempFile = \"{0}.tmp\".format(name)\n with open(tempFile, \"w\") as f:\n json.dump(data, f, indent=4)\n shutil.copyfile(tempFile, file)\n os.remove(tempFile)","def ref_resp2files(output_file, output_json):\n with open(output_file, \"w\") as reference_text:\n reference_text.write(output_json)","def fix_subfiles(ln):\n m = input_re.search(ln)\n if m:\n fn = m.group(1)\n fI = file(fn,\"r\")\n fO = file(fn + \".tmp\",\"w\")\n for ln in fI:\n ln = sqb2_re.sub(\"[\",ln)\n fO.write(unescape_sqb(ln))\n fI.close()\n fO.close()\n fI = file(fn,\"w\")\n fO = file(fn + \".tmp\",\"r\")\n for ln in fO:\n fI.write(ln)\n fI.close()\n fI.close()","def process_obfuscated_pkg(self, pkg):\r\n chunks = pkg.split('/')\r\n prefix = list(itertools.dropwhile(lambda chunk: len(chunk) <= self.MAX_OBFUSCATION_CHUNK_SIZE, reversed(chunks)))\r\n res = '/'.join(reversed(prefix)) if len(prefix) > 1 or len(prefix) == len(chunks) else '_OBFUSCATED_'\r\n return res","def rewrite(self):\n for f in self.files:\n metadata = dict()\n metadata[\"description\"] = f.metadata.get(\"desc\", \"Unknown\")\n metadata[\"script\"] = os.path.basename(f.filename)\n metadata[\"requires\"] = []\n for package, component in f.requires:\n if package == self.key:\n metadata[\"requires\"].append(\"/\" + component)\n else:\n metadata[\"requires\"].append(package + \"/\" + component)\n metadata[\"provides\"] = [ p[1] for p in f.provides ]\n # Resolve symlinks\n real_filename = os.path.realpath(f.filename)\n LOG.info(\"Editing: \" + real_filename)\n new_filename = f.filename + \".new\"\n new = file(new_filename, \"w\")\n new.write(\"/*\\n---\\n\")\n new.write(yaml.dump(metadata))\n new.write(\"\\n...\\n*/\\n\")\n new.write(file(f.filename).read())\n new.close()\n os.rename(new_filename, real_filename)\n\n package_data = dict()\n package_data[\"name\"] = self.key\n package_data[\"sources\"] = []\n package_data[\"version\"] = \"Unknown\"\n package_data[\"copyright\"] = \"Unknown\"\n package_data[\"description\"] = \"Unknown\"\n target_dir = os.path.dirname(self.scripts_json_filename)\n # package.yml is typically in the parent of the scripts.json dir\n if os.path.basename(target_dir) == \"Source\":\n target_dir = os.path.dirname(target_dir)\n target_filename = os.path.join(target_dir, \"package.yml\")\n for f in self.files:\n common = os.path.commonprefix([target_filename, f.filename])\n source_file = f.filename[len(common):]\n package_data[\"sources\"].append(source_file)\n LOG.info(\"Writing: \" + target_filename)\n out = file(target_filename, \"w\")\n out.write(yaml.dump(package_data))\n out.close()","def refresh_cdb_json_file(file_path):\n cdb_dir = os.path.dirname(file_path)\n file_name = os.path.basename(file_path)\n upstream_dir = os.path.join(cdb_dir, 'upstream')\n upstream_md5 = os.path.join(upstream_dir, '{}.MD5'.format(file_name))\n upstream_json = os.path.join(upstream_dir, '{}.json'.format(file_name))\n\n logger = utils.get_logger()\n logger.debug('Processing: {}'.format(file_name))\n\n cdb_md5 = utils.md5_file(file_path)\n try:\n with open(upstream_md5, 'r') as f:\n json_md5 = f.read()\n\n # If the cdb file matches the generated md5,\n # no changes are needed to the json\n if json_md5 == cdb_md5:\n return True\n except IOError:\n pass\n\n tmp_json = tempfile.NamedTemporaryFile(delete=False)\n with open(file_path, 'r') as fp:\n reader = cdblib.Reader(fp.read())\n\n out = collections.OrderedDict()\n for k, v in reader.iteritems():\n out[k] = v\n\n json_data = json.dumps(out, indent=0, separators=(',', ':'))\n\n # Make python json.dumps match php's json_encode\n # Remove first newline\n json_data = json_data.replace('\\n', '', 1)\n\n # Escape slashes\n json_data = json_data.replace('/', '\\/')\n\n # Remove final newline\n json_data = ''.join(json_data.rsplit('\\n', 1))\n\n tmp_json.write(json_data)\n tmp_json.close()\n os.chmod(tmp_json.name, 0o644)\n shutil.move(tmp_json.name, upstream_json)\n logger.debug('Updated: {}'.format(upstream_json))\n\n with open(upstream_md5, 'w') as md5:\n md5.write(cdb_md5)\n\n return True","def test_tmp_file_content(self, mocker):\n payload = dict(id=\"B\", data={\"some\": \"data\"}, ai_service='A')\n headers = {'x-rh-identity': 'ABC'}\n\n with mocker.mock_module.patch.object(os, 'remove') as mock:\n self.client.post(self.url, json=payload, headers=headers)\n filename = mock.call_args[0][0]\n\n with tarfile.open(filename, 'r:gz') as tar:\n content = tar.extractfile('A_B.json').read()\n assert content == b'{\"some\": \"data\"}'\n\n os.remove(filename)","def make_json(prefix, input_dir):\n # get list of files\n file_list = os.listdir(input_dir)\n # set reference sequence\n tracklist = {'formatVersion': 1,\n 'refSeqs': '%s.ref.fa.fai' % prefix,\n 'tracks': []}\n # add reference sequence track to tracklist.json\n tracklist['tracks'].append({\"category\": \"Reference sequence\",\n \"key\": \"Reference sequence\",\n \"label\": \"Reference sequence\",\n \"type\": \"SequenceTrack\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/IndexedFasta\",\n \"urlTemplate\": \"%s.ref.fa\" % prefix,\n \"refSeqOrder\": \"False\"})\n tracklist['tracks'].append({\"category\": \"Consensus sequence\",\n \"key\": \"Consensus sequence\",\n \"label\": \"Consensus sequence\",\n \"type\": \"SequenceTrack\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/IndexedFasta\",\n \"urlTemplate\": \"%s.cons.fa\" % prefix,\n \"refSeqOrder\": \"False\"})\n # add bigwig track to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Coverage\",\n \"label\": \"Coverage\",\n \"type\": \"JBrowse/View/Track/Wiggle/XYPlot\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BigWig\",\n \"autoscale\": \"local\",\n \"urlTemplate\": \"%s.sorted.bw\" % prefix\n })\n # add BAM Sequence Coverage to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Sequence reads (SNPs/Coverage)\",\n \"label\": \"Sequence reads (SNPs/Coverage)\",\n \"type\": \"JBrowse/View/Track/SNPCoverage\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BAM\",\n \"urlTemplate\": \"%s.sorted.capped.bam\" % prefix,\n \"cacheMismatches\": \"True\",\n \"chunkSizeLimit\": \"5000000\"\n })\n # add BAM Sequence Alignments to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Sequence reads (Alignment)\",\n \"label\": \"Sequence reads (Alignment)\",\n \"type\": \"JBrowse/View/Track/Alignments2\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BAM\",\n \"urlTemplate\": \"%s.sorted.capped.bam\" % prefix,\n # add bigwig histogram option\n \"cacheMismatches\": \"True\",\n \"chunkSizeLimit\": \"5000000\"\n })\n # add GFF3 file to trackList.json\n tracklist['tracks'].append({\"category\": \"Annotation\",\n \"key\": \"Genbank annotation\",\n \"label\": \"Genbank annotation\",\n \"type\": \"JBrowse/View/Track/CanvasFeatures\",\n \"urlTemplate\": \"%s.gff3.gz\" % prefix,\n \"style\": {\n \"_defaultHistScale\": 4,\n \"_defaultLabelScale\": 30,\n \"_defaultDescriptionScale\": 120,\n # Comma-separated list of case-insensitive feature tags to use\n # for showing the feature's label.\n # The first one found will be used. Default 'name,id'.\n \"label\": \"product,id\",\n # style→description\tComma-separated list of case-insensitive\n # feature tags to check for the feature's long description.\n # The first one found will be used. Default 'note,description'.\n # If blank no description is used.\n \"description\": \"note, description\"\n },\n })\n\n json_path = os.path.join(input_dir, 'trackList.json')\n with open(json_path, 'wt') as output_handle:\n json_raw_str = json.dumps(tracklist, indent=4)\n output_handle.write(json_raw_str)\n return 'trackList.json'","def cleanJson(filename):\n saveFile = 'newFile.json'\n\n # check if file exists and exit if it does\n if os.path.exists(saveFile):\n return\n\n with open(filename) as f:\n contents = f.readlines()\n\n with open('newFile.json', 'a') as outfile:\n for line in contents:\n # convert line from JSON to Python dictionary\n dic = decode(line)\n # convert dic to a string representing a json object\n json_obj = json.dumps(dic)\n outfile.write(json_obj) # write to outfile\n outfile.write(\"\\n\")","def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\n\n old_and_new_paths = {}\n old_paths = list(raw_dir.rglob(\"*\"))\n print(f\"Sorting {len(old_paths)} paths into a dictionary.\") \n\n def task_name_of(path_to_func_or_json):\n \"\"\"\n Returns the task name of a func or json file. This function OVERWRITES the function\n \"task_name_of\" that we imported at the top of this script. BUT! It only overwrites it\n HERE, in \"create_dictionary_of_old_and_new_paths\".\n \"\"\"\n\n list_of_lines_containing_raw_subject_info = []\n for path in old_paths:\n if filetype_of(path) == \"subject info\":\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\n break\n\n for line in list_of_lines_containing_raw_subject_info:\n if path_to_func_or_json.stem in line:\n return line.split(\"z\")[1]\n\n\n for old_path in old_paths:\n\n new_path = old_path\n\n if filetype_of(old_path.with_suffix(\".nii\")) == \"anat\" and acquisition_number_of(old_path) == \"14\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"anat\" / f\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"func\" and acquisition_number_of(old_path) != \"02\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"func\" / f\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"fieldmap\" and not exclude_fieldmaps:\n old_affix = old_path.stem.split(\"_\")[-1]\n new_affix = \"phasediff\"\n if old_affix == \"e1\":\n new_affix = \"magnitude1\"\n if old_affix == \"e2\":\n new_affix = \"magnitude2\"\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"fmap\" / f\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\"\n\n old_and_new_paths[old_path] = new_path\n\n print(\"Paths sorted.\")\n\n return old_and_new_paths","def updateCache(self):\n for root, dirs, files in os.walk(cachedFilesPath):\n for file in files:\n if file.endswith(cachedFileExtensionSuffix):\n path = os.getcwd()+'/'+cachedFilesPath+file\n with open(path, mode='r') as f:\n payload_json = f.read()\n payload_obj=jsonpickle.decode(payload_json)\n r= self.upload(payload_obj)\n if isinstance(r, types.NoneType):\n #do nothing\n print(\"\")\n else:\n if r.status_code == 200 :\n #uploaded!\n if cacheArhive:\n #move it to archive\n dst=os.getcwd()+'/'+cachedArchivePath+file\n shutil.move(path, dst)\n print(\"archived log: \", file)\n else:\n #delete it\n os.remove(path)","def changeFilenames(reduced, path, input):\n file = path + '/' + input\n data = open(file, 'r').readlines()\n os.remove(file)\n\n fh = open(file, 'w')\n for line in data:\n if 'includegraphics' in line:\n for key in reduced:\n if key in line:\n new = line.replace(key, reduced[key])\n fh.write(new)\n\n logging.debug('Changed {0:>s} to {1:>s} '.format(line, new))\n else:\n fh.write(line)\n\n fh.close()","def add_base64_files(self, file_dict):\n if self.src_keys is None:\n self.src_keys, self.rgb_cam_list, self.rgb_of_depth_cam_list = init_cam_set(file_dict)\n self.src_keys_dict = {v: i for i, v in enumerate(self.src_keys)}\n logger.info('Init Calibrator done.')\n for k, v in file_dict.items():\n filename = str(10000000 + self.counter)[1:]\n if k.startswith('cam'):\n if 'dept' in k:\n continue\n cam_id = self.src_keys_dict[k]\n dst_path = os.path.join(self.calib_data_dir, str(\n cam_id), 'cam0', filename + '.jpg')\n if not os.path.exists(os.path.dirname(dst_path)):\n os.makedirs(os.path.dirname(dst_path))\n # print('calib data copy', v, dst_path)\n # print >> sys.stderr, 'calib data copy', v, dst_path\n with open(dst_path, 'w') as fout:\n fout.write(base64.b64decode(v))\n elif k.startswith('xeye'):\n for i, imgb64 in enumerate(v):\n cam_id = self.src_keys_dict[('xeye_image', i)]\n dst_path = os.path.join(self.calib_data_dir, str(\n cam_id), 'cam0', filename + '.png')\n if not os.path.exists(os.path.dirname(dst_path)):\n os.makedirs(os.path.dirname(dst_path))\n if self.resize_xeye:\n with open(self.record_path, 'a') as fout:\n fout.write('resize ' + imgb64 + ' ' + dst_path + '\\n')\n # resize_xeye_image_file(imgpath, dst_path)\n else:\n with open(dst_path, 'w') as fout:\n fout.write(base64.b64decode(imgb64))\n else:\n logger.warn('Unrocognize key: {}'.format(k))\n return\n self.counter += 1","def clearString(name):\n if name.find(\".tar\") != 0:\n name = name.replace(\".tar\", \"\")\n\n if name.find(\".gz\") != 0:\n name = name.replace(\".gz\", \"\")\n return name","def make_cached_json(file_name):\n result = None\n path = clean_path(file_name)\n working_directory = os.path.split(os.path.abspath(file_name))[0]\n file_type_switch = \"-s\" if is_sats_file(file_name) else \"-d\"\n command = []\n command.append(\"patsopt\")\n command.append(\"--jsonize-2\")\n command.append(file_type_switch)\n command.append(path)\n (stdout, _stderr, return_code) = run(\n working_directory,\n command,\n POSTIATS_ENCODING)\n if return_code == 0:\n cached_file_name = get_cached_file_name(path)\n cached_directory = os.path.split(cached_file_name)[0]\n if not os.path.exists(cached_directory):\n os.makedirs(cached_directory)\n output = open(cached_file_name, \"w\")\n output.write(stdout)\n output.close()\n result = json.loads(stdout)\n return result","def clean_out_old_env():\n d = \"dict_racey.json\"\n if os.path.exists(d):\n print(\"Remove the old cached JSON before continuing.\")\n os.remove(d)","def create_baseline_json(baseline_json_file):\n # TODO: Update this... Technically shouldn't need to sort it again since it was sorted when written to the results\n # directory\n baseline_json_file = baseline_json_file.replace(' ', '')\n if 'json' not in baseline_json_file:\n baseline_json_file += \".json\"\n with open(baseline_json_file, 'r') as json_file:\n try:\n json_object = json.load(json_file)\n except:\n print(\"Failed to open {}\".format(json_file))\n return\n\n # cmd = \"cat output/results/\" + baseline_json_file + \" | jq --sort-keys 'if .sysmlid? != null then sort_by(.sysmlId)? else . end' > output/baseline/\" + baseline_json_file.replace(\n # '_orig', '').replace('.json', '') + \"_sorted.json\"\n # print(commands.getoutput(cmd))","def beautify_json(self) -> None:\n for letter in self.data:\n for category in self.data[letter]:\n self.data[letter][category] = str(self.data[letter][category.lower()])\n self.save()\n with open(dict_path, encoding='utf-8') as x:\n data = x.read()\n with open(dict_path, 'w', encoding='utf-8') as y:\n data2 = data.replace('\"[', '[').replace(']\"', ']').replace(\"'\", '\"')\n y.write(data2)","def ModifyScenarioFiles(base_path):\n enumrealm = socket.gethostbyname('enum_realm')\n prirealm = socket.gethostbyname('prv_rsa')\n pubrealm = socket.gethostbyname('pub_rsa')\n\n strList = ['ENUM_REALM_IP','PRI_REALM_IP','PUB_REALM_IP']\n repList = [enumrealm,prirealm,pubrealm]\n fileName = ['Basic_Receiver_enum.xml','Basic_Receiver_pri.xml','Basic_Receiver_pub.xml']\n \n try:\n for i in range(len(strList)):\n zfile=open(base_path + fileName[i],\"r\")\n zList = zfile.readlines()\n zfile.close()\n\n for j in zList:\n if j.__contains__(strList[i]):\n str1 = j.replace(strList[i],repList[i])\n ind = zList.index(j)\n zList[ind] = str1\n break\n \n zfile=open(base_path + fileName[i],\"w\")\n zList = zfile.writelines(zList)\n zfile.close()\n except Exception, e:\n log.error('error: %s' %str(e))","def filter_json_file(filename, filters_list):\n filename = filename.replace(\" \", \"\")\n print(\"Filters List {}\".format(filters_list))\n if isinstance(filters_list, list) is False:\n filters_list = [filters_list]\n with open(robot_dir + \"/output/original/{}_orig.json\".format(filename), \"r\") as file_orig:\n # Get the root Json Object\n json_root_object = json.load(file_orig)\n\n if \"commitId\" in json_root_object:\n del json_root_object[\"commitId\"]\n\n # Store the original json object\n orig_json_object = json.dumps(json_root_object)\n root_key = json_root_object.keys()[0]\n\n if root_key == \"message\" and len(json_root_object.keys()) > 1:\n root_key = json_root_object.keys()[1]\n\n # Get the array of objects under the root\n try:\n if len(filters_list) > 0:\n json_root_object = delete_keys_from_dict(json_root_object, filters_list)\n except:\n print('Failed to delete keys from json_root_object before iteration')\n\n if root_key in ROOT_RETURN_ELEMENTS:\n json_array = json_root_object[root_key]\n\n if isinstance(json_array, list):\n # Clear the original array\n json_root_object[root_key] = []\n\n # For each object remove any of the keys that are specified in the filter list then put the object back into\n # the array\n for json_object in json_array:\n if len(filters_list) > 0:\n json_object = delete_keys_from_dict(json_object, filters_list)\n json_root_object[root_key].append(json_object)\n # json_root_object = sorted(json_root_object)\n elif isinstance(json_array, str):\n json_root_object = json_array\n\n # Serialize the JSON object before writing it to the file\n json_object = json.dumps(json_root_object, sort_keys=True, indent=4, separators=(',', ': '))\n # Write to result .json file:\n filtered_filename = robot_dir + \"/output/results/{}.json\".format(filename)\n filtered_file = open(filtered_filename, \"w\")\n # print(json_object)\n filtered_file.writelines(json_object)\n filtered_file.close()\n\n # return filtered_output, orig_output\n return json_object, orig_json_object","def test_to_json_file(self):\n\n output_file = \"this_file_is_a_ghost\"\n File(output_file).delete()\n\n Dict(self.test_subject.copy()).to_json_file(output_file)\n\n expected = self.test_subject.copy()\n\n actual = Dict().from_json_file(output_file)\n\n self.assertEqual(expected, actual)\n\n File(output_file).delete()","def download_files_from_minio(bucket_name, file_prefix, ls_files_to_download):\n minio_client = get_minio_client()\n ls_minio_files = list(minio_client.list_objects(bucket_name, file_prefix))\n ls_downloaded_files = []\n local_object_dir = tempfile.mkdtemp()\n for minio_object_path in ls_files_to_download:\n local_object_name = minio_object_path.replace(file_prefix, \"\")\n local_object_path = os.path.join(local_object_dir,local_object_name) \n get_file_fromMinio(bucket_name, minio_object_path, local_object_path)\n ls_downloaded_files.append(local_object_path)\n return ls_downloaded_files\n\n\n def process_columns(string_to_process, replace_string='_'):\n \"\"\"\n Process a column name by :\n - processing special aplphabetical characters\n - replacing special characters by value set in 'replace_string' \n #Parameters\n :param string_to_process (str): String to process (column name)\n :param replace_string (str, default : '_'): Value to set for replaced characters\n (ex : \"/\" -> \"\", where \"\" is the replace_string)\n #Return\n return out (str): Processed string\n \"\"\"\n BIGQUERY_COLUMN_NAME_RE = \"[^0-9a-zA-Z_]+\"\n # Get encoding of column\n str_bytes = str.encode(string_to_process)\n encoding = 'utf-8'\n # Process any special alphabetical character\n temp_out = unicodedata\\\n .normalize('NFKD', string_to_process)\\\n .encode('ASCII', 'ignore')\\\n .decode(encoding)\n \n out = re.sub(BIGQUERY_COLUMN_NAME_RE, replace_string, temp_out)\n out = out.lower()\n return out","def convertFiles():\n\n #### Get file lists\n tmp = os.path.join(remarkableBackupDirectory,remContent)\n files = [x for x in os.listdir(tmp) if \".\" not in x]\n\n for i in range(0, len(files)):\n # get file reference number\n refNrPath = os.path.join(remarkableBackupDirectory, remContent,\n files[i])\n # get meta Data\n meta = json.loads(open(refNrPath + \".metadata\").read())\n fname = meta[\"visibleName\"]\n fname = fname.replace(\" \", \"_\")\n # Does this lines file have an associated pdf?\n AnnotPDF = os.path.isfile(refNrPath + \".pdf\")\n # Get list of all rm files i.e. all pages\n npages = len(glob.glob(refNrPath + \"/*.rm\"))\n if npages != 0:\n if AnnotPDF:\n # we have found an annotated pdf\n # now make sure it has the right ending\n if meta[\"visibleName\"][-4:] != \".pdf\":\n syncFilePath = os.path.join(syncDirectory, \"*\",\n meta[\"visibleName\"] + \".pdf\")\n else:\n syncFilePath = os.path.join(syncDirectory, \"*\",\n meta[\"visibleName\"])\n\n # does the file exist in our system?\n inSyncFolder = glob.glob(syncFilePath) != []\n\n if inSyncFolder:\n # have we exported this thing before?\n local_annotExist = \\\n glob.glob(syncFilePath[:-4] + \"_annot.pdf\") != []\n # first, assume, it needs converting\n remoteChanged = True\n if local_annotExist:\n # if it already exists check when it was last updated\n local_annotPath = \\\n glob.glob(syncFilePath[:-4]+\"_annot.pdf\")[0]\n local_annot_mod_time = os.path.getmtime(local_annotPath)\n # rm time is in ms\n remote_annot_mod_time = int(meta[\"lastModified\"])/1000\n # has this version changed since we last exported it?\n remoteChanged = \\\n remote_annot_mod_time > local_annot_mod_time\n # update if the remote version has changed\n if remoteChanged:\n origPDF = glob.glob(syncFilePath)[0]\n #####\n convertAnnotatedPDF(fname, refNrPath, origPDF)\n #####\n else:\n print(fname + \"hasn't been modified\")\n else:\n print(fname + \" does not exist in the sync directory\")\n # TODO allow y/n input whether it should be copied there\n # anyway\n else:\n # we found a note\n print(\"exporting Notebook \" + fname)\n syncFilePath = os.path.join(syncDirectory, notesDirectory,\n fname + \".pdf\")\n inSyncFolder = glob.glob(syncFilePath) != []\n remoteChanged = True\n if inSyncFolder:\n local_annot_mod_time = os.path.getmtime(syncFilePath)\n remote_annot_mod_time = int(meta['lastModified'])/1000\n remoteChanged = remote_annot_mod_time > local_annot_mod_time\n if remoteChanged:\n #####\n convertNotebook(fname, refNrPath)\n #####\n else:\n print(fname + \"has not changed\")","def __rm_general(file_contents: str) -> str:\n\n new_file_contents = file_contents\n\n for regex in COBOL_FORMAT_RM_REGEXES:\n for match in re.finditer(regex, file_contents):\n match_str = match_to_str(match)\n new_file_contents = new_file_contents.replace(match_str, '')\n\n return new_file_contents","def correct_naming(obsid, inst):\n cobsid = str(int(float(obsid)))\n if len(cobsid) == 5:\n return \n\n lobsid = mcf.add_leading_zero(obsid, 5)\n \n for sdir in ['secondary', 'analysis']:\n\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\n os.system(cmd)\n\n data = mcf.read_data_file(zspace, remove=1)\n for ent in data:\n atemp = re.split('\\/', ent)\n fname = atemp[-1]\n mc = re.search(lobsid, fname)\n if mc is not None:\n continue\n else:\n atemp = re.split('hrcf', fname)\n btemp = re.split('_', atemp[1])\n sobs = btemp[0]\n new = fname.replace(sobs, lobsid)\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\n\n cmd = 'mv ' + ent + ' ' + full\n os.system(cmd)","def tearDown(self):\n if os.path.exists(\"file.json\"):\n os.remove(\"file.json\")","def tearDown(self):\n if os.path.exists(\"file.json\"):\n os.remove(\"file.json\")","def transform_file(input_file_path: str, output_file_path: str):\n\n # Open json\n with open(input_file_path, mode=\"r\") as in_file:\n input_data = json.load(in_file)\n\n # Transform and write\n with jsonlines.open(output_file_path, mode=\"w\", compact=True) as out_file:\n for item in input_data[\"items\"]:\n out_file.write(transform_item(item))","def rewrite_MS_filename(rawfile_name):\n print(\"Rewriting mz filename...\")\n\n # rename MS filename by its m/z.\n # open file, read the 2nd row (where m/z is written) and make that into the filename\n newfname = []\n replacename = ''\n for folder in rawfile_name:\n msfiles = [os.path.basename(path) for path in sorted(glob.glob(opfolder+\"/files/\"+folder+\"/*-MS Chromatogram.txt\"))]\n for fname in msfiles: # MS chromatogram files のファイル名を mzに書き換える。そのファイル名リストをnewfnameに入れる\n filepath = opfolder+\"/files/{}/{}\".format(folder,fname)\n with open(filepath, 'r') as f:\n for i, line in enumerate(f):\n if i == 2: break\n if i == 1: # read 2nd row, where the m/z are written\n if isfloat(line[-8:-2].strip()):\n replacename = '{}-{}'.format(folder,line[-8:-2].strip())\n newfname.append(\"{}/{}.txt\".format(folder,replacename))\n elif re.search(r'1-1MS',line) :\n replacename = '{}-{}-1'.format(folder,line[-5:].strip())\n newfname.append(\"{}/{}.txt\".format(folder,replacename))\n elif re.search(r'1-2MS',line) :\n replacename = '{}-{}-2'.format(folder,line[-5:].strip())\n newfname.append(\"{}/{}.txt\".format(folder,replacename))\n f.close()\n os.rename(filepath,opfolder+\"/mz/{}/{}.txt\".format(folder,replacename))\n print(\"Done\")\n return newfname","def tearDown(self):\n if os.path.exists('file.json'):\n os.remove(\"file.json\")","def space_cleaning(file=\"\"):\n intermediate = str(file) + str(\"_intermediate\")\n output_file = str(file)\n\n os.rename(intermediate, output_file)","def test_add_model_file_prefixed(self):\n with open(TEST_AVATAR_PATH, 'rb') as avatar:\n self.user.avatar_tmp = File(avatar)\n self.user.save()\n\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\n file_path = archive.add_model_file(self.user.avatar_tmp, prefix=\"prefix\")\n\n self.assertTrue(os.path.isfile(file_path))\n \n data_dir_path = str(archive.data_dir_path)\n self.assertTrue(str(file_path).startswith(data_dir_path))\n \n filename = os.path.basename(self.user.avatar_tmp.name)\n target_filename = 'prefix-{}'.format(filename)\n self.assertTrue(str(file_path).endswith(target_filename))","def reformat_json_file(infilename, outfilename, clobber=False):\n # open input json file\n with open(infilename) as json_file:\n json_string = json_file.read()\n json_data = json.loads(json_string)\n\n # see if output file already exists and determine course of action\n if os.path.exists(outfilename):\n if clobber:\n os.remove(outfilename)\n else:\n sys.exit(\"Error: output file {} already exists and would be overwritten!\".format(outfilename))\n\n # write out reformatted json file\n with open(outfilename, 'w') as f:\n json.dump(json_data, f, indent=4)","def _restore_file(file):\n\n os.remove(file)\n os.rename(file + '.bak', file)","def test_write_to_json():\r\n tmp_dir = os.getcwd()\r\n json_content = '{ \"name\":\"John\", \"age\":30}'\r\n directory = os.path.join(tmp_dir, 'inputspec.json')\r\n write_to_json(directory, json_content) \r\n with open(directory) as json_file:\r\n data = json.load(json_file)\r\n json_string = json.dumps(data)\r\n if os.path.exists(directory):\r\n os.remove(directory)\r\n assert json_string.replace(' ', '') == json_content.replace(' ' , '')","def _dumpJson(data, file):\n name, ext = os.path.splitext(file)\n tempFile = \"{0}.tmp\".format(name)\n with open(tempFile, \"w\") as f:\n json.dump(data, f, indent=4)\n shutil.copyfile(tempFile, file)\n os.remove(tempFile)","def _handle_downloads_inline(self, downloads_inline: Dict[str,\n str]) -> None:\n import base64\n import zlib\n for fname, fdata in downloads_inline.items():\n dirname = os.path.dirname(fname)\n if dirname:\n os.makedirs(dirname, exist_ok=True)\n data_zipped = base64.b64decode(fdata)\n data = zlib.decompress(data_zipped)\n with open(fname, 'wb') as outfile:\n outfile.write(data)","async def test_deprecated_save_json(\n caplog: pytest.LogCaptureFixture, tmp_path: Path\n) -> None:\n # pylint: disable-next=hass-deprecated-import,import-outside-toplevel\n from homeassistant.util.json import save_json\n\n fname = tmp_path / \"test1.json\"\n save_json(fname, TEST_JSON_A)\n assert \"uses save_json from homeassistant.util.json\" in caplog.text\n assert \"should be updated to use homeassistant.helpers.json module\" in caplog.text","async def test_deprecated_save_json(\n caplog: pytest.LogCaptureFixture, tmp_path: Path\n) -> None:\n # pylint: disable-next=hass-deprecated-import,import-outside-toplevel\n from homeassistant.util.json import save_json\n\n fname = tmp_path / \"test1.json\"\n save_json(fname, TEST_JSON_A)\n assert \"uses save_json from homeassistant.util.json\" in caplog.text\n assert \"should be updated to use homeassistant.helpers.json module\" in caplog.text","def clean_path(source):\n source.file_name = source.file_name.replace('\\\\','/')\n return source","def test_replace_namespaced_image_stream(self):\n pass","def fixit(file):\n with open(file, \"r\") as f:\n config = json.load(f)\n if \"job_status\" in config[\"supply-curve-aggregation\"]:\n del config[\"supply-curve-aggregation\"][\"job_status\"]\n if \"rep-profiles\" in config:\n del config[\"rep-profiles\"]\n fname = os.path.basename(file)\n cname = \"_\".join(fname.split(\"_\")[:-1]) + \"_agg\"\n config[\"supply-curve-aggregation\"][cname][\"job_status\"] = \"successful\"\n\n with open(file, \"w\") as f:\n f.write(json.dumps(config, indent=4))","def test_valid_file_name(self):\n Base.save_to_file([self.r0, self.s1])\n self.assertTrue(path.exists('Base.json'))","def __correct_encoding(self, encode, filename):\n if encode == 'None' or encode == self.__tencoding:\n return\n buffname = '~old' + filename\n self.__os.rename(filename, buffname)\n with open(buffname, 'r', encoding=self.__tencoding) as fr:\n with open(filename, 'w', encoding=self.__tencoding) as fw:\n for line in fr:\n fw.write(line[:-1] + '\\r\\n')\n self.__os.remove(buffname)","def test_make_json_advanced(self):\n resources = get_test_resources()\n output, filename = make_json(commit=\"1245\", exclude=[\"tei:note\", \"tei:orig\"], credit=\"PerseusDL\", **resources)\n output = json.loads(output)\n self.assertEqual(\n output[\"text\"][\"0\"][\"0\"][\"0\"], \"Spero me secutum in libellis meis tale temperamen-\",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"1\"], \"Et comites longae quaeris habere viae, \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"1\"][\"3\"], \"Crede mihi, nimium Martia turba sapit. \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"0\"], \"Qui tecum cupis esse meos ubicumque libellos \",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n filename, \"textgroup__work__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )\n self.assertEqual(\n output[\"original-urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1\",\n \"Original URN should be fed\"\n )\n self.assertEqual(\n output[\"urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1-simple\",\n \"CLTK URN should be suffixed\"\n )\n self.assertEqual(\n output[\"credit\"], \"PerseusDL\",\n \"Credit should be empty by default\"\n )\n self.assertEqual(\n output[\"meta\"], \"book-poem-line\",\n \"meta should reflect the citation scheme\"\n )\n self.assertEqual(\n output[\"author\"], \"textgroup\",\n \"Author name should be the English textgroup name\"\n )\n self.assertEqual(\n output[\"work\"], \"work\",\n \"Work name should be the English work name\"\n )\n self.assertEqual(\n output[\"edition\"], \"description\",\n \"We should have the English description\"\n )\n self.assertEqual(\n output[\"commit\"], \"1245\",\n \"We should have the commit information\"\n )","def sanitize_paths(self):\n\n for wadfile in self.files:\n if wadfile.path:\n path, filename = os.path.split(wadfile.path)\n if len(filename) < 255:\n continue\n\n basename, ext = os.path.splitext(filename)\n wadfile.path = os.path.join(path, f\"{basename[:255-17-len(ext)]}.{wadfile.path_hash:016x}{ext}\")","def stripKeyFile(keyFileName,iNewFileName,newFileId,skimKeyFileName):\n\n print \"stripKeyFile called - look at this code!\"\n sys.exit(1)\n\n newFileName = string.split(iNewFileName,\"-esdb\")[0]+\"-esdb.ikey\"\n pos,needToSwap,nRecordNames,sNames,nSV=keyFileHeaderReader(keyFileName)\n origKeyFile = open(keyFileName,'r')\n origKeyFile.seek(pos)\n\n # read information from skimKeyFileName\n skimPos,skimSwap,skimRecords,skimStreamNames,skimNumberSV=keyFileHeaderReader(skimKeyFileName)\n skimKeyFile = open(skimKeyFileName,'r')\n skimKeyFile.seek(skimPos)\n \n streamNameString =\"\"\n for name in sNames:\n streamNameString = streamNameString+name +\"\\0\"\n streamNameString = streamNameString[:-1]\n while 0 != len(streamNameString) % 4:\n streamNameString = streamNameString + \"\\0\"\n nameWords = array.array('I')\n nameWords.fromstring(streamNameString)\n\n nameList = nameWords.tolist()\n number32BitWordsInNameList = len(nameList)\n nWordsInHeader = len(sNames)+number32BitWordsInNameList+1+1+1\n headerList = [2718281*256,newFileId,nWordsInHeader,len(sNames)]\n headerList+= [number32BitWordsInNameList]+nameList+[nSV,nWordsInHeader]\n keyFile = open(newFileName,'w+b')\n keyHeader = array.array('I')\n keyHeader.fromlist(headerList)\n keyHeader.tofile(keyFile)\n \n # loop over all sv's in original key file and write out those which are not in fakeSVList\n i = 0\n fakeIdx = 0\n counter = 0\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\n print \"orig\",origKeyFile.name\n print \"skim\",skimKeyFile.name\n while i<nSV:\n if not skimSV: break\n sv,recIdxList = decodeKeyRecord(origKeyFile,needToSwap,nRecordNames)\n if not sv: break\n i+=1\n # we event number from parent key file is become larger then from skim, advance the skim\n if sv[1]>skimSV[1]:\n try:\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\n except:\n skimSV=()\n break\n if skimSV!=sv:\n continue\n else: # write out\n run = sv[0]\n evt = sv[1]\n lowerId, upperId = gen_util.lowerUpperBitsOfUID(sv[2])\n recordArray = array.array('I')\n recordHeader = [sv[0],sv[1],lowerId,upperId]+skimIdxList\n recordArray.fromlist(recordHeader)\n recordArray.tofile(keyFile)\n counter+=1\n # read one more event from skim file\n try:\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\n except:\n skimSV=()\n # seek to position where total SV's written and fix it to new number of SV's\n keyFile.seek(pos-2*4)\n pos = keyFile.tell()\n nSVHeader = array.array('I')\n nSVHeader.fromfile(keyFile,1)\n if nSVHeader[0]!=nSV:\n print \"nSVHeader[0]\",nSVHeader[0],nSV\n print \"Miss position of nSyncValues in a file\"\n return \"\"\n keyFile.seek(pos)\n nSVHeader[0]=counter\n nSVHeader.tofile(keyFile)\n keyFile.close()\n\n return newFileName","def test_gzip_file_no_extension(self):\n # Write the data to a file\n temp_file = tempfile.NamedTemporaryFile()\n with gzip.open(temp_file.name, 'wb') as out:\n for item in self.data:\n serialzed = json.dumps(item).encode()\n out.write(serialzed + b'\\n')\n\n # Load from file, ensure it is correct\n actual_data = []\n with JsonlReader(temp_file.name) as f:\n for item in f:\n actual_data.append(item)\n self.assertEqual(self.data, actual_data)","def rewrite_jaraco(pkg_files, new_root):\n for file in pkg_files.glob('*.py'):\n text = file.read_text()\n text = re.sub(r' (more_itertools)', rf' {new_root}.\\1', text)\n file.write_text(text)\n # required for zip-packaged setuptools #3084\n pkg_files.joinpath('__init__.py').write_text('')","def updateCountryNames(self):\n try:\n with open('countryNameMapping.json', 'r') as file:\n name_mapping = json.loads(file.read())\n except:\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\n \n for key, value in name_mapping.items():\n self.covid_df.replace(key, value, inplace=True)\n \n try:\n with open('countryNameISO2.json', 'r') as file:\n self.name_iso2_mapping = json.loads(file.read())\n except:\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\n self.writeCountryCodeFile()\n print('Re-importing required JSONs...')\n self.updateCountryNames()","def test_find_raw_file_json(self):\n\n this_file_name = probsevere_io.find_raw_file(\n top_directory_name=TOP_DIRECTORY_NAME,\n unix_time_sec=VALID_TIME_UNIX_SEC,\n file_extension=probsevere_io.JSON_FILE_EXTENSION,\n raise_error_if_missing=False)\n\n self.assertTrue(this_file_name == JSON_FILE_NAME)","def calc_fullpath(data_folder, name):\n return os.path.join(data_folder, f\"{alias(name)}.json\")","def _restore_image_name(self, data: Dict[str, str]) -> ImageName:\n return ImageName.parse(data[\"str\"])","def _post_recording_scrub(self):\n src_path = self.cassette_path\n rg_name = getattr(self, 'resource_group', None)\n rg_original = getattr(self, 'resource_group_original', None)\n\n t = tempfile.NamedTemporaryFile('r+')\n with open(src_path, 'r') as f:\n for line in f:\n # scrub resource group names\n if rg_name != rg_original:\n line = line.replace(rg_name, rg_original)\n # omit bearer tokens\n if 'authorization:' not in line.lower():\n t.write(line)\n t.seek(0)\n with open(src_path, 'w') as f:\n for line in t:\n f.write(line)\n t.close()","def _raw_read(self, filepath, dirpath=None):\n self.json_dict = super().read(filepath)\n return self.json_dict","def clean(self):\n actual_output_file = path.splitext(self.source_name)[0] + \".actual\"\n if path.exists(self.binary_name):\n os.unlink(self.binary_name)\n if path.exists(actual_output_file):\n os.unlink(actual_output_file)","def test_WronJSONFormat():\n\n tree = MerkleTree()\n\n with pytest.raises(WrongJSONFormat):\n tree.encryptFilePerObject(\n os.path.join(os.path.dirname(__file__),\n 'objects/sample.json')\n )","def tearDown(self):\n try:\n remove(\"file.json\")\n except:\n pass","def change_pic(link_to:str):\n with open(os.path.dirname(os.path.abspath(__file__))+'\\\\data.json', 'r') as test:\n f = json.load(test)\n f['button_pic'] = link_to\n with open(os.path.dirname(os.path.abspath(__file__))+'\\\\data.json', 'w') as test:\n json.dump(f, test, indent=2)","def combine_with_assets(coins):\n \n with open('index_assets.json', encoding='utf-8') as f:\n \n data = json.loads(f.read())\n \n for coin in coins:\n symbol = coin['symbol']\n original_symbol = symbol\n\n if coin['gecko_id'] in [asset['gecko_id'] for asset in data.values()]:\n continue\n\n print('got a new coin: {}'.format(coin))\n\n counter = 1\n while symbol in data:\n print('symbol {} repeats !'.format(symbol))\n symbol = original_symbol + \"_\" + str(counter)\n counter += 1\n\n data[symbol] = {'gecko_id': coin['gecko_id'], 'symbol': coin['symbol']}\n if 'logo' in coin:\n data[symbol]['logo'] = coin['logo']\n else:\n print('could not find image')\n\n\n\n with open('index_assets.json', 'w', encoding='utf-8') as f:\n f.write(json.dumps(data))\n print('wrote to file')","def fix_filename(self):\n if not self.remove_path:\n return\n self.filename = re.sub(\".+\\/\", \".../\", self.filename)","def restructure_file(raw_file_name, destination_file, label_file):\n unique_words = answer_vocabulary(raw_file_name)\n answer_labels = convert2labels(unique_words, label_file)\n\n qa_list = json.load(open(raw_file_name))\n new_qa_list = list()\n\n for qa_dict in qa_list:\n answer = str(qa_dict[\"answer\"]).lower()\n first_word = answer.split(\" \")[0]\n\n new_qa_dict = {\n \"image_name\": qa_dict[\"image_name\"],\n \"question\": qa_dict[\"question\"],\n \"answer_label\": answer_labels[first_word]\n }\n\n new_qa_list.append(new_qa_dict)\n\n json.dump(new_qa_list, open(destination_file, \"w\"), indent=4)","def test_transform_file(self, mock_transform_object):\n mock_transform_object.return_value = {}\n with CliRunner().isolated_filesystem() as t:\n transform_path = \"transform/out.jsonl.gz\"\n\n # Create works entity file\n works = {\"works\": \"content\"}\n works_download_path = \"works.jsonl.gz\"\n with gzip.open(works_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(works, f_out)\n\n # Create other entity file (concepts or institution)\n concepts = {\"concepts\": \"content\"}\n concepts_download_path = \"concepts.jsonl.gz\"\n with gzip.open(concepts_download_path, \"wt\", encoding=\"ascii\") as f_out:\n json.dump(concepts, f_out)\n\n # Test when dir of transform path does not exist yet, using 'works' entity'\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test when dir of transform path does exist, using 'works' entity\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\n\n transform_file(works_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"682a6d42\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(works, \"abstract_inverted_index\")\n mock_transform_object.reset_mock()\n os.remove(transform_path)\n\n # Test for \"concepts\" and \"institution\" entities\n transform_file(concepts_download_path, transform_path)\n self.assert_file_integrity(transform_path, \"d8cafe16\", \"gzip_crc\")\n mock_transform_object.assert_called_once_with(concepts, \"international\")","def renamefile(filename):\n new_data_list = []\n with open(filename, 'r') as f:\n data_list = f.read().split('\\n')\n\n print('Generating new data list..')\n for data in tqdm(data_list):\n if len(data) == 0:\n continue\n data_info = data.split(' ')\n\n #data_info[0] = data_info[0].replace('jpg', 'png')\n #data_info[1] = data_info[1].replace('jpg', 'png')\n for it, name in enumerate(data_info):\n data_info[it] = '/'.join(name.split('/')[1:])\n if data_info[2].find('extras') == -1:\n new_data_list.append(' '.join(data_info))\n\n with open(filename, 'w') as f:\n print('writing new data names..')\n\n for it, data in tqdm(enumerate(new_data_list)):\n if len(data) == 0:\n continue\n\n if it == len(new_data_list)-1:\n f.write(data)\n else:\n f.write(data+'\\n')\n\n print('Done.')","def _transform_name(self) -> None:\n self.name = utils.maybe_rename_for_k8s(self.name)"],"string":"[\n \"def replace_gen(self):\\r\\n current_path = os.path.join(self.settings.save_path, 'current.json')\\r\\n current_folder_path = os.path.join(self.settings.save_path, 'current')\\r\\n history_path = os.path.join(self.settings.save_path, 'history')\\r\\n archive_folder_path = os.path.join(history_path, f'gen{self.generation}')\\r\\n archive_path = os.path.join(archive_folder_path, 'current') # no ending allowed\\r\\n archive_json_path = os.path.join(archive_folder_path, 'current.json')\\r\\n\\r\\n\\r\\n if not os.path.exists(current_path):\\r\\n raise FileNotFoundError\\r\\n if not os.path.exists(current_folder_path):\\r\\n raise FileNotFoundError\\r\\n\\r\\n os.makedirs(history_path, exist_ok=True)\\r\\n os.makedirs(archive_folder_path)\\r\\n\\r\\n cwd = os.getcwd()\\r\\n shutil.make_archive(archive_path, 'zip', current_folder_path)\\r\\n os.chdir(cwd)\\r\\n shutil.rmtree(current_folder_path, onerror=_ignore_del_dir_failure)\\r\\n os.chdir(cwd)\\r\\n\\r\\n os.rename(current_path, archive_json_path)\",\n \"def anonymize(data_dir):\\n\\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\\n for dir_name in sorted(dirs):\\n dir_path = os.path.join(root, dir_name)\\n json_path = os.path.join(root, dir_name, 'data.json')\\n print(json_path)\\n\\n with open(json_path) as f:\\n data = json.load(f)\\n\\n data.pop('user_email')\\n data.pop('user_name')\\n data.pop('survey_data')\\n\\n with open(json_path, 'w') as f:\\n json.dump(data, f)\",\n \"def regenerate_json_file():\\n \\n # filepaths used in generating json data...\\n dir_export = f\\\"C:\\\\\\\\Users\\\\\\\\{os.getlogin()}\\\\\\\\Downloads\\\"\\n list_name = 'my-favourite-films.csv'\\n json_output_filename = 'reviews_web_data.json'\\n path_to_rootreducer = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\reducers\\\\\\\\RootReducer.js';\\n path_to_json_output = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\components\\\\\\\\films\\\\\\\\{json_output_filename}'\\n \\n # 1) find letterboxd zip export...\\n prefix = 'letterboxd'\\n postfix = 'utc.zip'\\n zip_file_name = \\\"\\\"\\n download_folder = sorted(glob.glob(f\\\"{dir_export}/*.zip\\\"), key=os.path.getmtime)\\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\\n for filepath in download_folder:\\n filename = filepath.split('\\\\\\\\')[-1]\\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\\n zip_file_name = filename\\n print(f\\\"Found the zip export! -> {zip_file_name}\\\")\\n break\\n else:\\n continue\\n\\n path_to_zip_file = f\\\"{dir_export}\\\\\\\\{zip_file_name}\\\" # path to zip file we downlodaded from letterboxd...\\n path_to_extracted_zip = f\\\"{dir_export}\\\\\\\\{zip_file_name[:-4]}\\\" # path to extracted zip (which we are about to do)...\\n\\n # 2) extract zip automatically (if not done already)...\\n if os.path.exists(path=path_to_zip_file):\\n if not os.path.exists(path=path_to_extracted_zip):\\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\\n z.extractall(path_to_extracted_zip)\\n print(f\\\"Extract complete! -> {path_to_extracted_zip}\\\")\\n else:\\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\\n else:\\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\\n\\n\\n # local version of letterboxd data list\\n letterboxd_list = []\\n \\n # 3) locate the csv file of interest\\n if os.path.exists(path_to_extracted_zip): \\n # open csv file...\\n path_to_list = f'{path_to_extracted_zip}\\\\\\\\lists\\\\\\\\{list_name}'\\n with open(path_to_list, 'r') as f:\\n # csv reader object\\n csv_reader = csv.reader(f)\\n \\n # skip header in the csv file...\\n rows_to_skip = 5\\n for i in range(0, rows_to_skip):\\n next(csv_reader)\\n \\n # 4) iterate over each row (i.e. each film) in csv file...\\n for csv_row in csv_reader:\\n pos = csv_row[0]\\n title = csv_row[1]\\n year = csv_row[2]\\n letterboxd_url = csv_row[3]\\n letterboxd_film_id = letterboxd_url.split('/')[-1]\\n genres = []\\n directors = []\\n duration = 0\\n language = \\\"\\\"\\n imdb_url = \\\"\\\"\\n imdb_avg_rating = \\\"\\\"\\n imdb_num_votes = \\\"\\\"\\n tmdb_url = \\\"\\\"\\n poster_url = \\\"\\\"\\n \\n # parse data from letterboxd web page... (this takes ~1.21s)\\n page = session.get(url=letterboxd_url, verify=False, stream=True)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n \\n # retrieve list of genres...\\n div_genres = soup.select_one('#tab-genres')\\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\\n if 'genre' in link['href']:\\n genre = link.text.capitalize()\\n if genre == 'Science-fiction':\\n genre = 'Sci-fi'\\n genres.append(genre)\\n\\n # retrieve duration\\n textfooter = soup.select_one('section.col-main > p.text-footer').text\\n if 'mins' in textfooter:\\n minstext = textfooter.find('mins', 0, len(textfooter))\\n duration = textfooter[minstext-5:minstext].strip()\\n \\n # retrieve the first spoken language\\n div_details = soup.select_one('#tab-details')\\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\\n if 'language' in link['href']:\\n language = link.text.capitalize()\\n break\\n \\n # retrieve IMDB url\\n footer = soup.select_one('section.col-main p.text-footer')\\n url_buttons = footer.select('a.micro-button')\\n for url in url_buttons:\\n if 'imdb' in url.text.lower():\\n # get IMDB URL\\n imdb_url = url['href']\\n elif 'tmdb' in url.text.lower():\\n # get TMDB URL\\n tmdb_url = url['href']\\n if len(url_buttons) == 1:\\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\\n\\n # retrieve avg rating on letterboxd\\n # page_content_str = page.content.decode('utf-8')\\n # letterboxd_avg_rating = soup.select_one('.average-rating')\\n\\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\\n imdb_film_id = imdb_url.split('/')[-2]\\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\\n imdb = requests.get(url=url, verify=False)\\n imdb_json = json.loads(imdb.text)\\n\\n # retrieve avg IMD rating\\n imdb_avg_rating = imdb_json['imdbRating']\\n \\n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\\n \\n # retrieve poster from IMDB\\n poster_url = imdb_json['Poster']\\n if 'SX300' in poster_url:\\n poster_url = poster_url.split('SX300')[0]\\n \\n # retrieve title from IMDB (because letterboxd parsing is shite!)\\n # title = imdb_json['Title']\\n \\n # retrieve list of directors (because letterboxd parsing is shite!)\\n directors = imdb_json['Director'].split(', ')\\n \\n # id of my review!\\n titlev2 = Helpers.simplify_movie_title(title=title)\\n review_id = f\\\"{titlev2}-{letterboxd_film_id}-review\\\"\\n \\n \\\"\\\"\\\"\\n # iterate over \\\\\\\\img\\\\\\\\films\\\\\\\\\\n screenshots = []\\n directory_in_str = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\img\\\\\\\\films';\\n for subdir, dirs, files in os.walk(directory_in_str):\\n for file in files:\\n # find the right directory...\\n title_from_directory_storing_screenshots = subdir.split('\\\\\\\\')[-1]\\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\\n if titlev3 == titlev2:\\n # get my screenshots...\\n if 'screenshot' in file:\\n screenshot = os.path.join(subdir, file)\\n screenshots.append(screenshot)\\n \\n # use my custom poster if I put one there...\\n if 'custom_poster' in file:\\n poster_url = os.path.join(subdir, file)\\n \\\"\\\"\\\"\\n \\n # DEBUGGING....\\n print(f\\\" > {pos}: {title}\\\")\\n #print(f' > Title = ({title})')\\n #print(f' > IMDB url = ({imdb_url})')\\n #print(f' > Language = ({language})')\\n #print(f' > Duration = ({duration})')\\n #print(f' > Genres = ({genres})')\\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\\n #print(f' > IMDB num votes = ({imdb_num_votes})')\\n #print(f' > Poster = ({poster_url})')\\n #print(f' > Directors = ({directors})')\\n #print(f' > Tags = ({my_tags})')\\n \\n # append to list...\\n letterboxd_list.append({\\n 'letterboxdFilmId': letterboxd_film_id,\\n 'imdbFilmId': imdb_film_id,\\n 'letterboxdUrl': letterboxd_url,\\n 'imdbUrl': imdb_url,\\n 'posterUrl': poster_url,\\n 'position': pos,\\n 'title': title,\\n 'year': year,\\n 'duration': duration,\\n 'language': language,\\n 'imdbAvgRating': imdb_avg_rating,\\n 'imdbNumVotes': imdb_num_votes,\\n 'tmdbUrl': tmdb_url,\\n 'directors': directors,\\n 'genres': genres,\\n 'reviewId': review_id\\n })\\n \\n # clear json file first...\\n open(path_to_json_output, 'w').close()\\n \\n # write new content...\\n with open(path_to_json_output, 'w') as f:\\n json.dump(letterboxd_list, f, indent=4)\\n \\n print(f'JSON export finished! -> {path_to_json_output}')\",\n \"def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\\n\\n print(\\\"Fixing the acquisition numbers of the .json files in sourcedata.\\\")\\n\\n for old_path in raw_dir.rglob(\\\"*.json\\\"):\\n\\n parts_of_stem_of_old_path = old_path.stem.split(\\\"_\\\")\\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\\n fresh_new_stem = \\\"_\\\".join(stem_parts_with_correct_acquisition_number)\\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\\n old_path.replace(fresh_new_path)\",\n \"def test_rotate_filenames():\\n tmpdir = os.path.join(tempfile.gettempdir(), \\\"jade-test-tmp87alkj8ew\\\")\\n os.makedirs(tmpdir, exist_ok=True)\\n\\n data = {\\\"A\\\": 1, \\\"B\\\": 2}\\n json_file1 = os.path.join(tmpdir, \\\"a1.json\\\")\\n dump_data(data, json_file1)\\n\\n json_file2 = os.path.join(tmpdir, \\\"a2.json\\\")\\n dump_data(data, json_file2)\\n\\n rotate_filenames(tmpdir, \\\".json\\\")\\n\\n if os.path.exists(tmpdir):\\n shutil.rmtree(tmpdir)\",\n \"def minify_json(self) -> None:\\n print(f\\\"[FileManager: INFO] Minifing file {self.path}\\\")\\n file_data = open(self.path, \\\"r\\\", encoding=\\\"utf-8\\\").read()\\n json_data = json.loads(file_data) \\n json_string = json.dumps(json_data, separators=(',', \\\":\\\")) \\n path = str(self.path).replace(\\\".json\\\", \\\"\\\")\\n new_path = \\\"{0}_min.json\\\".format(path)\\n open(new_path, \\\"w+\\\", encoding=\\\"utf-8\\\").write(json_string)\",\n \"def fix_path(self):\\n paths = self.data['path'].tolist()\\n prefixes = [re.findall(r'[A-Z\\\\-0-9]+', path) for path in paths]\\n prefix_good = [str(prefix[0]) + \\\".json\\\" for prefix in prefixes]\\n self.data['path'] = prefix_good\",\n \"def sanitize_json_files(unsanitized_json_file):\\n with open(develop_baseline_dir + unsanitized_json_file) as f:\\n lines = f.readlines()\\n\\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\\n w.writelines([item for item in lines[:-1]])\",\n \"def _files_from_json(self, file_json):\\n self.compressed_file_json = zlib.compress(json.dumps(file_json).encode('utf-8'))\\n self.compression_algorithm = 'gzip'\\n self.compressed_content_hash = hashlib.sha256(self.compressed_file_json).hexdigest()\",\n \"def json_to_cache(new_json: Dict, file_name: str) -> None:\\n\\n json_path = os.path.join(CACHE_DIR, file_name)\\n ensure_dir(json_path)\\n with open(json_path, \\\"w\\\") as outfile:\\n json.dump(new_json, outfile, ensure_ascii=False)\",\n \"def processed_json_path(path):\\n return path.replace(RAW_ASSETS_PATH, ASSETS_PATH).replace('.json', '.bin')\",\n \"def process_files_json():\\n # chdir into beep root\\n pwd = os.getcwd()\\n os.chdir(os.environ.get(\\\"BEEP_ROOT\\\", \\\"/\\\"))\\n\\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\\n\\n all_list = sorted(all_list)\\n dumpfn(all_list, \\\"all_files.json\\\")\\n\\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\\n\\n new_file_index = file_id\\n\\n for filename in tqdm(sorted(file_list)):\\n # If the file has already been renamed another entry should not be made\\n if mapdf['filename'].str.contains(filename).sum() > 0:\\n continue\\n old_file = os.path.join(SRC_DIR, filename)\\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\\n shutil.copy(old_file, new_path) # copy main data file\\n shutil.copy(old_file.replace(\\\".csv\\\", '_Metadata.csv'), new_path) # copy meta data file\\n\\n if PROJECT_NAME == 'FastCharge':\\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\\n elif PROJECT_NAME == 'ClosedLoopOED':\\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\\n else:\\n raise ValueError(\\\"Unsupported PROJECT_NAME: {}\\\".format(PROJECT_NAME))\\n\\n df_dup = mapdf.set_index(['protocol', 'date'])\\n if (protocol, date) in df_dup.index:\\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\\n file_id = row['fid'].iloc[0]\\n protocol = row['protocol'].iloc[0]\\n date = row['date'].iloc[0]\\n strname = row['strname'].iloc[0]\\n else:\\n file_id = new_file_index\\n new_file_index = new_file_index + 1\\n\\n new_name = \\\"{}_{}_{}\\\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \\\"{}.csv\\\".format(new_name))\\n\\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\\n os.path.abspath(old_file),\\n os.path.abspath(new_file)]],\\n columns=METADATA_COLUMN_NAMES)\\n mapdf = mapdf.append(new_row)\\n\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\\\".csv\\\", \\\"_Metadata.csv\\\"),\\n new_file.replace(\\\".csv\\\", \\\"_Metadata.csv\\\"))\\n\\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \\\"map.csv\\\"), index=False)\\n mapdf = mapdf.reset_index(drop=True)\\n os.chdir(pwd)\\n return json.dumps(mapdf.to_dict(\\\"list\\\"))\",\n \"def fix_jsons_in(bids_dir: Path):\\n\\n print(\\\"Finalizing task json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"func/*_task-*.json\\\"):\\n append_to_json_file(key=\\\"TaskName\\\", value=task_name_of(path), path_to_json=path)\\n\\n print(\\\"Appending echo times to phase difference json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*_phasediff.json\\\"):\\n magnitude1_path = the_path_that_matches(pattern=\\\"sub-*_magnitude1.json\\\", in_directory=path.parent)\\n magnitude2_path = the_path_that_matches(pattern=\\\"sub-*_magnitude2.json\\\", in_directory=path.parent)\\n echo_time1 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude1_path)\\n echo_time2 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude2_path)\\n append_to_json_file(key=\\\"EchoTime1\\\", value=echo_time1, path_to_json=path)\\n append_to_json_file(key=\\\"EchoTime2\\\", value=echo_time2, path_to_json=path)\\n\\n print(\\\"Setting targets of fieldmap json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*.json\\\"):\\n func_dir = path.parent.parent / \\\"func\\\"\\n trimmed_func_paths = [\\\"func/\\\" + func_path.name for func_path in func_dir.glob(\\\"*.nii\\\")]\\n append_to_json_file(key=\\\"IntendedFor\\\", value=trimmed_func_paths, path_to_json=path)\",\n \"def get_source_file_name(json_name):\\n assert json_name.endswith(JSON_EXT)\\n (directory, base_name) = os.path.split(json_name)\\n new_directory = os.path.relpath(directory, start=CACHE)\\n new_directory = os.path.join(\\\"/\\\", new_directory)\\n new_base_name = base_name[:-len(JSON_EXT)]\\n i = new_base_name.rfind(\\\"-\\\")\\n if i != -1:\\n new_base_name = new_base_name[:i] + \\\".\\\" + new_base_name[i + 1:]\\n result = os.path.join(new_directory, new_base_name)\\n return result\",\n \"def reset_data():\\n shutil.copy2(\\n 'data/one_producer_many_consumers.ORIG.json',\\n 'data/one_producer_many_consumers.json'\\n )\",\n \"def getcleanjson(self):\\n dico=self.dico.copy() # shalow copie as we remove second level data in the copied\\n for key in [\\\"basefiles\\\",\\\"grader\\\",\\\"soluce\\\"]:\\n if key in dico:\\n del dico[key]\\n return str(json.dumps(dico))\",\n \"def reformfile0():\\n txt = \\\"\\\"\\\"\\n {\\n \\\"policy\\\": {\\n \\\"_SS_Earnings_c\\\": {\\\"2016\\\": [300000],\\n \\\"2018\\\": [500000],\\n \\\"2020\\\": [700000]}\\n }\\n }\\n \\\"\\\"\\\"\\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\\n rfile.write(txt + '\\\\n')\\n rfile.close()\\n # Must close and then yield for Windows platform\\n yield rfile\\n if os.path.isfile(rfile.name):\\n try:\\n os.remove(rfile.name)\\n except OSError:\\n pass # sometimes we can't remove a generated temporary file\",\n \"def fileRenameandReplace(filename,newfilename):\\n try:\\n os.rename(filename,newfilename)\\n logging.info(\\\"Json file renamed in PD path\\\")\\n except Exception as er:\\n print (\\\"Not able to rename the json file \\\")\\n return False\",\n \"def reformfile1():\\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\\n rfile.write(REFORM1_CONTENTS)\\n rfile.close()\\n # must close and then yield for Windows platform\\n yield rfile\\n if os.path.isfile(rfile.name):\\n try:\\n os.remove(rfile.name)\\n except OSError:\\n pass # sometimes we can't remove a generated temporary file\",\n \"def repair_json(in_file, out_file, path_to_img):\\n with open(in_file, 'rb') as f:\\n data = f.readlines()\\n\\n # delete all \\\\n characters\\n data = map(lambda x: x.rstrip(), data)\\n\\n # make one JSON object per row\\n json_rows = []\\n start = -1\\n while True:\\n try:\\n start = data.index('{', start + 1)\\n end = data.index('}', start)\\n row = ''.join(data[start:end+1])\\n row = re.sub(\\\"\\\\\\\"Bmp\\\\\\\"\\\", \\\"\\\\\\\"Image\\\\\\\"\\\", row)\\n row = re.sub(\\\".bmp\\\", \\\".jpg\\\", row)\\n json_rows.append(row)\\n start = end\\n except ValueError:\\n break\\n\\n # join all JSON objects into one comme delimited string enclosed in square brackets\\n data_join_str = \\\"[\\\" + ','.join(json_rows) + \\\"]\\\"\\n\\n # create JSON object\\n repaired_json = json.loads(data_join_str)\\n for x in repaired_json:\\n f = os.path.join(path_to_img, x['Image'])\\n print x['Image']\\n if not os.path.isfile(f):\\n repaired_json.remove(x)\\n # remove out_file if it exists\\n try:\\n os.remove(out_file)\\n except OSError:\\n pass\\n except IOError:\\n pass\\n print 'dumping...'\\n with open(out_file, 'w+') as f:\\n json.dump(repaired_json, f)\",\n \"def get_metadata_file(self, file_in_cache):\\n return re.sub(r'\\\\.tar$', '.json', file_in_cache)\",\n \"def fix_image_dict(folder, image_dict):\\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \\\"*.*\\\")\\n for file_path in glob.glob(image_pattern):\\n file_name = os.path.basename(file_path)\\n if file_name not in image_dict:\\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]\",\n \"def restore_base_data():\\n\\n db_dirname = os.path.dirname(os.path.realpath(__file__))\\n shutil.copyfile(src=os.path.join(db_dirname, 'consolemini.base.json'),\\n dst=os.path.join(db_dirname, 'consolemini.test.json'))\",\n \"def backeruper(file_name, file_num=0):\\n\\n if not os.path.exists('%s.json' % file_name):\\n write_backup('%s.json' % file_name)\\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\\n write_backup('%s.%s.json' % (file_name, file_num))\\n else:\\n file_num += 1\\n backeruper(file_name, file_num)\",\n \"def remove_base64(examples: List[TaskType]) -> List[TaskType]:\\n for eg in examples:\\n if \\\"audio\\\" in eg and eg[\\\"audio\\\"].startswith(\\\"data:\\\") and \\\"path\\\" in eg:\\n eg[\\\"audio\\\"] = eg[\\\"path\\\"]\\n if \\\"video\\\" in eg and eg[\\\"video\\\"].startswith(\\\"data:\\\") and \\\"path\\\" in eg:\\n eg[\\\"video\\\"] = eg[\\\"path\\\"]\\n return examples\",\n \"def test_get_pathless_raw_file_name_json(self):\\n\\n this_pathless_file_name = probsevere_io._get_pathless_raw_file_name(\\n unix_time_sec=VALID_TIME_UNIX_SEC,\\n file_extension=probsevere_io.JSON_FILE_EXTENSION)\\n\\n self.assertTrue(this_pathless_file_name == PATHLESS_JSON_FILE_NAME)\",\n \"def fix_file(\\n self,\\n filepath: Path,\\n output_dir: Path,\\n add_unique_suffix: bool = False,\\n ) -> str | Path:\\n return filepath\",\n \"def unpack_rename_data(self):\\n for old, new in self.f_name_map.items():\\n try:\\n read_path = Path(os.environ[\\\"DATA_PATH\\\"]) / old\\n write_path = Path(os.environ[\\\"DATA_PATH\\\"]) / new\\n if \\\"ZIP\\\" in old:\\n shutil.unpack_archive(read_path, write_path, \\\"zip\\\")\\n else:\\n shutil.unpack_archive(read_path, write_path)\\n read_path.unlink() # delete original file\\n except OSError:\\n print(f\\\"Did not unpack {read_path}\\\")\",\n \"def remove_useless_file(rootPath):\\n all_file_paddle_list = get_all_paddle_file(rootPath)\\n ut_file_map_new = {}\\n ut_file_map = \\\"%s/build/ut_file_map.json\\\" % rootPath\\n with open(ut_file_map, 'r') as load_f:\\n load_dict = json.load(load_f)\\n for key in load_dict:\\n if key in all_file_paddle_list:\\n ut_file_map_new[key] = load_dict[key]\\n\\n with open(\\\"%s/build/ut_file_map.json\\\" % rootPath, \\\"w\\\") as f:\\n json.dump(ut_file_map_new, f, indent=4)\\n print(\\\"remove_useless_file ut_file_map success!!\\\")\",\n \"def main():\\n\\n # Set up argument parser.\\n parser = argparse.ArgumentParser(\\n description='Removes duplicate key-value pairs from JSON files.')\\n parser.add_argument('--suffix', default='',\\n help='optional suffix for output files; '\\n 'if empty, files will be changed in place')\\n parser.add_argument('files', nargs='+', help='input files')\\n args = parser.parse_args()\\n\\n # Iterate over files.\\n for filename in args.files:\\n # Read in json using Python libraries. This eliminates duplicates.\\n print('Processing ' + filename + '...')\\n try:\\n with codecs.open(filename, 'r', 'utf-8') as infile:\\n j = json.load(infile)\\n except ValueError as e:\\n print('Error reading ' + filename)\\n raise InputError(filename, str(e))\\n\\n # Built up output strings as an array to make output of delimiters easier.\\n output = []\\n for key in j:\\n if key != '@metadata':\\n output.append('\\\\t\\\"' + key + '\\\": \\\"' +\\n j[key].replace('\\\\n', '\\\\\\\\n') + '\\\"')\\n\\n # Output results.\\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\\n outfile.write('{\\\\n')\\n outfile.write(',\\\\n'.join(output))\\n outfile.write('\\\\n}\\\\n')\",\n \"def rewrite_data_files():\\n return False\",\n \"def newJsonFile():\\n nonlocal currentFile\\n currentFile = join(rootFolder, 'tweetsRaw-' + str(now()) + '.json')\\n f = open(currentFile)\\n f.write('[\\\\n')\\n return f\",\n \"def reformat(self):\\n\\t\\told_path = os.path.join( self.path, self.init_str )\\n\\t\\tnew_path = os.path.join( self.path, self.reorder() )\\n\\t\\tos.rename(old_path,new_path)\",\n \"def copy_json():\\n sourcePath = 'contents/external/'\\n targetPath = 'build/external/'\\n for base,subdirs,files in os.walk(sourcePath):\\n for file in files:\\n orig = os.path.join(base, file)\\n if os.path.isfile(orig) and file[-5:] == '.json':\\n targetBase = os.path.join(targetPath, base[len(sourcePath):])\\n dest = os.path.join(targetBase, file)\\n puts(\\\"Checking diretory %s\\\" % targetBase)\\n if not os.path.exists(targetBase):\\n puts(yellow(\\\"Not found! Creating...\\\"))\\n os.makedirs(targetBase)\\n puts(\\\"Copying from %s to %s\\\" % (orig, dest))\\n copyfile(orig, dest)\",\n \"def setUp(self):\\n if os.path.exists('file.json'):\\n os.remove(\\\"file.json\\\")\",\n \"def _dumpJson(self, data, file):\\n name, ext = os.path.splitext(file)\\n tempFile = \\\"{0}.tmp\\\".format(name)\\n with open(tempFile, \\\"w\\\") as f:\\n json.dump(data, f, indent=4)\\n shutil.copyfile(tempFile, file)\\n os.remove(tempFile)\",\n \"def ref_resp2files(output_file, output_json):\\n with open(output_file, \\\"w\\\") as reference_text:\\n reference_text.write(output_json)\",\n \"def fix_subfiles(ln):\\n m = input_re.search(ln)\\n if m:\\n fn = m.group(1)\\n fI = file(fn,\\\"r\\\")\\n fO = file(fn + \\\".tmp\\\",\\\"w\\\")\\n for ln in fI:\\n ln = sqb2_re.sub(\\\"[\\\",ln)\\n fO.write(unescape_sqb(ln))\\n fI.close()\\n fO.close()\\n fI = file(fn,\\\"w\\\")\\n fO = file(fn + \\\".tmp\\\",\\\"r\\\")\\n for ln in fO:\\n fI.write(ln)\\n fI.close()\\n fI.close()\",\n \"def process_obfuscated_pkg(self, pkg):\\r\\n chunks = pkg.split('/')\\r\\n prefix = list(itertools.dropwhile(lambda chunk: len(chunk) <= self.MAX_OBFUSCATION_CHUNK_SIZE, reversed(chunks)))\\r\\n res = '/'.join(reversed(prefix)) if len(prefix) > 1 or len(prefix) == len(chunks) else '_OBFUSCATED_'\\r\\n return res\",\n \"def rewrite(self):\\n for f in self.files:\\n metadata = dict()\\n metadata[\\\"description\\\"] = f.metadata.get(\\\"desc\\\", \\\"Unknown\\\")\\n metadata[\\\"script\\\"] = os.path.basename(f.filename)\\n metadata[\\\"requires\\\"] = []\\n for package, component in f.requires:\\n if package == self.key:\\n metadata[\\\"requires\\\"].append(\\\"/\\\" + component)\\n else:\\n metadata[\\\"requires\\\"].append(package + \\\"/\\\" + component)\\n metadata[\\\"provides\\\"] = [ p[1] for p in f.provides ]\\n # Resolve symlinks\\n real_filename = os.path.realpath(f.filename)\\n LOG.info(\\\"Editing: \\\" + real_filename)\\n new_filename = f.filename + \\\".new\\\"\\n new = file(new_filename, \\\"w\\\")\\n new.write(\\\"/*\\\\n---\\\\n\\\")\\n new.write(yaml.dump(metadata))\\n new.write(\\\"\\\\n...\\\\n*/\\\\n\\\")\\n new.write(file(f.filename).read())\\n new.close()\\n os.rename(new_filename, real_filename)\\n\\n package_data = dict()\\n package_data[\\\"name\\\"] = self.key\\n package_data[\\\"sources\\\"] = []\\n package_data[\\\"version\\\"] = \\\"Unknown\\\"\\n package_data[\\\"copyright\\\"] = \\\"Unknown\\\"\\n package_data[\\\"description\\\"] = \\\"Unknown\\\"\\n target_dir = os.path.dirname(self.scripts_json_filename)\\n # package.yml is typically in the parent of the scripts.json dir\\n if os.path.basename(target_dir) == \\\"Source\\\":\\n target_dir = os.path.dirname(target_dir)\\n target_filename = os.path.join(target_dir, \\\"package.yml\\\")\\n for f in self.files:\\n common = os.path.commonprefix([target_filename, f.filename])\\n source_file = f.filename[len(common):]\\n package_data[\\\"sources\\\"].append(source_file)\\n LOG.info(\\\"Writing: \\\" + target_filename)\\n out = file(target_filename, \\\"w\\\")\\n out.write(yaml.dump(package_data))\\n out.close()\",\n \"def refresh_cdb_json_file(file_path):\\n cdb_dir = os.path.dirname(file_path)\\n file_name = os.path.basename(file_path)\\n upstream_dir = os.path.join(cdb_dir, 'upstream')\\n upstream_md5 = os.path.join(upstream_dir, '{}.MD5'.format(file_name))\\n upstream_json = os.path.join(upstream_dir, '{}.json'.format(file_name))\\n\\n logger = utils.get_logger()\\n logger.debug('Processing: {}'.format(file_name))\\n\\n cdb_md5 = utils.md5_file(file_path)\\n try:\\n with open(upstream_md5, 'r') as f:\\n json_md5 = f.read()\\n\\n # If the cdb file matches the generated md5,\\n # no changes are needed to the json\\n if json_md5 == cdb_md5:\\n return True\\n except IOError:\\n pass\\n\\n tmp_json = tempfile.NamedTemporaryFile(delete=False)\\n with open(file_path, 'r') as fp:\\n reader = cdblib.Reader(fp.read())\\n\\n out = collections.OrderedDict()\\n for k, v in reader.iteritems():\\n out[k] = v\\n\\n json_data = json.dumps(out, indent=0, separators=(',', ':'))\\n\\n # Make python json.dumps match php's json_encode\\n # Remove first newline\\n json_data = json_data.replace('\\\\n', '', 1)\\n\\n # Escape slashes\\n json_data = json_data.replace('/', '\\\\/')\\n\\n # Remove final newline\\n json_data = ''.join(json_data.rsplit('\\\\n', 1))\\n\\n tmp_json.write(json_data)\\n tmp_json.close()\\n os.chmod(tmp_json.name, 0o644)\\n shutil.move(tmp_json.name, upstream_json)\\n logger.debug('Updated: {}'.format(upstream_json))\\n\\n with open(upstream_md5, 'w') as md5:\\n md5.write(cdb_md5)\\n\\n return True\",\n \"def test_tmp_file_content(self, mocker):\\n payload = dict(id=\\\"B\\\", data={\\\"some\\\": \\\"data\\\"}, ai_service='A')\\n headers = {'x-rh-identity': 'ABC'}\\n\\n with mocker.mock_module.patch.object(os, 'remove') as mock:\\n self.client.post(self.url, json=payload, headers=headers)\\n filename = mock.call_args[0][0]\\n\\n with tarfile.open(filename, 'r:gz') as tar:\\n content = tar.extractfile('A_B.json').read()\\n assert content == b'{\\\"some\\\": \\\"data\\\"}'\\n\\n os.remove(filename)\",\n \"def make_json(prefix, input_dir):\\n # get list of files\\n file_list = os.listdir(input_dir)\\n # set reference sequence\\n tracklist = {'formatVersion': 1,\\n 'refSeqs': '%s.ref.fa.fai' % prefix,\\n 'tracks': []}\\n # add reference sequence track to tracklist.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Reference sequence\\\",\\n \\\"key\\\": \\\"Reference sequence\\\",\\n \\\"label\\\": \\\"Reference sequence\\\",\\n \\\"type\\\": \\\"SequenceTrack\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/IndexedFasta\\\",\\n \\\"urlTemplate\\\": \\\"%s.ref.fa\\\" % prefix,\\n \\\"refSeqOrder\\\": \\\"False\\\"})\\n tracklist['tracks'].append({\\\"category\\\": \\\"Consensus sequence\\\",\\n \\\"key\\\": \\\"Consensus sequence\\\",\\n \\\"label\\\": \\\"Consensus sequence\\\",\\n \\\"type\\\": \\\"SequenceTrack\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/IndexedFasta\\\",\\n \\\"urlTemplate\\\": \\\"%s.cons.fa\\\" % prefix,\\n \\\"refSeqOrder\\\": \\\"False\\\"})\\n # add bigwig track to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Coverage\\\",\\n \\\"label\\\": \\\"Coverage\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/Wiggle/XYPlot\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BigWig\\\",\\n \\\"autoscale\\\": \\\"local\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.bw\\\" % prefix\\n })\\n # add BAM Sequence Coverage to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Sequence reads (SNPs/Coverage)\\\",\\n \\\"label\\\": \\\"Sequence reads (SNPs/Coverage)\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/SNPCoverage\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BAM\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.capped.bam\\\" % prefix,\\n \\\"cacheMismatches\\\": \\\"True\\\",\\n \\\"chunkSizeLimit\\\": \\\"5000000\\\"\\n })\\n # add BAM Sequence Alignments to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Sequence reads (Alignment)\\\",\\n \\\"label\\\": \\\"Sequence reads (Alignment)\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/Alignments2\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BAM\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.capped.bam\\\" % prefix,\\n # add bigwig histogram option\\n \\\"cacheMismatches\\\": \\\"True\\\",\\n \\\"chunkSizeLimit\\\": \\\"5000000\\\"\\n })\\n # add GFF3 file to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Annotation\\\",\\n \\\"key\\\": \\\"Genbank annotation\\\",\\n \\\"label\\\": \\\"Genbank annotation\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/CanvasFeatures\\\",\\n \\\"urlTemplate\\\": \\\"%s.gff3.gz\\\" % prefix,\\n \\\"style\\\": {\\n \\\"_defaultHistScale\\\": 4,\\n \\\"_defaultLabelScale\\\": 30,\\n \\\"_defaultDescriptionScale\\\": 120,\\n # Comma-separated list of case-insensitive feature tags to use\\n # for showing the feature's label.\\n # The first one found will be used. Default 'name,id'.\\n \\\"label\\\": \\\"product,id\\\",\\n # style→description\\tComma-separated list of case-insensitive\\n # feature tags to check for the feature's long description.\\n # The first one found will be used. Default 'note,description'.\\n # If blank no description is used.\\n \\\"description\\\": \\\"note, description\\\"\\n },\\n })\\n\\n json_path = os.path.join(input_dir, 'trackList.json')\\n with open(json_path, 'wt') as output_handle:\\n json_raw_str = json.dumps(tracklist, indent=4)\\n output_handle.write(json_raw_str)\\n return 'trackList.json'\",\n \"def cleanJson(filename):\\n saveFile = 'newFile.json'\\n\\n # check if file exists and exit if it does\\n if os.path.exists(saveFile):\\n return\\n\\n with open(filename) as f:\\n contents = f.readlines()\\n\\n with open('newFile.json', 'a') as outfile:\\n for line in contents:\\n # convert line from JSON to Python dictionary\\n dic = decode(line)\\n # convert dic to a string representing a json object\\n json_obj = json.dumps(dic)\\n outfile.write(json_obj) # write to outfile\\n outfile.write(\\\"\\\\n\\\")\",\n \"def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\\n\\n old_and_new_paths = {}\\n old_paths = list(raw_dir.rglob(\\\"*\\\"))\\n print(f\\\"Sorting {len(old_paths)} paths into a dictionary.\\\") \\n\\n def task_name_of(path_to_func_or_json):\\n \\\"\\\"\\\"\\n Returns the task name of a func or json file. This function OVERWRITES the function\\n \\\"task_name_of\\\" that we imported at the top of this script. BUT! It only overwrites it\\n HERE, in \\\"create_dictionary_of_old_and_new_paths\\\".\\n \\\"\\\"\\\"\\n\\n list_of_lines_containing_raw_subject_info = []\\n for path in old_paths:\\n if filetype_of(path) == \\\"subject info\\\":\\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\\n break\\n\\n for line in list_of_lines_containing_raw_subject_info:\\n if path_to_func_or_json.stem in line:\\n return line.split(\\\"z\\\")[1]\\n\\n\\n for old_path in old_paths:\\n\\n new_path = old_path\\n\\n if filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"anat\\\" and acquisition_number_of(old_path) == \\\"14\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"anat\\\" / f\\\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"func\\\" and acquisition_number_of(old_path) != \\\"02\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"func\\\" / f\\\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"fieldmap\\\" and not exclude_fieldmaps:\\n old_affix = old_path.stem.split(\\\"_\\\")[-1]\\n new_affix = \\\"phasediff\\\"\\n if old_affix == \\\"e1\\\":\\n new_affix = \\\"magnitude1\\\"\\n if old_affix == \\\"e2\\\":\\n new_affix = \\\"magnitude2\\\"\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"fmap\\\" / f\\\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\\\"\\n\\n old_and_new_paths[old_path] = new_path\\n\\n print(\\\"Paths sorted.\\\")\\n\\n return old_and_new_paths\",\n \"def updateCache(self):\\n for root, dirs, files in os.walk(cachedFilesPath):\\n for file in files:\\n if file.endswith(cachedFileExtensionSuffix):\\n path = os.getcwd()+'/'+cachedFilesPath+file\\n with open(path, mode='r') as f:\\n payload_json = f.read()\\n payload_obj=jsonpickle.decode(payload_json)\\n r= self.upload(payload_obj)\\n if isinstance(r, types.NoneType):\\n #do nothing\\n print(\\\"\\\")\\n else:\\n if r.status_code == 200 :\\n #uploaded!\\n if cacheArhive:\\n #move it to archive\\n dst=os.getcwd()+'/'+cachedArchivePath+file\\n shutil.move(path, dst)\\n print(\\\"archived log: \\\", file)\\n else:\\n #delete it\\n os.remove(path)\",\n \"def changeFilenames(reduced, path, input):\\n file = path + '/' + input\\n data = open(file, 'r').readlines()\\n os.remove(file)\\n\\n fh = open(file, 'w')\\n for line in data:\\n if 'includegraphics' in line:\\n for key in reduced:\\n if key in line:\\n new = line.replace(key, reduced[key])\\n fh.write(new)\\n\\n logging.debug('Changed {0:>s} to {1:>s} '.format(line, new))\\n else:\\n fh.write(line)\\n\\n fh.close()\",\n \"def add_base64_files(self, file_dict):\\n if self.src_keys is None:\\n self.src_keys, self.rgb_cam_list, self.rgb_of_depth_cam_list = init_cam_set(file_dict)\\n self.src_keys_dict = {v: i for i, v in enumerate(self.src_keys)}\\n logger.info('Init Calibrator done.')\\n for k, v in file_dict.items():\\n filename = str(10000000 + self.counter)[1:]\\n if k.startswith('cam'):\\n if 'dept' in k:\\n continue\\n cam_id = self.src_keys_dict[k]\\n dst_path = os.path.join(self.calib_data_dir, str(\\n cam_id), 'cam0', filename + '.jpg')\\n if not os.path.exists(os.path.dirname(dst_path)):\\n os.makedirs(os.path.dirname(dst_path))\\n # print('calib data copy', v, dst_path)\\n # print >> sys.stderr, 'calib data copy', v, dst_path\\n with open(dst_path, 'w') as fout:\\n fout.write(base64.b64decode(v))\\n elif k.startswith('xeye'):\\n for i, imgb64 in enumerate(v):\\n cam_id = self.src_keys_dict[('xeye_image', i)]\\n dst_path = os.path.join(self.calib_data_dir, str(\\n cam_id), 'cam0', filename + '.png')\\n if not os.path.exists(os.path.dirname(dst_path)):\\n os.makedirs(os.path.dirname(dst_path))\\n if self.resize_xeye:\\n with open(self.record_path, 'a') as fout:\\n fout.write('resize ' + imgb64 + ' ' + dst_path + '\\\\n')\\n # resize_xeye_image_file(imgpath, dst_path)\\n else:\\n with open(dst_path, 'w') as fout:\\n fout.write(base64.b64decode(imgb64))\\n else:\\n logger.warn('Unrocognize key: {}'.format(k))\\n return\\n self.counter += 1\",\n \"def clearString(name):\\n if name.find(\\\".tar\\\") != 0:\\n name = name.replace(\\\".tar\\\", \\\"\\\")\\n\\n if name.find(\\\".gz\\\") != 0:\\n name = name.replace(\\\".gz\\\", \\\"\\\")\\n return name\",\n \"def make_cached_json(file_name):\\n result = None\\n path = clean_path(file_name)\\n working_directory = os.path.split(os.path.abspath(file_name))[0]\\n file_type_switch = \\\"-s\\\" if is_sats_file(file_name) else \\\"-d\\\"\\n command = []\\n command.append(\\\"patsopt\\\")\\n command.append(\\\"--jsonize-2\\\")\\n command.append(file_type_switch)\\n command.append(path)\\n (stdout, _stderr, return_code) = run(\\n working_directory,\\n command,\\n POSTIATS_ENCODING)\\n if return_code == 0:\\n cached_file_name = get_cached_file_name(path)\\n cached_directory = os.path.split(cached_file_name)[0]\\n if not os.path.exists(cached_directory):\\n os.makedirs(cached_directory)\\n output = open(cached_file_name, \\\"w\\\")\\n output.write(stdout)\\n output.close()\\n result = json.loads(stdout)\\n return result\",\n \"def clean_out_old_env():\\n d = \\\"dict_racey.json\\\"\\n if os.path.exists(d):\\n print(\\\"Remove the old cached JSON before continuing.\\\")\\n os.remove(d)\",\n \"def create_baseline_json(baseline_json_file):\\n # TODO: Update this... Technically shouldn't need to sort it again since it was sorted when written to the results\\n # directory\\n baseline_json_file = baseline_json_file.replace(' ', '')\\n if 'json' not in baseline_json_file:\\n baseline_json_file += \\\".json\\\"\\n with open(baseline_json_file, 'r') as json_file:\\n try:\\n json_object = json.load(json_file)\\n except:\\n print(\\\"Failed to open {}\\\".format(json_file))\\n return\\n\\n # cmd = \\\"cat output/results/\\\" + baseline_json_file + \\\" | jq --sort-keys 'if .sysmlid? != null then sort_by(.sysmlId)? else . end' > output/baseline/\\\" + baseline_json_file.replace(\\n # '_orig', '').replace('.json', '') + \\\"_sorted.json\\\"\\n # print(commands.getoutput(cmd))\",\n \"def beautify_json(self) -> None:\\n for letter in self.data:\\n for category in self.data[letter]:\\n self.data[letter][category] = str(self.data[letter][category.lower()])\\n self.save()\\n with open(dict_path, encoding='utf-8') as x:\\n data = x.read()\\n with open(dict_path, 'w', encoding='utf-8') as y:\\n data2 = data.replace('\\\"[', '[').replace(']\\\"', ']').replace(\\\"'\\\", '\\\"')\\n y.write(data2)\",\n \"def ModifyScenarioFiles(base_path):\\n enumrealm = socket.gethostbyname('enum_realm')\\n prirealm = socket.gethostbyname('prv_rsa')\\n pubrealm = socket.gethostbyname('pub_rsa')\\n\\n strList = ['ENUM_REALM_IP','PRI_REALM_IP','PUB_REALM_IP']\\n repList = [enumrealm,prirealm,pubrealm]\\n fileName = ['Basic_Receiver_enum.xml','Basic_Receiver_pri.xml','Basic_Receiver_pub.xml']\\n \\n try:\\n for i in range(len(strList)):\\n zfile=open(base_path + fileName[i],\\\"r\\\")\\n zList = zfile.readlines()\\n zfile.close()\\n\\n for j in zList:\\n if j.__contains__(strList[i]):\\n str1 = j.replace(strList[i],repList[i])\\n ind = zList.index(j)\\n zList[ind] = str1\\n break\\n \\n zfile=open(base_path + fileName[i],\\\"w\\\")\\n zList = zfile.writelines(zList)\\n zfile.close()\\n except Exception, e:\\n log.error('error: %s' %str(e))\",\n \"def filter_json_file(filename, filters_list):\\n filename = filename.replace(\\\" \\\", \\\"\\\")\\n print(\\\"Filters List {}\\\".format(filters_list))\\n if isinstance(filters_list, list) is False:\\n filters_list = [filters_list]\\n with open(robot_dir + \\\"/output/original/{}_orig.json\\\".format(filename), \\\"r\\\") as file_orig:\\n # Get the root Json Object\\n json_root_object = json.load(file_orig)\\n\\n if \\\"commitId\\\" in json_root_object:\\n del json_root_object[\\\"commitId\\\"]\\n\\n # Store the original json object\\n orig_json_object = json.dumps(json_root_object)\\n root_key = json_root_object.keys()[0]\\n\\n if root_key == \\\"message\\\" and len(json_root_object.keys()) > 1:\\n root_key = json_root_object.keys()[1]\\n\\n # Get the array of objects under the root\\n try:\\n if len(filters_list) > 0:\\n json_root_object = delete_keys_from_dict(json_root_object, filters_list)\\n except:\\n print('Failed to delete keys from json_root_object before iteration')\\n\\n if root_key in ROOT_RETURN_ELEMENTS:\\n json_array = json_root_object[root_key]\\n\\n if isinstance(json_array, list):\\n # Clear the original array\\n json_root_object[root_key] = []\\n\\n # For each object remove any of the keys that are specified in the filter list then put the object back into\\n # the array\\n for json_object in json_array:\\n if len(filters_list) > 0:\\n json_object = delete_keys_from_dict(json_object, filters_list)\\n json_root_object[root_key].append(json_object)\\n # json_root_object = sorted(json_root_object)\\n elif isinstance(json_array, str):\\n json_root_object = json_array\\n\\n # Serialize the JSON object before writing it to the file\\n json_object = json.dumps(json_root_object, sort_keys=True, indent=4, separators=(',', ': '))\\n # Write to result .json file:\\n filtered_filename = robot_dir + \\\"/output/results/{}.json\\\".format(filename)\\n filtered_file = open(filtered_filename, \\\"w\\\")\\n # print(json_object)\\n filtered_file.writelines(json_object)\\n filtered_file.close()\\n\\n # return filtered_output, orig_output\\n return json_object, orig_json_object\",\n \"def test_to_json_file(self):\\n\\n output_file = \\\"this_file_is_a_ghost\\\"\\n File(output_file).delete()\\n\\n Dict(self.test_subject.copy()).to_json_file(output_file)\\n\\n expected = self.test_subject.copy()\\n\\n actual = Dict().from_json_file(output_file)\\n\\n self.assertEqual(expected, actual)\\n\\n File(output_file).delete()\",\n \"def download_files_from_minio(bucket_name, file_prefix, ls_files_to_download):\\n minio_client = get_minio_client()\\n ls_minio_files = list(minio_client.list_objects(bucket_name, file_prefix))\\n ls_downloaded_files = []\\n local_object_dir = tempfile.mkdtemp()\\n for minio_object_path in ls_files_to_download:\\n local_object_name = minio_object_path.replace(file_prefix, \\\"\\\")\\n local_object_path = os.path.join(local_object_dir,local_object_name) \\n get_file_fromMinio(bucket_name, minio_object_path, local_object_path)\\n ls_downloaded_files.append(local_object_path)\\n return ls_downloaded_files\\n\\n\\n def process_columns(string_to_process, replace_string='_'):\\n \\\"\\\"\\\"\\n Process a column name by :\\n - processing special aplphabetical characters\\n - replacing special characters by value set in 'replace_string' \\n #Parameters\\n :param string_to_process (str): String to process (column name)\\n :param replace_string (str, default : '_'): Value to set for replaced characters\\n (ex : \\\"/\\\" -> \\\"\\\", where \\\"\\\" is the replace_string)\\n #Return\\n return out (str): Processed string\\n \\\"\\\"\\\"\\n BIGQUERY_COLUMN_NAME_RE = \\\"[^0-9a-zA-Z_]+\\\"\\n # Get encoding of column\\n str_bytes = str.encode(string_to_process)\\n encoding = 'utf-8'\\n # Process any special alphabetical character\\n temp_out = unicodedata\\\\\\n .normalize('NFKD', string_to_process)\\\\\\n .encode('ASCII', 'ignore')\\\\\\n .decode(encoding)\\n \\n out = re.sub(BIGQUERY_COLUMN_NAME_RE, replace_string, temp_out)\\n out = out.lower()\\n return out\",\n \"def convertFiles():\\n\\n #### Get file lists\\n tmp = os.path.join(remarkableBackupDirectory,remContent)\\n files = [x for x in os.listdir(tmp) if \\\".\\\" not in x]\\n\\n for i in range(0, len(files)):\\n # get file reference number\\n refNrPath = os.path.join(remarkableBackupDirectory, remContent,\\n files[i])\\n # get meta Data\\n meta = json.loads(open(refNrPath + \\\".metadata\\\").read())\\n fname = meta[\\\"visibleName\\\"]\\n fname = fname.replace(\\\" \\\", \\\"_\\\")\\n # Does this lines file have an associated pdf?\\n AnnotPDF = os.path.isfile(refNrPath + \\\".pdf\\\")\\n # Get list of all rm files i.e. all pages\\n npages = len(glob.glob(refNrPath + \\\"/*.rm\\\"))\\n if npages != 0:\\n if AnnotPDF:\\n # we have found an annotated pdf\\n # now make sure it has the right ending\\n if meta[\\\"visibleName\\\"][-4:] != \\\".pdf\\\":\\n syncFilePath = os.path.join(syncDirectory, \\\"*\\\",\\n meta[\\\"visibleName\\\"] + \\\".pdf\\\")\\n else:\\n syncFilePath = os.path.join(syncDirectory, \\\"*\\\",\\n meta[\\\"visibleName\\\"])\\n\\n # does the file exist in our system?\\n inSyncFolder = glob.glob(syncFilePath) != []\\n\\n if inSyncFolder:\\n # have we exported this thing before?\\n local_annotExist = \\\\\\n glob.glob(syncFilePath[:-4] + \\\"_annot.pdf\\\") != []\\n # first, assume, it needs converting\\n remoteChanged = True\\n if local_annotExist:\\n # if it already exists check when it was last updated\\n local_annotPath = \\\\\\n glob.glob(syncFilePath[:-4]+\\\"_annot.pdf\\\")[0]\\n local_annot_mod_time = os.path.getmtime(local_annotPath)\\n # rm time is in ms\\n remote_annot_mod_time = int(meta[\\\"lastModified\\\"])/1000\\n # has this version changed since we last exported it?\\n remoteChanged = \\\\\\n remote_annot_mod_time > local_annot_mod_time\\n # update if the remote version has changed\\n if remoteChanged:\\n origPDF = glob.glob(syncFilePath)[0]\\n #####\\n convertAnnotatedPDF(fname, refNrPath, origPDF)\\n #####\\n else:\\n print(fname + \\\"hasn't been modified\\\")\\n else:\\n print(fname + \\\" does not exist in the sync directory\\\")\\n # TODO allow y/n input whether it should be copied there\\n # anyway\\n else:\\n # we found a note\\n print(\\\"exporting Notebook \\\" + fname)\\n syncFilePath = os.path.join(syncDirectory, notesDirectory,\\n fname + \\\".pdf\\\")\\n inSyncFolder = glob.glob(syncFilePath) != []\\n remoteChanged = True\\n if inSyncFolder:\\n local_annot_mod_time = os.path.getmtime(syncFilePath)\\n remote_annot_mod_time = int(meta['lastModified'])/1000\\n remoteChanged = remote_annot_mod_time > local_annot_mod_time\\n if remoteChanged:\\n #####\\n convertNotebook(fname, refNrPath)\\n #####\\n else:\\n print(fname + \\\"has not changed\\\")\",\n \"def __rm_general(file_contents: str) -> str:\\n\\n new_file_contents = file_contents\\n\\n for regex in COBOL_FORMAT_RM_REGEXES:\\n for match in re.finditer(regex, file_contents):\\n match_str = match_to_str(match)\\n new_file_contents = new_file_contents.replace(match_str, '')\\n\\n return new_file_contents\",\n \"def correct_naming(obsid, inst):\\n cobsid = str(int(float(obsid)))\\n if len(cobsid) == 5:\\n return \\n\\n lobsid = mcf.add_leading_zero(obsid, 5)\\n \\n for sdir in ['secondary', 'analysis']:\\n\\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\\n os.system(cmd)\\n\\n data = mcf.read_data_file(zspace, remove=1)\\n for ent in data:\\n atemp = re.split('\\\\/', ent)\\n fname = atemp[-1]\\n mc = re.search(lobsid, fname)\\n if mc is not None:\\n continue\\n else:\\n atemp = re.split('hrcf', fname)\\n btemp = re.split('_', atemp[1])\\n sobs = btemp[0]\\n new = fname.replace(sobs, lobsid)\\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\\n\\n cmd = 'mv ' + ent + ' ' + full\\n os.system(cmd)\",\n \"def tearDown(self):\\n if os.path.exists(\\\"file.json\\\"):\\n os.remove(\\\"file.json\\\")\",\n \"def tearDown(self):\\n if os.path.exists(\\\"file.json\\\"):\\n os.remove(\\\"file.json\\\")\",\n \"def transform_file(input_file_path: str, output_file_path: str):\\n\\n # Open json\\n with open(input_file_path, mode=\\\"r\\\") as in_file:\\n input_data = json.load(in_file)\\n\\n # Transform and write\\n with jsonlines.open(output_file_path, mode=\\\"w\\\", compact=True) as out_file:\\n for item in input_data[\\\"items\\\"]:\\n out_file.write(transform_item(item))\",\n \"def rewrite_MS_filename(rawfile_name):\\n print(\\\"Rewriting mz filename...\\\")\\n\\n # rename MS filename by its m/z.\\n # open file, read the 2nd row (where m/z is written) and make that into the filename\\n newfname = []\\n replacename = ''\\n for folder in rawfile_name:\\n msfiles = [os.path.basename(path) for path in sorted(glob.glob(opfolder+\\\"/files/\\\"+folder+\\\"/*-MS Chromatogram.txt\\\"))]\\n for fname in msfiles: # MS chromatogram files のファイル名を mzに書き換える。そのファイル名リストをnewfnameに入れる\\n filepath = opfolder+\\\"/files/{}/{}\\\".format(folder,fname)\\n with open(filepath, 'r') as f:\\n for i, line in enumerate(f):\\n if i == 2: break\\n if i == 1: # read 2nd row, where the m/z are written\\n if isfloat(line[-8:-2].strip()):\\n replacename = '{}-{}'.format(folder,line[-8:-2].strip())\\n newfname.append(\\\"{}/{}.txt\\\".format(folder,replacename))\\n elif re.search(r'1-1MS',line) :\\n replacename = '{}-{}-1'.format(folder,line[-5:].strip())\\n newfname.append(\\\"{}/{}.txt\\\".format(folder,replacename))\\n elif re.search(r'1-2MS',line) :\\n replacename = '{}-{}-2'.format(folder,line[-5:].strip())\\n newfname.append(\\\"{}/{}.txt\\\".format(folder,replacename))\\n f.close()\\n os.rename(filepath,opfolder+\\\"/mz/{}/{}.txt\\\".format(folder,replacename))\\n print(\\\"Done\\\")\\n return newfname\",\n \"def tearDown(self):\\n if os.path.exists('file.json'):\\n os.remove(\\\"file.json\\\")\",\n \"def space_cleaning(file=\\\"\\\"):\\n intermediate = str(file) + str(\\\"_intermediate\\\")\\n output_file = str(file)\\n\\n os.rename(intermediate, output_file)\",\n \"def test_add_model_file_prefixed(self):\\n with open(TEST_AVATAR_PATH, 'rb') as avatar:\\n self.user.avatar_tmp = File(avatar)\\n self.user.save()\\n\\n with DataArchive(self.user, DATA_DOWNLOADS_WORKING_DIR) as archive:\\n file_path = archive.add_model_file(self.user.avatar_tmp, prefix=\\\"prefix\\\")\\n\\n self.assertTrue(os.path.isfile(file_path))\\n \\n data_dir_path = str(archive.data_dir_path)\\n self.assertTrue(str(file_path).startswith(data_dir_path))\\n \\n filename = os.path.basename(self.user.avatar_tmp.name)\\n target_filename = 'prefix-{}'.format(filename)\\n self.assertTrue(str(file_path).endswith(target_filename))\",\n \"def reformat_json_file(infilename, outfilename, clobber=False):\\n # open input json file\\n with open(infilename) as json_file:\\n json_string = json_file.read()\\n json_data = json.loads(json_string)\\n\\n # see if output file already exists and determine course of action\\n if os.path.exists(outfilename):\\n if clobber:\\n os.remove(outfilename)\\n else:\\n sys.exit(\\\"Error: output file {} already exists and would be overwritten!\\\".format(outfilename))\\n\\n # write out reformatted json file\\n with open(outfilename, 'w') as f:\\n json.dump(json_data, f, indent=4)\",\n \"def _restore_file(file):\\n\\n os.remove(file)\\n os.rename(file + '.bak', file)\",\n \"def test_write_to_json():\\r\\n tmp_dir = os.getcwd()\\r\\n json_content = '{ \\\"name\\\":\\\"John\\\", \\\"age\\\":30}'\\r\\n directory = os.path.join(tmp_dir, 'inputspec.json')\\r\\n write_to_json(directory, json_content) \\r\\n with open(directory) as json_file:\\r\\n data = json.load(json_file)\\r\\n json_string = json.dumps(data)\\r\\n if os.path.exists(directory):\\r\\n os.remove(directory)\\r\\n assert json_string.replace(' ', '') == json_content.replace(' ' , '')\",\n \"def _dumpJson(data, file):\\n name, ext = os.path.splitext(file)\\n tempFile = \\\"{0}.tmp\\\".format(name)\\n with open(tempFile, \\\"w\\\") as f:\\n json.dump(data, f, indent=4)\\n shutil.copyfile(tempFile, file)\\n os.remove(tempFile)\",\n \"def _handle_downloads_inline(self, downloads_inline: Dict[str,\\n str]) -> None:\\n import base64\\n import zlib\\n for fname, fdata in downloads_inline.items():\\n dirname = os.path.dirname(fname)\\n if dirname:\\n os.makedirs(dirname, exist_ok=True)\\n data_zipped = base64.b64decode(fdata)\\n data = zlib.decompress(data_zipped)\\n with open(fname, 'wb') as outfile:\\n outfile.write(data)\",\n \"async def test_deprecated_save_json(\\n caplog: pytest.LogCaptureFixture, tmp_path: Path\\n) -> None:\\n # pylint: disable-next=hass-deprecated-import,import-outside-toplevel\\n from homeassistant.util.json import save_json\\n\\n fname = tmp_path / \\\"test1.json\\\"\\n save_json(fname, TEST_JSON_A)\\n assert \\\"uses save_json from homeassistant.util.json\\\" in caplog.text\\n assert \\\"should be updated to use homeassistant.helpers.json module\\\" in caplog.text\",\n \"async def test_deprecated_save_json(\\n caplog: pytest.LogCaptureFixture, tmp_path: Path\\n) -> None:\\n # pylint: disable-next=hass-deprecated-import,import-outside-toplevel\\n from homeassistant.util.json import save_json\\n\\n fname = tmp_path / \\\"test1.json\\\"\\n save_json(fname, TEST_JSON_A)\\n assert \\\"uses save_json from homeassistant.util.json\\\" in caplog.text\\n assert \\\"should be updated to use homeassistant.helpers.json module\\\" in caplog.text\",\n \"def clean_path(source):\\n source.file_name = source.file_name.replace('\\\\\\\\','/')\\n return source\",\n \"def test_replace_namespaced_image_stream(self):\\n pass\",\n \"def fixit(file):\\n with open(file, \\\"r\\\") as f:\\n config = json.load(f)\\n if \\\"job_status\\\" in config[\\\"supply-curve-aggregation\\\"]:\\n del config[\\\"supply-curve-aggregation\\\"][\\\"job_status\\\"]\\n if \\\"rep-profiles\\\" in config:\\n del config[\\\"rep-profiles\\\"]\\n fname = os.path.basename(file)\\n cname = \\\"_\\\".join(fname.split(\\\"_\\\")[:-1]) + \\\"_agg\\\"\\n config[\\\"supply-curve-aggregation\\\"][cname][\\\"job_status\\\"] = \\\"successful\\\"\\n\\n with open(file, \\\"w\\\") as f:\\n f.write(json.dumps(config, indent=4))\",\n \"def test_valid_file_name(self):\\n Base.save_to_file([self.r0, self.s1])\\n self.assertTrue(path.exists('Base.json'))\",\n \"def __correct_encoding(self, encode, filename):\\n if encode == 'None' or encode == self.__tencoding:\\n return\\n buffname = '~old' + filename\\n self.__os.rename(filename, buffname)\\n with open(buffname, 'r', encoding=self.__tencoding) as fr:\\n with open(filename, 'w', encoding=self.__tencoding) as fw:\\n for line in fr:\\n fw.write(line[:-1] + '\\\\r\\\\n')\\n self.__os.remove(buffname)\",\n \"def test_make_json_advanced(self):\\n resources = get_test_resources()\\n output, filename = make_json(commit=\\\"1245\\\", exclude=[\\\"tei:note\\\", \\\"tei:orig\\\"], credit=\\\"PerseusDL\\\", **resources)\\n output = json.loads(output)\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Spero me secutum in libellis meis tale temperamen-\\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"1\\\"], \\\"Et comites longae quaeris habere viae, \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"1\\\"][\\\"3\\\"], \\\"Crede mihi, nimium Martia turba sapit. \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n filename, \\\"textgroup__work__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\\n self.assertEqual(\\n output[\\\"original-urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1\\\",\\n \\\"Original URN should be fed\\\"\\n )\\n self.assertEqual(\\n output[\\\"urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1-simple\\\",\\n \\\"CLTK URN should be suffixed\\\"\\n )\\n self.assertEqual(\\n output[\\\"credit\\\"], \\\"PerseusDL\\\",\\n \\\"Credit should be empty by default\\\"\\n )\\n self.assertEqual(\\n output[\\\"meta\\\"], \\\"book-poem-line\\\",\\n \\\"meta should reflect the citation scheme\\\"\\n )\\n self.assertEqual(\\n output[\\\"author\\\"], \\\"textgroup\\\",\\n \\\"Author name should be the English textgroup name\\\"\\n )\\n self.assertEqual(\\n output[\\\"work\\\"], \\\"work\\\",\\n \\\"Work name should be the English work name\\\"\\n )\\n self.assertEqual(\\n output[\\\"edition\\\"], \\\"description\\\",\\n \\\"We should have the English description\\\"\\n )\\n self.assertEqual(\\n output[\\\"commit\\\"], \\\"1245\\\",\\n \\\"We should have the commit information\\\"\\n )\",\n \"def sanitize_paths(self):\\n\\n for wadfile in self.files:\\n if wadfile.path:\\n path, filename = os.path.split(wadfile.path)\\n if len(filename) < 255:\\n continue\\n\\n basename, ext = os.path.splitext(filename)\\n wadfile.path = os.path.join(path, f\\\"{basename[:255-17-len(ext)]}.{wadfile.path_hash:016x}{ext}\\\")\",\n \"def stripKeyFile(keyFileName,iNewFileName,newFileId,skimKeyFileName):\\n\\n print \\\"stripKeyFile called - look at this code!\\\"\\n sys.exit(1)\\n\\n newFileName = string.split(iNewFileName,\\\"-esdb\\\")[0]+\\\"-esdb.ikey\\\"\\n pos,needToSwap,nRecordNames,sNames,nSV=keyFileHeaderReader(keyFileName)\\n origKeyFile = open(keyFileName,'r')\\n origKeyFile.seek(pos)\\n\\n # read information from skimKeyFileName\\n skimPos,skimSwap,skimRecords,skimStreamNames,skimNumberSV=keyFileHeaderReader(skimKeyFileName)\\n skimKeyFile = open(skimKeyFileName,'r')\\n skimKeyFile.seek(skimPos)\\n \\n streamNameString =\\\"\\\"\\n for name in sNames:\\n streamNameString = streamNameString+name +\\\"\\\\0\\\"\\n streamNameString = streamNameString[:-1]\\n while 0 != len(streamNameString) % 4:\\n streamNameString = streamNameString + \\\"\\\\0\\\"\\n nameWords = array.array('I')\\n nameWords.fromstring(streamNameString)\\n\\n nameList = nameWords.tolist()\\n number32BitWordsInNameList = len(nameList)\\n nWordsInHeader = len(sNames)+number32BitWordsInNameList+1+1+1\\n headerList = [2718281*256,newFileId,nWordsInHeader,len(sNames)]\\n headerList+= [number32BitWordsInNameList]+nameList+[nSV,nWordsInHeader]\\n keyFile = open(newFileName,'w+b')\\n keyHeader = array.array('I')\\n keyHeader.fromlist(headerList)\\n keyHeader.tofile(keyFile)\\n \\n # loop over all sv's in original key file and write out those which are not in fakeSVList\\n i = 0\\n fakeIdx = 0\\n counter = 0\\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\\n print \\\"orig\\\",origKeyFile.name\\n print \\\"skim\\\",skimKeyFile.name\\n while i<nSV:\\n if not skimSV: break\\n sv,recIdxList = decodeKeyRecord(origKeyFile,needToSwap,nRecordNames)\\n if not sv: break\\n i+=1\\n # we event number from parent key file is become larger then from skim, advance the skim\\n if sv[1]>skimSV[1]:\\n try:\\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\\n except:\\n skimSV=()\\n break\\n if skimSV!=sv:\\n continue\\n else: # write out\\n run = sv[0]\\n evt = sv[1]\\n lowerId, upperId = gen_util.lowerUpperBitsOfUID(sv[2])\\n recordArray = array.array('I')\\n recordHeader = [sv[0],sv[1],lowerId,upperId]+skimIdxList\\n recordArray.fromlist(recordHeader)\\n recordArray.tofile(keyFile)\\n counter+=1\\n # read one more event from skim file\\n try:\\n skimSV,skimIdxList = decodeKeyRecord(skimKeyFile,skimSwap,skimRecords)\\n except:\\n skimSV=()\\n # seek to position where total SV's written and fix it to new number of SV's\\n keyFile.seek(pos-2*4)\\n pos = keyFile.tell()\\n nSVHeader = array.array('I')\\n nSVHeader.fromfile(keyFile,1)\\n if nSVHeader[0]!=nSV:\\n print \\\"nSVHeader[0]\\\",nSVHeader[0],nSV\\n print \\\"Miss position of nSyncValues in a file\\\"\\n return \\\"\\\"\\n keyFile.seek(pos)\\n nSVHeader[0]=counter\\n nSVHeader.tofile(keyFile)\\n keyFile.close()\\n\\n return newFileName\",\n \"def test_gzip_file_no_extension(self):\\n # Write the data to a file\\n temp_file = tempfile.NamedTemporaryFile()\\n with gzip.open(temp_file.name, 'wb') as out:\\n for item in self.data:\\n serialzed = json.dumps(item).encode()\\n out.write(serialzed + b'\\\\n')\\n\\n # Load from file, ensure it is correct\\n actual_data = []\\n with JsonlReader(temp_file.name) as f:\\n for item in f:\\n actual_data.append(item)\\n self.assertEqual(self.data, actual_data)\",\n \"def rewrite_jaraco(pkg_files, new_root):\\n for file in pkg_files.glob('*.py'):\\n text = file.read_text()\\n text = re.sub(r' (more_itertools)', rf' {new_root}.\\\\1', text)\\n file.write_text(text)\\n # required for zip-packaged setuptools #3084\\n pkg_files.joinpath('__init__.py').write_text('')\",\n \"def updateCountryNames(self):\\n try:\\n with open('countryNameMapping.json', 'r') as file:\\n name_mapping = json.loads(file.read())\\n except:\\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\\n \\n for key, value in name_mapping.items():\\n self.covid_df.replace(key, value, inplace=True)\\n \\n try:\\n with open('countryNameISO2.json', 'r') as file:\\n self.name_iso2_mapping = json.loads(file.read())\\n except:\\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\\n self.writeCountryCodeFile()\\n print('Re-importing required JSONs...')\\n self.updateCountryNames()\",\n \"def test_find_raw_file_json(self):\\n\\n this_file_name = probsevere_io.find_raw_file(\\n top_directory_name=TOP_DIRECTORY_NAME,\\n unix_time_sec=VALID_TIME_UNIX_SEC,\\n file_extension=probsevere_io.JSON_FILE_EXTENSION,\\n raise_error_if_missing=False)\\n\\n self.assertTrue(this_file_name == JSON_FILE_NAME)\",\n \"def calc_fullpath(data_folder, name):\\n return os.path.join(data_folder, f\\\"{alias(name)}.json\\\")\",\n \"def _restore_image_name(self, data: Dict[str, str]) -> ImageName:\\n return ImageName.parse(data[\\\"str\\\"])\",\n \"def _post_recording_scrub(self):\\n src_path = self.cassette_path\\n rg_name = getattr(self, 'resource_group', None)\\n rg_original = getattr(self, 'resource_group_original', None)\\n\\n t = tempfile.NamedTemporaryFile('r+')\\n with open(src_path, 'r') as f:\\n for line in f:\\n # scrub resource group names\\n if rg_name != rg_original:\\n line = line.replace(rg_name, rg_original)\\n # omit bearer tokens\\n if 'authorization:' not in line.lower():\\n t.write(line)\\n t.seek(0)\\n with open(src_path, 'w') as f:\\n for line in t:\\n f.write(line)\\n t.close()\",\n \"def _raw_read(self, filepath, dirpath=None):\\n self.json_dict = super().read(filepath)\\n return self.json_dict\",\n \"def clean(self):\\n actual_output_file = path.splitext(self.source_name)[0] + \\\".actual\\\"\\n if path.exists(self.binary_name):\\n os.unlink(self.binary_name)\\n if path.exists(actual_output_file):\\n os.unlink(actual_output_file)\",\n \"def test_WronJSONFormat():\\n\\n tree = MerkleTree()\\n\\n with pytest.raises(WrongJSONFormat):\\n tree.encryptFilePerObject(\\n os.path.join(os.path.dirname(__file__),\\n 'objects/sample.json')\\n )\",\n \"def tearDown(self):\\n try:\\n remove(\\\"file.json\\\")\\n except:\\n pass\",\n \"def change_pic(link_to:str):\\n with open(os.path.dirname(os.path.abspath(__file__))+'\\\\\\\\data.json', 'r') as test:\\n f = json.load(test)\\n f['button_pic'] = link_to\\n with open(os.path.dirname(os.path.abspath(__file__))+'\\\\\\\\data.json', 'w') as test:\\n json.dump(f, test, indent=2)\",\n \"def combine_with_assets(coins):\\n \\n with open('index_assets.json', encoding='utf-8') as f:\\n \\n data = json.loads(f.read())\\n \\n for coin in coins:\\n symbol = coin['symbol']\\n original_symbol = symbol\\n\\n if coin['gecko_id'] in [asset['gecko_id'] for asset in data.values()]:\\n continue\\n\\n print('got a new coin: {}'.format(coin))\\n\\n counter = 1\\n while symbol in data:\\n print('symbol {} repeats !'.format(symbol))\\n symbol = original_symbol + \\\"_\\\" + str(counter)\\n counter += 1\\n\\n data[symbol] = {'gecko_id': coin['gecko_id'], 'symbol': coin['symbol']}\\n if 'logo' in coin:\\n data[symbol]['logo'] = coin['logo']\\n else:\\n print('could not find image')\\n\\n\\n\\n with open('index_assets.json', 'w', encoding='utf-8') as f:\\n f.write(json.dumps(data))\\n print('wrote to file')\",\n \"def fix_filename(self):\\n if not self.remove_path:\\n return\\n self.filename = re.sub(\\\".+\\\\/\\\", \\\".../\\\", self.filename)\",\n \"def restructure_file(raw_file_name, destination_file, label_file):\\n unique_words = answer_vocabulary(raw_file_name)\\n answer_labels = convert2labels(unique_words, label_file)\\n\\n qa_list = json.load(open(raw_file_name))\\n new_qa_list = list()\\n\\n for qa_dict in qa_list:\\n answer = str(qa_dict[\\\"answer\\\"]).lower()\\n first_word = answer.split(\\\" \\\")[0]\\n\\n new_qa_dict = {\\n \\\"image_name\\\": qa_dict[\\\"image_name\\\"],\\n \\\"question\\\": qa_dict[\\\"question\\\"],\\n \\\"answer_label\\\": answer_labels[first_word]\\n }\\n\\n new_qa_list.append(new_qa_dict)\\n\\n json.dump(new_qa_list, open(destination_file, \\\"w\\\"), indent=4)\",\n \"def test_transform_file(self, mock_transform_object):\\n mock_transform_object.return_value = {}\\n with CliRunner().isolated_filesystem() as t:\\n transform_path = \\\"transform/out.jsonl.gz\\\"\\n\\n # Create works entity file\\n works = {\\\"works\\\": \\\"content\\\"}\\n works_download_path = \\\"works.jsonl.gz\\\"\\n with gzip.open(works_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(works, f_out)\\n\\n # Create other entity file (concepts or institution)\\n concepts = {\\\"concepts\\\": \\\"content\\\"}\\n concepts_download_path = \\\"concepts.jsonl.gz\\\"\\n with gzip.open(concepts_download_path, \\\"wt\\\", encoding=\\\"ascii\\\") as f_out:\\n json.dump(concepts, f_out)\\n\\n # Test when dir of transform path does not exist yet, using 'works' entity'\\n self.assertFalse(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test when dir of transform path does exist, using 'works' entity\\n self.assertTrue(os.path.isdir(os.path.dirname(transform_path)))\\n\\n transform_file(works_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"682a6d42\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(works, \\\"abstract_inverted_index\\\")\\n mock_transform_object.reset_mock()\\n os.remove(transform_path)\\n\\n # Test for \\\"concepts\\\" and \\\"institution\\\" entities\\n transform_file(concepts_download_path, transform_path)\\n self.assert_file_integrity(transform_path, \\\"d8cafe16\\\", \\\"gzip_crc\\\")\\n mock_transform_object.assert_called_once_with(concepts, \\\"international\\\")\",\n \"def renamefile(filename):\\n new_data_list = []\\n with open(filename, 'r') as f:\\n data_list = f.read().split('\\\\n')\\n\\n print('Generating new data list..')\\n for data in tqdm(data_list):\\n if len(data) == 0:\\n continue\\n data_info = data.split(' ')\\n\\n #data_info[0] = data_info[0].replace('jpg', 'png')\\n #data_info[1] = data_info[1].replace('jpg', 'png')\\n for it, name in enumerate(data_info):\\n data_info[it] = '/'.join(name.split('/')[1:])\\n if data_info[2].find('extras') == -1:\\n new_data_list.append(' '.join(data_info))\\n\\n with open(filename, 'w') as f:\\n print('writing new data names..')\\n\\n for it, data in tqdm(enumerate(new_data_list)):\\n if len(data) == 0:\\n continue\\n\\n if it == len(new_data_list)-1:\\n f.write(data)\\n else:\\n f.write(data+'\\\\n')\\n\\n print('Done.')\",\n \"def _transform_name(self) -> None:\\n self.name = utils.maybe_rename_for_k8s(self.name)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6086128","0.6033686","0.59726596","0.59672356","0.5949546","0.5894795","0.58688366","0.5825079","0.5788089","0.5704787","0.5688017","0.56608254","0.559506","0.55057395","0.54784393","0.5455468","0.54384154","0.5428078","0.5389018","0.53759176","0.53649086","0.53404623","0.53389364","0.5322401","0.5291311","0.52876985","0.52365816","0.52279794","0.52140486","0.52138966","0.5206602","0.5193186","0.5156779","0.5152611","0.5144636","0.5139964","0.51295525","0.5120816","0.5115279","0.51079774","0.5099405","0.5090614","0.50636226","0.5056139","0.50544906","0.5030647","0.5030543","0.50221324","0.50151676","0.50019217","0.49999663","0.49813977","0.49812123","0.49746397","0.49730122","0.49563095","0.4941209","0.49338904","0.49308884","0.49235213","0.49201575","0.49201575","0.49160713","0.49048075","0.48994523","0.4898143","0.48937777","0.48919874","0.48902678","0.48832625","0.4873067","0.48679414","0.48590523","0.48590523","0.4847286","0.48440492","0.48427683","0.48418182","0.4840079","0.48368505","0.48350352","0.48337412","0.48295516","0.48258385","0.4815393","0.48068944","0.48064595","0.48042434","0.48032406","0.47963318","0.47868073","0.4785296","0.47816724","0.47702086","0.4767814","0.4763922","0.4763434","0.47604525","0.4760176","0.47591332"],"string":"[\n \"0.6086128\",\n \"0.6033686\",\n \"0.59726596\",\n \"0.59672356\",\n \"0.5949546\",\n \"0.5894795\",\n \"0.58688366\",\n \"0.5825079\",\n \"0.5788089\",\n \"0.5704787\",\n \"0.5688017\",\n \"0.56608254\",\n \"0.559506\",\n \"0.55057395\",\n \"0.54784393\",\n \"0.5455468\",\n \"0.54384154\",\n \"0.5428078\",\n \"0.5389018\",\n \"0.53759176\",\n \"0.53649086\",\n \"0.53404623\",\n \"0.53389364\",\n \"0.5322401\",\n \"0.5291311\",\n \"0.52876985\",\n \"0.52365816\",\n \"0.52279794\",\n \"0.52140486\",\n \"0.52138966\",\n \"0.5206602\",\n \"0.5193186\",\n \"0.5156779\",\n \"0.5152611\",\n \"0.5144636\",\n \"0.5139964\",\n \"0.51295525\",\n \"0.5120816\",\n \"0.5115279\",\n \"0.51079774\",\n \"0.5099405\",\n \"0.5090614\",\n \"0.50636226\",\n \"0.5056139\",\n \"0.50544906\",\n \"0.5030647\",\n \"0.5030543\",\n \"0.50221324\",\n \"0.50151676\",\n \"0.50019217\",\n \"0.49999663\",\n \"0.49813977\",\n \"0.49812123\",\n \"0.49746397\",\n \"0.49730122\",\n \"0.49563095\",\n \"0.4941209\",\n \"0.49338904\",\n \"0.49308884\",\n \"0.49235213\",\n \"0.49201575\",\n \"0.49201575\",\n \"0.49160713\",\n \"0.49048075\",\n \"0.48994523\",\n \"0.4898143\",\n \"0.48937777\",\n \"0.48919874\",\n \"0.48902678\",\n \"0.48832625\",\n \"0.4873067\",\n \"0.48679414\",\n \"0.48590523\",\n \"0.48590523\",\n \"0.4847286\",\n \"0.48440492\",\n \"0.48427683\",\n \"0.48418182\",\n \"0.4840079\",\n \"0.48368505\",\n \"0.48350352\",\n \"0.48337412\",\n \"0.48295516\",\n \"0.48258385\",\n \"0.4815393\",\n \"0.48068944\",\n \"0.48064595\",\n \"0.48042434\",\n \"0.48032406\",\n \"0.47963318\",\n \"0.47868073\",\n \"0.4785296\",\n \"0.47816724\",\n \"0.47702086\",\n \"0.4767814\",\n \"0.4763922\",\n \"0.4763434\",\n \"0.47604525\",\n \"0.4760176\",\n \"0.47591332\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6098598"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85179,"cells":{"query":{"kind":"string","value":"Onetime use function. Method for rebasing .json files. Add a \"clipDate\" key to clippings."},"document":{"kind":"string","value":"def rebase_add_date():\n\tfilenames, clippings = load_clippings(inFolder)\n\tfor file, clip in zip(filenames, clippings):\n\t\tdate = \"-\".join(file.split(\"-\")[:3])\n\t\tdate = date.split(\"/\")[-1]\n\t\tclip[\"clipDate\"] = date\n\t\twith open(file, \"w\") as outfile:\n\t\t\tjson.dump(clip, outfile)"},"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 process_files_json():\n # chdir into beep root\n pwd = os.getcwd()\n os.chdir(os.environ.get(\"BEEP_ROOT\", \"/\"))\n\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\n\n all_list = sorted(all_list)\n dumpfn(all_list, \"all_files.json\")\n\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\n\n new_file_index = file_id\n\n for filename in tqdm(sorted(file_list)):\n # If the file has already been renamed another entry should not be made\n if mapdf['filename'].str.contains(filename).sum() > 0:\n continue\n old_file = os.path.join(SRC_DIR, filename)\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\n shutil.copy(old_file, new_path) # copy main data file\n shutil.copy(old_file.replace(\".csv\", '_Metadata.csv'), new_path) # copy meta data file\n\n if PROJECT_NAME == 'FastCharge':\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\n elif PROJECT_NAME == 'ClosedLoopOED':\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\n else:\n raise ValueError(\"Unsupported PROJECT_NAME: {}\".format(PROJECT_NAME))\n\n df_dup = mapdf.set_index(['protocol', 'date'])\n if (protocol, date) in df_dup.index:\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\n file_id = row['fid'].iloc[0]\n protocol = row['protocol'].iloc[0]\n date = row['date'].iloc[0]\n strname = row['strname'].iloc[0]\n else:\n file_id = new_file_index\n new_file_index = new_file_index + 1\n\n new_name = \"{}_{}_{}\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \"{}.csv\".format(new_name))\n\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\n os.path.abspath(old_file),\n os.path.abspath(new_file)]],\n columns=METADATA_COLUMN_NAMES)\n mapdf = mapdf.append(new_row)\n\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\".csv\", \"_Metadata.csv\"),\n new_file.replace(\".csv\", \"_Metadata.csv\"))\n\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \"map.csv\"), index=False)\n mapdf = mapdf.reset_index(drop=True)\n os.chdir(pwd)\n return json.dumps(mapdf.to_dict(\"list\"))","def fix_jsons_in(bids_dir: Path):\n\n print(\"Finalizing task json files.\")\n\n for path in bids_dir.rglob(\"func/*_task-*.json\"):\n append_to_json_file(key=\"TaskName\", value=task_name_of(path), path_to_json=path)\n\n print(\"Appending echo times to phase difference json files.\")\n\n for path in bids_dir.rglob(\"fmap/*_phasediff.json\"):\n magnitude1_path = the_path_that_matches(pattern=\"sub-*_magnitude1.json\", in_directory=path.parent)\n magnitude2_path = the_path_that_matches(pattern=\"sub-*_magnitude2.json\", in_directory=path.parent)\n echo_time1 = value_of_key_in_json_file(\"EchoTime\", magnitude1_path)\n echo_time2 = value_of_key_in_json_file(\"EchoTime\", magnitude2_path)\n append_to_json_file(key=\"EchoTime1\", value=echo_time1, path_to_json=path)\n append_to_json_file(key=\"EchoTime2\", value=echo_time2, path_to_json=path)\n\n print(\"Setting targets of fieldmap json files.\")\n\n for path in bids_dir.rglob(\"fmap/*.json\"):\n func_dir = path.parent.parent / \"func\"\n trimmed_func_paths = [\"func/\" + func_path.name for func_path in func_dir.glob(\"*.nii\")]\n append_to_json_file(key=\"IntendedFor\", value=trimmed_func_paths, path_to_json=path)","def clip_out_acp (in_dir, out_dir, base_out_name=\"ACP_data\"):\n in_files = glob.glob(os.path.join(in_dir, \"*.tif\"))\n # print(in_files)\n for file_path in sorted(in_files): \n print(file_path)\n file = os.path.split(file_path)[1] \n month, year = file[:-4].split('_')[-2:] \n out_file = os.path.join(\n out_dir, base_out_name + '_' + year + \"_\" + month + \".tif\"\n ) \n raster.clip_raster(file_path, out_file, ACP_EXTENT)","def sanitize_json_files(unsanitized_json_file):\n with open(develop_baseline_dir + unsanitized_json_file) as f:\n lines = f.readlines()\n\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\n w.writelines([item for item in lines[:-1]])","def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\n\n print(\"Fixing the acquisition numbers of the .json files in sourcedata.\")\n\n for old_path in raw_dir.rglob(\"*.json\"):\n\n parts_of_stem_of_old_path = old_path.stem.split(\"_\")\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\n fresh_new_stem = \"_\".join(stem_parts_with_correct_acquisition_number)\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\n old_path.replace(fresh_new_path)","def minify_json(self) -> None:\n print(f\"[FileManager: INFO] Minifing file {self.path}\")\n file_data = open(self.path, \"r\", encoding=\"utf-8\").read()\n json_data = json.loads(file_data) \n json_string = json.dumps(json_data, separators=(',', \":\")) \n path = str(self.path).replace(\".json\", \"\")\n new_path = \"{0}_min.json\".format(path)\n open(new_path, \"w+\", encoding=\"utf-8\").write(json_string)","def anonymize(data_dir):\n\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\n for dir_name in sorted(dirs):\n dir_path = os.path.join(root, dir_name)\n json_path = os.path.join(root, dir_name, 'data.json')\n print(json_path)\n\n with open(json_path) as f:\n data = json.load(f)\n\n data.pop('user_email')\n data.pop('user_name')\n data.pop('survey_data')\n\n with open(json_path, 'w') as f:\n json.dump(data, f)","def reset_data():\n shutil.copy2(\n 'data/one_producer_many_consumers.ORIG.json',\n 'data/one_producer_many_consumers.json'\n )","def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\n\n old_and_new_paths = {}\n old_paths = list(raw_dir.rglob(\"*\"))\n print(f\"Sorting {len(old_paths)} paths into a dictionary.\") \n\n def task_name_of(path_to_func_or_json):\n \"\"\"\n Returns the task name of a func or json file. This function OVERWRITES the function\n \"task_name_of\" that we imported at the top of this script. BUT! It only overwrites it\n HERE, in \"create_dictionary_of_old_and_new_paths\".\n \"\"\"\n\n list_of_lines_containing_raw_subject_info = []\n for path in old_paths:\n if filetype_of(path) == \"subject info\":\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\n break\n\n for line in list_of_lines_containing_raw_subject_info:\n if path_to_func_or_json.stem in line:\n return line.split(\"z\")[1]\n\n\n for old_path in old_paths:\n\n new_path = old_path\n\n if filetype_of(old_path.with_suffix(\".nii\")) == \"anat\" and acquisition_number_of(old_path) == \"14\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"anat\" / f\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"func\" and acquisition_number_of(old_path) != \"02\":\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"func\" / f\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\"\n\n elif filetype_of(old_path.with_suffix(\".nii\")) == \"fieldmap\" and not exclude_fieldmaps:\n old_affix = old_path.stem.split(\"_\")[-1]\n new_affix = \"phasediff\"\n if old_affix == \"e1\":\n new_affix = \"magnitude1\"\n if old_affix == \"e2\":\n new_affix = \"magnitude2\"\n new_path = bids_dir / f\"sub-{subject_id_of(old_path)}\" / \"fmap\" / f\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\"\n\n old_and_new_paths[old_path] = new_path\n\n print(\"Paths sorted.\")\n\n return old_and_new_paths","def backeruper(file_name, file_num=0):\n\n if not os.path.exists('%s.json' % file_name):\n write_backup('%s.json' % file_name)\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\n write_backup('%s.%s.json' % (file_name, file_num))\n else:\n file_num += 1\n backeruper(file_name, file_num)","def fix_file_dates(source_file_name, dest_file_name):\n shutil.copystat(source_file_name, dest_file_name)\n print(\"Fixed dates for \" + dest_file_name)","def add_date(jsonfile, outputfile):\n print(\"Add Date\")\n start_time = time.time()\n\n with open(jsonfile, 'r') as f:\n json_str = json.load(f)\n\n for i in range(len(json_str)):\n day = str(json_str[i][\"Day\"])\n day_str = day[:4] + \"-\" + day[4:6] + \"-\" + day[6:8]\n\n json_str[i][\"Day\"] = day_str\n\n with open(outputfile, \"w\") as jsonFile:\n json.dump(json_str, jsonFile)\n\n elapsed_time = time.time() - start_time\n print(\" | Elapsed time : \", elapsed_time)","def fix_path(self):\n paths = self.data['path'].tolist()\n prefixes = [re.findall(r'[A-Z\\-0-9]+', path) for path in paths]\n prefix_good = [str(prefix[0]) + \".json\" for prefix in prefixes]\n self.data['path'] = prefix_good","def replace_gen(self):\r\n current_path = os.path.join(self.settings.save_path, 'current.json')\r\n current_folder_path = os.path.join(self.settings.save_path, 'current')\r\n history_path = os.path.join(self.settings.save_path, 'history')\r\n archive_folder_path = os.path.join(history_path, f'gen{self.generation}')\r\n archive_path = os.path.join(archive_folder_path, 'current') # no ending allowed\r\n archive_json_path = os.path.join(archive_folder_path, 'current.json')\r\n\r\n\r\n if not os.path.exists(current_path):\r\n raise FileNotFoundError\r\n if not os.path.exists(current_folder_path):\r\n raise FileNotFoundError\r\n\r\n os.makedirs(history_path, exist_ok=True)\r\n os.makedirs(archive_folder_path)\r\n\r\n cwd = os.getcwd()\r\n shutil.make_archive(archive_path, 'zip', current_folder_path)\r\n os.chdir(cwd)\r\n shutil.rmtree(current_folder_path, onerror=_ignore_del_dir_failure)\r\n os.chdir(cwd)\r\n\r\n os.rename(current_path, archive_json_path)","def filter_json_file(filename, filters_list):\n filename = filename.replace(\" \", \"\")\n print(\"Filters List {}\".format(filters_list))\n if isinstance(filters_list, list) is False:\n filters_list = [filters_list]\n with open(robot_dir + \"/output/original/{}_orig.json\".format(filename), \"r\") as file_orig:\n # Get the root Json Object\n json_root_object = json.load(file_orig)\n\n if \"commitId\" in json_root_object:\n del json_root_object[\"commitId\"]\n\n # Store the original json object\n orig_json_object = json.dumps(json_root_object)\n root_key = json_root_object.keys()[0]\n\n if root_key == \"message\" and len(json_root_object.keys()) > 1:\n root_key = json_root_object.keys()[1]\n\n # Get the array of objects under the root\n try:\n if len(filters_list) > 0:\n json_root_object = delete_keys_from_dict(json_root_object, filters_list)\n except:\n print('Failed to delete keys from json_root_object before iteration')\n\n if root_key in ROOT_RETURN_ELEMENTS:\n json_array = json_root_object[root_key]\n\n if isinstance(json_array, list):\n # Clear the original array\n json_root_object[root_key] = []\n\n # For each object remove any of the keys that are specified in the filter list then put the object back into\n # the array\n for json_object in json_array:\n if len(filters_list) > 0:\n json_object = delete_keys_from_dict(json_object, filters_list)\n json_root_object[root_key].append(json_object)\n # json_root_object = sorted(json_root_object)\n elif isinstance(json_array, str):\n json_root_object = json_array\n\n # Serialize the JSON object before writing it to the file\n json_object = json.dumps(json_root_object, sort_keys=True, indent=4, separators=(',', ': '))\n # Write to result .json file:\n filtered_filename = robot_dir + \"/output/results/{}.json\".format(filename)\n filtered_file = open(filtered_filename, \"w\")\n # print(json_object)\n filtered_file.writelines(json_object)\n filtered_file.close()\n\n # return filtered_output, orig_output\n return json_object, orig_json_object","def regenerate_json_file():\n \n # filepaths used in generating json data...\n dir_export = f\"C:\\\\Users\\\\{os.getlogin()}\\\\Downloads\"\n list_name = 'my-favourite-films.csv'\n json_output_filename = 'reviews_web_data.json'\n path_to_rootreducer = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\reducers\\\\RootReducer.js';\n path_to_json_output = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\components\\\\films\\\\{json_output_filename}'\n \n # 1) find letterboxd zip export...\n prefix = 'letterboxd'\n postfix = 'utc.zip'\n zip_file_name = \"\"\n download_folder = sorted(glob.glob(f\"{dir_export}/*.zip\"), key=os.path.getmtime)\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\n for filepath in download_folder:\n filename = filepath.split('\\\\')[-1]\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\n zip_file_name = filename\n print(f\"Found the zip export! -> {zip_file_name}\")\n break\n else:\n continue\n\n path_to_zip_file = f\"{dir_export}\\\\{zip_file_name}\" # path to zip file we downlodaded from letterboxd...\n path_to_extracted_zip = f\"{dir_export}\\\\{zip_file_name[:-4]}\" # path to extracted zip (which we are about to do)...\n\n # 2) extract zip automatically (if not done already)...\n if os.path.exists(path=path_to_zip_file):\n if not os.path.exists(path=path_to_extracted_zip):\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\n z.extractall(path_to_extracted_zip)\n print(f\"Extract complete! -> {path_to_extracted_zip}\")\n else:\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\n else:\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\n\n\n # local version of letterboxd data list\n letterboxd_list = []\n \n # 3) locate the csv file of interest\n if os.path.exists(path_to_extracted_zip): \n # open csv file...\n path_to_list = f'{path_to_extracted_zip}\\\\lists\\\\{list_name}'\n with open(path_to_list, 'r') as f:\n # csv reader object\n csv_reader = csv.reader(f)\n \n # skip header in the csv file...\n rows_to_skip = 5\n for i in range(0, rows_to_skip):\n next(csv_reader)\n \n # 4) iterate over each row (i.e. each film) in csv file...\n for csv_row in csv_reader:\n pos = csv_row[0]\n title = csv_row[1]\n year = csv_row[2]\n letterboxd_url = csv_row[3]\n letterboxd_film_id = letterboxd_url.split('/')[-1]\n genres = []\n directors = []\n duration = 0\n language = \"\"\n imdb_url = \"\"\n imdb_avg_rating = \"\"\n imdb_num_votes = \"\"\n tmdb_url = \"\"\n poster_url = \"\"\n \n # parse data from letterboxd web page... (this takes ~1.21s)\n page = session.get(url=letterboxd_url, verify=False, stream=True)\n soup = BeautifulSoup(page.content, 'html.parser')\n \n # retrieve list of genres...\n div_genres = soup.select_one('#tab-genres')\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\n if 'genre' in link['href']:\n genre = link.text.capitalize()\n if genre == 'Science-fiction':\n genre = 'Sci-fi'\n genres.append(genre)\n\n # retrieve duration\n textfooter = soup.select_one('section.col-main > p.text-footer').text\n if 'mins' in textfooter:\n minstext = textfooter.find('mins', 0, len(textfooter))\n duration = textfooter[minstext-5:minstext].strip()\n \n # retrieve the first spoken language\n div_details = soup.select_one('#tab-details')\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\n if 'language' in link['href']:\n language = link.text.capitalize()\n break\n \n # retrieve IMDB url\n footer = soup.select_one('section.col-main p.text-footer')\n url_buttons = footer.select('a.micro-button')\n for url in url_buttons:\n if 'imdb' in url.text.lower():\n # get IMDB URL\n imdb_url = url['href']\n elif 'tmdb' in url.text.lower():\n # get TMDB URL\n tmdb_url = url['href']\n if len(url_buttons) == 1:\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\n\n # retrieve avg rating on letterboxd\n # page_content_str = page.content.decode('utf-8')\n # letterboxd_avg_rating = soup.select_one('.average-rating')\n\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\n imdb_film_id = imdb_url.split('/')[-2]\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\n imdb = requests.get(url=url, verify=False)\n imdb_json = json.loads(imdb.text)\n\n # retrieve avg IMD rating\n imdb_avg_rating = imdb_json['imdbRating']\n \n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\n \n # retrieve poster from IMDB\n poster_url = imdb_json['Poster']\n if 'SX300' in poster_url:\n poster_url = poster_url.split('SX300')[0]\n \n # retrieve title from IMDB (because letterboxd parsing is shite!)\n # title = imdb_json['Title']\n \n # retrieve list of directors (because letterboxd parsing is shite!)\n directors = imdb_json['Director'].split(', ')\n \n # id of my review!\n titlev2 = Helpers.simplify_movie_title(title=title)\n review_id = f\"{titlev2}-{letterboxd_film_id}-review\"\n \n \"\"\"\n # iterate over \\\\img\\\\films\\\\\n screenshots = []\n directory_in_str = f'D:\\\\Programming-Projects\\\\nathansteele\\\\src\\\\img\\\\films';\n for subdir, dirs, files in os.walk(directory_in_str):\n for file in files:\n # find the right directory...\n title_from_directory_storing_screenshots = subdir.split('\\\\')[-1]\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\n if titlev3 == titlev2:\n # get my screenshots...\n if 'screenshot' in file:\n screenshot = os.path.join(subdir, file)\n screenshots.append(screenshot)\n \n # use my custom poster if I put one there...\n if 'custom_poster' in file:\n poster_url = os.path.join(subdir, file)\n \"\"\"\n \n # DEBUGGING....\n print(f\" > {pos}: {title}\")\n #print(f' > Title = ({title})')\n #print(f' > IMDB url = ({imdb_url})')\n #print(f' > Language = ({language})')\n #print(f' > Duration = ({duration})')\n #print(f' > Genres = ({genres})')\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\n #print(f' > IMDB num votes = ({imdb_num_votes})')\n #print(f' > Poster = ({poster_url})')\n #print(f' > Directors = ({directors})')\n #print(f' > Tags = ({my_tags})')\n \n # append to list...\n letterboxd_list.append({\n 'letterboxdFilmId': letterboxd_film_id,\n 'imdbFilmId': imdb_film_id,\n 'letterboxdUrl': letterboxd_url,\n 'imdbUrl': imdb_url,\n 'posterUrl': poster_url,\n 'position': pos,\n 'title': title,\n 'year': year,\n 'duration': duration,\n 'language': language,\n 'imdbAvgRating': imdb_avg_rating,\n 'imdbNumVotes': imdb_num_votes,\n 'tmdbUrl': tmdb_url,\n 'directors': directors,\n 'genres': genres,\n 'reviewId': review_id\n })\n \n # clear json file first...\n open(path_to_json_output, 'w').close()\n \n # write new content...\n with open(path_to_json_output, 'w') as f:\n json.dump(letterboxd_list, f, indent=4)\n \n print(f'JSON export finished! -> {path_to_json_output}')","def _post_recording_scrub(self):\n src_path = self.cassette_path\n rg_name = getattr(self, 'resource_group', None)\n rg_original = getattr(self, 'resource_group_original', None)\n\n t = tempfile.NamedTemporaryFile('r+')\n with open(src_path, 'r') as f:\n for line in f:\n # scrub resource group names\n if rg_name != rg_original:\n line = line.replace(rg_name, rg_original)\n # omit bearer tokens\n if 'authorization:' not in line.lower():\n t.write(line)\n t.seek(0)\n with open(src_path, 'w') as f:\n for line in t:\n f.write(line)\n t.close()","def rebase_add_encoding_prefix():\n\tfilenames, clippings = load_clippings(inFolder)\n\tfor file, clip in zip(filenames, clippings):\n\t\timg = clip[\"imgEncoding\"]\n\t\tstr = \"data:image/png;base64,\"\n\t\tif str not in img:\n\t\t\tclip[\"imgEncoding\"] = str + img\n\t\t\twith open(file, \"w\") as outfile:\n\t\t\t\tjson.dump(clip, outfile)","def _clean_up_composite_json(composite_json: dict) -> dict:\n objects = composite_json.get(\"objects\", {})\n objects = _fix_modified_dates(objects)\n objects = CleanUpCompositeJson._fix_parent_child_relationships(objects)\n composite_json[\"objects\"] = objects\n return composite_json","def json_to_cache(new_json: Dict, file_name: str) -> None:\n\n json_path = os.path.join(CACHE_DIR, file_name)\n ensure_dir(json_path)\n with open(json_path, \"w\") as outfile:\n json.dump(new_json, outfile, ensure_ascii=False)","def fixit(file):\n with open(file, \"r\") as f:\n config = json.load(f)\n if \"job_status\" in config[\"supply-curve-aggregation\"]:\n del config[\"supply-curve-aggregation\"][\"job_status\"]\n if \"rep-profiles\" in config:\n del config[\"rep-profiles\"]\n fname = os.path.basename(file)\n cname = \"_\".join(fname.split(\"_\")[:-1]) + \"_agg\"\n config[\"supply-curve-aggregation\"][cname][\"job_status\"] = \"successful\"\n\n with open(file, \"w\") as f:\n f.write(json.dumps(config, indent=4))","def clip(self):\n \n subprocess.call(['gdaltindex', self.extent, self.referenceImagePath])\n dataNames = sorted(glob.glob(self.fullPath + '/full*.tif'))\n splitAt = len(self.fullPath) + 1\n\n for i in range(len(dataNames)):\n x = dataNames[i]\n y = dataNames[i][:splitAt] + dataNames[i][splitAt+4:]\n subprocess.call(['gdalwarp', '-r', 'near', '-cutline', self.extent, '-crop_to_cutline', x, y, '-dstnodata', '9999'])\n \n for n in dataNames:\n os.remove(n)\n dataNames = sorted(glob.glob(self.fullPath + '/*.tif'))\n test = gdal.Open(dataNames[0]).ReadAsArray()\n logger.log('SUCCESS', 'Clipping complete! %d %s files were successfully clipped to the size of %s with dimensions %d rows by %d columns' % (len(dataNames), str(self.outformat), str(self.referenceImagePath), test.shape[0], test.shape[1]))","def rename(source_dir,dest_dir):\n keep_going(text=\"This script will backup the original folder to dest_dir/Source/** and remove the original folder. It will make copies of the original files and rename them in directories called Darks, Flats, etc. Do you wish to continue? Answer Y or N.\")\n\n ## Backup Original Source Folder\n dir_util.copy_tree(source_dir, dest_dir + '/Source')\n\n data = []\n for file in os.listdir(\"./\" + source_dir): # put in your path directory\n if file.endswith(\".fits\"): # what does the file end with?\n data.append(os.path.join(source_dir, file))\n\n n = len(data)\n obj, itime, filt, renamed, datemod, count, flatmod, mod = ([] for i in range(8))\n for i in range(0, n):\n header = fits.getheader(data[i])\n Name, Date, Number, Ext = data[i].split(\".\")\n obj.append(header['OBJECT'])\n itime.append(header['ITIME'])\n filt.append(header['FWINAME'])\n mod.append((header['OBJECT'] + header['FWINAME']))\n flatmod.append((header['OBJECT'] + header['FWINAME'] + Date))\n datemod.append(datetime.strptime(Date, \"%Y%m%d\").date())\n if flatmod[i] in flatmod:\n count = flatmod.count(flatmod[i])\n if ('Lamp' in obj[i] or 'Flat' in obj[i]):\n renamed.append((dest_dir + '/Flats/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Flats/' + str(datemod[i]) + '/'), exist_ok=True)\n elif ('Dark' in obj[i]) or ('dark' in obj[i]):\n renamed.append((dest_dir + '/Darks/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Darks/' + str(datemod[i]) + '/'), exist_ok=True)\n elif ('Sky' in obj[i]) or ('sky' in obj[i]):\n renamed.append((dest_dir + '/Skys/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + header['FWINAME'] + str(\n count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Skys/' + str(datemod[i]) + '/'), exist_ok=True)\n else:\n renamed.append((dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/' + 'K' + list(header['CAMNAME'])[0].title() + header['OBJECT'].upper() +\n header['FWINAME'] + str(\n count) + \".fits\"))\n os.makedirs(os.path.dirname(dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/'), exist_ok=True)\n os.rename(data[i], renamed[i])\n\n ## REMOVE LEFT OVER original Folders\n shutil.rmtree(source_dir)\n\n lists = [data, mod, datemod, itime, flatmod, renamed]\n data_headers = pd.concat([pd.Series(x) for x in lists], axis=1)\n\n return data_headers","def genOwnershipVoucherJsonFile( ownershipVoucher, voucherFileJson ):\n template = { \"created-on\": str,\n \"expires-on\": str,\n \"assertion\": str,\n \"serial-number\": str,\n \"pinned-domain-cert\": str,\n \"domain-cert-revocation-checks\": bool,\n \"last-renewal-date\": str\n }\n\n def validDateTime( dateTime ):\n \"\"\"Verify a dateTime string conforms to RFC3339 format (only Z TZ accepted)\"\"\"\n try:\n datetime.strptime( dateTime, \"%Y-%m-%dT%H:%M:%S.%fZ\" )\n return True\n except ValueError:\n return False\n\n mandatory = [ \"created-on\", \"assertion\", \"serial-number\", \"pinned-domain-cert\" ]\n # verify ownership-coucher dict is correctly constructed\n assert isinstance( ownershipVoucher, dict ), \"Expected dict\"\n assert set( ownershipVoucher.keys() ).issubset( template.keys() ), \\\n \"Unexpected keys in dict\"\n assert verifyDictTypes( template, ownershipVoucher ), \\\n \"Unexpected value types\"\n assert set( mandatory ).issubset( ownershipVoucher ), \\\n \"Mandatory keys not present\"\n assert ownershipVoucher[ \"assertion\" ] == \"verified\", \\\n \"Unsupported assertion value\"\n assert validDateTime( ownershipVoucher.get( \"created-on\" ) ) and \\\n validDateTime( ownershipVoucher.get( \"expires-on\", \"\" ) ) and \\\n validDateTime( ownershipVoucher.get( \"last-renewal-date\", \"\" ) ), \\\n \"Invalid datetime value\"\n\n ietfVoucher = { \"ietf-voucher:voucher\": ownershipVoucher }\n jsonOwnershipVoucher = json.dumps( ietfVoucher, indent=4 )\n\n # save to file\n with open( voucherFileJson, \"w\" ) as tmpFile:\n tmpFile.write( jsonOwnershipVoucher )","def convertFiles():\n\n #### Get file lists\n tmp = os.path.join(remarkableBackupDirectory,remContent)\n files = [x for x in os.listdir(tmp) if \".\" not in x]\n\n for i in range(0, len(files)):\n # get file reference number\n refNrPath = os.path.join(remarkableBackupDirectory, remContent,\n files[i])\n # get meta Data\n meta = json.loads(open(refNrPath + \".metadata\").read())\n fname = meta[\"visibleName\"]\n fname = fname.replace(\" \", \"_\")\n # Does this lines file have an associated pdf?\n AnnotPDF = os.path.isfile(refNrPath + \".pdf\")\n # Get list of all rm files i.e. all pages\n npages = len(glob.glob(refNrPath + \"/*.rm\"))\n if npages != 0:\n if AnnotPDF:\n # we have found an annotated pdf\n # now make sure it has the right ending\n if meta[\"visibleName\"][-4:] != \".pdf\":\n syncFilePath = os.path.join(syncDirectory, \"*\",\n meta[\"visibleName\"] + \".pdf\")\n else:\n syncFilePath = os.path.join(syncDirectory, \"*\",\n meta[\"visibleName\"])\n\n # does the file exist in our system?\n inSyncFolder = glob.glob(syncFilePath) != []\n\n if inSyncFolder:\n # have we exported this thing before?\n local_annotExist = \\\n glob.glob(syncFilePath[:-4] + \"_annot.pdf\") != []\n # first, assume, it needs converting\n remoteChanged = True\n if local_annotExist:\n # if it already exists check when it was last updated\n local_annotPath = \\\n glob.glob(syncFilePath[:-4]+\"_annot.pdf\")[0]\n local_annot_mod_time = os.path.getmtime(local_annotPath)\n # rm time is in ms\n remote_annot_mod_time = int(meta[\"lastModified\"])/1000\n # has this version changed since we last exported it?\n remoteChanged = \\\n remote_annot_mod_time > local_annot_mod_time\n # update if the remote version has changed\n if remoteChanged:\n origPDF = glob.glob(syncFilePath)[0]\n #####\n convertAnnotatedPDF(fname, refNrPath, origPDF)\n #####\n else:\n print(fname + \"hasn't been modified\")\n else:\n print(fname + \" does not exist in the sync directory\")\n # TODO allow y/n input whether it should be copied there\n # anyway\n else:\n # we found a note\n print(\"exporting Notebook \" + fname)\n syncFilePath = os.path.join(syncDirectory, notesDirectory,\n fname + \".pdf\")\n inSyncFolder = glob.glob(syncFilePath) != []\n remoteChanged = True\n if inSyncFolder:\n local_annot_mod_time = os.path.getmtime(syncFilePath)\n remote_annot_mod_time = int(meta['lastModified'])/1000\n remoteChanged = remote_annot_mod_time > local_annot_mod_time\n if remoteChanged:\n #####\n convertNotebook(fname, refNrPath)\n #####\n else:\n print(fname + \"has not changed\")","def update_is_streamed_json(self, index):\n time_now = datetime.datetime.now()\n read_path = self.base_path + time_now.strftime('%Y-%m-%d') + '.json'\n try:\n json_file = open(read_path, 'r')\n data = json.load(json_file)\n json_file.close()\n\n data[index]['being_streamed'] = True\n\n json_file = open(read_path, 'w+')\n json_file.write(json.dumps(data))\n json_file.close()\n \n except IOError:\n print 'File not found'","def flatten_json_data(beer_json):\n if 'available' in beer_json:\n if 'name' in beer_json['available']:\n beer_json['available_name'] = beer_json['available']['name']\n del beer_json['available']\n if 'glass' in beer_json:\n if 'name' in beer_json['glass']:\n beer_json['glass_name'] = beer_json['glass']['name']\n del beer_json['glass']\n if 'style' in beer_json:\n if 'abvMax' in beer_json['style']:\n beer_json['style_abvMax'] = beer_json['style']['abvMax']\n if 'abvMin' in beer_json['style']:\n beer_json['style_abvMin'] = beer_json['style']['abvMin']\n if 'category' in beer_json['style']:\n beer_json['style_category_name'] = beer_json['style']['category']['name']\n if 'description' in beer_json['style']:\n beer_json['style_description'] = beer_json['style']['description']\n if 'fgMax' in beer_json['style']:\n beer_json['style_fgMax'] = beer_json['style']['fgMax']\n if 'fgMin' in beer_json['style']:\n beer_json['style_fgMin'] = beer_json['style']['fgMin']\n if 'ibuMax' in beer_json['style']:\n beer_json['style_ibuMax'] = beer_json['style']['ibuMax']\n if 'ibuMin' in beer_json['style']:\n beer_json['style_ibuMin'] = beer_json['style']['ibuMin']\n if 'name' in beer_json['style']:\n beer_json['style_name'] = beer_json['style']['name']\n if 'ogMin' in beer_json['style']:\n beer_json['style_ogMin'] = beer_json['style']['ogMin']\n if 'ogMax' in beer_json['style']:\n beer_json['style_ogMax'] = beer_json['style']['ogMax']\n if 'shortName' in beer_json['style']:\n beer_json['style_shortName'] = beer_json['style']['shortName']\n if 'srmMax' in beer_json['style']:\n beer_json['style_srmMax'] = beer_json['style']['srmMax']\n if 'srmMin' in beer_json['style']:\n beer_json['style_srmMin'] = beer_json['style']['srmMin']\n del (beer_json['style'])\n else:\n beer_json = None\n\n return beer_json","def make_clips(self):\n\n average_messege_count, streamer_messeges_data = self.__do_analysis()\n\n clipworthy_clips = []\n\n #add clipworthy clips\n for entry in streamer_messeges_data:\n if((entry['messeges_count']*entry['messeges_count']) > (average_messege_count*1.8)):\n clipworthy_clips.append(entry)\n\n #combine clips that are next to one another in time\n clip_number = 0\n while(True):\n #print('clip_number = ' + str(clip_number) +' , length of cliparr = ' + str(len(clipworthy_clips)))\n if(clip_number >= (len(clipworthy_clips))-1):\n #at end of clips\n break\n\n if (clipworthy_clips[clip_number]['end_time']==clipworthy_clips[clip_number+1]['start_time']):\n #duplicate clip detected\n #print('dublicate clip detected for clip ' + str(clip_number))\n clipworthy_clips[clip_number]['end_time']=clipworthy_clips[clip_number+1]['end_time']\n #print('cliparr length before ridding: ' + str(len(clipworthy_clips)))\n clipworthy_clips.remove(clipworthy_clips[clip_number+1])\n #print('cliparr length after ridding: ' + str(len(clipworthy_clips)))\n #print('')\n else:\n clip_number = clip_number + 1\n\n\n print('clipworthy clips will now be made')\n clipSlicer = ClipSlicer(clipworthy_clips)\n clipSlicer.make_clips()\n\n print(\"clipworthy clips for streamer \"+ self.streamer + \" have been made\")","def time_calibration(input_file):\n original_path = os.getcwd()\n save_path = input_file['save_path']\n #change to save data reduction directory\n os.chdir(save_path)\n print '\\n Reading the list of images ....\\n'\n planet = input_file['exoplanet'] #set exoplanet name\n images = sorted(glob.glob('AB'+planet+'*.fits'))\n print images\n #include de RA,DEC and epoch of the exoplanet\n RA,DEC,epoch = input_file['RA'],input_file['DEC'],input_file['epoch']\n #obtain ST JD using iraf task and introduce in the header\n for i in range(len(images)):\n hdr = fits.getheader(images[i])\n if int(split(hdr['UT'],':')[0]) < int(hdr['timezone']):\n new_date = use.yesterday(hdr['date-obs'])\n #print images[i], new_date\n else:\n new_date = hdr['date-obs']\n year,month,day = split(new_date,'-')\n iraf.asttimes(year=year,month=month,day=day,time=hdr['loctime'],obs=input_file['observatory'])\n JD = iraf.asttimes.jd #obtain julian date\n LMST = iraf.asttimes.lmst #obtain the sideral time\n LMST = use.sexagesimal_format(LMST) #convert sideral time in sexagesimal format\n iraf.hedit(images[i],'ST',LMST,add='yes',verify='no',show='no',update='yes') #create the ST keyword in the header\n iraf.ccdhedit(images[i],'LMST',LMST,type='string') #include the mean sideral time in the header\n iraf.ccdhedit(images[i],'JD',JD,type='string') #include de julian date in the header\n #include RA, and DEC of the object in your header\n iraf.ccdhedit(images[i],\"RA\",RA,type=\"string\") #include right ascention in the header\n iraf.ccdhedit(images[i],\"DEC\",DEC,type=\"string\") #include declination in the header\n iraf.ccdhedit(images[i],\"epoch\",epoch,type=\"string\") #include epoch in the header\n # use.update_progress((i+1.)/len(images))\n print '\\n Setting airmass ....\\n'\n for i in range(len(images)):\n print '# ',images[i]\n #iraf.hedit(images[i],'airmass',airmass,add='yes')\n #iraf.hedit(images[i],'HJD',HJD,add='yes')\n iraf.setairmass.observatory = input_file['observatory']\n iraf.setairmass(images[i])\n iraf.setjd.time = 'ut'\n iraf.setjd(images[i])\n print '\\n.... done.\\n'\n #export information\n hjd, jd, airmass, st = [],[],[],[]\n for i in range(len(images)):\n hdr = fits.getheader(images[i])\n hjd.append(hdr['HJD'])\n jd.append(hdr['JD'])\n airmass.append(hdr['airmass'])\n st.append(hdr['st'])\n #saving the data\n data = DataFrame([list(hjd),list(jd),list(st),list(airmass)]).T\n data.columns = ['HJD','JD','ST','Airmass']\n data.to_csv('results_iraf_calibrations.csv')\n #change to workings directory\n os.chdir(original_path)\n return","def _edit_job_file(self, edits):\n for key in edits:\n self.json_dict[key] = edits[key]","def main(input_dir, bids_dir, exclude_fieldmaps):\n\n input_dir = Path(input_dir).absolute()\n bids_dir = Path(bids_dir).absolute()\n raw_dir = bids_dir / \"sourcedata\"\n\n copy_all_paths_to_sourcedata(input_dir, raw_dir)\n\n fix_acquisition_numbers_of_json_files_in(raw_dir)\n\n old_and_new_paths = create_dictionary_of_old_and_new_paths(raw_dir, bids_dir, exclude_fieldmaps)\n\n copy_files_to_their_new_homes(old_and_new_paths)\n\n fix_jsons_in(bids_dir)\n\n add_dataset_description_to(bids_dir)\n\n write_tsvs(raw_dir, bids_dir)\n\n print(\"Congratulations! You're BIDS-compliant, yay!\")\n print(\"To double-check, use this handy dandy BIDS validator: https://bids-standard.github.io/bids-validator/\")","def read_json_file_to_be_edited(self):\n _json_file = self.job[\"JSONfileToBeEdited\"]\n if _json_file in self.config:\n # Substitute the path defined in the macro\n _json_file = self.config[_json_file]\n self.json_o.read(_json_file)","def refresh_cdb_json_file(file_path):\n cdb_dir = os.path.dirname(file_path)\n file_name = os.path.basename(file_path)\n upstream_dir = os.path.join(cdb_dir, 'upstream')\n upstream_md5 = os.path.join(upstream_dir, '{}.MD5'.format(file_name))\n upstream_json = os.path.join(upstream_dir, '{}.json'.format(file_name))\n\n logger = utils.get_logger()\n logger.debug('Processing: {}'.format(file_name))\n\n cdb_md5 = utils.md5_file(file_path)\n try:\n with open(upstream_md5, 'r') as f:\n json_md5 = f.read()\n\n # If the cdb file matches the generated md5,\n # no changes are needed to the json\n if json_md5 == cdb_md5:\n return True\n except IOError:\n pass\n\n tmp_json = tempfile.NamedTemporaryFile(delete=False)\n with open(file_path, 'r') as fp:\n reader = cdblib.Reader(fp.read())\n\n out = collections.OrderedDict()\n for k, v in reader.iteritems():\n out[k] = v\n\n json_data = json.dumps(out, indent=0, separators=(',', ':'))\n\n # Make python json.dumps match php's json_encode\n # Remove first newline\n json_data = json_data.replace('\\n', '', 1)\n\n # Escape slashes\n json_data = json_data.replace('/', '\\/')\n\n # Remove final newline\n json_data = ''.join(json_data.rsplit('\\n', 1))\n\n tmp_json.write(json_data)\n tmp_json.close()\n os.chmod(tmp_json.name, 0o644)\n shutil.move(tmp_json.name, upstream_json)\n logger.debug('Updated: {}'.format(upstream_json))\n\n with open(upstream_md5, 'w') as md5:\n md5.write(cdb_md5)\n\n return True","def preprocess(self):\r\n file_name = os.path.join(self.raw_path, \"amazon-amazon-instant-video.json.gz\")\r\n print(f\"file_name: {file_name}\")\r\n if not os.path.exists(file_name):\r\n self.download()\r\n\r\n # parse json data\r\n data = self.get_data_frame_from_gzip_file(file_name)\r\n\r\n # rename columns\r\n data = data.rename(\r\n columns={\r\n \"reviewerID\": DEFAULT_USER_COL,\r\n \"asin\": DEFAULT_ITEM_COL,\r\n \"overall\": DEFAULT_RATING_COL,\r\n \"unixReviewTime\": DEFAULT_TIMESTAMP_COL,\r\n }\r\n )\r\n\r\n # select necessary columns\r\n data = pd.DataFrame(\r\n data,\r\n columns=[\r\n DEFAULT_USER_COL,\r\n DEFAULT_ITEM_COL,\r\n DEFAULT_RATING_COL,\r\n DEFAULT_TIMESTAMP_COL,\r\n ],\r\n )\r\n\r\n self.save_dataframe_as_npz(\r\n data,\r\n os.path.join(self.processed_path, f\"{self.dataset_name}_interaction.npz\"),\r\n )","def _archiveDataByDate(self, src, dest):\n root = os.getcwd()\n srcPath = join(root,src)\n destPath = join(root,dest)\n f = [] #Array with list of files in directory\n fDate = [] #Array with list of files with certain date;\n s = [] #Array with list of files successfully copied\n for (dirpath, dirnames, filenames) in walk(srcPath):\n f.extend(filenames)\n if len(f) > 0:\n for i in f:\n match = re.search(r'\\d{4}-\\d{2}-\\d{2}', i)\n if str(i) != 'archiving_log.txt' and str(i) != 'archiving_log.txt~' and str(i) != 'archivingScript.py' and match.group() == self.date:\n try:\n buffer_size = int(20000)\n fileSrcPath = join(dirpath, i)\n fileDestPath = join(destPath, i)\n with open(fileSrcPath, 'rb') as fsrc:\n with open(fileDestPath, 'wb') as fdest:\n copy = shutil.copyfileobj(fsrc,fdest,buffer_size)\n copy\n self._backupLog('Copy Operation File: '+str(i)+ '\\t' + 'Time: '+ str(time.strftime(\"%H:%M:%S\")) +'\\n') #+ '\\t'+ 'Path: '+ str(srcPath)\n s.append(i)\n except shutil.Error as e:\n self._backupLog('Error: %s' % e + '\\t' + 'File: '+str(i)+ '\\t' + 'Time: '+ str(time.strftime(\"%H:%M:%S\")) + '\\n')\n except IOError as e:\n self._backupLog('Error: %s' % e.strerror + '\\t' + 'File: '+str(i)+ '\\t' + 'Time: '+ str(time.strftime(\"%H:%M:%S\")) + '\\n')\n if len(s) >0:\n for (dirpath,dirnames,filenames) in walk(srcPath):\n for cfile in f:\n for sfile in s:\n if cfile == sfile:\n try:\n filetoDelete = join(srcPath, cfile)\n os.remove(filetoDelete)\n self._backupLog('Delete Operation File: '+str(cfile)+ '\\t' + 'Time: '+ str(time.strftime(\"%H:%M:%S\")) + '\\n')\n except OSError, e:\n self._backupLog('Error deleting file: %s - %s.' % (e.filename, e.strerror) + '\\t' + 'Time: '+ str(time.strftime(\"%H:%M:%S\")) + '\\n')","def readdata(self, filepaths):\n pass","def json_to_ratdb(local_dir,filename): \n ratdbdir = local_dir\n\n jsonfile = filename\n\n splitjson = jsonfile.split(\"_\")\n\n runnumber = splitjson[1]\n\n print \"Converting the JSON table to RATDb format for run \" + str(runnumber)\n\n # Create the DQ LL table in ratdb format\n ratdbfile = \"{0}run_{1}_dqll.ratdb\".format(ratdbdir,runnumber)\n \n ratdbtable = open(ratdbfile,'w')\n\n # Open the JSON table and reads it\n jsontable = open(jsonfile,'r')\n \n beginline = jsontable.readline()\n\n ratdbtable.write(beginline)\n\n for i in range(7):\n\n headerstring = jsontable.readline().split(\":\")\n\n noquoteheader = headerstring[0].split(\"\\\"\")\n\n ratdbheaderstring = \"{0}:{1}\".format(noquoteheader[1],headerstring[1])\n\n ratdbtable.write(ratdbheaderstring)\n\n # Timestamps need special treatment\n timestampstring = jsontable.readline().split(\":\")\n\n noquotetimestamp = timestampstring[0].split(\"\\\"\")\n\n ratdbtimestampstring = \"{0}:{1}:{2}:{3}:{4}\".format(noquotetimestamp[1], timestampstring[1],\n timestampstring[2], \n timestampstring[3],\n timestampstring[4])\n\n ratdbtable.write(ratdbtimestampstring)\n\n returnline1 = jsontable.readline()\n\n ratdbtable.write(returnline1)\n\n for i in range(2):\n\n timestring = jsontable.readline().split(\":\")\n\n noquotetime = timestring[0].split(\"\\\"\")\n\n ratdbtimestring = \"{0}:{1}:{2}:{3}:{4}\".format(noquotetime[1], timestring[1],\n timestring[2],\n timestring[3],\n timestring[4])\n\n ratdbtable.write(ratdbtimestring)\n \n durationstring = jsontable.readline().split(\":\")\n\n noquoteduration = durationstring[0].split(\"\\\"\")\n\n ratdbdurationstring = \"{0}:{1}\".format(noquoteduration[1],durationstring[1])\n\n ratdbtable.write(ratdbdurationstring)\n\n returnline2 = jsontable.readline()\n\n ratdbtable.write(returnline2)\n\n for i in range(2):\n\n cratestatusstring = jsontable.readline().split(\":\")\n\n noquotecratestatus = cratestatusstring[0].split(\"\\\"\")\n\n ratdbcratestatusstring = \"{0}:{1}\".format(noquotecratestatus[1],cratestatusstring[1])\n\n ratdbtable.write(ratdbcratestatusstring)\n\n returnline3 = jsontable.readline()\n\n ratdbtable.write(returnline3)\n\n for i in range(2):\n\n cratenominalstring = jsontable.readline().split(\":\")\n \n noquotecratenominal = cratenominalstring[0].split(\"\\\"\")\n\n ratdbcratenominalstring = \"{0}:{1}\".format(noquotecratenominal[1],cratenominalstring[1])\n \n ratdbtable.write(ratdbcratenominalstring)\n\n returnline4 = jsontable.readline()\n\n ratdbtable.write(returnline4)\n\n for i in range(2):\n\n cratehvreadstring = jsontable.readline().split(\":\")\n \n noquotecratehvread = cratehvreadstring[0].split(\"\\\"\")\n\n ratdbcratehvreadstring = \"{0}:{1}\".format(noquotecratehvread[1],cratehvreadstring[1])\n \n ratdbtable.write(ratdbcratehvreadstring)\n\n returnline5 = jsontable.readline()\n\n ratdbtable.write(returnline5)\n\n for i in range(2):\n\n cratecurrentreadstring = jsontable.readline().split(\":\")\n \n noquotecratecurrentread = cratecurrentreadstring[0].split(\"\\\"\")\n\n ratdbcratecurrentreadstring = \"{0}:{1}\".format(noquotecratecurrentread[1],cratecurrentreadstring[1])\n \n ratdbtable.write(ratdbcratecurrentreadstring)\n\n returnline6 = jsontable.readline()\n\n ratdbtable.write(returnline6)\n\n for i in range(6):\n\n xl3errorstring = jsontable.readline().split(\":\")\n \n noquotexl3error = xl3errorstring[0].split(\"\\\"\")\n\n ratdbxl3errorstring = \"{0}:{1}\".format(noquotexl3error[1],xl3errorstring[1])\n \n ratdbtable.write(ratdbxl3errorstring)\n\n returnline7 = jsontable.readline()\n\n ratdbtable.write(returnline7)\n\n xl3screwedstring = jsontable.readline().split(\":\")\n \n noquotexl3screwed = xl3screwedstring[0].split(\"\\\"\")\n\n ratdbxl3screwedstring = \"{0}:{1}\".format(noquotexl3screwed[1],xl3screwedstring[1])\n \n ratdbtable.write(ratdbxl3screwedstring)\n\n endline = jsontable.readline()\n\n ratdbtable.write(endline)\n \n jsontable.close()\n\n ratdbtable.close()","def mk_json_clms(dlas, outpath, prefix):\n for abssys in dlas._abs_sys:\n tdict = abssys._clmdict\n # Convert AbsLine to dicts\n if 'lines' in tdict.keys():\n new_lines = {}\n for key in tdict['lines']:\n new_lines[key] = tdict['lines'][key].to_dict()\n # Replace\n tdict['lines'] = new_lines\n tdict['Name'] = abssys.name\n tdict['Creation_date'] = str(datetime.date.today().strftime('%Y-%b-%d'))\n # Outfil\n name = survey_name(prefix, abssys)\n outfil = outpath+name+'_clm.json'\n # Write\n print('Writing {:s}'.format(outfil))\n with io.open(outfil, 'w', encoding='utf-8') as f:\n f.write(unicode(json.dumps(tdict, sort_keys=True, indent=4,\n separators=(',', ': '))))","def updateCountryNames(self):\n try:\n with open('countryNameMapping.json', 'r') as file:\n name_mapping = json.loads(file.read())\n except:\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\n \n for key, value in name_mapping.items():\n self.covid_df.replace(key, value, inplace=True)\n \n try:\n with open('countryNameISO2.json', 'r') as file:\n self.name_iso2_mapping = json.loads(file.read())\n except:\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\n self.writeCountryCodeFile()\n print('Re-importing required JSONs...')\n self.updateCountryNames()","def main():\n\n # Set up argument parser.\n parser = argparse.ArgumentParser(\n description='Removes duplicate key-value pairs from JSON files.')\n parser.add_argument('--suffix', default='',\n help='optional suffix for output files; '\n 'if empty, files will be changed in place')\n parser.add_argument('files', nargs='+', help='input files')\n args = parser.parse_args()\n\n # Iterate over files.\n for filename in args.files:\n # Read in json using Python libraries. This eliminates duplicates.\n print('Processing ' + filename + '...')\n try:\n with codecs.open(filename, 'r', 'utf-8') as infile:\n j = json.load(infile)\n except ValueError as e:\n print('Error reading ' + filename)\n raise InputError(filename, str(e))\n\n # Built up output strings as an array to make output of delimiters easier.\n output = []\n for key in j:\n if key != '@metadata':\n output.append('\\t\"' + key + '\": \"' +\n j[key].replace('\\n', '\\\\n') + '\"')\n\n # Output results.\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\n outfile.write('{\\n')\n outfile.write(',\\n'.join(output))\n outfile.write('\\n}\\n')","def main():\n\n # Script arguments... \n \"\"\" If running as standalone, hardcode theWorkspace and inFile \"\"\"\n theWorkspace = arcpy.GetParameterAsText(0)\n if not theWorkspace:\n theWorkspace = r\"d:\\_dataTest\"\n arcpy.env.workspace = theWorkspace\n arcpy.env.overwriteOutput = True\t\n\n inFile = arcpy.GetParameterAsText(1)\n if not inFile:\n inFile = \"updateMultipleSourcePaths.csv\"\n inFile = r\"\\\\dfg.alaska.local\\gis\\Anchorage\\GISStaff\\___gisStaffConnections\\RepairBrokenSrcAug242015.csv\"\n\n outWorkspace = arcpy.GetParameterAsText(2)\n if not outWorkspace:\n outWorkspace = os.path.join(theWorkspace, \"_repaired\")\n '''if not os.path.isdir(outWorkspace): \n os.makedirs(outWorkspace)\n myMsgs(\"created new directory {0} \\n\".format(outWorkspace))'''\n\n # Create .txt Report of what it thinks was fixed, tagged with YYYYMMDD_HHMM\n outFile = \"FixedReport\"\n fileDateTime = curFileDateTime()\n currentDate = curDate()\n outfileTXT = os.path.join(theWorkspace, outFile) + fileDateTime + \".txt\" \n myMsgs (outFile)\n reportFile = open(outfileTXT, 'w')\n myMsgs( \"File {0} is open? {1}\".format(outfileTXT, str(not reportFile.closed)))\n outText = \"Report for what it THINKS it repaired in {0}, on {1} \\n \".format(theWorkspace, currentDate)\n outText += \" Includes coverages (pts, poly, arc, anno), shapes, and FGDB data.\" + '\\n'\n outText += \"-----------------------------------------------------\" + '\\n' \n reportFile.write(outText)\t\n\n mxd = None\n outMXDName = \"none\"\n updatePath = []\n cvrList = [r\"\\arc\", r\"\\polygon\", r\"\\region\", r\"\\point\", r\"\\tic\" ]\n lstExtDatatype = [[\".shp\", \"SHAPEFILE_WORKSPACE\" ], [\".sde\",\"SDE_WORKSPACE\"], \n [\".mdb\", \"ACCESS_WORKSPACE\" ], [\".gdb\", \"FILEGDB_WORKSPACE\"], \n [\"cover\", \"ARCINFO_WORKSPACE\"]]\t\n cntMXD = 0\n cntFixed = 0\n cntTotalFixed = 0\n\n # makes sure the .csv file exists\n if arcpy.Exists(inFile):\n myMsgs (\"->Using {0} to repair paths.\\n==============================\".format(inFile))\n # walks thru the workspace to create list of files \n for root, dirs, files in os.walk(theWorkspace): \t\t\n for fileName in files:\n if root == outWorkspace: # don't process mxd's in the target directory\n pass\n else:\n fullPath = os.path.join(root, fileName)\n basename, extension = os.path.splitext(fileName)\n # Only process .mxd files\n if extension == \".mxd\":\n myMsgs(\"\\nReviewing MXD: {0}\".format(fullPath))\n reportFile.write(\"\\nReviewing MXD: {0}\".format(fullPath))\n mxd = arcpy.mapping.MapDocument(fullPath)\n dfs = arcpy.mapping.ListDataFrames(mxd)\n cntMXD += 1\n cntFixed = 0\n basename, extension = os.path.splitext(fileName)\n # New output mxd name....\n outMXDName = os.path.join(outWorkspace, (str(basename) + \".mxd\")) #\"_fix.mxd\"))\n # create list of the tables since they are handle differently\n theTables = arcpy.mapping.ListTableViews(mxd)\n # Loops thru dataframes so adding and deleting Services will work.\n for df in dfs:\n # Loops thru layers, checks for broken links and tries to repair\n lyrList = arcpy.mapping.ListLayers(mxd, \"\", df)\n for lyr in lyrList:\n if lyr.isBroken:\n if not lyr.supports(\"DATASOURCE\") and not lyr.isServiceLayer:\n myMsgs(\" ->Skipping {0} not a Service layer, and does not support DATASOURCE\".format(lyr.name))\n pass #continue\n elif not lyr.supports(\"DATASOURCE\") and lyr.isServiceLayer:\n myMsgs(\" -Broken Service: {0}\".format(lyr.name))\n else:\n myMsgs(\" -Broken: {0}\".format(lyr.dataSource))\n #myMsgs(\"layer is Group {0} or ServiceLayer {1}\".format(lyr.isGroupLayer, lyr.isServiceLayer))\n if (lyr.isGroupLayer or (\"Events\" in lyr.name)) and (not lyr.isServiceLayer): # Groups and Event FC skipped\n myMsgs(\" ...skipping group or event: {0}\".format(lyr.name))\n reportFile.write(\"\\n *skipping group or event: {0} \\n\".format(lyr.name))\n pass #break\n elif lyr.isServiceLayer: # services might have to be handle differently\n if lyr.supports(\"SERVICEPROPERTIES\"):\n for spType, spName in lyr.serviceProperties.iteritems():\n myMsgs(\" Service Properties: {0}: {1}\".format(spType, spName ))\n if spType == \"URL\": \n dataSource = str(spName)\n lyrType = (\"service_{}\".format(lyr.name))\n break\n myMsgs(\" ->this ia a service....using add and remove layer\")\n updatePath = findUpdatePath(inFile, dataSource, lyrType.strip().lower())\n newDSPath, newDSName = os.path.split(updatePath[0])\n if (\"service\" in updatePath[3]) and (\"service\" in updatePath[1]):\n insertLayer = arcpy.mapping.Layer(updatePath[0])\n print(\"dataframe: {0}\".format(df))\n arcpy.mapping.InsertLayer(df, lyr, insertLayer, \"AFTER\")\n arcpy.mapping.RemoveLayer(df, lyr)\n reportFile.write(\"\\n ->sees this as service....{0} \\n\".format(dataSource))\n # will still look at deleted version after insert, not the new version..\n # isBroken will give false info even if fixed, so \n # don't use myMsgs(\"Still broken? {0}\".format(lyr.isBroken)) \n else:\n myMsgs(\" --> a service layer but no SERVICE PROPERTIES\")\n elif lyr.supports(\"DATASOURCE\") and lyr.supports(\"DATASETNAME\"): \n # not a group, event or what it thinks is a service\n updatePath = findUpdatePath(inFile, lyr.dataSource, \"\")\n newDSPath, newDSName = os.path.split(updatePath[0])\n sameType = updatePath[2] \n for cvr in cvrList: #checks to see if the source layer is a coverage...must handle different\n if cvr in lyr.dataSource:\n sourceIsCoverage = True\n break\n else:\n sourceIsCoverage = False\n # updatePath[1] is False if there wasn't a match\n # so \"not update[1]\" means no match was found, and moves to next layer\t\t\t\t\t\t\t\t\n if not updatePath[1]: # if no match was found\n myMsgs(\" !! no match to: {0} \".format(lyr.dataSource))\n updateStatus = \"no match, not changed\" # used for message only\n pass\n elif updatePath[1].strip().lower() == \"drive\":\n myMsgs(\" skipping drive-letter matches for now: {0}\".format(lyr.dataSource))\n updateStatus = \"can only find drive match...look into it)\"\n pass\n elif updatePath[1].strip().lower() == \"_review\":\n myMsgs(\" no new source assigned yet for: {0}\".format(lyr.dataSource))\n updateStatus = (\"review and update {0}\".format(inFile))\n pass\n else: #if lyr.supports(\"DATASOURCE\") and lyr.supports(\"DATASETNAME\"):\n updateStatus = str(updatePath[0]) # used for message only\n if lyr in theTables:\n #myMsgs(\" thinks its a table....using findAndReplsWorkspacePath\")\n myMsgs(\" *Moving {0}: {1} to new: {2}\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n reportFile.write(\"\\n Moving {0}: {1} to new: {2} \\n\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n lyr.findAndReplaceWorkspacePath(lyr.dataSource, updatePath, False) \n elif lyr.isRasterLayer:\n #myMsgs(\" thinks its a raster....using findAndReplsWorkspacePath\")\n myMsgs(\" *Moving {0}: {1} to new: {2}\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n reportFile.write(\"\\n Moving {0}: {1} to new: {2} \\n\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n newType = \"RASTER_WORKSPACE\"\n for extType in lstExtDatatype:\n if extType[0] in updatePath[0]:\n newType = extType[1] \n if extType[0] == '.gdb':\n newDSPath = newDSPath.split('.gdb', 1)[0] + '.gdb'\n #newType = extType[1]\n elif extType[0] == '.sde':\n newDSPath = newDSPath.split('.sde', 1)[0] + '.sde'\n break \n lyr.replaceDataSource(newDSPath, newType, newDSName, False)\n if not sameType:\n testOldTOC = updatePath[4].strip('\\\\')\n if lyr.name == testOldTOC:\n lyr.name = lyr.datasetName\n else:\n newType = updatePath[1] \n if sourceIsCoverage and sameType:\n newDSPath = os.path.split(newDSPath)[0]\n newType = \"ARCINFO_WORKSPACE\"\n for extType in lstExtDatatype:\n if extType[0] in updatePath[0]:\n newType = extType[1]\n if extType[0] == '.gdb':\n newDSPath = newDSPath.split('.gdb', 1)[0] + '.gdb'\n #newType = extType[1]\n elif extType[0] == '.sde':\n newDSPath = newDSPath.split('.sde', 1)[0] + '.sde'\n\n break\n print(\"line ~281 newType is: {0}\".format(newType))\n myMsgs(\" *Moving {0}: {1} to new: {2}\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n reportFile.write(\"\\n Moving {0}: {1} to new: {2}\".format(updatePath[3], lyr.dataSource, updatePath[0]))\n lyr.replaceDataSource(newDSPath, newType, newDSName, False)\n #myMsgs(\" new datasource: {0}\".format(lyr.dataSource))\n myMsgs(\" **the new data source: {0}\".format(updateStatus))\n cntFixed += 1\n myMsgs(\" Still broken? {0}\".format(lyr.isBroken))\n else:\n myMsgs(\"not sure what it is, but can't process {0}\".format(lyr.name))\n \n else:\n myMsgs(\" -Not Broken: {0}\".format(str(lyr)))\n\n myMsgs(\" Number of links fixed processed: {0}\".format(cntFixed))\n myMsgs(\" -{0} Review complete.\".format(fullPath))\n reportFile.write(\" -Number of links fixed processed: {0} \\n\".format(cntFixed))\t\t\t\t\t\t\n reportFile.write(\" -{0} Review complete. \\n\\n\".format(fullPath))\n\n if cntFixed > 0:\n mxd.save()\n myMsgs(\"saved to {0}\".format(fullPath))\n reportFile.write(\"saved to {0}\".format(fullPath))\n cntTotalFixed += cntFixed\n cntFixed = 0\n \"\"\"if cntFixed > 0:\n\t\t\t\t\t\t\tmxd.saveACopy(outMXDName, '10.1')\n\t\t\t\t\t\t\tmyMsgs(\"saved to {0}\".format(outMXDName))\n\t\t\t\t\t\t\tcntFixed = 0\"\"\"\n '''if arcpy.Exists(outMXDName):\n outMXDName.()\n myMsgs(\"saved 1\")\n else:\n mxd.saveACopy(outMXDName, '10.1')\n myMsgs(\"saved 2\")'''\n del mxd\n cntFixed = 0\n else:\n myMsgs (\"ERROR: Required repair source list: [0] does not exit. \\n\".format(inFile))\n outText = (\"\\n\\n ==========================================\")\n outText += (\"\\n Number of MXD's processed: {0} \\n\".format(cntMXD))\n outText += (\" Total Number of links it fixed, all mxds: {0} \\n\".format(cntTotalFixed) )\n\n myMsgs(\" {0}\".format(outText))\n\n reportFile.write(outText)\n # close the .txt file, \n reportFile.close()\n myMsgs( \"File {0} is closed? {1}\".format(outfileTXT, str(reportFile.closed)))\t\n\n myMsgs('!!! Success !!! ')","def reformfile0():\n txt = \"\"\"\n {\n \"policy\": {\n \"_SS_Earnings_c\": {\"2016\": [300000],\n \"2018\": [500000],\n \"2020\": [700000]}\n }\n }\n \"\"\"\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\n rfile.write(txt + '\\n')\n rfile.close()\n # Must close and then yield for Windows platform\n yield rfile\n if os.path.isfile(rfile.name):\n try:\n os.remove(rfile.name)\n except OSError:\n pass # sometimes we can't remove a generated temporary file","def test_repair_file(self):\n\n audio_path = self.converter.audio\n self.assertTrue(audio_path.endswith('.wav'))\n # Make sure it can be loaded in moviepy\n clip = AudioFileClip(audio_path)","def readdata(self, prefix, date, county):\n print('F30A: prefix and date', prefix, date)\n\n filetoread = open(prefix + 'EL30A')\n\n lines = []\n for line in filetoread:\n lines.append(line)\n\n linelimit = len(lines)\n# print('LINELIMIT', linelimit)\n linesub = 0\n while linesub < linelimit:\n line = lines[linesub]\n\n if len(line) < 4:\n linesub += 1\n continue\n if len(line.split()) < 2:\n linesub += 1\n continue\n possiblepctnumber = line[0:4]\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\n self._pctnumber = possiblepctnumber\n self._pctname = line[4:].strip()\n if self._pctnumber not in globalpcts:\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\n else:\n onepct = globalpcts[self._pctnumber]\n\n # here's the new 12 June 2018 kluge to get the numbers\n if 'BALLOTS CAST - TOTAL' in line:\n line = line.replace('.', ' ')\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\n line = line.replace(',', '') # commas in numbers\n\n# linesplit = line.split()\n self._ballots = []\n for item in line.split():\n self._ballots.append(int(item))\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\n onepct.updatefrom30a(self._registered, self._ballots, county)\n globalpcts[self._pctnumber] = onepct\n linesub += 1","def getcleanjson(self):\n dico=self.dico.copy() # shalow copie as we remove second level data in the copied\n for key in [\"basefiles\",\"grader\",\"soluce\"]:\n if key in dico:\n del dico[key]\n return str(json.dumps(dico))","def reformat_json_file(infilename, outfilename, clobber=False):\n # open input json file\n with open(infilename) as json_file:\n json_string = json_file.read()\n json_data = json.loads(json_string)\n\n # see if output file already exists and determine course of action\n if os.path.exists(outfilename):\n if clobber:\n os.remove(outfilename)\n else:\n sys.exit(\"Error: output file {} already exists and would be overwritten!\".format(outfilename))\n\n # write out reformatted json file\n with open(outfilename, 'w') as f:\n json.dump(json_data, f, indent=4)","def main(transcribe_bucket_name, mp3_bucket_name):\n\n s3 = boto3.resource('s3')\n for bucket in s3.buckets.all():\n if bucket.name == transcribe_bucket_name:\n for key in bucket.objects.all():\n if key.key.endswith('.json'):\n r = {}\n # Get reference number\n reference = basename(key.key).replace('.json', '')\n r['ref'] = reference\n # Get URL\n location = boto3.client('s3') \\\n .get_bucket_location(\n Bucket=mp3_bucket_name)['LocationConstraint']\n base_url = join('https://s3-%s.amazonaws.com' % location,\n mp3_bucket_name)\n url = join(base_url, key.key.replace('.json', '.mp3'))\n r['url'] = url\n # Download json file\n try:\n s3.Bucket(transcribe_bucket_name) \\\n .download_file(key.key, key.key)\n except Exception as exception:\n return 1\n # Get text\n with open(key.key, 'r') as f:\n data = json.load(f)\n text = data['results']['transcripts'][0]['transcript']\n r['text'] = text\n # Get sentiment\n sentiment = get_sentiment(text)\n r['sentiment'] = sentiment\n # Check promotion\n promo = check_promo(text)\n r['promo'] = promo\n # Save to Gooogle Sheets\n values = [r['ref'], r['text'], r['promo'], r['sentiment'],\n r['url']]\n append_row(values)\n # Remove tmp json file from local machine\n remove(key.key)","def copy_json():\n sourcePath = 'contents/external/'\n targetPath = 'build/external/'\n for base,subdirs,files in os.walk(sourcePath):\n for file in files:\n orig = os.path.join(base, file)\n if os.path.isfile(orig) and file[-5:] == '.json':\n targetBase = os.path.join(targetPath, base[len(sourcePath):])\n dest = os.path.join(targetBase, file)\n puts(\"Checking diretory %s\" % targetBase)\n if not os.path.exists(targetBase):\n puts(yellow(\"Not found! Creating...\"))\n os.makedirs(targetBase)\n puts(\"Copying from %s to %s\" % (orig, dest))\n copyfile(orig, dest)","def reformat(self):\n\t\told_path = os.path.join( self.path, self.init_str )\n\t\tnew_path = os.path.join( self.path, self.reorder() )\n\t\tos.rename(old_path,new_path)","def filterCollections(path, context):\n filteredObj = []\n for obj in os.listdir(path):\n if os.path.splitext(obj)[-1] == '.json':\n if obj.split('_', 1)[0] == context:\n filteredObj.append(obj.encode('utf8'))\n baseC = context + '_baseCollection.json'\n filteredObj = sorted(filteredObj, key=str.lower)\n filteredObj.insert(0, filteredObj.pop(filteredObj.index(baseC)))\n return filteredObj","def restructure_file(raw_file_name, destination_file, label_file):\n unique_words = answer_vocabulary(raw_file_name)\n answer_labels = convert2labels(unique_words, label_file)\n\n qa_list = json.load(open(raw_file_name))\n new_qa_list = list()\n\n for qa_dict in qa_list:\n answer = str(qa_dict[\"answer\"]).lower()\n first_word = answer.split(\" \")[0]\n\n new_qa_dict = {\n \"image_name\": qa_dict[\"image_name\"],\n \"question\": qa_dict[\"question\"],\n \"answer_label\": answer_labels[first_word]\n }\n\n new_qa_list.append(new_qa_dict)\n\n json.dump(new_qa_list, open(destination_file, \"w\"), indent=4)","def get_prep(file_name):\n\n headers = {\n \"User-Agent\": \"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0\"}\n\n url = \"https://rp18.ine.mx/assets/JSON/PRESIDENTE/NACIONAL/Presidente_NACIONAL.json\"\n\n with requests.get(url, headers=headers) as response:\n\n # Save a copy for future analysis.\n with open(\"./raw_data/{}.json\".format(file_name), \"w\", encoding=\"utf-8\") as temp_file:\n temp_file.write(response.text)\n\n candidates = list()\n percentages = list()\n votes = list()\n colors = list()\n\n json_data = response.json()\n\n for item in json_data[\"votosCandidatoPartidoCoalicion\"]:\n\n name = item[\"nombreCandidatoPropietario\"]\n\n if item[\"siglasPartido\"] == \"CNR\":\n name = \"Candidatos No Registrados\"\n\n if item[\"siglasPartido\"] == \"VN\":\n name = \"Nulos\"\n\n color = \"#{}\".format(item[\"colorPartido\"])\n colors.append(color)\n\n candidates.append(name)\n percentages.append(float(item[\"porcentaje\"]))\n votes.append(int(item[\"total\"]))\n\n return dict({\"candidates\": candidates, \"percentages\": percentages,\n \"votes\": votes, \"colors\": colors, \"totalVotos\": json_data[\"totalVotos\"],\n \"actasCapturadas\": json_data[\"actasCapturadas\"][\"porcentaje\"]})","def change_file(paths, object):\r\n \"\"\" \r\n for x in os.listdir(dirs): print(x) \r\n \"\"\"\r\n check_path = paths + \"\\changer\"\r\n\r\n for x in object:\r\n pass_data = False\r\n name = x.split('.')[0]\r\n for y in os.listdir(check_path):\r\n if name in y:\r\n pass_data = True\r\n\r\n if pass_data:\r\n pass\r\n else:\r\n vid = VideoFileClip(os.path.join(paths, \"\", x))\r\n\r\n vid.audio.write_audiofile(os.path.join(\r\n paths, \"changer\", name+\".mp3\")\r\n )\r\n show_result(check_path)","def make_cached_json(file_name):\n result = None\n path = clean_path(file_name)\n working_directory = os.path.split(os.path.abspath(file_name))[0]\n file_type_switch = \"-s\" if is_sats_file(file_name) else \"-d\"\n command = []\n command.append(\"patsopt\")\n command.append(\"--jsonize-2\")\n command.append(file_type_switch)\n command.append(path)\n (stdout, _stderr, return_code) = run(\n working_directory,\n command,\n POSTIATS_ENCODING)\n if return_code == 0:\n cached_file_name = get_cached_file_name(path)\n cached_directory = os.path.split(cached_file_name)[0]\n if not os.path.exists(cached_directory):\n os.makedirs(cached_directory)\n output = open(cached_file_name, \"w\")\n output.write(stdout)\n output.close()\n result = json.loads(stdout)\n return result","def crop_acc_mask(images_dir, images_output_dir, masks_dir, mask_suffix=None, masks_output_dir=None): \n image_suffix_list = [\"C0\", \"DE\", \"T2\"]\n if not os.path.exists(images_output_dir):\n os.makedirs(images_output_dir)\n if masks_output_dir is not None and (not os.path.exists(masks_output_dir)):\n os.makedirs(masks_output_dir)\n margin = [0, 30, 30]\n masks_list = os.listdir(masks_dir)\n masks_list.sort()\n json_dict = OrderedDict()\n for mask in masks_list:\n mask_path = os.path.join(masks_dir, mask)\n if mask.endswith(\".nii.gz\"):\n print(\"#\" * 11 *11)\n print(mask_path)\n mask_sitk = sitk.ReadImage(mask_path)\n mask_npy = sitk.GetArrayFromImage(mask_sitk)\n mask_shape = mask_npy.shape\n crop_bbox_min, crop_bbox_max = get_ND_bounding_box(mask_npy, margin=margin)\n # do not crop along depth dimension\n crop_bbox_min[0] = 0\n crop_bbox_max[0] = mask_shape[0]\n print(crop_bbox_min, crop_bbox_max)\n json_dict[mask_path] = {\"crop_bbox_min\": crop_bbox_min, \"crop_bbox_max\": crop_bbox_max}\n mask_output_npy = crop_ND_volume_with_bounding_box(mask_npy, crop_bbox_min, crop_bbox_max)\n if mask_suffix is not None:\n mask = mask.replace(\"_\" + mask_suffix + \".nii.gz\", \".nii.gz\")\n if masks_output_dir is not None:\n save_cropped_array_as_nifty_volume(mask_output_npy, os.path.join(masks_output_dir, mask), mask_sitk)\n save_cropped_array_as_nifty_volume(convert_label(mask_output_npy, [1, 2, 3, 4, 5], [1, 2, 3, 1, 1]), \\\n os.path.join(images_output_dir, mask.replace(\".nii.gz\", \"_{0:04d}.nii.gz\".format(len( \\\n image_suffix_list)))), mask_sitk)\n for i, image_suffix in enumerate(image_suffix_list):\n image = mask.replace(\".nii.gz\", \"_{}.nii.gz\".format(image_suffix))\n image_path = os.path.join(images_dir, image)\n print(image_path)\n image_sitk = sitk.ReadImage(image_path)\n image_npy = sitk.GetArrayFromImage(image_sitk)\n image_output_npy = crop_ND_volume_with_bounding_box(image_npy, crop_bbox_min, crop_bbox_max)\n save_cropped_array_as_nifty_volume(image_output_npy, os.path.join(images_output_dir, mask.replace( \\\n \".nii.gz\", \"_{0:04d}.nii.gz\".format(i))), image_sitk)\n save_json(json_dict, os.path.join(images_output_dir, \"crop_information.json\"))\n if masks_output_dir is not None:\n save_json(json_dict, os.path.join(masks_output_dir, \"crop_information.json\"))","def make_json(prefix, input_dir):\n # get list of files\n file_list = os.listdir(input_dir)\n # set reference sequence\n tracklist = {'formatVersion': 1,\n 'refSeqs': '%s.ref.fa.fai' % prefix,\n 'tracks': []}\n # add reference sequence track to tracklist.json\n tracklist['tracks'].append({\"category\": \"Reference sequence\",\n \"key\": \"Reference sequence\",\n \"label\": \"Reference sequence\",\n \"type\": \"SequenceTrack\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/IndexedFasta\",\n \"urlTemplate\": \"%s.ref.fa\" % prefix,\n \"refSeqOrder\": \"False\"})\n tracklist['tracks'].append({\"category\": \"Consensus sequence\",\n \"key\": \"Consensus sequence\",\n \"label\": \"Consensus sequence\",\n \"type\": \"SequenceTrack\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/IndexedFasta\",\n \"urlTemplate\": \"%s.cons.fa\" % prefix,\n \"refSeqOrder\": \"False\"})\n # add bigwig track to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Coverage\",\n \"label\": \"Coverage\",\n \"type\": \"JBrowse/View/Track/Wiggle/XYPlot\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BigWig\",\n \"autoscale\": \"local\",\n \"urlTemplate\": \"%s.sorted.bw\" % prefix\n })\n # add BAM Sequence Coverage to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Sequence reads (SNPs/Coverage)\",\n \"label\": \"Sequence reads (SNPs/Coverage)\",\n \"type\": \"JBrowse/View/Track/SNPCoverage\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BAM\",\n \"urlTemplate\": \"%s.sorted.capped.bam\" % prefix,\n \"cacheMismatches\": \"True\",\n \"chunkSizeLimit\": \"5000000\"\n })\n # add BAM Sequence Alignments to trackList.json\n tracklist['tracks'].append({\"category\": \"Sequence data\",\n \"key\": \"Sequence reads (Alignment)\",\n \"label\": \"Sequence reads (Alignment)\",\n \"type\": \"JBrowse/View/Track/Alignments2\",\n \"storeClass\": \"JBrowse/Store/SeqFeature/BAM\",\n \"urlTemplate\": \"%s.sorted.capped.bam\" % prefix,\n # add bigwig histogram option\n \"cacheMismatches\": \"True\",\n \"chunkSizeLimit\": \"5000000\"\n })\n # add GFF3 file to trackList.json\n tracklist['tracks'].append({\"category\": \"Annotation\",\n \"key\": \"Genbank annotation\",\n \"label\": \"Genbank annotation\",\n \"type\": \"JBrowse/View/Track/CanvasFeatures\",\n \"urlTemplate\": \"%s.gff3.gz\" % prefix,\n \"style\": {\n \"_defaultHistScale\": 4,\n \"_defaultLabelScale\": 30,\n \"_defaultDescriptionScale\": 120,\n # Comma-separated list of case-insensitive feature tags to use\n # for showing the feature's label.\n # The first one found will be used. Default 'name,id'.\n \"label\": \"product,id\",\n # style→description\tComma-separated list of case-insensitive\n # feature tags to check for the feature's long description.\n # The first one found will be used. Default 'note,description'.\n # If blank no description is used.\n \"description\": \"note, description\"\n },\n })\n\n json_path = os.path.join(input_dir, 'trackList.json')\n with open(json_path, 'wt') as output_handle:\n json_raw_str = json.dumps(tracklist, indent=4)\n output_handle.write(json_raw_str)\n return 'trackList.json'","def generate_clips(input_dir, output_dir, duration=20, ext='.mkv'):\n \n i = [0,0,0,0]\n \n output_dirs = [os.path.join(output_dir, 'goals'),\n os.path.join(output_dir, 'bg'),\n os.path.join(output_dir, 'cards'),\n os.path.join(output_dir, 'subs')]\n\n for dir in output_dirs:\n if not os.path.exists(dir):\n os.mkdir(dir)\n print('Made directory ' + dir)\n \n \n for path in input_dir:\n print(path)\n \n with open(os.path.join(path, 'Labels.json')) as f:\n file = json.load(f)\n labels = parseLabels(file)\n \n # for each item in label, crop a specified length and save to output_dir\n for timestamp, label in labels:\n half = timestamp[0]\n time = timestamp[1]\n vid_name = os.path.join(path, half + ext)\n\n if time - 5 > 0:\n\n if label == 'soccer-ball':\n # collect an instance of a goal\n clip_video(vid_name, time - 5, duration, i[0], output_dirs[0])\n i[0] += 1\n\n # collect an instance of a non-goal, if it does not overlap with another event\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\n i[1] += 1\n\n elif 'card' in label:\n # collect an instance of a carding event\n clip_video(vid_name, time - 4, duration, i[2], output_dirs[2])\n i[2] += 1\n\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\n i[1] += 1\n\n\n elif 'substitution' in label:\n # collect an instance of a carding event\n clip_video(vid_name, time - 4, duration, i[3], output_dirs[3])\n i[3] += 1\n\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\n i[1] += 1\n\n print('Saved clip from ' + path)","def build_words_map(self, to_clip=True):\n import clipboard\n import json_utils\n words_map = {}\n rev_map = {}\n rs = []\n all_words=self.get_all_words()\n for word in all_words:\n key = self.get_norm_key(word)\n if len(key) > 0:\n if key in words_map:\n words_map[key].append(word)\n else:\n words_map[key] = [word]\n rev_map[word] = key\n rs.append('%s %s' % (key, word))\n\n print('write to', self.target_file)\n json_utils.write_json_to_file(self.target_file, words_map)\n json_utils.write_json_to_file(self.target_file_rev, rev_map)\n if to_clip:\n print('copy to clipboard ...')\n clipboard.copy('\\n'.join(rs))\n print('done')","def raging_fire():\n\n if editspin1.get() != '0': # season\n select_values[0] = int(editspin1.get()) # modify the change\n select_values[3] = \"{}\".format(datetime.datetime.now().date()) # update the modify date\n with open('Other_title_categories.json', 'w') as f:\n completeDict[curItem] = select_values\n json.dump(other_categories_foData, f, indent=2)\n print(\"done writing changes\")\n\n if editspin2.get() != '0': # episode\n select_values[1] = int(editspin2.get())\n select_values[3] = \"{}\".format(datetime.datetime.now().date()) # update the modify date\n with open('Other_title_categories.json', 'w') as f:\n completeDict[curItem] = select_values\n json.dump(other_categories_foData, f, indent=2)\n print(\"done writing changes\")\n\n if editentvar.get() != curItem: # name\n removed_values = completeDict.pop(curItem) # remove the previous title and write the new one\n completeDict[editentvar.get()] = removed_values\n select_values[3] = \"{}\".format(datetime.datetime.now().date())\n with open('Other_title_categories.json', 'w') as f:\n completeDict[editentvar.get()] = select_values # set the values of the edited title\n json.dump(other_categories_foData, f, indent=2)\n print(\"done writing changes\")\n\n edittop.destroy()","def test_make_json_advanced(self):\n resources = get_test_resources()\n output, filename = make_json(commit=\"1245\", exclude=[\"tei:note\", \"tei:orig\"], credit=\"PerseusDL\", **resources)\n output = json.loads(output)\n self.assertEqual(\n output[\"text\"][\"0\"][\"0\"][\"0\"], \"Spero me secutum in libellis meis tale temperamen-\",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"1\"], \"Et comites longae quaeris habere viae, \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"1\"][\"3\"], \"Crede mihi, nimium Martia turba sapit. \",\n \"Text passages should be parsed correctly and note removed\"\n )\n self.assertEqual(\n output[\"text\"][\"1\"][\"0\"][\"0\"], \"Qui tecum cupis esse meos ubicumque libellos \",\n \"Text passages should be parsed correctly\"\n )\n self.assertEqual(\n filename, \"textgroup__work__lat.json\",\n \"Filename should be created in a stable and understandable manner\"\n )\n self.assertEqual(\n output[\"original-urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1\",\n \"Original URN should be fed\"\n )\n self.assertEqual(\n output[\"urn\"], \"urn:cts:latinLit:textgroup.work.version-lat1-simple\",\n \"CLTK URN should be suffixed\"\n )\n self.assertEqual(\n output[\"credit\"], \"PerseusDL\",\n \"Credit should be empty by default\"\n )\n self.assertEqual(\n output[\"meta\"], \"book-poem-line\",\n \"meta should reflect the citation scheme\"\n )\n self.assertEqual(\n output[\"author\"], \"textgroup\",\n \"Author name should be the English textgroup name\"\n )\n self.assertEqual(\n output[\"work\"], \"work\",\n \"Work name should be the English work name\"\n )\n self.assertEqual(\n output[\"edition\"], \"description\",\n \"We should have the English description\"\n )\n self.assertEqual(\n output[\"commit\"], \"1245\",\n \"We should have the commit information\"\n )","def _filename_pre_data(self) -> dict:\n key = []\n remainder = \"\"\n prework = {}\n for i in self.draft_file:\n if i == \"{\":\n remainder = \"\"\n elif i == \"}\":\n key.append(remainder)\n else:\n remainder += i\n list_filename = self.filename.split(\"_\")\n for key, value in zip(key, list_filename):\n prework[key] = value\n self.pre_data = prework","def test_get_pathless_raw_file_name_json(self):\n\n this_pathless_file_name = probsevere_io._get_pathless_raw_file_name(\n unix_time_sec=VALID_TIME_UNIX_SEC,\n file_extension=probsevere_io.JSON_FILE_EXTENSION)\n\n self.assertTrue(this_pathless_file_name == PATHLESS_JSON_FILE_NAME)","def main():\r\n parent_dir = 'D:\\\\Profession\\\\Intern\\\\Assignments\\\\Codes\\\\Assignement Codes\\\\Part 2\\\\data_dumps'\r\n\r\n if not (os.path.isdir(parent_dir)):\r\n raise Exception(\"The directory doesn't exist\")\r\n\r\n directories = []\r\n\r\n for directory in os.listdir(parent_dir):\r\n directories.append(os.path.join(parent_dir, directory))\r\n\r\n # The group_dic represents the dictionary with keys equal to the unique dates in the directories\r\n # And the values represent a list of all files that have the same date prefix across the data_dumps\r\n group_dic = grouping(directories)\r\n\r\n # Moving Files into New Directory\r\n move(group_dic, parent_dir)\r\n print(\"Files Moved Successfully\")","def main(filename):\n with open(filename) as json_file:\n data = json.load(json_file)\n\n course_dict = {}\n course_dict['course_id'] = str(os.path.split(filename.strip('/'))[-1])\n course_dict['blocks'] = build_course_map(data)\n\n filename = '%s' % course_dict['course_id']\n filepath = os.path.join('../input/', filename)\n\n with open(filepath, 'w') as outfile:\n json.dump(course_dict, outfile, indent=4)","def clean_subreddit(filename):\n\n # Get name for processed file\n regex = r\"([^\\/]+)(?=\\-all)\"\n matches = re.search(regex, subreddit_folder)\n new_file = matches.group(1)\n\n # Create list of columns to keep\n keep_cols = ['id', 'created_utc', 'author', 'title',\\\n 'score', 'num_comments', 'subreddit', 'link_flair_text']\n\n keep_cols_text = ['id', 'created_utc', 'author', 'selftext']\n\n # Create file name\n processedfile_csv = \"data/processed/submissions/\" + new_file + \\\n \"-metadata\" + \".csv\"\n\n processed_textfile_csv = \"data/processed/submissions/\" + new_file + \\\n \"-text\" + \".csv\"\n\n # Create empty data frame\n df_keep = pd.DataFrame()\n df_keep_text = pd.DataFrame()\n\n # Read in json file\n try:\n data = pd.read_json(filename)\n\n # ValueError: Trailing data thrown if file is pretty indented\n except ValueError:\n data = pd.read_json(filename, lines = True)\n\n try:\n df_keep = df_keep.append(data[keep_cols])\n except KeyError:\n keep_cols = ['id', 'created_utc', 'author', 'title',\\\n 'score', 'num_comments', 'subreddit']\n df_keep = df_keep.append(data[keep_cols])\n\n try:\n df_keep_text = df_keep_text.append(data[keep_cols_text])\n except KeyError:\n keep_cols_text = ['id', 'created_utc', 'author']\n df_keep_text = df_keep_text.append(data[keep_cols_text])\n\n\n # Change date format\n ## For metadata\n df_keep['datetime_dv'] = pd.to_datetime(df_keep['created_utc'], unit = 's')# dv = derived\n df_keep['date_dv'] = df_keep['datetime_dv'].dt.date\n\n # For text\n df_keep_text['datetime_dv'] = pd.to_datetime(df_keep_text['created_utc'], unit = 's')# dv = derived\n df_keep_text['date_dv'] = df_keep_text['datetime_dv'].dt.date\n\n\n ##### Delimit by date #####\n # Create mask of time slot\n mask = (df_keep['date_dv'] >= start) & (df_keep['date_dv'] <= end) # inclusive on either end\n mask_text = (df_keep_text['date_dv'] >= start) & (df_keep_text['date_dv'] <= end)\n\n # Only keep data within date frame\n df_keep = df_keep.loc[mask]\n df_keep_text = df_keep_text.loc[mask_text]\n ############################\n\n\n # Save to json\n df_keep_text.to_csv(processed_textfile_csv, mode = \"w\")\n df_keep.to_csv(processedfile_csv, mode = \"w\") # mode= w will overwrite previous file\n print(len(df_keep_text.index))\n print(processed_textfile_csv)\n\n\n data = [] # force empty","def test_raw_file_name_to_time_json_alternative(self):\n\n this_time_unix_sec = probsevere_io.raw_file_name_to_time(\n ALTERNATIVE_JSON_FILE_NAME)\n\n self.assertTrue(this_time_unix_sec == VALID_TIME_UNIX_SEC)","def process(self):\n first_line = self.setup[\"first_line\"]\n last_line = self.setup[\"last_line\"]\n\n self.logger.info(\"Using lines %s - %s\", first_line, last_line)\n\n path_temp = \"{}_\".format(self.path)\n\n with open(self.path, \"r\") as src, open(path_temp, \"w\") as dest:\n lines = src.r..\n copy_lines = lines[first_line-1:last_line]\n dest.write(\"\".join(copy_lines))\n\n os.rename(path_temp, self.path)","def _clean_up_project_file(self):\n\n print \"Reading in project file...\"\n with open(self.project_file,'r') as f_in:\n project_json = json.load(f_in)\n\n # Go through design_files references\n configurations = project_json['Project']['Configurations']\n n = len(configurations)\n indices_to_delete = []\n for i in range(n):\n if not os.path.basename(configurations[i]) in self.design_files:\n indices_to_delete.append(i)\n\n indices_to_delete.reverse()\n for i in indices_to_delete:\n del configurations[i]\n\n # Go through design_space_files references\n design_space_models = project_json['Project']['DesignSpaceModels']\n n = len(design_space_models)\n indices_to_delete = []\n for i in range(n):\n if not os.path.basename(design_space_models[i]) in self.design_space_files:\n indices_to_delete.append(i)\n\n indices_to_delete.reverse()\n for i in indices_to_delete:\n del design_space_models[i]\n\n # Go through test_bench_files references\n #test_benches = project_json['Project']['TestBenches']\n #n = len(test_benches)\n #indices_to_delete = []\n #for i in range(n):\n # if not os.path.basename(test_benches[i]) in self.test_bench_files:\n # indices_to_delete.append(i)\n #\n #for i in indices_to_delete.reverse():\n # del test_benches[i]\n\n # Write out the new, reduced in size, project dictionary\n with open(self.project_file,'wb') as f_out:\n json.dump(project_json, f_out, indent=4)\n\n print \"Written out cleaned up project dictionary.\"","def create_newfile():\n date = datetime.today().strftime('%d_%m_%Y').replace(\" \", \"_\")\n file_name = screen_name + '_' + date + \".json\"\n with io.FileIO(file_name, \"w\") as file:\n file.write(\"Json\")\n file.close()\n return file_name","def cleanJson(filename):\n saveFile = 'newFile.json'\n\n # check if file exists and exit if it does\n if os.path.exists(saveFile):\n return\n\n with open(filename) as f:\n contents = f.readlines()\n\n with open('newFile.json', 'a') as outfile:\n for line in contents:\n # convert line from JSON to Python dictionary\n dic = decode(line)\n # convert dic to a string representing a json object\n json_obj = json.dumps(dic)\n outfile.write(json_obj) # write to outfile\n outfile.write(\"\\n\")","def transform_file(input_file_path: str, output_file_path: str):\n\n # Open json\n with open(input_file_path, mode=\"r\") as in_file:\n input_data = json.load(in_file)\n\n # Transform and write\n with jsonlines.open(output_file_path, mode=\"w\", compact=True) as out_file:\n for item in input_data[\"items\"]:\n out_file.write(transform_item(item))","def newJsonFile():\n nonlocal currentFile\n currentFile = join(rootFolder, 'tweetsRaw-' + str(now()) + '.json')\n f = open(currentFile)\n f.write('[\\n')\n return f","def write_to_json(data):\n # Serializing json \n json_object = json.dumps(data, indent = 4) \n\n date = datetime.now()\n date_str = date.strftime(\"%y%m%d_%H%M\")\n \n # Writing to sample.json \n with open(\"./intraday_data/json/i_data_{0}_{1}.json\".format(date_str, int(time.time())), \"w\") as outfile: \n outfile.write(json_object)","def load_clip_times(clip_list_file, path_to_data, start_times_file, output_dir, mouse_type):\n print \"clip_list_file\", clip_list_file\n pkl_file = open(clip_list_file, 'rb')\n all_peak_times_dict = pickle.load(pkl_file)\n all_peak_vals_dict = pickle.load(pkl_file)\n all_local_times_dict = pickle.load(pkl_file)\n all_interaction_start_times_dict = pickle.load(pkl_file)\n all_interaction_end_times_dict = pickle.load(pkl_file)\n all_start_times_dict = load_start_times(start_times_file)\n\n movie_info_dict = dict()\n for name in all_peak_times_dict.keys():\n movie_info = dict()\n movie_info['movie_file'] = get_movie_file(name, path_to_data)\n movie_info['output_file'] = get_output_file(name, output_dir)\n movie_info['peak_times'] = all_peak_times_dict[name]\n movie_info['peak_vals'] = all_peak_vals_dict[name]\n # movie_info['local_times'] = all_local_times_dict[name]\n movie_info['name'] = name\n movie_info['start_time'] = all_start_times_dict[name]\n movie_info['interaction_start'] = all_interaction_start_times_dict[name]\n movie_info['interaction_end'] = all_interaction_end_times_dict[name]\n movie_info['mouse_type'] = mouse_type\n\n movie_info_dict[name] = movie_info\n return movie_info_dict","def __cleaned(game, json):\n link = game.link\n title = \" - \".join(map(lambda x: x.strip(), game.title.split('-')))\n date = datetime.datetime(*game.updated_parsed[:6])\n\n # convert date to timestamp\n if json:\n date = date.strftime('%a, %d %b %Y')\n \n return {'title': title, 'link': link, 'date': date}","def updateCache(self):\n for root, dirs, files in os.walk(cachedFilesPath):\n for file in files:\n if file.endswith(cachedFileExtensionSuffix):\n path = os.getcwd()+'/'+cachedFilesPath+file\n with open(path, mode='r') as f:\n payload_json = f.read()\n payload_obj=jsonpickle.decode(payload_json)\n r= self.upload(payload_obj)\n if isinstance(r, types.NoneType):\n #do nothing\n print(\"\")\n else:\n if r.status_code == 200 :\n #uploaded!\n if cacheArhive:\n #move it to archive\n dst=os.getcwd()+'/'+cachedArchivePath+file\n shutil.move(path, dst)\n print(\"archived log: \", file)\n else:\n #delete it\n os.remove(path)","def patch_files():\n args = parser.parse_args()\n doc = json.load(args.ORIGINAL)\n patch = json.load(args.PATCH)\n result = jsonpatch.apply_patch(doc, patch)\n print(json.dumps(result, indent=args.indent))","def write_new_date(self) -> None:\n\n with open(str(os.path.join(THIS_DIR, \"data_file.json\")), mode='r') as json_file:\n data = json.load(json_file)\n data[self.site] = str(self.get_last_image_date())\n json_file.close()\n with open(str(os.path.join(THIS_DIR, \"data_file.json\")), mode='w') as json_file:\n json.dump(data, json_file)\n json_file.close()","def correct_naming(obsid, inst):\n cobsid = str(int(float(obsid)))\n if len(cobsid) == 5:\n return \n\n lobsid = mcf.add_leading_zero(obsid, 5)\n \n for sdir in ['secondary', 'analysis']:\n\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\n os.system(cmd)\n\n data = mcf.read_data_file(zspace, remove=1)\n for ent in data:\n atemp = re.split('\\/', ent)\n fname = atemp[-1]\n mc = re.search(lobsid, fname)\n if mc is not None:\n continue\n else:\n atemp = re.split('hrcf', fname)\n btemp = re.split('_', atemp[1])\n sobs = btemp[0]\n new = fname.replace(sobs, lobsid)\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\n\n cmd = 'mv ' + ent + ' ' + full\n os.system(cmd)","def _rebuildOcean(self, tk, templateFile = '', fields = '', id = '', shotNum = '', inprogressBar = ''):\r\n\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Deleting current Ocean now....', verbose = False)\r\n\t\tself._removeOcean()\r\n\r\n\t\t## Get all the publishes from shotgun now for the blocking or animation step as required..\r\n\t\tif self.app.get_setting('shotStep') == 'Blocking':\r\n\t\t\tgetAnimVersionFolders = tk.paths_from_template(templateFile, {'Step' : 'Blck', 'id' : id, 'Shot' : shotNum})\r\n\t\telif self.app.get_setting('shotStep') == 'Animation':\r\n\t\t\tgetAnimVersionFolders = tk.paths_from_template(templateFile, {'Step' : 'Anm', 'id' : id, 'Shot' : shotNum})\r\n\r\n\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'getAnimVersionFolders...%s' % getAnimVersionFolders, verbose = False)\r\n\r\n\t\t## Fix path for maya to read in properly\r\n\t\tif getAnimVersionFolders:\r\n\t\t\t## now find the highest version folder number\r\n\t\t\thighestVersionFolder = r'%s' % max(getAnimVersionFolders)\r\n\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'highestVersionFolder...%s' % highestVersionFolder, verbose = False)\r\n\r\n\t\t\thighestVersionFolder = highestVersionFolder.replace('\\\\', '/')\r\n\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'highestVersionFolder replaced \\\\ with /...\\n%s' % highestVersionFolder, verbose = False)\r\n\r\n\t\t\tversionNumber = highestVersionFolder.split('/')[-1]\r\n\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'versionNumber: %s' % versionNumber, verbose = False)\r\n\r\n\t\t\tgetCacheFiles = os.listdir(highestVersionFolder)\r\n\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'getCacheFiles...\\n%s' % getCacheFiles, verbose = False)\r\n\t\t\t##################################################################################################################\r\n\t\t\t## APPLY OCEAN PRESET TO A NEW OCEAN\r\n\t\t\tif 'publish/fx' in highestVersionFolder: ## The ocean preset.mel is saved out to the fx folder in the animation/publish/fx folders\r\n\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Loading ocean files now...', verbose = False)\r\n\r\n\t\t\t\t## Build the group if it doesn't already exist\r\n\t\t\t\tself._buildGroup('FX_CACHES_hrc', versionNumber)\r\n\r\n\t\t\t\t## No maya ocean in scene? Build a new one...\r\n\t\t\t\tif not cmds.objExists('oceanShader1'):\r\n\t\t\t\t\tmel.eval(\"CreateOcean;\")\r\n\r\n\t\t\t\t\t## Clean up the names\r\n\t\t\t\t\t## NOTE we are not renaming the actual OCEAN SHADER here because in Marks scripts we are reconnecting like so\r\n\t\t\t\t\t## cmds.disconnectAttr('oceanShader1.outColor', 'oceanShader1SG.surfaceShader')\r\n\t\t\t\t\theightField = cmds.listRelatives(cmds.ls(selection = True)[0], parent = True, fullPath = True)[0]\r\n\t\t\t\t\tcmds.rename(heightField, 'oceanPreviewPlane_prv')\r\n\t\t\t\t\tcmds.rename('oceanPlane1', 'ocean_srf')\r\n\t\t\t\t\tcmds.rename('oceanPreviewPlane1', 'oceanPreviewPlane_heightF')\r\n\t\t\t\t\tcmds.parent('ocean_srf', 'FX_CACHES_hrc')\r\n\t\t\t\t\tcmds.parent('oceanPreviewPlane_prv', 'FX_CACHES_hrc')\r\n\t\t\t\t\tcmds.rename('oceanShader1', CONST.OCEANDISPSHADER)\r\n\t\t\t\t\tcmds.rename('oceanShader1SG', '%sSG' % CONST.OCEANDISPSHADER)\r\n\r\n\t\t\t\t\t## Lock translateY and rotation so that monkeys don't mess up with the ocean level\r\n\t\t\t\t\ttoLock = ['translateY', 'rotateX', 'rotateY', 'rotateZ']\r\n\t\t\t\t\tfor attr in toLock:\r\n\t\t\t\t\t\tcmds.setAttr('ocean_srf.%s' % attr, lock = True)\r\n\r\n\t\t\t\t\t## Hard set the render tesselation\r\n\t\t\t\t\tcmds.setAttr(\"ocean_srfShape.numberU\", 200)\r\n\t\t\t\t\tcmds.setAttr(\"ocean_srfShape.numberV\", 200)\r\n\r\n\t\t\t\t\tallOceans = cmds.ls(type= 'oceanShader')\r\n\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'allOceans: %s' % allOceans, verbose = False)\r\n\r\n\t\t\t\t\t## now put the ocean in the right position\r\n\t\t\t\t\tif cmds.objExists('fluids_hrc'):\r\n\t\t\t\t\t\tself._setOceanLocation()\r\n\t\t\t\t\telse:\r\n\t\t\t\t\t\tif cmds.objExists('ocean_srf') and cmds.objExists('oceanPreviewPlane_prv'):\r\n\t\t\t\t\t\t\tif not cmds.isConnected('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX'):\r\n\t\t\t\t\t\t\t\tcmds.connectAttr('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX', f = True)\r\n\t\t\t\t\t\t\tif not cmds.isConnected('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ'):\r\n\t\t\t\t\t\t\t\tcmds.connectAttr('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ', f = True)\r\n\t\t\t\t\t\telse:\r\n\t\t\t\t\t\t\tcmds.warning('MISSING ocean_srf or oceanPreviewPlane_prv node from scene...')\r\n\r\n\t\t\t\tfor each in getCacheFiles:\r\n\t\t\t\t\t## Now attach the preset to the maya ocean build a new one if it doesn't already exist\r\n\t\t\t\t\tif each.endswith('.mel'): ## the ocean shader preset saved out\r\n\t\t\t\t\t\tpathToPreset = '%s/%s' % (highestVersionFolder, each)\r\n# presetVersion = each.split('/')\r\n\r\n\t\t\t\t\t\t## Now apply the exported preset to each ocean in the scene. There really should only be ONE\r\n\t\t\t\t\t\tfor eachOcean in allOceans:\r\n\t\t\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Add version number for ocean preset on Ocean_Hrc', verbose = False)\r\n\t\t\t\t\t\t\tif cmds.objExists('FX_CACHES_hrc'):\r\n\t\t\t\t\t\t\t\tif not cmds.objExists('FX_CACHES_hrc.presetVersion'):\r\n\t\t\t\t\t\t\t\t\tcmds.addAttr('FX_CACHES_hrc', ln='presetVersion', dt='string')\r\n\t\t\t\t\t\t\t\t\tcmds.setAttr('FX_CACHES_hrc.presetVersion' , versionNumber, type='string')\r\n\t\t\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Applying ocean preset: %s to %s' % (pathToPreset, eachOcean), verbose = False)\r\n\t\t\t\t\t\t\tmel.eval( 'applyPresetToNode \"%s\" \"\" \"\" \"%s\" 1;' %(eachOcean, pathToPreset) )\r\n\t\t\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean and presets assigned successfully...', verbose = False)\r\n\r\n\t\t\t\t\t## Import ATOM\r\n\t\t\t\t\tif each.endswith('.atom'):\r\n\t\t\t\t\t\tpathToPreset = '%s/%s' % (highestVersionFolder, each)\r\n\t\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Transferring ocean shader\\'s animation from %s' % pathToPreset, verbose = False)\r\n\r\n\t\t\t\t\t\tmel.eval('performImportAnim 1;')\r\n\t\t\t\t\t\tcmds.select(allOceans, replace = True)\r\n\r\n\t\t\t\t\t\tcmds.file(pathToPreset,\r\n\t\t\t\t\t\ttype = 'atomImport',\r\n\t\t\t\t\t\ti = True,\r\n\t\t\t\t\t\tra = True,\r\n\t\t\t\t\t\tnamespace = 'oceanDisp_shader',\r\n\t\t\t\t\t\toptions = '; ; targetTime = 3; option = insert; match = hierarchy; selected = selectedOnly; search = ; replace = ; prefix = ; suffix = ; mapFile = ;',\r\n\t\t\t\t\t\t)\r\n\r\n\t\t\t\t\t\tif cmds.window('OptionBoxWindow', exists = True):\r\n\t\t\t\t\t\t\tcmds.deleteUI('OptionBoxWindow', window = True)\r\n\r\n\t\t\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean shader\\'s animation transferred successfully.', verbose = False)\r\n\r\n\t\t\t\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean imported successfully...', verbose = False)","def convert_to_json(basepath, sendto):\n\n logger = logging.getLogger('WikiLog')\n\n k = bucket.new_key(basepath)\n\n filenames = []\n year = month = day = hrs = ''\n\n for key in bucket.list():\n thisfile = key.name.encode('utf-8')\n if 'projectviews' not in thisfile and 'sql' not in thisfile and '.gz' in thisfile and thisfile.startswith(basepath):\n # S3 key name is of the format kt-wiki/pageviews/2016/2016-06/pageviews-20160601-000000.gz\n # Split by / to get last element\n filenames.append(thisfile)\n logger.info(\"Processing file: {}\".format(thisfile))\n fname = thisfile.split('/')\n\n # Get content from filename and save to local\n # Split again to Grab year, month, day, hour value from filename\n key.get_contents_to_filename('/home/ubuntu/WikiView/data/' + fname[-1])\n fname1 = fname[-1]\n data_time = fname1[:-3].split('-')\n year, month, day, hrs = data_time[1][:4], data_time[1][4:6], data_time[1][-2:], data_time[-1]\n\n docname = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\n dictlist = []\n\n # save file from s3 to local, read, write to json, push json to s3\n with open(docname, 'w') as fp:\n #\n with gzip.open('/home/ubuntu/WikiView/data/'+fname[-1],'r') as fin:\n for line in fin:\n line = line.split(' ')\n doc = {}\n doc['ymdh'] = year + '-' + month + '-' + day + '-' + hrs\n try:\n # format: project, title, views, bytes ~ en Main_Page 242332 4737756101\n prj, title, vcount = line[0], line[1], line[2]\n doc['prj'] = prj\n doc['title'] = title\n doc['vcount'] = vcount\n json.dump(doc,fp)\n fp.write('\\n')\n except:\n logger.error('Error reading gzip file {} at line: {}'.format(thisfile, line))\n pass\n# sys.exc_clear()\n\n # Now, save the json file to \n key_name = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\n full_key_name = os.path.join(sendto, key_name)\n k = bucket.new_key(full_key_name)\n\n logger.info(\"Sending json file to S3: {}\".format(docname))\n k.set_contents_from_filename(key_name)\n\n # Remove temp file\n logger.info(\"Removing temp file: {} {}\".format('/home/ubuntu/WikiView/data/', fname[-1]))\n os.remove('/home/ubuntu/WikiView/data/'+fname[-1])\n logger.info(\"Removing temp file: {}\".format(key_name))\n os.remove(key_name)\n logger.info('Finished!!!')","def test_create_json(civic, diff):\n test_date = '19980108'\n civic._create_json(diff, test_date)\n file_name = APP_ROOT / 'data' / 'civic' / 'delta' / f'civic_deltas' \\\n f'_{test_date}.json'\n assert file_name.exists()\n os.remove(file_name)\n assert not file_name.exists()","def importFile(self):\n\n ## Backing up old CSV and JSON files before beginning import operations\n if os.path.isfile(\"text_files/customers.csv\") and os.path.isfile(\"text_files/customers.json\"):\n print(\"\\nCreating a backup of the existing customer .csv and .json files before overwriting\")\n shutil.copy2(\"text_files/customers.csv\", \"text_files/customers.csv.backup\" + str(time.time()))\n shutil.copy2(\"text_files/customers.json\", \"text_files/customers.json.backup\" + str(time.time()))\n\n ## Importing the text file for cleaning then converting to CSV\n input_file = open(\"text_files/customer_export.txt\", \"r\")\n output_file = open(\"text_files/customers.csv\", \"w\")\n\n ## A loop to clean and write the customer_export txt file to a CSV\n for line in input_file:\n clean_text = \"\"\n check_line = line.replace(\"#\", \"\").replace(\",,\",\"\").split(\"|\")\n for line in check_line:\n if line != check_line[10]:\n clean_text += line + \",\"\n elif line == check_line[10]:\n clean_text += line + \"\\n\"\n output_file.write(clean_text)\n\n ## Closing TXT file and CSV file after formatting\n input_file.close()\n output_file.close()\n\n ## Opening the cleaned CSV file for conversion to Json\n with open('text_files/customers.csv') as clean_csv:\n ## Converting CSV file to Json\n converted = csv.DictReader(clean_csv)\n rows = list(converted)\n\n ## Writing converted CSV to Json file\n with open('text_files/customers.json', 'w') as convert:\n json.dump(rows, convert)\n\n ## Deleting all data currently in database before importing new file\n db_connection.executeQuery(\"DELETE FROM CRM;DBCC CHECKIDENT ('CRM', RESEED, 0) DELETE FROM Mailings; DBCC CHECKIDENT ('Mailings', RESEED, 0) COMMIT\") \n\n ## Loading the newly created Json file\n with open(\"text_files/customers.json\") as customers_json:\n customers = json.load(customers_json)\n\n ## A loop to add the contents of the Json file to the database \n print(\"Writing imported file to database please wait...\")\n for key in customers:\n db_connection.executeQuery(\"INSERT INTO dbo.CRM (f_name, l_name, company, address, city, county, state, zip, primary_phone, secondary_phone, email_address) VALUES ('\" + key[\"first_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"last_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"company_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"address\"] + \"', '\" + key[\"city\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"county\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"state\"] + \"', '\" + str(key[\"zip\"]) + \"', '\" + key[\"phone1\"] + \"', '\" + key[\"phone2\"] + \"' , '\" + key[\"email\"] + \"'); COMMIT\")\n db_connection.executeQuery(\"INSERT INTO dbo.Mailings (name, company, address) VALUES ('\" + key[\"first_name\"].replace(\"\\'\", \"\\'\\'\") + \" \" + key[\"last_name\"].replace(\"\\'\", \"\\'\\'\") + \"', '\" + key[\"company_name\"].replace(\"\\'\", \"\\'\\'\") + \"','\" + key[\"address\"] + \" \" + key[\"city\"] + \" \" + key[\"county\"] + \" \" + key[\"state\"] + \" \" + str(key[\"zip\"]) + \"'); COMMIT\") \n\n print(\"\\nFinished writing to file. Returning to main menu...\")","def convert_schema(bco, filename, mapping_dict):\n for item in mapping_dict['to_swap']:\n value_list = mapping_dict['to_swap'][item]\n for i in range(0, len(value_list)):\n rename_dict_key_HELPER(bco, value_list[i]['index'],\n value_list[i]['value']) # Change key name\n\n for item in mapping_dict['to_delete']:\n value_list = mapping_dict['to_delete'][item]\n for i in range(0, len(value_list)):\n delete_key_HELPER(bco, value_list[i]['index'], value_list[i]['value']) # delete key\n\n for item in mapping_dict['to_add']:\n value_list = mapping_dict['to_add'][item]\n for i in range(0, len(value_list)):\n set_key_in_dict_HELPER(bco, value_list[i]['index'], value_list[i]['value']) # add key\n\n new_bco = bco\n try:\n new_bco['provenance_domain'][\n 'modified'] = datetime.now().isoformat() # change date to current\n\n temp_bco = dict(new_bco)\n del temp_bco['object_id'], temp_bco['etag'], temp_bco['spec_version']\n\n new_bco['spec_version'] = \"https://w3id.org/ieee/ieee-2791-schema/2791object.json\"\n new_bco[\"etag\"] = sha256(json.dumps(temp_bco).encode('utf-8')).hexdigest()\n except KeyError: # Vital field was missing, will be caught by final error checker\n pass\n file = open(filename, \"w\")\n json.dump(new_bco, file, indent=4)","def beautify_json(self) -> None:\n for letter in self.data:\n for category in self.data[letter]:\n self.data[letter][category] = str(self.data[letter][category.lower()])\n self.save()\n with open(dict_path, encoding='utf-8') as x:\n data = x.read()\n with open(dict_path, 'w', encoding='utf-8') as y:\n data2 = data.replace('\"[', '[').replace(']\"', ']').replace(\"'\", '\"')\n y.write(data2)","def repairZeptoData(self, zeptoData):\n # Check for duplicate slide records, for the same slide file.\n slidePaths = set([slide[\"Slide\"] for slide in zeptoData[\"Slides\"]])\n pathToSlideIds = {slidePath:[] for slidePath in slidePaths}\n for slide in zeptoData[\"Slides\"]:\n pathToSlideIds[slide[\"Slide\"]].append(slide[\"NumId\"])\n\n duplicateSlideIds = [(k, v) for (k, v) in pathToSlideIds.items() if len(v) != 1]\n with open(lisaConfig.dataFolderPath + \"debugDuplicateSlideIDs.json\", \"w\") as fp:\n json.dump(duplicateSlideIds, fp, indent=2)\n\n # Slides with \"enhaced\" style.\n slidesWithEnhaced = [slide[\"NumId\"] for slide in zeptoData[\"Slides\"] if slide[\"Style\"] == \"Enhaced\"]\n with open(lisaConfig.dataFolderPath + \"slidesWithEnhacedStyle.json\", \"w\") as fp:\n json.dump(slidesWithEnhaced, fp, indent=2)\n\n for slide in zeptoData[\"Slides\"]:\n # Style has Enhanced mis-spelled as Enhaced for some slides.\n if slide[\"Style\"] == \"Enhaced\":\n slide[\"Style\"] = \"Enhanced\"\n\n # Content has Limited which is mis-spelled as Light for some slides.\n if slide[\"Content\"] == \"Light\" or not slide[\"Content\"]:\n slide[\"Content\"] = \"Limited\"\n\n # Content has Medium which is mis-spelled as Moderate/Modeate for some slides.\n if slide[\"Content\"] == \"Moderate\" or slide[\"Content\"] == \"Modeate\":\n slide[\"Content\"] = \"Medium\"\n\n # Parts of tag data are corrupted. Fixing.\n slideTagLists = []\n for tag in slide[\"Tags\"]:\n tag = tag.strip().lower()\n if tag.count(\",\") >= 3:\n slideTagLists.append(tag.split(\",\"))\n elif tag.count(\" \") >= 3:\n slideTagLists.append(tag.split(\" \"))\n else:\n slideTagLists.append([tag])\n\n # Force unqiueness.\n slideTagsSet = set()\n for tagList in slideTagLists:\n for tag in tagList:\n if tag:\n slideTagsSet.add(tag)\n\n # Keep the list in canonical form.\n slide[\"Tags\"] = sorted([tag.strip() for tag in slideTagsSet])\n return zeptoData","def transformZeptoData(self, zeptoData):\n retval = {}\n # Make all the latest concepts compatible with SlideDB system.\n transformedConcepts = []\n conceptsDict = {}\n for latestConcept in zeptoData[\"Concepts\"]:\n transformedConcept = {}\n\n # ID at the server can be obtained from zeptoId attribute.\n # transformedSlide[\"parent\"] = self.baseURL + \"slidedb/constructs/\" + str(latestSlide[\"ConstructId\"]) + \"/\"\n # zeptoSlideForAtto[\"enabled\"] = slide[\"Enabled\"]\n transformedConcept[\"enabled\"] = True if latestConcept[\"Enabled\"] == \"Y\" else False\n transformedConcept[\"name\"] = latestConcept[\"Name\"].strip()\n transformedConcept[\"zeptoId\"] = latestConcept[\"NumId\"]\n\n conceptsDict[transformedConcept[\"zeptoId\"]] = transformedConcept\n transformedConcepts.append(transformedConcept)\n retval[\"Concepts\"] = transformedConcepts\n\n # Make all the latest subConcepts compatible with SlideDB system.\n transformedSubConcepts = []\n subConceptsDict = {}\n for latestSubConcept in zeptoData[\"SubConcepts\"]:\n transformedSubConcept = {}\n # ID at the server can be obtained from zeptoId attribute.\n transformedSubConcept[\"parent\"] = conceptsDict[int(latestSubConcept[\"Parent\"])]\n transformedSubConcept[\"enabled\"] = True if latestSubConcept[\"Enabled\"] == \"Y\" else False\n transformedSubConcept[\"name\"] = latestSubConcept[\"Name\"].strip()\n transformedSubConcept[\"zeptoId\"] = latestSubConcept[\"NumId\"]\n\n subConceptsDict[transformedSubConcept[\"zeptoId\"]] = transformedSubConcept\n transformedSubConcepts.append(transformedSubConcept)\n\n retval[\"SubConcepts\"] = transformedSubConcepts\n\n # Make all the latest subConcepts compatible with SlideDB system.\n transformedConstructs = []\n constructsDict = {}\n for latestConstruct in zeptoData[\"Constructs\"]:\n transformedConstruct = {}\n\n # ID at the server can be obtained from zeptoId attribute.\n transformedConstruct[\"parent\"] = subConceptsDict[int(latestConstruct[\"Parent\"])]\n transformedConstruct[\"enabled\"] = True if latestConstruct[\"Enabled\"] == \"Y\" else False\n transformedConstruct[\"name\"] = latestConstruct[\"Name\"].strip()\n transformedConstruct[\"zeptoId\"] = latestConstruct[\"NumId\"]\n\n constructsDict[transformedConstruct[\"zeptoId\"]] = transformedConstruct\n transformedConstructs.append(transformedConstruct)\n retval[\"Constructs\"] = transformedConstructs\n\n # Make all the latest slides compatible with SlideDB system.\n transformedSlides = []\n for latestSlide in zeptoData[\"Slides\"]:\n transformedSlide = AttrDict()\n\n # ID at the server can be obtained from zeptoId attribute.\n transformedSlide[\"parent\"] = constructsDict[int(latestSlide[\"Parent\"])]\n transformedSlide[\"tags\"] = latestSlide[\"Tags\"]\n\n # zeptoSlideForAtto[\"enabled\"] = slide[\"Enabled\"]\n transformedSlide[\"enabled\"] = True\n transformedSlide[\"pptFile\"] = urllib.parse.quote(latestSlide[\"Slide\"], \"/:\")\n transformedSlide[\"thumbnailFile\"] = urllib.parse.quote(latestSlide[\"Thumbnail\"], \"/:\")\n transformedSlide[\"hasIcon\"] = True if latestSlide[\"Icon\"].lower() == \"yes\" else False\n transformedSlide[\"hasImage\"] = True if latestSlide[\"Image\"].lower() == \"yes\" else False\n transformedSlide[\"layout\"] = latestSlide[\"Layout\"]\n transformedSlide[\"style\"] = latestSlide[\"Style\"]\n transformedSlide[\"content\"] = latestSlide[\"Content\"]\n transformedSlide[\"zeptoId\"] = latestSlide[\"NumId\"]\n transformedSlide[\"zeptoDownloads\"] = latestSlide[\"Downloads\"]\n transformedSlides.append(transformedSlide)\n retval[\"Slides\"] = transformedSlides\n\n return retval","def loadAndClean(jfile):\n with open(jfile) as json_file:\n data = json.load(json_file)[\"G15\"]\n newDict = {}\n # Print the type of data variable\n \n for entry in data:\n\n if \"version\" in data[entry] and data[entry][\"assessed_by\"] not in filterList:\n\n if data[entry][\"assessed_by\"] in dictTries:\n dictTries[data[entry][\"assessed_by\"]].append(data[entry])\n\n \n\n if len(dictTries[data[entry][\"assessed_by\"]]) == 2:\n ml = dictTries[data[entry][\"assessed_by\"]]\n #vou querer calcular o maior \n # comparisson = \"accuracy\"\n comparisson = \"target_w_penalty\"\n \n if ml[0][comparisson] <= ml[1][comparisson]:\n if ml[0][\"accuracy\"] > 90:\n printSingle(ml[0])\n newDict[entry] = ml[0]\n\n else:\n if ml[1][\"accuracy\"] > 90:\n printSingle(ml[1])\n newDict[entry] = ml[1]\n dictTries[data[entry][\"assessed_by\"]] = []\n\n else:\n dictTries[data[entry][\"assessed_by\"]] = [data[entry]]\n\n\n\n # dictTries[data[\"assessed_by\"]]\n\n # newDict[entry] = data[entry]\n # print(data[entry])\n # print()\n # printDict(newDict)\n return newDict","def autodel(): #i hate this code so much\n today, tasks = datetime.today(), []\n to_remove_indexes = []\n deleted_tasks = 0\n\n with open(todofile, 'r') as todo:\n tasks = todo.readlines()\n for i, task in enumerate(tasks):\n try:\n task = json.loads(task)\n except json.decoder.JSONDecodeError:\n return False, False\n if task['deadline'] == \"None\": #because i converted to string in adding\n continue\n dline = datetime.strptime(task['deadline'], \"%Y-%m-%d %H:%M:%S\")\n if dline < today and not task['no_del']:\n to_remove_indexes.append(i)\n deleted_tasks += 1\n\n for index in to_remove_indexes[::-1]:\n del tasks[index]\n \n with open(todofile, 'w') as todo:\n for task in tasks:\n todo.write(task)\n \n return deleted_tasks, True","def test_rotate_filenames():\n tmpdir = os.path.join(tempfile.gettempdir(), \"jade-test-tmp87alkj8ew\")\n os.makedirs(tmpdir, exist_ok=True)\n\n data = {\"A\": 1, \"B\": 2}\n json_file1 = os.path.join(tmpdir, \"a1.json\")\n dump_data(data, json_file1)\n\n json_file2 = os.path.join(tmpdir, \"a2.json\")\n dump_data(data, json_file2)\n\n rotate_filenames(tmpdir, \".json\")\n\n if os.path.exists(tmpdir):\n shutil.rmtree(tmpdir)","def _dumpJson(self, data, file):\n name, ext = os.path.splitext(file)\n tempFile = \"{0}.tmp\".format(name)\n with open(tempFile, \"w\") as f:\n json.dump(data, f, indent=4)\n shutil.copyfile(tempFile, file)\n os.remove(tempFile)","def remove_conversion(tmp_path):\n import masci_tools\n\n #We need to use the __file__ attribute, since we do not know, whether the package was installed with -e\n package_root = Path(masci_tools.__file__).parent.resolve()\n conversion_folder = package_root / Path('tools/conversions')\n\n shutil.move(os.fspath(conversion_folder / 'conversion_031_to_034.json'), os.fspath(tmp_path))\n\n try:\n yield conversion_folder / 'conversion_031_to_034.json'\n finally:\n #Move the conversion back\n shutil.copy(os.fspath(tmp_path / 'conversion_031_to_034.json'), os.fspath(conversion_folder))","def main():\n parser = ArgumentParser(\n description='Category Filter: Filter a List of Categories from a JSON')\n parser.add_argument('json_file_path', help='JSON file path')\n parser.add_argument('out_file', help='Output filename')\n args = parser.parse_args()\n\n ann_file = open(args.json_file_path)\n category_names = [\"sports ball\", \"cell phone\", \"couch\", \"elephant\", \"tie\", \"spoon\", \"skis\", \"apple\", \"giraffe\", \"laptop\", \"tennis racket\", \"sink\", \"dog\", \"fork\", \"cat\", \"teddy bear\", \"train\", \"skateboard\", \"toilet\", \"sandwich\", \"bed\", \"keyboard\", \"baseball glove\", \"baseball bat\", \"airplane\", \"oven\", \"hot dog\", \"refrigerator\", \"frisbee\", \"mouse\", \"fire hydrant\", \"stop sign\", \"bear\", \"snowboard\", \"parking meter\", \"toothbrush\", \"microwave\", \"scissors\", \"hair drier\", \"toaster\"]\n\n json_coco = json.load(ann_file)\n new_json = deepcopy(json_coco)\n\n for ann in json_coco['annotations']:\n if return_cat_name(json_coco, ann['category_id']) in category_names:\n new_json['annotations'].remove(ann)\n\n for cat in json_coco['categories']:\n if cat['name'] in category_names:\n new_json['categories'].remove(cat)\n\n output = open(args.out_file, \"w\")\n json.dump(new_json, output)\n output.close()","def helperCompare(stubName):\n\n # input and expected output file paths\n inputFile = os.path.join(FOLDER_PATH, \"examples/{}.txt\".format(stubName))\n outputFile = os.path.join(FOLDER_PATH, \"examples/expected_output/{}.json\".format(stubName))\n print(\"testing file: {}\".format(inputFile))\n\n # read expected output\n with open(outputFile) as f:\n expectedJson = json.load(f) # expected output\n\n # produce actual output\n bookList = ClippyKindle.parseClippings(inputFile) # list of Book objects\n outData = []\n for book in bookList:\n # book.sort(removeDups=False) # (sorting/removing duplicates)\n outData.append(book.toDict())\n # write output to file for reference\n with open(os.path.join(TMP_PATH, \"{}.json\".format(stubName)), 'w') as f:\n json.dump(outData, f, indent=2) # write indented json to file (for reference)\n\n assert(json.dumps(outData, sort_keys=True) == json.dumps(expectedJson, sort_keys=True))","def main(args):\r\n print(\"Anonymizing ...\")\r\n print(args)\r\n\r\n file_loc = args.file\r\n origdata = pd.read_csv(file_loc, sep=',', low_memory=False)\r\n\r\n print(origdata)\r\n\r\n print(args.col_customer)\r\n\r\n ID_field = args.col_customer #TBU CustomerID field name\r\n TS_field = args.col_time #TBU TS field name \r\n\r\n sub = origdata.loc[:,:] #Uncomment for applying on complete dataset\r\n\r\n def anonymizeID(data,ID_field):\r\n df=pd.DataFrame(data.loc[:,ID_field])\r\n df2=df.applymap(lambda x: ((HMAC.new(b\"key\", bytes(x), MD5)).hexdigest()))\r\n return df2.loc[:,ID_field]\r\n\r\n def shiftTimeForTrace(data,TS_field):\r\n # print(df.head())\r\n df=pd.DataFrame(data.loc[:,TS_field])\r\n df2 = df.loc[:,TS_field].apply(lambda x: pd.to_datetime(x)) \r\n # print(df2.head())\r\n rand_days = random.randint(-5,5) #range can be updated\r\n df2 = df2 + pd.DateOffset(days=rand_days)\r\n # print(df2.head())\r\n return df2\r\n\r\n #OG subset for reference\r\n print(sub.head())\r\n\r\n # sub1=sub.sort_values(by=ID_field)\r\n sub1 = sub.loc[:,:]\r\n uniqueIDs = list(sub[ID_field].unique())\r\n # sub2 = sub.loc[:,TS_field].apply(lambda x: pd.to_datetime(x))\r\n for ID in uniqueIDs:\r\n sub3=sub1.loc[sub1[ID_field] == ID]\r\n sub3.loc[:,TS_field]=shiftTimeForTrace(sub3,TS_field)\r\n # print(sub1.loc[sub1[ID_field] == ID][TS_field])\r\n # print(pd.DataFrame(sub3[TS_field]))\r\n sub1.loc[sub1[ID_field] == ID,TS_field] = pd.DataFrame(sub3[TS_field])\r\n\r\n # Results post TS shift\r\n print(sub1.head())\r\n\r\n sub4 = sub1.loc[:,:]\r\n sub4.loc[:,ID_field] = anonymizeID(sub4,ID_field)\r\n\r\n #Results post ID anonymization\r\n print(sub4.head())\r\n sub4.to_csv('out.csv',index=False)","def createMasks(inputFolderName=\"Masks_From_VolumeTracing\", outputFolderName=\"Masks_From_VolumeTracing_Lines_From_VolumeTracing\"):\n\n root, df = loader.dataModules()\n\n PATH_TO_RAW_FRAMES_PARENT_DIR = os.path.join(root, inputFolderName) # frames path\n PATH_TO_OUTPUT_DIR = os.path.join(root, outputFolderName) # frames path\n \n os.makedirs(PATH_TO_OUTPUT_DIR, exist_ok=True) # creates ground truth mask parent directory\n\n print(\"Drawing lines on each mask from VolumeTracings\")\n for i in tqdm(range(len(df))): # iterates through each row of data frame\n videoName = df.iloc[i, 0] # name of video\n frameNumber = df.iloc[i, 1] # timing for clip\n\n frameName = videoName + \".avi_\" + str(frameNumber) + \".png\" # concatenate video name with frame number as file name\n PATH_TO_RAW_FRAME = os.path.join(PATH_TO_RAW_FRAMES_PARENT_DIR, frameName)\n PATH_TO_OUTPUT_RAW_FRAME = os.path.join(PATH_TO_OUTPUT_DIR, frameName)\n\n image = cv2.imread(\"/Users/ishan/Downloads/Untraced.png\") # read in the image from the specified frame path\n if os.path.exists(PATH_TO_RAW_FRAME) and videoName == \"0X16A6CEDE7F61E211\" and int(frameNumber) == 131: # checks if frame exists\n x1 = list(literal_eval(df.iloc[i, 2])) # x1 coords\n y1 = list(literal_eval(df.iloc[i, 3])) # y1 coords\n x2 = list(literal_eval(df.iloc[i, 4])) # x2 coords\n y2 = list(literal_eval(df.iloc[i, 5])) # y2 coords\n\n for coord in range(len(x1)): # iterate through each coordinate\n if coord is 0: # gets the perpendicular/long line\n longLine1stCoords = (int(x1[coord]), int(y1[coord]))\n longLine2ndCoords = (int(x2[coord]), int(y2[coord]))\n else: # draws the parallel lines\n cv2.line(image, (int(x1[coord]), int(y1[coord])), (int(x2[coord]), int(y2[coord])), (255, 255, 255), 1)\n \n cv2.line(image, longLine1stCoords, longLine2ndCoords, (255, 255, 255), 1) # Drawing the perpendicular/long line in different color\n\n cv2.imwrite(\"/Users/ishan/Downloads/Traced.png\", image)","def remove_useless_file(rootPath):\n all_file_paddle_list = get_all_paddle_file(rootPath)\n ut_file_map_new = {}\n ut_file_map = \"%s/build/ut_file_map.json\" % rootPath\n with open(ut_file_map, 'r') as load_f:\n load_dict = json.load(load_f)\n for key in load_dict:\n if key in all_file_paddle_list:\n ut_file_map_new[key] = load_dict[key]\n\n with open(\"%s/build/ut_file_map.json\" % rootPath, \"w\") as f:\n json.dump(ut_file_map_new, f, indent=4)\n print(\"remove_useless_file ut_file_map success!!\")","def _prep_roidb_entry(self, entry):\n im_path = os.path.join(self.root, 'images', self.img_dir_name, entry['file_name'])\n assert os.path.exists(im_path), 'Image \\'{}\\' not found'.format(im_path)\n entry['image'] = im_path\n entry['flipped'] = False\n # empty placeholders\n entry['bboxes'] = np.empty((0, 4), dtype=np.float32)\n entry['gt_classes'] = np.empty((0), dtype=np.int32)\n # remove unwanted fields that come from the json file\n for k in ['date_captured', 'coco_url', 'license', 'url', 'file_name', 'flickr_url']:\n if k in entry:\n del entry[k]","def fix_image_dict(folder, image_dict):\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \"*.*\")\n for file_path in glob.glob(image_pattern):\n file_name = os.path.basename(file_path)\n if file_name not in image_dict:\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]","def repair_json(in_file, out_file, path_to_img):\n with open(in_file, 'rb') as f:\n data = f.readlines()\n\n # delete all \\n characters\n data = map(lambda x: x.rstrip(), data)\n\n # make one JSON object per row\n json_rows = []\n start = -1\n while True:\n try:\n start = data.index('{', start + 1)\n end = data.index('}', start)\n row = ''.join(data[start:end+1])\n row = re.sub(\"\\\"Bmp\\\"\", \"\\\"Image\\\"\", row)\n row = re.sub(\".bmp\", \".jpg\", row)\n json_rows.append(row)\n start = end\n except ValueError:\n break\n\n # join all JSON objects into one comme delimited string enclosed in square brackets\n data_join_str = \"[\" + ','.join(json_rows) + \"]\"\n\n # create JSON object\n repaired_json = json.loads(data_join_str)\n for x in repaired_json:\n f = os.path.join(path_to_img, x['Image'])\n print x['Image']\n if not os.path.isfile(f):\n repaired_json.remove(x)\n # remove out_file if it exists\n try:\n os.remove(out_file)\n except OSError:\n pass\n except IOError:\n pass\n print 'dumping...'\n with open(out_file, 'w+') as f:\n json.dump(repaired_json, f)"],"string":"[\n \"def process_files_json():\\n # chdir into beep root\\n pwd = os.getcwd()\\n os.chdir(os.environ.get(\\\"BEEP_ROOT\\\", \\\"/\\\"))\\n\\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DIR)))\\n all_list = list(filter(lambda x: '.csv' in x, os.listdir(SRC_DIR)))\\n\\n all_list = sorted(all_list)\\n dumpfn(all_list, \\\"all_files.json\\\")\\n\\n [file_id, mapdf] = init_map(PROJECT_NAME, DEST_DIR)\\n\\n new_file_index = file_id\\n\\n for filename in tqdm(sorted(file_list)):\\n # If the file has already been renamed another entry should not be made\\n if mapdf['filename'].str.contains(filename).sum() > 0:\\n continue\\n old_file = os.path.join(SRC_DIR, filename)\\n new_path = os.path.join(DEST_DIR, PROJECT_NAME)\\n shutil.copy(old_file, new_path) # copy main data file\\n shutil.copy(old_file.replace(\\\".csv\\\", '_Metadata.csv'), new_path) # copy meta data file\\n\\n if PROJECT_NAME == 'FastCharge':\\n [date, channel_no, strname, protocol] = get_parameters_fastcharge(filename, SRC_DIR)\\n elif PROJECT_NAME == 'ClosedLoopOED':\\n [date, channel_no, strname, protocol] = get_parameters_oed(filename, SRC_DIR)\\n else:\\n raise ValueError(\\\"Unsupported PROJECT_NAME: {}\\\".format(PROJECT_NAME))\\n\\n df_dup = mapdf.set_index(['protocol', 'date'])\\n if (protocol, date) in df_dup.index:\\n row = mapdf[(mapdf['protocol'] == protocol) & (mapdf['date'] == date)]\\n file_id = row['fid'].iloc[0]\\n protocol = row['protocol'].iloc[0]\\n date = row['date'].iloc[0]\\n strname = row['strname'].iloc[0]\\n else:\\n file_id = new_file_index\\n new_file_index = new_file_index + 1\\n\\n new_name = \\\"{}_{}_{}\\\".format(PROJECT_NAME, f'{file_id:06}', channel_no)\\n new_file = os.path.join(DEST_DIR, PROJECT_NAME, \\\"{}.csv\\\".format(new_name))\\n\\n new_row = pd.DataFrame([[file_id, protocol, channel_no, date, strname,\\n os.path.abspath(old_file),\\n os.path.abspath(new_file)]],\\n columns=METADATA_COLUMN_NAMES)\\n mapdf = mapdf.append(new_row)\\n\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename), new_file)\\n os.rename(os.path.join(DEST_DIR, PROJECT_NAME, filename).replace(\\\".csv\\\", \\\"_Metadata.csv\\\"),\\n new_file.replace(\\\".csv\\\", \\\"_Metadata.csv\\\"))\\n\\n mapdf.to_csv(os.path.join(DEST_DIR, PROJECT_NAME, PROJECT_NAME + \\\"map.csv\\\"), index=False)\\n mapdf = mapdf.reset_index(drop=True)\\n os.chdir(pwd)\\n return json.dumps(mapdf.to_dict(\\\"list\\\"))\",\n \"def fix_jsons_in(bids_dir: Path):\\n\\n print(\\\"Finalizing task json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"func/*_task-*.json\\\"):\\n append_to_json_file(key=\\\"TaskName\\\", value=task_name_of(path), path_to_json=path)\\n\\n print(\\\"Appending echo times to phase difference json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*_phasediff.json\\\"):\\n magnitude1_path = the_path_that_matches(pattern=\\\"sub-*_magnitude1.json\\\", in_directory=path.parent)\\n magnitude2_path = the_path_that_matches(pattern=\\\"sub-*_magnitude2.json\\\", in_directory=path.parent)\\n echo_time1 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude1_path)\\n echo_time2 = value_of_key_in_json_file(\\\"EchoTime\\\", magnitude2_path)\\n append_to_json_file(key=\\\"EchoTime1\\\", value=echo_time1, path_to_json=path)\\n append_to_json_file(key=\\\"EchoTime2\\\", value=echo_time2, path_to_json=path)\\n\\n print(\\\"Setting targets of fieldmap json files.\\\")\\n\\n for path in bids_dir.rglob(\\\"fmap/*.json\\\"):\\n func_dir = path.parent.parent / \\\"func\\\"\\n trimmed_func_paths = [\\\"func/\\\" + func_path.name for func_path in func_dir.glob(\\\"*.nii\\\")]\\n append_to_json_file(key=\\\"IntendedFor\\\", value=trimmed_func_paths, path_to_json=path)\",\n \"def clip_out_acp (in_dir, out_dir, base_out_name=\\\"ACP_data\\\"):\\n in_files = glob.glob(os.path.join(in_dir, \\\"*.tif\\\"))\\n # print(in_files)\\n for file_path in sorted(in_files): \\n print(file_path)\\n file = os.path.split(file_path)[1] \\n month, year = file[:-4].split('_')[-2:] \\n out_file = os.path.join(\\n out_dir, base_out_name + '_' + year + \\\"_\\\" + month + \\\".tif\\\"\\n ) \\n raster.clip_raster(file_path, out_file, ACP_EXTENT)\",\n \"def sanitize_json_files(unsanitized_json_file):\\n with open(develop_baseline_dir + unsanitized_json_file) as f:\\n lines = f.readlines()\\n\\n with open('sanitizedJson/sanitized_{}'.format(unsanitized_json_file), 'w') as w:\\n w.writelines([item for item in lines[:-1]])\",\n \"def fix_acquisition_numbers_of_json_files_in(raw_dir: Path):\\n\\n print(\\\"Fixing the acquisition numbers of the .json files in sourcedata.\\\")\\n\\n for old_path in raw_dir.rglob(\\\"*.json\\\"):\\n\\n parts_of_stem_of_old_path = old_path.stem.split(\\\"_\\\")\\n stem_parts_with_correct_acquisition_number = parts_of_stem_of_old_path[:-1] + [acquisition_number_of(old_path)]\\n fresh_new_stem = \\\"_\\\".join(stem_parts_with_correct_acquisition_number)\\n fresh_new_path = old_path.with_name(fresh_new_stem + old_path.suffix)\\n old_path.replace(fresh_new_path)\",\n \"def minify_json(self) -> None:\\n print(f\\\"[FileManager: INFO] Minifing file {self.path}\\\")\\n file_data = open(self.path, \\\"r\\\", encoding=\\\"utf-8\\\").read()\\n json_data = json.loads(file_data) \\n json_string = json.dumps(json_data, separators=(',', \\\":\\\")) \\n path = str(self.path).replace(\\\".json\\\", \\\"\\\")\\n new_path = \\\"{0}_min.json\\\".format(path)\\n open(new_path, \\\"w+\\\", encoding=\\\"utf-8\\\").write(json_string)\",\n \"def anonymize(data_dir):\\n\\n for root, dirs, files in os.walk(dst_data_dir, topdown=False):\\n for dir_name in sorted(dirs):\\n dir_path = os.path.join(root, dir_name)\\n json_path = os.path.join(root, dir_name, 'data.json')\\n print(json_path)\\n\\n with open(json_path) as f:\\n data = json.load(f)\\n\\n data.pop('user_email')\\n data.pop('user_name')\\n data.pop('survey_data')\\n\\n with open(json_path, 'w') as f:\\n json.dump(data, f)\",\n \"def reset_data():\\n shutil.copy2(\\n 'data/one_producer_many_consumers.ORIG.json',\\n 'data/one_producer_many_consumers.json'\\n )\",\n \"def create_dictionary_of_old_and_new_paths(raw_dir: Path, bids_dir: Path, exclude_fieldmaps: bool) -> dict:\\n\\n old_and_new_paths = {}\\n old_paths = list(raw_dir.rglob(\\\"*\\\"))\\n print(f\\\"Sorting {len(old_paths)} paths into a dictionary.\\\") \\n\\n def task_name_of(path_to_func_or_json):\\n \\\"\\\"\\\"\\n Returns the task name of a func or json file. This function OVERWRITES the function\\n \\\"task_name_of\\\" that we imported at the top of this script. BUT! It only overwrites it\\n HERE, in \\\"create_dictionary_of_old_and_new_paths\\\".\\n \\\"\\\"\\\"\\n\\n list_of_lines_containing_raw_subject_info = []\\n for path in old_paths:\\n if filetype_of(path) == \\\"subject info\\\":\\n list_of_lines_containing_raw_subject_info = path.read_text().splitlines()\\n break\\n\\n for line in list_of_lines_containing_raw_subject_info:\\n if path_to_func_or_json.stem in line:\\n return line.split(\\\"z\\\")[1]\\n\\n\\n for old_path in old_paths:\\n\\n new_path = old_path\\n\\n if filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"anat\\\" and acquisition_number_of(old_path) == \\\"14\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"anat\\\" / f\\\"sub-{subject_id_of(old_path)}_T1w{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"func\\\" and acquisition_number_of(old_path) != \\\"02\\\":\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"func\\\" / f\\\"sub-{subject_id_of(old_path)}_task-{task_name_of(old_path)}_acq-{acquisition_number_of(old_path)}_bold{old_path.suffix}\\\"\\n\\n elif filetype_of(old_path.with_suffix(\\\".nii\\\")) == \\\"fieldmap\\\" and not exclude_fieldmaps:\\n old_affix = old_path.stem.split(\\\"_\\\")[-1]\\n new_affix = \\\"phasediff\\\"\\n if old_affix == \\\"e1\\\":\\n new_affix = \\\"magnitude1\\\"\\n if old_affix == \\\"e2\\\":\\n new_affix = \\\"magnitude2\\\"\\n new_path = bids_dir / f\\\"sub-{subject_id_of(old_path)}\\\" / \\\"fmap\\\" / f\\\"sub-{subject_id_of(old_path)}_{new_affix}{old_path.suffix}\\\"\\n\\n old_and_new_paths[old_path] = new_path\\n\\n print(\\\"Paths sorted.\\\")\\n\\n return old_and_new_paths\",\n \"def backeruper(file_name, file_num=0):\\n\\n if not os.path.exists('%s.json' % file_name):\\n write_backup('%s.json' % file_name)\\n elif not os.path.exists('%s.%s.json' % (file_name, file_num)):\\n write_backup('%s.%s.json' % (file_name, file_num))\\n else:\\n file_num += 1\\n backeruper(file_name, file_num)\",\n \"def fix_file_dates(source_file_name, dest_file_name):\\n shutil.copystat(source_file_name, dest_file_name)\\n print(\\\"Fixed dates for \\\" + dest_file_name)\",\n \"def add_date(jsonfile, outputfile):\\n print(\\\"Add Date\\\")\\n start_time = time.time()\\n\\n with open(jsonfile, 'r') as f:\\n json_str = json.load(f)\\n\\n for i in range(len(json_str)):\\n day = str(json_str[i][\\\"Day\\\"])\\n day_str = day[:4] + \\\"-\\\" + day[4:6] + \\\"-\\\" + day[6:8]\\n\\n json_str[i][\\\"Day\\\"] = day_str\\n\\n with open(outputfile, \\\"w\\\") as jsonFile:\\n json.dump(json_str, jsonFile)\\n\\n elapsed_time = time.time() - start_time\\n print(\\\" | Elapsed time : \\\", elapsed_time)\",\n \"def fix_path(self):\\n paths = self.data['path'].tolist()\\n prefixes = [re.findall(r'[A-Z\\\\-0-9]+', path) for path in paths]\\n prefix_good = [str(prefix[0]) + \\\".json\\\" for prefix in prefixes]\\n self.data['path'] = prefix_good\",\n \"def replace_gen(self):\\r\\n current_path = os.path.join(self.settings.save_path, 'current.json')\\r\\n current_folder_path = os.path.join(self.settings.save_path, 'current')\\r\\n history_path = os.path.join(self.settings.save_path, 'history')\\r\\n archive_folder_path = os.path.join(history_path, f'gen{self.generation}')\\r\\n archive_path = os.path.join(archive_folder_path, 'current') # no ending allowed\\r\\n archive_json_path = os.path.join(archive_folder_path, 'current.json')\\r\\n\\r\\n\\r\\n if not os.path.exists(current_path):\\r\\n raise FileNotFoundError\\r\\n if not os.path.exists(current_folder_path):\\r\\n raise FileNotFoundError\\r\\n\\r\\n os.makedirs(history_path, exist_ok=True)\\r\\n os.makedirs(archive_folder_path)\\r\\n\\r\\n cwd = os.getcwd()\\r\\n shutil.make_archive(archive_path, 'zip', current_folder_path)\\r\\n os.chdir(cwd)\\r\\n shutil.rmtree(current_folder_path, onerror=_ignore_del_dir_failure)\\r\\n os.chdir(cwd)\\r\\n\\r\\n os.rename(current_path, archive_json_path)\",\n \"def filter_json_file(filename, filters_list):\\n filename = filename.replace(\\\" \\\", \\\"\\\")\\n print(\\\"Filters List {}\\\".format(filters_list))\\n if isinstance(filters_list, list) is False:\\n filters_list = [filters_list]\\n with open(robot_dir + \\\"/output/original/{}_orig.json\\\".format(filename), \\\"r\\\") as file_orig:\\n # Get the root Json Object\\n json_root_object = json.load(file_orig)\\n\\n if \\\"commitId\\\" in json_root_object:\\n del json_root_object[\\\"commitId\\\"]\\n\\n # Store the original json object\\n orig_json_object = json.dumps(json_root_object)\\n root_key = json_root_object.keys()[0]\\n\\n if root_key == \\\"message\\\" and len(json_root_object.keys()) > 1:\\n root_key = json_root_object.keys()[1]\\n\\n # Get the array of objects under the root\\n try:\\n if len(filters_list) > 0:\\n json_root_object = delete_keys_from_dict(json_root_object, filters_list)\\n except:\\n print('Failed to delete keys from json_root_object before iteration')\\n\\n if root_key in ROOT_RETURN_ELEMENTS:\\n json_array = json_root_object[root_key]\\n\\n if isinstance(json_array, list):\\n # Clear the original array\\n json_root_object[root_key] = []\\n\\n # For each object remove any of the keys that are specified in the filter list then put the object back into\\n # the array\\n for json_object in json_array:\\n if len(filters_list) > 0:\\n json_object = delete_keys_from_dict(json_object, filters_list)\\n json_root_object[root_key].append(json_object)\\n # json_root_object = sorted(json_root_object)\\n elif isinstance(json_array, str):\\n json_root_object = json_array\\n\\n # Serialize the JSON object before writing it to the file\\n json_object = json.dumps(json_root_object, sort_keys=True, indent=4, separators=(',', ': '))\\n # Write to result .json file:\\n filtered_filename = robot_dir + \\\"/output/results/{}.json\\\".format(filename)\\n filtered_file = open(filtered_filename, \\\"w\\\")\\n # print(json_object)\\n filtered_file.writelines(json_object)\\n filtered_file.close()\\n\\n # return filtered_output, orig_output\\n return json_object, orig_json_object\",\n \"def regenerate_json_file():\\n \\n # filepaths used in generating json data...\\n dir_export = f\\\"C:\\\\\\\\Users\\\\\\\\{os.getlogin()}\\\\\\\\Downloads\\\"\\n list_name = 'my-favourite-films.csv'\\n json_output_filename = 'reviews_web_data.json'\\n path_to_rootreducer = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\reducers\\\\\\\\RootReducer.js';\\n path_to_json_output = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\components\\\\\\\\films\\\\\\\\{json_output_filename}'\\n \\n # 1) find letterboxd zip export...\\n prefix = 'letterboxd'\\n postfix = 'utc.zip'\\n zip_file_name = \\\"\\\"\\n download_folder = sorted(glob.glob(f\\\"{dir_export}/*.zip\\\"), key=os.path.getmtime)\\n download_folder.reverse() # reversing the list means most recent downloads are first in the list...\\n for filepath in download_folder:\\n filename = filepath.split('\\\\\\\\')[-1]\\n if filename.split('-')[0] == prefix and filename.split('-')[-1] == postfix:\\n zip_file_name = filename\\n print(f\\\"Found the zip export! -> {zip_file_name}\\\")\\n break\\n else:\\n continue\\n\\n path_to_zip_file = f\\\"{dir_export}\\\\\\\\{zip_file_name}\\\" # path to zip file we downlodaded from letterboxd...\\n path_to_extracted_zip = f\\\"{dir_export}\\\\\\\\{zip_file_name[:-4]}\\\" # path to extracted zip (which we are about to do)...\\n\\n # 2) extract zip automatically (if not done already)...\\n if os.path.exists(path=path_to_zip_file):\\n if not os.path.exists(path=path_to_extracted_zip):\\n with zipfile.ZipFile(file=path_to_zip_file , mode='r') as z:\\n z.extractall(path_to_extracted_zip)\\n print(f\\\"Extract complete! -> {path_to_extracted_zip}\\\")\\n else:\\n print(f'Zip file already exists... No need to extract again... -> ({path_to_extracted_zip})')\\n else:\\n print(f'Zip file could not be found... -> ({path_to_zip_file})')\\n\\n\\n # local version of letterboxd data list\\n letterboxd_list = []\\n \\n # 3) locate the csv file of interest\\n if os.path.exists(path_to_extracted_zip): \\n # open csv file...\\n path_to_list = f'{path_to_extracted_zip}\\\\\\\\lists\\\\\\\\{list_name}'\\n with open(path_to_list, 'r') as f:\\n # csv reader object\\n csv_reader = csv.reader(f)\\n \\n # skip header in the csv file...\\n rows_to_skip = 5\\n for i in range(0, rows_to_skip):\\n next(csv_reader)\\n \\n # 4) iterate over each row (i.e. each film) in csv file...\\n for csv_row in csv_reader:\\n pos = csv_row[0]\\n title = csv_row[1]\\n year = csv_row[2]\\n letterboxd_url = csv_row[3]\\n letterboxd_film_id = letterboxd_url.split('/')[-1]\\n genres = []\\n directors = []\\n duration = 0\\n language = \\\"\\\"\\n imdb_url = \\\"\\\"\\n imdb_avg_rating = \\\"\\\"\\n imdb_num_votes = \\\"\\\"\\n tmdb_url = \\\"\\\"\\n poster_url = \\\"\\\"\\n \\n # parse data from letterboxd web page... (this takes ~1.21s)\\n page = session.get(url=letterboxd_url, verify=False, stream=True)\\n soup = BeautifulSoup(page.content, 'html.parser')\\n \\n # retrieve list of genres...\\n div_genres = soup.select_one('#tab-genres')\\n for link in div_genres.select('div.text-sluglist a.text-slug[href]'):\\n if 'genre' in link['href']:\\n genre = link.text.capitalize()\\n if genre == 'Science-fiction':\\n genre = 'Sci-fi'\\n genres.append(genre)\\n\\n # retrieve duration\\n textfooter = soup.select_one('section.col-main > p.text-footer').text\\n if 'mins' in textfooter:\\n minstext = textfooter.find('mins', 0, len(textfooter))\\n duration = textfooter[minstext-5:minstext].strip()\\n \\n # retrieve the first spoken language\\n div_details = soup.select_one('#tab-details')\\n for link in div_details.select('div.text-sluglist a.text-slug[href]'):\\n if 'language' in link['href']:\\n language = link.text.capitalize()\\n break\\n \\n # retrieve IMDB url\\n footer = soup.select_one('section.col-main p.text-footer')\\n url_buttons = footer.select('a.micro-button')\\n for url in url_buttons:\\n if 'imdb' in url.text.lower():\\n # get IMDB URL\\n imdb_url = url['href']\\n elif 'tmdb' in url.text.lower():\\n # get TMDB URL\\n tmdb_url = url['href']\\n if len(url_buttons) == 1:\\n # if there's only 1 url_button, it's usually the IMDB link that's missing...\\n if soup.select_one('#featured-film-header > h1').text == 'xxxHOLiC':\\n imdb_url = 'https://www.imdb.com/title/tt16233104/'\\n\\n # retrieve avg rating on letterboxd\\n # page_content_str = page.content.decode('utf-8')\\n # letterboxd_avg_rating = soup.select_one('.average-rating')\\n\\n # Use the OMDB API (https://www.omdbapi.com/) to retrieve some additional data from IMDB website...\\n omdb_api_key = '4af56bed' # apparently this expires after 1000 days (today is 07/02/2023, 1000 days from now is 03/11/2025... holy shit!)\\n imdb_film_id = imdb_url.split('/')[-2]\\n url = f'http://www.omdbapi.com/?i={imdb_film_id}&apikey={omdb_api_key}'\\n imdb = requests.get(url=url, verify=False)\\n imdb_json = json.loads(imdb.text)\\n\\n # retrieve avg IMD rating\\n imdb_avg_rating = imdb_json['imdbRating']\\n \\n # retrieve number of votes on IMDB (we remove the comma, because react is fucking stupid and cant sort numbers when they contain commas)\\n imdb_num_votes = imdb_json['imdbVotes'].replace(',', '')\\n \\n # retrieve poster from IMDB\\n poster_url = imdb_json['Poster']\\n if 'SX300' in poster_url:\\n poster_url = poster_url.split('SX300')[0]\\n \\n # retrieve title from IMDB (because letterboxd parsing is shite!)\\n # title = imdb_json['Title']\\n \\n # retrieve list of directors (because letterboxd parsing is shite!)\\n directors = imdb_json['Director'].split(', ')\\n \\n # id of my review!\\n titlev2 = Helpers.simplify_movie_title(title=title)\\n review_id = f\\\"{titlev2}-{letterboxd_film_id}-review\\\"\\n \\n \\\"\\\"\\\"\\n # iterate over \\\\\\\\img\\\\\\\\films\\\\\\\\\\n screenshots = []\\n directory_in_str = f'D:\\\\\\\\Programming-Projects\\\\\\\\nathansteele\\\\\\\\src\\\\\\\\img\\\\\\\\films';\\n for subdir, dirs, files in os.walk(directory_in_str):\\n for file in files:\\n # find the right directory...\\n title_from_directory_storing_screenshots = subdir.split('\\\\\\\\')[-1]\\n titlev3 = Helpers.simplify_movie_title(title=title_from_directory_storing_screenshots)\\n if titlev3 == titlev2:\\n # get my screenshots...\\n if 'screenshot' in file:\\n screenshot = os.path.join(subdir, file)\\n screenshots.append(screenshot)\\n \\n # use my custom poster if I put one there...\\n if 'custom_poster' in file:\\n poster_url = os.path.join(subdir, file)\\n \\\"\\\"\\\"\\n \\n # DEBUGGING....\\n print(f\\\" > {pos}: {title}\\\")\\n #print(f' > Title = ({title})')\\n #print(f' > IMDB url = ({imdb_url})')\\n #print(f' > Language = ({language})')\\n #print(f' > Duration = ({duration})')\\n #print(f' > Genres = ({genres})')\\n #print(f' > IMDB avg rating = ({imdb_avg_rating})')\\n #print(f' > IMDB num votes = ({imdb_num_votes})')\\n #print(f' > Poster = ({poster_url})')\\n #print(f' > Directors = ({directors})')\\n #print(f' > Tags = ({my_tags})')\\n \\n # append to list...\\n letterboxd_list.append({\\n 'letterboxdFilmId': letterboxd_film_id,\\n 'imdbFilmId': imdb_film_id,\\n 'letterboxdUrl': letterboxd_url,\\n 'imdbUrl': imdb_url,\\n 'posterUrl': poster_url,\\n 'position': pos,\\n 'title': title,\\n 'year': year,\\n 'duration': duration,\\n 'language': language,\\n 'imdbAvgRating': imdb_avg_rating,\\n 'imdbNumVotes': imdb_num_votes,\\n 'tmdbUrl': tmdb_url,\\n 'directors': directors,\\n 'genres': genres,\\n 'reviewId': review_id\\n })\\n \\n # clear json file first...\\n open(path_to_json_output, 'w').close()\\n \\n # write new content...\\n with open(path_to_json_output, 'w') as f:\\n json.dump(letterboxd_list, f, indent=4)\\n \\n print(f'JSON export finished! -> {path_to_json_output}')\",\n \"def _post_recording_scrub(self):\\n src_path = self.cassette_path\\n rg_name = getattr(self, 'resource_group', None)\\n rg_original = getattr(self, 'resource_group_original', None)\\n\\n t = tempfile.NamedTemporaryFile('r+')\\n with open(src_path, 'r') as f:\\n for line in f:\\n # scrub resource group names\\n if rg_name != rg_original:\\n line = line.replace(rg_name, rg_original)\\n # omit bearer tokens\\n if 'authorization:' not in line.lower():\\n t.write(line)\\n t.seek(0)\\n with open(src_path, 'w') as f:\\n for line in t:\\n f.write(line)\\n t.close()\",\n \"def rebase_add_encoding_prefix():\\n\\tfilenames, clippings = load_clippings(inFolder)\\n\\tfor file, clip in zip(filenames, clippings):\\n\\t\\timg = clip[\\\"imgEncoding\\\"]\\n\\t\\tstr = \\\"data:image/png;base64,\\\"\\n\\t\\tif str not in img:\\n\\t\\t\\tclip[\\\"imgEncoding\\\"] = str + img\\n\\t\\t\\twith open(file, \\\"w\\\") as outfile:\\n\\t\\t\\t\\tjson.dump(clip, outfile)\",\n \"def _clean_up_composite_json(composite_json: dict) -> dict:\\n objects = composite_json.get(\\\"objects\\\", {})\\n objects = _fix_modified_dates(objects)\\n objects = CleanUpCompositeJson._fix_parent_child_relationships(objects)\\n composite_json[\\\"objects\\\"] = objects\\n return composite_json\",\n \"def json_to_cache(new_json: Dict, file_name: str) -> None:\\n\\n json_path = os.path.join(CACHE_DIR, file_name)\\n ensure_dir(json_path)\\n with open(json_path, \\\"w\\\") as outfile:\\n json.dump(new_json, outfile, ensure_ascii=False)\",\n \"def fixit(file):\\n with open(file, \\\"r\\\") as f:\\n config = json.load(f)\\n if \\\"job_status\\\" in config[\\\"supply-curve-aggregation\\\"]:\\n del config[\\\"supply-curve-aggregation\\\"][\\\"job_status\\\"]\\n if \\\"rep-profiles\\\" in config:\\n del config[\\\"rep-profiles\\\"]\\n fname = os.path.basename(file)\\n cname = \\\"_\\\".join(fname.split(\\\"_\\\")[:-1]) + \\\"_agg\\\"\\n config[\\\"supply-curve-aggregation\\\"][cname][\\\"job_status\\\"] = \\\"successful\\\"\\n\\n with open(file, \\\"w\\\") as f:\\n f.write(json.dumps(config, indent=4))\",\n \"def clip(self):\\n \\n subprocess.call(['gdaltindex', self.extent, self.referenceImagePath])\\n dataNames = sorted(glob.glob(self.fullPath + '/full*.tif'))\\n splitAt = len(self.fullPath) + 1\\n\\n for i in range(len(dataNames)):\\n x = dataNames[i]\\n y = dataNames[i][:splitAt] + dataNames[i][splitAt+4:]\\n subprocess.call(['gdalwarp', '-r', 'near', '-cutline', self.extent, '-crop_to_cutline', x, y, '-dstnodata', '9999'])\\n \\n for n in dataNames:\\n os.remove(n)\\n dataNames = sorted(glob.glob(self.fullPath + '/*.tif'))\\n test = gdal.Open(dataNames[0]).ReadAsArray()\\n logger.log('SUCCESS', 'Clipping complete! %d %s files were successfully clipped to the size of %s with dimensions %d rows by %d columns' % (len(dataNames), str(self.outformat), str(self.referenceImagePath), test.shape[0], test.shape[1]))\",\n \"def rename(source_dir,dest_dir):\\n keep_going(text=\\\"This script will backup the original folder to dest_dir/Source/** and remove the original folder. It will make copies of the original files and rename them in directories called Darks, Flats, etc. Do you wish to continue? Answer Y or N.\\\")\\n\\n ## Backup Original Source Folder\\n dir_util.copy_tree(source_dir, dest_dir + '/Source')\\n\\n data = []\\n for file in os.listdir(\\\"./\\\" + source_dir): # put in your path directory\\n if file.endswith(\\\".fits\\\"): # what does the file end with?\\n data.append(os.path.join(source_dir, file))\\n\\n n = len(data)\\n obj, itime, filt, renamed, datemod, count, flatmod, mod = ([] for i in range(8))\\n for i in range(0, n):\\n header = fits.getheader(data[i])\\n Name, Date, Number, Ext = data[i].split(\\\".\\\")\\n obj.append(header['OBJECT'])\\n itime.append(header['ITIME'])\\n filt.append(header['FWINAME'])\\n mod.append((header['OBJECT'] + header['FWINAME']))\\n flatmod.append((header['OBJECT'] + header['FWINAME'] + Date))\\n datemod.append(datetime.strptime(Date, \\\"%Y%m%d\\\").date())\\n if flatmod[i] in flatmod:\\n count = flatmod.count(flatmod[i])\\n if ('Lamp' in obj[i] or 'Flat' in obj[i]):\\n renamed.append((dest_dir + '/Flats/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Flats/' + str(datemod[i]) + '/'), exist_ok=True)\\n elif ('Dark' in obj[i]) or ('dark' in obj[i]):\\n renamed.append((dest_dir + '/Darks/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + str(count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Darks/' + str(datemod[i]) + '/'), exist_ok=True)\\n elif ('Sky' in obj[i]) or ('sky' in obj[i]):\\n renamed.append((dest_dir + '/Skys/' + str(datemod[i]) + '/' + 'K' + header['OBJECT'] + header['FWINAME'] + str(\\n count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Skys/' + str(datemod[i]) + '/'), exist_ok=True)\\n else:\\n renamed.append((dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/' + 'K' + list(header['CAMNAME'])[0].title() + header['OBJECT'].upper() +\\n header['FWINAME'] + str(\\n count) + \\\".fits\\\"))\\n os.makedirs(os.path.dirname(dest_dir + '/Objects/' + header['OBJECT'].upper() + '/' + str(datemod[i]) + '/'), exist_ok=True)\\n os.rename(data[i], renamed[i])\\n\\n ## REMOVE LEFT OVER original Folders\\n shutil.rmtree(source_dir)\\n\\n lists = [data, mod, datemod, itime, flatmod, renamed]\\n data_headers = pd.concat([pd.Series(x) for x in lists], axis=1)\\n\\n return data_headers\",\n \"def genOwnershipVoucherJsonFile( ownershipVoucher, voucherFileJson ):\\n template = { \\\"created-on\\\": str,\\n \\\"expires-on\\\": str,\\n \\\"assertion\\\": str,\\n \\\"serial-number\\\": str,\\n \\\"pinned-domain-cert\\\": str,\\n \\\"domain-cert-revocation-checks\\\": bool,\\n \\\"last-renewal-date\\\": str\\n }\\n\\n def validDateTime( dateTime ):\\n \\\"\\\"\\\"Verify a dateTime string conforms to RFC3339 format (only Z TZ accepted)\\\"\\\"\\\"\\n try:\\n datetime.strptime( dateTime, \\\"%Y-%m-%dT%H:%M:%S.%fZ\\\" )\\n return True\\n except ValueError:\\n return False\\n\\n mandatory = [ \\\"created-on\\\", \\\"assertion\\\", \\\"serial-number\\\", \\\"pinned-domain-cert\\\" ]\\n # verify ownership-coucher dict is correctly constructed\\n assert isinstance( ownershipVoucher, dict ), \\\"Expected dict\\\"\\n assert set( ownershipVoucher.keys() ).issubset( template.keys() ), \\\\\\n \\\"Unexpected keys in dict\\\"\\n assert verifyDictTypes( template, ownershipVoucher ), \\\\\\n \\\"Unexpected value types\\\"\\n assert set( mandatory ).issubset( ownershipVoucher ), \\\\\\n \\\"Mandatory keys not present\\\"\\n assert ownershipVoucher[ \\\"assertion\\\" ] == \\\"verified\\\", \\\\\\n \\\"Unsupported assertion value\\\"\\n assert validDateTime( ownershipVoucher.get( \\\"created-on\\\" ) ) and \\\\\\n validDateTime( ownershipVoucher.get( \\\"expires-on\\\", \\\"\\\" ) ) and \\\\\\n validDateTime( ownershipVoucher.get( \\\"last-renewal-date\\\", \\\"\\\" ) ), \\\\\\n \\\"Invalid datetime value\\\"\\n\\n ietfVoucher = { \\\"ietf-voucher:voucher\\\": ownershipVoucher }\\n jsonOwnershipVoucher = json.dumps( ietfVoucher, indent=4 )\\n\\n # save to file\\n with open( voucherFileJson, \\\"w\\\" ) as tmpFile:\\n tmpFile.write( jsonOwnershipVoucher )\",\n \"def convertFiles():\\n\\n #### Get file lists\\n tmp = os.path.join(remarkableBackupDirectory,remContent)\\n files = [x for x in os.listdir(tmp) if \\\".\\\" not in x]\\n\\n for i in range(0, len(files)):\\n # get file reference number\\n refNrPath = os.path.join(remarkableBackupDirectory, remContent,\\n files[i])\\n # get meta Data\\n meta = json.loads(open(refNrPath + \\\".metadata\\\").read())\\n fname = meta[\\\"visibleName\\\"]\\n fname = fname.replace(\\\" \\\", \\\"_\\\")\\n # Does this lines file have an associated pdf?\\n AnnotPDF = os.path.isfile(refNrPath + \\\".pdf\\\")\\n # Get list of all rm files i.e. all pages\\n npages = len(glob.glob(refNrPath + \\\"/*.rm\\\"))\\n if npages != 0:\\n if AnnotPDF:\\n # we have found an annotated pdf\\n # now make sure it has the right ending\\n if meta[\\\"visibleName\\\"][-4:] != \\\".pdf\\\":\\n syncFilePath = os.path.join(syncDirectory, \\\"*\\\",\\n meta[\\\"visibleName\\\"] + \\\".pdf\\\")\\n else:\\n syncFilePath = os.path.join(syncDirectory, \\\"*\\\",\\n meta[\\\"visibleName\\\"])\\n\\n # does the file exist in our system?\\n inSyncFolder = glob.glob(syncFilePath) != []\\n\\n if inSyncFolder:\\n # have we exported this thing before?\\n local_annotExist = \\\\\\n glob.glob(syncFilePath[:-4] + \\\"_annot.pdf\\\") != []\\n # first, assume, it needs converting\\n remoteChanged = True\\n if local_annotExist:\\n # if it already exists check when it was last updated\\n local_annotPath = \\\\\\n glob.glob(syncFilePath[:-4]+\\\"_annot.pdf\\\")[0]\\n local_annot_mod_time = os.path.getmtime(local_annotPath)\\n # rm time is in ms\\n remote_annot_mod_time = int(meta[\\\"lastModified\\\"])/1000\\n # has this version changed since we last exported it?\\n remoteChanged = \\\\\\n remote_annot_mod_time > local_annot_mod_time\\n # update if the remote version has changed\\n if remoteChanged:\\n origPDF = glob.glob(syncFilePath)[0]\\n #####\\n convertAnnotatedPDF(fname, refNrPath, origPDF)\\n #####\\n else:\\n print(fname + \\\"hasn't been modified\\\")\\n else:\\n print(fname + \\\" does not exist in the sync directory\\\")\\n # TODO allow y/n input whether it should be copied there\\n # anyway\\n else:\\n # we found a note\\n print(\\\"exporting Notebook \\\" + fname)\\n syncFilePath = os.path.join(syncDirectory, notesDirectory,\\n fname + \\\".pdf\\\")\\n inSyncFolder = glob.glob(syncFilePath) != []\\n remoteChanged = True\\n if inSyncFolder:\\n local_annot_mod_time = os.path.getmtime(syncFilePath)\\n remote_annot_mod_time = int(meta['lastModified'])/1000\\n remoteChanged = remote_annot_mod_time > local_annot_mod_time\\n if remoteChanged:\\n #####\\n convertNotebook(fname, refNrPath)\\n #####\\n else:\\n print(fname + \\\"has not changed\\\")\",\n \"def update_is_streamed_json(self, index):\\n time_now = datetime.datetime.now()\\n read_path = self.base_path + time_now.strftime('%Y-%m-%d') + '.json'\\n try:\\n json_file = open(read_path, 'r')\\n data = json.load(json_file)\\n json_file.close()\\n\\n data[index]['being_streamed'] = True\\n\\n json_file = open(read_path, 'w+')\\n json_file.write(json.dumps(data))\\n json_file.close()\\n \\n except IOError:\\n print 'File not found'\",\n \"def flatten_json_data(beer_json):\\n if 'available' in beer_json:\\n if 'name' in beer_json['available']:\\n beer_json['available_name'] = beer_json['available']['name']\\n del beer_json['available']\\n if 'glass' in beer_json:\\n if 'name' in beer_json['glass']:\\n beer_json['glass_name'] = beer_json['glass']['name']\\n del beer_json['glass']\\n if 'style' in beer_json:\\n if 'abvMax' in beer_json['style']:\\n beer_json['style_abvMax'] = beer_json['style']['abvMax']\\n if 'abvMin' in beer_json['style']:\\n beer_json['style_abvMin'] = beer_json['style']['abvMin']\\n if 'category' in beer_json['style']:\\n beer_json['style_category_name'] = beer_json['style']['category']['name']\\n if 'description' in beer_json['style']:\\n beer_json['style_description'] = beer_json['style']['description']\\n if 'fgMax' in beer_json['style']:\\n beer_json['style_fgMax'] = beer_json['style']['fgMax']\\n if 'fgMin' in beer_json['style']:\\n beer_json['style_fgMin'] = beer_json['style']['fgMin']\\n if 'ibuMax' in beer_json['style']:\\n beer_json['style_ibuMax'] = beer_json['style']['ibuMax']\\n if 'ibuMin' in beer_json['style']:\\n beer_json['style_ibuMin'] = beer_json['style']['ibuMin']\\n if 'name' in beer_json['style']:\\n beer_json['style_name'] = beer_json['style']['name']\\n if 'ogMin' in beer_json['style']:\\n beer_json['style_ogMin'] = beer_json['style']['ogMin']\\n if 'ogMax' in beer_json['style']:\\n beer_json['style_ogMax'] = beer_json['style']['ogMax']\\n if 'shortName' in beer_json['style']:\\n beer_json['style_shortName'] = beer_json['style']['shortName']\\n if 'srmMax' in beer_json['style']:\\n beer_json['style_srmMax'] = beer_json['style']['srmMax']\\n if 'srmMin' in beer_json['style']:\\n beer_json['style_srmMin'] = beer_json['style']['srmMin']\\n del (beer_json['style'])\\n else:\\n beer_json = None\\n\\n return beer_json\",\n \"def make_clips(self):\\n\\n average_messege_count, streamer_messeges_data = self.__do_analysis()\\n\\n clipworthy_clips = []\\n\\n #add clipworthy clips\\n for entry in streamer_messeges_data:\\n if((entry['messeges_count']*entry['messeges_count']) > (average_messege_count*1.8)):\\n clipworthy_clips.append(entry)\\n\\n #combine clips that are next to one another in time\\n clip_number = 0\\n while(True):\\n #print('clip_number = ' + str(clip_number) +' , length of cliparr = ' + str(len(clipworthy_clips)))\\n if(clip_number >= (len(clipworthy_clips))-1):\\n #at end of clips\\n break\\n\\n if (clipworthy_clips[clip_number]['end_time']==clipworthy_clips[clip_number+1]['start_time']):\\n #duplicate clip detected\\n #print('dublicate clip detected for clip ' + str(clip_number))\\n clipworthy_clips[clip_number]['end_time']=clipworthy_clips[clip_number+1]['end_time']\\n #print('cliparr length before ridding: ' + str(len(clipworthy_clips)))\\n clipworthy_clips.remove(clipworthy_clips[clip_number+1])\\n #print('cliparr length after ridding: ' + str(len(clipworthy_clips)))\\n #print('')\\n else:\\n clip_number = clip_number + 1\\n\\n\\n print('clipworthy clips will now be made')\\n clipSlicer = ClipSlicer(clipworthy_clips)\\n clipSlicer.make_clips()\\n\\n print(\\\"clipworthy clips for streamer \\\"+ self.streamer + \\\" have been made\\\")\",\n \"def time_calibration(input_file):\\n original_path = os.getcwd()\\n save_path = input_file['save_path']\\n #change to save data reduction directory\\n os.chdir(save_path)\\n print '\\\\n Reading the list of images ....\\\\n'\\n planet = input_file['exoplanet'] #set exoplanet name\\n images = sorted(glob.glob('AB'+planet+'*.fits'))\\n print images\\n #include de RA,DEC and epoch of the exoplanet\\n RA,DEC,epoch = input_file['RA'],input_file['DEC'],input_file['epoch']\\n #obtain ST JD using iraf task and introduce in the header\\n for i in range(len(images)):\\n hdr = fits.getheader(images[i])\\n if int(split(hdr['UT'],':')[0]) < int(hdr['timezone']):\\n new_date = use.yesterday(hdr['date-obs'])\\n #print images[i], new_date\\n else:\\n new_date = hdr['date-obs']\\n year,month,day = split(new_date,'-')\\n iraf.asttimes(year=year,month=month,day=day,time=hdr['loctime'],obs=input_file['observatory'])\\n JD = iraf.asttimes.jd #obtain julian date\\n LMST = iraf.asttimes.lmst #obtain the sideral time\\n LMST = use.sexagesimal_format(LMST) #convert sideral time in sexagesimal format\\n iraf.hedit(images[i],'ST',LMST,add='yes',verify='no',show='no',update='yes') #create the ST keyword in the header\\n iraf.ccdhedit(images[i],'LMST',LMST,type='string') #include the mean sideral time in the header\\n iraf.ccdhedit(images[i],'JD',JD,type='string') #include de julian date in the header\\n #include RA, and DEC of the object in your header\\n iraf.ccdhedit(images[i],\\\"RA\\\",RA,type=\\\"string\\\") #include right ascention in the header\\n iraf.ccdhedit(images[i],\\\"DEC\\\",DEC,type=\\\"string\\\") #include declination in the header\\n iraf.ccdhedit(images[i],\\\"epoch\\\",epoch,type=\\\"string\\\") #include epoch in the header\\n # use.update_progress((i+1.)/len(images))\\n print '\\\\n Setting airmass ....\\\\n'\\n for i in range(len(images)):\\n print '# ',images[i]\\n #iraf.hedit(images[i],'airmass',airmass,add='yes')\\n #iraf.hedit(images[i],'HJD',HJD,add='yes')\\n iraf.setairmass.observatory = input_file['observatory']\\n iraf.setairmass(images[i])\\n iraf.setjd.time = 'ut'\\n iraf.setjd(images[i])\\n print '\\\\n.... done.\\\\n'\\n #export information\\n hjd, jd, airmass, st = [],[],[],[]\\n for i in range(len(images)):\\n hdr = fits.getheader(images[i])\\n hjd.append(hdr['HJD'])\\n jd.append(hdr['JD'])\\n airmass.append(hdr['airmass'])\\n st.append(hdr['st'])\\n #saving the data\\n data = DataFrame([list(hjd),list(jd),list(st),list(airmass)]).T\\n data.columns = ['HJD','JD','ST','Airmass']\\n data.to_csv('results_iraf_calibrations.csv')\\n #change to workings directory\\n os.chdir(original_path)\\n return\",\n \"def _edit_job_file(self, edits):\\n for key in edits:\\n self.json_dict[key] = edits[key]\",\n \"def main(input_dir, bids_dir, exclude_fieldmaps):\\n\\n input_dir = Path(input_dir).absolute()\\n bids_dir = Path(bids_dir).absolute()\\n raw_dir = bids_dir / \\\"sourcedata\\\"\\n\\n copy_all_paths_to_sourcedata(input_dir, raw_dir)\\n\\n fix_acquisition_numbers_of_json_files_in(raw_dir)\\n\\n old_and_new_paths = create_dictionary_of_old_and_new_paths(raw_dir, bids_dir, exclude_fieldmaps)\\n\\n copy_files_to_their_new_homes(old_and_new_paths)\\n\\n fix_jsons_in(bids_dir)\\n\\n add_dataset_description_to(bids_dir)\\n\\n write_tsvs(raw_dir, bids_dir)\\n\\n print(\\\"Congratulations! You're BIDS-compliant, yay!\\\")\\n print(\\\"To double-check, use this handy dandy BIDS validator: https://bids-standard.github.io/bids-validator/\\\")\",\n \"def read_json_file_to_be_edited(self):\\n _json_file = self.job[\\\"JSONfileToBeEdited\\\"]\\n if _json_file in self.config:\\n # Substitute the path defined in the macro\\n _json_file = self.config[_json_file]\\n self.json_o.read(_json_file)\",\n \"def refresh_cdb_json_file(file_path):\\n cdb_dir = os.path.dirname(file_path)\\n file_name = os.path.basename(file_path)\\n upstream_dir = os.path.join(cdb_dir, 'upstream')\\n upstream_md5 = os.path.join(upstream_dir, '{}.MD5'.format(file_name))\\n upstream_json = os.path.join(upstream_dir, '{}.json'.format(file_name))\\n\\n logger = utils.get_logger()\\n logger.debug('Processing: {}'.format(file_name))\\n\\n cdb_md5 = utils.md5_file(file_path)\\n try:\\n with open(upstream_md5, 'r') as f:\\n json_md5 = f.read()\\n\\n # If the cdb file matches the generated md5,\\n # no changes are needed to the json\\n if json_md5 == cdb_md5:\\n return True\\n except IOError:\\n pass\\n\\n tmp_json = tempfile.NamedTemporaryFile(delete=False)\\n with open(file_path, 'r') as fp:\\n reader = cdblib.Reader(fp.read())\\n\\n out = collections.OrderedDict()\\n for k, v in reader.iteritems():\\n out[k] = v\\n\\n json_data = json.dumps(out, indent=0, separators=(',', ':'))\\n\\n # Make python json.dumps match php's json_encode\\n # Remove first newline\\n json_data = json_data.replace('\\\\n', '', 1)\\n\\n # Escape slashes\\n json_data = json_data.replace('/', '\\\\/')\\n\\n # Remove final newline\\n json_data = ''.join(json_data.rsplit('\\\\n', 1))\\n\\n tmp_json.write(json_data)\\n tmp_json.close()\\n os.chmod(tmp_json.name, 0o644)\\n shutil.move(tmp_json.name, upstream_json)\\n logger.debug('Updated: {}'.format(upstream_json))\\n\\n with open(upstream_md5, 'w') as md5:\\n md5.write(cdb_md5)\\n\\n return True\",\n \"def preprocess(self):\\r\\n file_name = os.path.join(self.raw_path, \\\"amazon-amazon-instant-video.json.gz\\\")\\r\\n print(f\\\"file_name: {file_name}\\\")\\r\\n if not os.path.exists(file_name):\\r\\n self.download()\\r\\n\\r\\n # parse json data\\r\\n data = self.get_data_frame_from_gzip_file(file_name)\\r\\n\\r\\n # rename columns\\r\\n data = data.rename(\\r\\n columns={\\r\\n \\\"reviewerID\\\": DEFAULT_USER_COL,\\r\\n \\\"asin\\\": DEFAULT_ITEM_COL,\\r\\n \\\"overall\\\": DEFAULT_RATING_COL,\\r\\n \\\"unixReviewTime\\\": DEFAULT_TIMESTAMP_COL,\\r\\n }\\r\\n )\\r\\n\\r\\n # select necessary columns\\r\\n data = pd.DataFrame(\\r\\n data,\\r\\n columns=[\\r\\n DEFAULT_USER_COL,\\r\\n DEFAULT_ITEM_COL,\\r\\n DEFAULT_RATING_COL,\\r\\n DEFAULT_TIMESTAMP_COL,\\r\\n ],\\r\\n )\\r\\n\\r\\n self.save_dataframe_as_npz(\\r\\n data,\\r\\n os.path.join(self.processed_path, f\\\"{self.dataset_name}_interaction.npz\\\"),\\r\\n )\",\n \"def _archiveDataByDate(self, src, dest):\\n root = os.getcwd()\\n srcPath = join(root,src)\\n destPath = join(root,dest)\\n f = [] #Array with list of files in directory\\n fDate = [] #Array with list of files with certain date;\\n s = [] #Array with list of files successfully copied\\n for (dirpath, dirnames, filenames) in walk(srcPath):\\n f.extend(filenames)\\n if len(f) > 0:\\n for i in f:\\n match = re.search(r'\\\\d{4}-\\\\d{2}-\\\\d{2}', i)\\n if str(i) != 'archiving_log.txt' and str(i) != 'archiving_log.txt~' and str(i) != 'archivingScript.py' and match.group() == self.date:\\n try:\\n buffer_size = int(20000)\\n fileSrcPath = join(dirpath, i)\\n fileDestPath = join(destPath, i)\\n with open(fileSrcPath, 'rb') as fsrc:\\n with open(fileDestPath, 'wb') as fdest:\\n copy = shutil.copyfileobj(fsrc,fdest,buffer_size)\\n copy\\n self._backupLog('Copy Operation File: '+str(i)+ '\\\\t' + 'Time: '+ str(time.strftime(\\\"%H:%M:%S\\\")) +'\\\\n') #+ '\\\\t'+ 'Path: '+ str(srcPath)\\n s.append(i)\\n except shutil.Error as e:\\n self._backupLog('Error: %s' % e + '\\\\t' + 'File: '+str(i)+ '\\\\t' + 'Time: '+ str(time.strftime(\\\"%H:%M:%S\\\")) + '\\\\n')\\n except IOError as e:\\n self._backupLog('Error: %s' % e.strerror + '\\\\t' + 'File: '+str(i)+ '\\\\t' + 'Time: '+ str(time.strftime(\\\"%H:%M:%S\\\")) + '\\\\n')\\n if len(s) >0:\\n for (dirpath,dirnames,filenames) in walk(srcPath):\\n for cfile in f:\\n for sfile in s:\\n if cfile == sfile:\\n try:\\n filetoDelete = join(srcPath, cfile)\\n os.remove(filetoDelete)\\n self._backupLog('Delete Operation File: '+str(cfile)+ '\\\\t' + 'Time: '+ str(time.strftime(\\\"%H:%M:%S\\\")) + '\\\\n')\\n except OSError, e:\\n self._backupLog('Error deleting file: %s - %s.' % (e.filename, e.strerror) + '\\\\t' + 'Time: '+ str(time.strftime(\\\"%H:%M:%S\\\")) + '\\\\n')\",\n \"def readdata(self, filepaths):\\n pass\",\n \"def json_to_ratdb(local_dir,filename): \\n ratdbdir = local_dir\\n\\n jsonfile = filename\\n\\n splitjson = jsonfile.split(\\\"_\\\")\\n\\n runnumber = splitjson[1]\\n\\n print \\\"Converting the JSON table to RATDb format for run \\\" + str(runnumber)\\n\\n # Create the DQ LL table in ratdb format\\n ratdbfile = \\\"{0}run_{1}_dqll.ratdb\\\".format(ratdbdir,runnumber)\\n \\n ratdbtable = open(ratdbfile,'w')\\n\\n # Open the JSON table and reads it\\n jsontable = open(jsonfile,'r')\\n \\n beginline = jsontable.readline()\\n\\n ratdbtable.write(beginline)\\n\\n for i in range(7):\\n\\n headerstring = jsontable.readline().split(\\\":\\\")\\n\\n noquoteheader = headerstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbheaderstring = \\\"{0}:{1}\\\".format(noquoteheader[1],headerstring[1])\\n\\n ratdbtable.write(ratdbheaderstring)\\n\\n # Timestamps need special treatment\\n timestampstring = jsontable.readline().split(\\\":\\\")\\n\\n noquotetimestamp = timestampstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbtimestampstring = \\\"{0}:{1}:{2}:{3}:{4}\\\".format(noquotetimestamp[1], timestampstring[1],\\n timestampstring[2], \\n timestampstring[3],\\n timestampstring[4])\\n\\n ratdbtable.write(ratdbtimestampstring)\\n\\n returnline1 = jsontable.readline()\\n\\n ratdbtable.write(returnline1)\\n\\n for i in range(2):\\n\\n timestring = jsontable.readline().split(\\\":\\\")\\n\\n noquotetime = timestring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbtimestring = \\\"{0}:{1}:{2}:{3}:{4}\\\".format(noquotetime[1], timestring[1],\\n timestring[2],\\n timestring[3],\\n timestring[4])\\n\\n ratdbtable.write(ratdbtimestring)\\n \\n durationstring = jsontable.readline().split(\\\":\\\")\\n\\n noquoteduration = durationstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbdurationstring = \\\"{0}:{1}\\\".format(noquoteduration[1],durationstring[1])\\n\\n ratdbtable.write(ratdbdurationstring)\\n\\n returnline2 = jsontable.readline()\\n\\n ratdbtable.write(returnline2)\\n\\n for i in range(2):\\n\\n cratestatusstring = jsontable.readline().split(\\\":\\\")\\n\\n noquotecratestatus = cratestatusstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbcratestatusstring = \\\"{0}:{1}\\\".format(noquotecratestatus[1],cratestatusstring[1])\\n\\n ratdbtable.write(ratdbcratestatusstring)\\n\\n returnline3 = jsontable.readline()\\n\\n ratdbtable.write(returnline3)\\n\\n for i in range(2):\\n\\n cratenominalstring = jsontable.readline().split(\\\":\\\")\\n \\n noquotecratenominal = cratenominalstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbcratenominalstring = \\\"{0}:{1}\\\".format(noquotecratenominal[1],cratenominalstring[1])\\n \\n ratdbtable.write(ratdbcratenominalstring)\\n\\n returnline4 = jsontable.readline()\\n\\n ratdbtable.write(returnline4)\\n\\n for i in range(2):\\n\\n cratehvreadstring = jsontable.readline().split(\\\":\\\")\\n \\n noquotecratehvread = cratehvreadstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbcratehvreadstring = \\\"{0}:{1}\\\".format(noquotecratehvread[1],cratehvreadstring[1])\\n \\n ratdbtable.write(ratdbcratehvreadstring)\\n\\n returnline5 = jsontable.readline()\\n\\n ratdbtable.write(returnline5)\\n\\n for i in range(2):\\n\\n cratecurrentreadstring = jsontable.readline().split(\\\":\\\")\\n \\n noquotecratecurrentread = cratecurrentreadstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbcratecurrentreadstring = \\\"{0}:{1}\\\".format(noquotecratecurrentread[1],cratecurrentreadstring[1])\\n \\n ratdbtable.write(ratdbcratecurrentreadstring)\\n\\n returnline6 = jsontable.readline()\\n\\n ratdbtable.write(returnline6)\\n\\n for i in range(6):\\n\\n xl3errorstring = jsontable.readline().split(\\\":\\\")\\n \\n noquotexl3error = xl3errorstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbxl3errorstring = \\\"{0}:{1}\\\".format(noquotexl3error[1],xl3errorstring[1])\\n \\n ratdbtable.write(ratdbxl3errorstring)\\n\\n returnline7 = jsontable.readline()\\n\\n ratdbtable.write(returnline7)\\n\\n xl3screwedstring = jsontable.readline().split(\\\":\\\")\\n \\n noquotexl3screwed = xl3screwedstring[0].split(\\\"\\\\\\\"\\\")\\n\\n ratdbxl3screwedstring = \\\"{0}:{1}\\\".format(noquotexl3screwed[1],xl3screwedstring[1])\\n \\n ratdbtable.write(ratdbxl3screwedstring)\\n\\n endline = jsontable.readline()\\n\\n ratdbtable.write(endline)\\n \\n jsontable.close()\\n\\n ratdbtable.close()\",\n \"def mk_json_clms(dlas, outpath, prefix):\\n for abssys in dlas._abs_sys:\\n tdict = abssys._clmdict\\n # Convert AbsLine to dicts\\n if 'lines' in tdict.keys():\\n new_lines = {}\\n for key in tdict['lines']:\\n new_lines[key] = tdict['lines'][key].to_dict()\\n # Replace\\n tdict['lines'] = new_lines\\n tdict['Name'] = abssys.name\\n tdict['Creation_date'] = str(datetime.date.today().strftime('%Y-%b-%d'))\\n # Outfil\\n name = survey_name(prefix, abssys)\\n outfil = outpath+name+'_clm.json'\\n # Write\\n print('Writing {:s}'.format(outfil))\\n with io.open(outfil, 'w', encoding='utf-8') as f:\\n f.write(unicode(json.dumps(tdict, sort_keys=True, indent=4,\\n separators=(',', ': '))))\",\n \"def updateCountryNames(self):\\n try:\\n with open('countryNameMapping.json', 'r') as file:\\n name_mapping = json.loads(file.read())\\n except:\\n sys.exit('countryNameMapping.json file is unavailable in current directory.')\\n \\n for key, value in name_mapping.items():\\n self.covid_df.replace(key, value, inplace=True)\\n \\n try:\\n with open('countryNameISO2.json', 'r') as file:\\n self.name_iso2_mapping = json.loads(file.read())\\n except:\\n print('countryNameISO2.json file is unavailable in current directory, creating file...')\\n self.writeCountryCodeFile()\\n print('Re-importing required JSONs...')\\n self.updateCountryNames()\",\n \"def main():\\n\\n # Set up argument parser.\\n parser = argparse.ArgumentParser(\\n description='Removes duplicate key-value pairs from JSON files.')\\n parser.add_argument('--suffix', default='',\\n help='optional suffix for output files; '\\n 'if empty, files will be changed in place')\\n parser.add_argument('files', nargs='+', help='input files')\\n args = parser.parse_args()\\n\\n # Iterate over files.\\n for filename in args.files:\\n # Read in json using Python libraries. This eliminates duplicates.\\n print('Processing ' + filename + '...')\\n try:\\n with codecs.open(filename, 'r', 'utf-8') as infile:\\n j = json.load(infile)\\n except ValueError as e:\\n print('Error reading ' + filename)\\n raise InputError(filename, str(e))\\n\\n # Built up output strings as an array to make output of delimiters easier.\\n output = []\\n for key in j:\\n if key != '@metadata':\\n output.append('\\\\t\\\"' + key + '\\\": \\\"' +\\n j[key].replace('\\\\n', '\\\\\\\\n') + '\\\"')\\n\\n # Output results.\\n with codecs.open(filename + args.suffix, 'w', 'utf-8') as outfile:\\n outfile.write('{\\\\n')\\n outfile.write(',\\\\n'.join(output))\\n outfile.write('\\\\n}\\\\n')\",\n \"def main():\\n\\n # Script arguments... \\n \\\"\\\"\\\" If running as standalone, hardcode theWorkspace and inFile \\\"\\\"\\\"\\n theWorkspace = arcpy.GetParameterAsText(0)\\n if not theWorkspace:\\n theWorkspace = r\\\"d:\\\\_dataTest\\\"\\n arcpy.env.workspace = theWorkspace\\n arcpy.env.overwriteOutput = True\\t\\n\\n inFile = arcpy.GetParameterAsText(1)\\n if not inFile:\\n inFile = \\\"updateMultipleSourcePaths.csv\\\"\\n inFile = r\\\"\\\\\\\\dfg.alaska.local\\\\gis\\\\Anchorage\\\\GISStaff\\\\___gisStaffConnections\\\\RepairBrokenSrcAug242015.csv\\\"\\n\\n outWorkspace = arcpy.GetParameterAsText(2)\\n if not outWorkspace:\\n outWorkspace = os.path.join(theWorkspace, \\\"_repaired\\\")\\n '''if not os.path.isdir(outWorkspace): \\n os.makedirs(outWorkspace)\\n myMsgs(\\\"created new directory {0} \\\\n\\\".format(outWorkspace))'''\\n\\n # Create .txt Report of what it thinks was fixed, tagged with YYYYMMDD_HHMM\\n outFile = \\\"FixedReport\\\"\\n fileDateTime = curFileDateTime()\\n currentDate = curDate()\\n outfileTXT = os.path.join(theWorkspace, outFile) + fileDateTime + \\\".txt\\\" \\n myMsgs (outFile)\\n reportFile = open(outfileTXT, 'w')\\n myMsgs( \\\"File {0} is open? {1}\\\".format(outfileTXT, str(not reportFile.closed)))\\n outText = \\\"Report for what it THINKS it repaired in {0}, on {1} \\\\n \\\".format(theWorkspace, currentDate)\\n outText += \\\" Includes coverages (pts, poly, arc, anno), shapes, and FGDB data.\\\" + '\\\\n'\\n outText += \\\"-----------------------------------------------------\\\" + '\\\\n' \\n reportFile.write(outText)\\t\\n\\n mxd = None\\n outMXDName = \\\"none\\\"\\n updatePath = []\\n cvrList = [r\\\"\\\\arc\\\", r\\\"\\\\polygon\\\", r\\\"\\\\region\\\", r\\\"\\\\point\\\", r\\\"\\\\tic\\\" ]\\n lstExtDatatype = [[\\\".shp\\\", \\\"SHAPEFILE_WORKSPACE\\\" ], [\\\".sde\\\",\\\"SDE_WORKSPACE\\\"], \\n [\\\".mdb\\\", \\\"ACCESS_WORKSPACE\\\" ], [\\\".gdb\\\", \\\"FILEGDB_WORKSPACE\\\"], \\n [\\\"cover\\\", \\\"ARCINFO_WORKSPACE\\\"]]\\t\\n cntMXD = 0\\n cntFixed = 0\\n cntTotalFixed = 0\\n\\n # makes sure the .csv file exists\\n if arcpy.Exists(inFile):\\n myMsgs (\\\"->Using {0} to repair paths.\\\\n==============================\\\".format(inFile))\\n # walks thru the workspace to create list of files \\n for root, dirs, files in os.walk(theWorkspace): \\t\\t\\n for fileName in files:\\n if root == outWorkspace: # don't process mxd's in the target directory\\n pass\\n else:\\n fullPath = os.path.join(root, fileName)\\n basename, extension = os.path.splitext(fileName)\\n # Only process .mxd files\\n if extension == \\\".mxd\\\":\\n myMsgs(\\\"\\\\nReviewing MXD: {0}\\\".format(fullPath))\\n reportFile.write(\\\"\\\\nReviewing MXD: {0}\\\".format(fullPath))\\n mxd = arcpy.mapping.MapDocument(fullPath)\\n dfs = arcpy.mapping.ListDataFrames(mxd)\\n cntMXD += 1\\n cntFixed = 0\\n basename, extension = os.path.splitext(fileName)\\n # New output mxd name....\\n outMXDName = os.path.join(outWorkspace, (str(basename) + \\\".mxd\\\")) #\\\"_fix.mxd\\\"))\\n # create list of the tables since they are handle differently\\n theTables = arcpy.mapping.ListTableViews(mxd)\\n # Loops thru dataframes so adding and deleting Services will work.\\n for df in dfs:\\n # Loops thru layers, checks for broken links and tries to repair\\n lyrList = arcpy.mapping.ListLayers(mxd, \\\"\\\", df)\\n for lyr in lyrList:\\n if lyr.isBroken:\\n if not lyr.supports(\\\"DATASOURCE\\\") and not lyr.isServiceLayer:\\n myMsgs(\\\" ->Skipping {0} not a Service layer, and does not support DATASOURCE\\\".format(lyr.name))\\n pass #continue\\n elif not lyr.supports(\\\"DATASOURCE\\\") and lyr.isServiceLayer:\\n myMsgs(\\\" -Broken Service: {0}\\\".format(lyr.name))\\n else:\\n myMsgs(\\\" -Broken: {0}\\\".format(lyr.dataSource))\\n #myMsgs(\\\"layer is Group {0} or ServiceLayer {1}\\\".format(lyr.isGroupLayer, lyr.isServiceLayer))\\n if (lyr.isGroupLayer or (\\\"Events\\\" in lyr.name)) and (not lyr.isServiceLayer): # Groups and Event FC skipped\\n myMsgs(\\\" ...skipping group or event: {0}\\\".format(lyr.name))\\n reportFile.write(\\\"\\\\n *skipping group or event: {0} \\\\n\\\".format(lyr.name))\\n pass #break\\n elif lyr.isServiceLayer: # services might have to be handle differently\\n if lyr.supports(\\\"SERVICEPROPERTIES\\\"):\\n for spType, spName in lyr.serviceProperties.iteritems():\\n myMsgs(\\\" Service Properties: {0}: {1}\\\".format(spType, spName ))\\n if spType == \\\"URL\\\": \\n dataSource = str(spName)\\n lyrType = (\\\"service_{}\\\".format(lyr.name))\\n break\\n myMsgs(\\\" ->this ia a service....using add and remove layer\\\")\\n updatePath = findUpdatePath(inFile, dataSource, lyrType.strip().lower())\\n newDSPath, newDSName = os.path.split(updatePath[0])\\n if (\\\"service\\\" in updatePath[3]) and (\\\"service\\\" in updatePath[1]):\\n insertLayer = arcpy.mapping.Layer(updatePath[0])\\n print(\\\"dataframe: {0}\\\".format(df))\\n arcpy.mapping.InsertLayer(df, lyr, insertLayer, \\\"AFTER\\\")\\n arcpy.mapping.RemoveLayer(df, lyr)\\n reportFile.write(\\\"\\\\n ->sees this as service....{0} \\\\n\\\".format(dataSource))\\n # will still look at deleted version after insert, not the new version..\\n # isBroken will give false info even if fixed, so \\n # don't use myMsgs(\\\"Still broken? {0}\\\".format(lyr.isBroken)) \\n else:\\n myMsgs(\\\" --> a service layer but no SERVICE PROPERTIES\\\")\\n elif lyr.supports(\\\"DATASOURCE\\\") and lyr.supports(\\\"DATASETNAME\\\"): \\n # not a group, event or what it thinks is a service\\n updatePath = findUpdatePath(inFile, lyr.dataSource, \\\"\\\")\\n newDSPath, newDSName = os.path.split(updatePath[0])\\n sameType = updatePath[2] \\n for cvr in cvrList: #checks to see if the source layer is a coverage...must handle different\\n if cvr in lyr.dataSource:\\n sourceIsCoverage = True\\n break\\n else:\\n sourceIsCoverage = False\\n # updatePath[1] is False if there wasn't a match\\n # so \\\"not update[1]\\\" means no match was found, and moves to next layer\\t\\t\\t\\t\\t\\t\\t\\t\\n if not updatePath[1]: # if no match was found\\n myMsgs(\\\" !! no match to: {0} \\\".format(lyr.dataSource))\\n updateStatus = \\\"no match, not changed\\\" # used for message only\\n pass\\n elif updatePath[1].strip().lower() == \\\"drive\\\":\\n myMsgs(\\\" skipping drive-letter matches for now: {0}\\\".format(lyr.dataSource))\\n updateStatus = \\\"can only find drive match...look into it)\\\"\\n pass\\n elif updatePath[1].strip().lower() == \\\"_review\\\":\\n myMsgs(\\\" no new source assigned yet for: {0}\\\".format(lyr.dataSource))\\n updateStatus = (\\\"review and update {0}\\\".format(inFile))\\n pass\\n else: #if lyr.supports(\\\"DATASOURCE\\\") and lyr.supports(\\\"DATASETNAME\\\"):\\n updateStatus = str(updatePath[0]) # used for message only\\n if lyr in theTables:\\n #myMsgs(\\\" thinks its a table....using findAndReplsWorkspacePath\\\")\\n myMsgs(\\\" *Moving {0}: {1} to new: {2}\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n reportFile.write(\\\"\\\\n Moving {0}: {1} to new: {2} \\\\n\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n lyr.findAndReplaceWorkspacePath(lyr.dataSource, updatePath, False) \\n elif lyr.isRasterLayer:\\n #myMsgs(\\\" thinks its a raster....using findAndReplsWorkspacePath\\\")\\n myMsgs(\\\" *Moving {0}: {1} to new: {2}\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n reportFile.write(\\\"\\\\n Moving {0}: {1} to new: {2} \\\\n\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n newType = \\\"RASTER_WORKSPACE\\\"\\n for extType in lstExtDatatype:\\n if extType[0] in updatePath[0]:\\n newType = extType[1] \\n if extType[0] == '.gdb':\\n newDSPath = newDSPath.split('.gdb', 1)[0] + '.gdb'\\n #newType = extType[1]\\n elif extType[0] == '.sde':\\n newDSPath = newDSPath.split('.sde', 1)[0] + '.sde'\\n break \\n lyr.replaceDataSource(newDSPath, newType, newDSName, False)\\n if not sameType:\\n testOldTOC = updatePath[4].strip('\\\\\\\\')\\n if lyr.name == testOldTOC:\\n lyr.name = lyr.datasetName\\n else:\\n newType = updatePath[1] \\n if sourceIsCoverage and sameType:\\n newDSPath = os.path.split(newDSPath)[0]\\n newType = \\\"ARCINFO_WORKSPACE\\\"\\n for extType in lstExtDatatype:\\n if extType[0] in updatePath[0]:\\n newType = extType[1]\\n if extType[0] == '.gdb':\\n newDSPath = newDSPath.split('.gdb', 1)[0] + '.gdb'\\n #newType = extType[1]\\n elif extType[0] == '.sde':\\n newDSPath = newDSPath.split('.sde', 1)[0] + '.sde'\\n\\n break\\n print(\\\"line ~281 newType is: {0}\\\".format(newType))\\n myMsgs(\\\" *Moving {0}: {1} to new: {2}\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n reportFile.write(\\\"\\\\n Moving {0}: {1} to new: {2}\\\".format(updatePath[3], lyr.dataSource, updatePath[0]))\\n lyr.replaceDataSource(newDSPath, newType, newDSName, False)\\n #myMsgs(\\\" new datasource: {0}\\\".format(lyr.dataSource))\\n myMsgs(\\\" **the new data source: {0}\\\".format(updateStatus))\\n cntFixed += 1\\n myMsgs(\\\" Still broken? {0}\\\".format(lyr.isBroken))\\n else:\\n myMsgs(\\\"not sure what it is, but can't process {0}\\\".format(lyr.name))\\n \\n else:\\n myMsgs(\\\" -Not Broken: {0}\\\".format(str(lyr)))\\n\\n myMsgs(\\\" Number of links fixed processed: {0}\\\".format(cntFixed))\\n myMsgs(\\\" -{0} Review complete.\\\".format(fullPath))\\n reportFile.write(\\\" -Number of links fixed processed: {0} \\\\n\\\".format(cntFixed))\\t\\t\\t\\t\\t\\t\\n reportFile.write(\\\" -{0} Review complete. \\\\n\\\\n\\\".format(fullPath))\\n\\n if cntFixed > 0:\\n mxd.save()\\n myMsgs(\\\"saved to {0}\\\".format(fullPath))\\n reportFile.write(\\\"saved to {0}\\\".format(fullPath))\\n cntTotalFixed += cntFixed\\n cntFixed = 0\\n \\\"\\\"\\\"if cntFixed > 0:\\n\\t\\t\\t\\t\\t\\t\\tmxd.saveACopy(outMXDName, '10.1')\\n\\t\\t\\t\\t\\t\\t\\tmyMsgs(\\\"saved to {0}\\\".format(outMXDName))\\n\\t\\t\\t\\t\\t\\t\\tcntFixed = 0\\\"\\\"\\\"\\n '''if arcpy.Exists(outMXDName):\\n outMXDName.()\\n myMsgs(\\\"saved 1\\\")\\n else:\\n mxd.saveACopy(outMXDName, '10.1')\\n myMsgs(\\\"saved 2\\\")'''\\n del mxd\\n cntFixed = 0\\n else:\\n myMsgs (\\\"ERROR: Required repair source list: [0] does not exit. \\\\n\\\".format(inFile))\\n outText = (\\\"\\\\n\\\\n ==========================================\\\")\\n outText += (\\\"\\\\n Number of MXD's processed: {0} \\\\n\\\".format(cntMXD))\\n outText += (\\\" Total Number of links it fixed, all mxds: {0} \\\\n\\\".format(cntTotalFixed) )\\n\\n myMsgs(\\\" {0}\\\".format(outText))\\n\\n reportFile.write(outText)\\n # close the .txt file, \\n reportFile.close()\\n myMsgs( \\\"File {0} is closed? {1}\\\".format(outfileTXT, str(reportFile.closed)))\\t\\n\\n myMsgs('!!! Success !!! ')\",\n \"def reformfile0():\\n txt = \\\"\\\"\\\"\\n {\\n \\\"policy\\\": {\\n \\\"_SS_Earnings_c\\\": {\\\"2016\\\": [300000],\\n \\\"2018\\\": [500000],\\n \\\"2020\\\": [700000]}\\n }\\n }\\n \\\"\\\"\\\"\\n rfile = tempfile.NamedTemporaryFile(suffix='.json', mode='a', delete=False)\\n rfile.write(txt + '\\\\n')\\n rfile.close()\\n # Must close and then yield for Windows platform\\n yield rfile\\n if os.path.isfile(rfile.name):\\n try:\\n os.remove(rfile.name)\\n except OSError:\\n pass # sometimes we can't remove a generated temporary file\",\n \"def test_repair_file(self):\\n\\n audio_path = self.converter.audio\\n self.assertTrue(audio_path.endswith('.wav'))\\n # Make sure it can be loaded in moviepy\\n clip = AudioFileClip(audio_path)\",\n \"def readdata(self, prefix, date, county):\\n print('F30A: prefix and date', prefix, date)\\n\\n filetoread = open(prefix + 'EL30A')\\n\\n lines = []\\n for line in filetoread:\\n lines.append(line)\\n\\n linelimit = len(lines)\\n# print('LINELIMIT', linelimit)\\n linesub = 0\\n while linesub < linelimit:\\n line = lines[linesub]\\n\\n if len(line) < 4:\\n linesub += 1\\n continue\\n if len(line.split()) < 2:\\n linesub += 1\\n continue\\n possiblepctnumber = line[0:4]\\n if (possiblepctnumber >= '0000') and (possiblepctnumber <= '9999'):\\n self._pctnumber = possiblepctnumber\\n self._pctname = line[4:].strip()\\n if self._pctnumber not in globalpcts:\\n print('NEW PCT %s %s' % (self._pctnumber, self._pctname))\\n onepct = OnePct(self._pctnumber, self._pctname, '30A')\\n else:\\n onepct = globalpcts[self._pctnumber]\\n\\n # here's the new 12 June 2018 kluge to get the numbers\\n if 'BALLOTS CAST - TOTAL' in line:\\n line = line.replace('.', ' ')\\n line = line.replace('BALLOTS CAST - TOTAL', ' ')\\n line = line.replace(',', '') # commas in numbers\\n\\n# linesplit = line.split()\\n self._ballots = []\\n for item in line.split():\\n self._ballots.append(int(item))\\n if (self._pctnumber >= '0000') and (self._pctnumber <= '9999'):\\n onepct.updatefrom30a(self._registered, self._ballots, county)\\n globalpcts[self._pctnumber] = onepct\\n linesub += 1\",\n \"def getcleanjson(self):\\n dico=self.dico.copy() # shalow copie as we remove second level data in the copied\\n for key in [\\\"basefiles\\\",\\\"grader\\\",\\\"soluce\\\"]:\\n if key in dico:\\n del dico[key]\\n return str(json.dumps(dico))\",\n \"def reformat_json_file(infilename, outfilename, clobber=False):\\n # open input json file\\n with open(infilename) as json_file:\\n json_string = json_file.read()\\n json_data = json.loads(json_string)\\n\\n # see if output file already exists and determine course of action\\n if os.path.exists(outfilename):\\n if clobber:\\n os.remove(outfilename)\\n else:\\n sys.exit(\\\"Error: output file {} already exists and would be overwritten!\\\".format(outfilename))\\n\\n # write out reformatted json file\\n with open(outfilename, 'w') as f:\\n json.dump(json_data, f, indent=4)\",\n \"def main(transcribe_bucket_name, mp3_bucket_name):\\n\\n s3 = boto3.resource('s3')\\n for bucket in s3.buckets.all():\\n if bucket.name == transcribe_bucket_name:\\n for key in bucket.objects.all():\\n if key.key.endswith('.json'):\\n r = {}\\n # Get reference number\\n reference = basename(key.key).replace('.json', '')\\n r['ref'] = reference\\n # Get URL\\n location = boto3.client('s3') \\\\\\n .get_bucket_location(\\n Bucket=mp3_bucket_name)['LocationConstraint']\\n base_url = join('https://s3-%s.amazonaws.com' % location,\\n mp3_bucket_name)\\n url = join(base_url, key.key.replace('.json', '.mp3'))\\n r['url'] = url\\n # Download json file\\n try:\\n s3.Bucket(transcribe_bucket_name) \\\\\\n .download_file(key.key, key.key)\\n except Exception as exception:\\n return 1\\n # Get text\\n with open(key.key, 'r') as f:\\n data = json.load(f)\\n text = data['results']['transcripts'][0]['transcript']\\n r['text'] = text\\n # Get sentiment\\n sentiment = get_sentiment(text)\\n r['sentiment'] = sentiment\\n # Check promotion\\n promo = check_promo(text)\\n r['promo'] = promo\\n # Save to Gooogle Sheets\\n values = [r['ref'], r['text'], r['promo'], r['sentiment'],\\n r['url']]\\n append_row(values)\\n # Remove tmp json file from local machine\\n remove(key.key)\",\n \"def copy_json():\\n sourcePath = 'contents/external/'\\n targetPath = 'build/external/'\\n for base,subdirs,files in os.walk(sourcePath):\\n for file in files:\\n orig = os.path.join(base, file)\\n if os.path.isfile(orig) and file[-5:] == '.json':\\n targetBase = os.path.join(targetPath, base[len(sourcePath):])\\n dest = os.path.join(targetBase, file)\\n puts(\\\"Checking diretory %s\\\" % targetBase)\\n if not os.path.exists(targetBase):\\n puts(yellow(\\\"Not found! Creating...\\\"))\\n os.makedirs(targetBase)\\n puts(\\\"Copying from %s to %s\\\" % (orig, dest))\\n copyfile(orig, dest)\",\n \"def reformat(self):\\n\\t\\told_path = os.path.join( self.path, self.init_str )\\n\\t\\tnew_path = os.path.join( self.path, self.reorder() )\\n\\t\\tos.rename(old_path,new_path)\",\n \"def filterCollections(path, context):\\n filteredObj = []\\n for obj in os.listdir(path):\\n if os.path.splitext(obj)[-1] == '.json':\\n if obj.split('_', 1)[0] == context:\\n filteredObj.append(obj.encode('utf8'))\\n baseC = context + '_baseCollection.json'\\n filteredObj = sorted(filteredObj, key=str.lower)\\n filteredObj.insert(0, filteredObj.pop(filteredObj.index(baseC)))\\n return filteredObj\",\n \"def restructure_file(raw_file_name, destination_file, label_file):\\n unique_words = answer_vocabulary(raw_file_name)\\n answer_labels = convert2labels(unique_words, label_file)\\n\\n qa_list = json.load(open(raw_file_name))\\n new_qa_list = list()\\n\\n for qa_dict in qa_list:\\n answer = str(qa_dict[\\\"answer\\\"]).lower()\\n first_word = answer.split(\\\" \\\")[0]\\n\\n new_qa_dict = {\\n \\\"image_name\\\": qa_dict[\\\"image_name\\\"],\\n \\\"question\\\": qa_dict[\\\"question\\\"],\\n \\\"answer_label\\\": answer_labels[first_word]\\n }\\n\\n new_qa_list.append(new_qa_dict)\\n\\n json.dump(new_qa_list, open(destination_file, \\\"w\\\"), indent=4)\",\n \"def get_prep(file_name):\\n\\n headers = {\\n \\\"User-Agent\\\": \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0\\\"}\\n\\n url = \\\"https://rp18.ine.mx/assets/JSON/PRESIDENTE/NACIONAL/Presidente_NACIONAL.json\\\"\\n\\n with requests.get(url, headers=headers) as response:\\n\\n # Save a copy for future analysis.\\n with open(\\\"./raw_data/{}.json\\\".format(file_name), \\\"w\\\", encoding=\\\"utf-8\\\") as temp_file:\\n temp_file.write(response.text)\\n\\n candidates = list()\\n percentages = list()\\n votes = list()\\n colors = list()\\n\\n json_data = response.json()\\n\\n for item in json_data[\\\"votosCandidatoPartidoCoalicion\\\"]:\\n\\n name = item[\\\"nombreCandidatoPropietario\\\"]\\n\\n if item[\\\"siglasPartido\\\"] == \\\"CNR\\\":\\n name = \\\"Candidatos No Registrados\\\"\\n\\n if item[\\\"siglasPartido\\\"] == \\\"VN\\\":\\n name = \\\"Nulos\\\"\\n\\n color = \\\"#{}\\\".format(item[\\\"colorPartido\\\"])\\n colors.append(color)\\n\\n candidates.append(name)\\n percentages.append(float(item[\\\"porcentaje\\\"]))\\n votes.append(int(item[\\\"total\\\"]))\\n\\n return dict({\\\"candidates\\\": candidates, \\\"percentages\\\": percentages,\\n \\\"votes\\\": votes, \\\"colors\\\": colors, \\\"totalVotos\\\": json_data[\\\"totalVotos\\\"],\\n \\\"actasCapturadas\\\": json_data[\\\"actasCapturadas\\\"][\\\"porcentaje\\\"]})\",\n \"def change_file(paths, object):\\r\\n \\\"\\\"\\\" \\r\\n for x in os.listdir(dirs): print(x) \\r\\n \\\"\\\"\\\"\\r\\n check_path = paths + \\\"\\\\changer\\\"\\r\\n\\r\\n for x in object:\\r\\n pass_data = False\\r\\n name = x.split('.')[0]\\r\\n for y in os.listdir(check_path):\\r\\n if name in y:\\r\\n pass_data = True\\r\\n\\r\\n if pass_data:\\r\\n pass\\r\\n else:\\r\\n vid = VideoFileClip(os.path.join(paths, \\\"\\\", x))\\r\\n\\r\\n vid.audio.write_audiofile(os.path.join(\\r\\n paths, \\\"changer\\\", name+\\\".mp3\\\")\\r\\n )\\r\\n show_result(check_path)\",\n \"def make_cached_json(file_name):\\n result = None\\n path = clean_path(file_name)\\n working_directory = os.path.split(os.path.abspath(file_name))[0]\\n file_type_switch = \\\"-s\\\" if is_sats_file(file_name) else \\\"-d\\\"\\n command = []\\n command.append(\\\"patsopt\\\")\\n command.append(\\\"--jsonize-2\\\")\\n command.append(file_type_switch)\\n command.append(path)\\n (stdout, _stderr, return_code) = run(\\n working_directory,\\n command,\\n POSTIATS_ENCODING)\\n if return_code == 0:\\n cached_file_name = get_cached_file_name(path)\\n cached_directory = os.path.split(cached_file_name)[0]\\n if not os.path.exists(cached_directory):\\n os.makedirs(cached_directory)\\n output = open(cached_file_name, \\\"w\\\")\\n output.write(stdout)\\n output.close()\\n result = json.loads(stdout)\\n return result\",\n \"def crop_acc_mask(images_dir, images_output_dir, masks_dir, mask_suffix=None, masks_output_dir=None): \\n image_suffix_list = [\\\"C0\\\", \\\"DE\\\", \\\"T2\\\"]\\n if not os.path.exists(images_output_dir):\\n os.makedirs(images_output_dir)\\n if masks_output_dir is not None and (not os.path.exists(masks_output_dir)):\\n os.makedirs(masks_output_dir)\\n margin = [0, 30, 30]\\n masks_list = os.listdir(masks_dir)\\n masks_list.sort()\\n json_dict = OrderedDict()\\n for mask in masks_list:\\n mask_path = os.path.join(masks_dir, mask)\\n if mask.endswith(\\\".nii.gz\\\"):\\n print(\\\"#\\\" * 11 *11)\\n print(mask_path)\\n mask_sitk = sitk.ReadImage(mask_path)\\n mask_npy = sitk.GetArrayFromImage(mask_sitk)\\n mask_shape = mask_npy.shape\\n crop_bbox_min, crop_bbox_max = get_ND_bounding_box(mask_npy, margin=margin)\\n # do not crop along depth dimension\\n crop_bbox_min[0] = 0\\n crop_bbox_max[0] = mask_shape[0]\\n print(crop_bbox_min, crop_bbox_max)\\n json_dict[mask_path] = {\\\"crop_bbox_min\\\": crop_bbox_min, \\\"crop_bbox_max\\\": crop_bbox_max}\\n mask_output_npy = crop_ND_volume_with_bounding_box(mask_npy, crop_bbox_min, crop_bbox_max)\\n if mask_suffix is not None:\\n mask = mask.replace(\\\"_\\\" + mask_suffix + \\\".nii.gz\\\", \\\".nii.gz\\\")\\n if masks_output_dir is not None:\\n save_cropped_array_as_nifty_volume(mask_output_npy, os.path.join(masks_output_dir, mask), mask_sitk)\\n save_cropped_array_as_nifty_volume(convert_label(mask_output_npy, [1, 2, 3, 4, 5], [1, 2, 3, 1, 1]), \\\\\\n os.path.join(images_output_dir, mask.replace(\\\".nii.gz\\\", \\\"_{0:04d}.nii.gz\\\".format(len( \\\\\\n image_suffix_list)))), mask_sitk)\\n for i, image_suffix in enumerate(image_suffix_list):\\n image = mask.replace(\\\".nii.gz\\\", \\\"_{}.nii.gz\\\".format(image_suffix))\\n image_path = os.path.join(images_dir, image)\\n print(image_path)\\n image_sitk = sitk.ReadImage(image_path)\\n image_npy = sitk.GetArrayFromImage(image_sitk)\\n image_output_npy = crop_ND_volume_with_bounding_box(image_npy, crop_bbox_min, crop_bbox_max)\\n save_cropped_array_as_nifty_volume(image_output_npy, os.path.join(images_output_dir, mask.replace( \\\\\\n \\\".nii.gz\\\", \\\"_{0:04d}.nii.gz\\\".format(i))), image_sitk)\\n save_json(json_dict, os.path.join(images_output_dir, \\\"crop_information.json\\\"))\\n if masks_output_dir is not None:\\n save_json(json_dict, os.path.join(masks_output_dir, \\\"crop_information.json\\\"))\",\n \"def make_json(prefix, input_dir):\\n # get list of files\\n file_list = os.listdir(input_dir)\\n # set reference sequence\\n tracklist = {'formatVersion': 1,\\n 'refSeqs': '%s.ref.fa.fai' % prefix,\\n 'tracks': []}\\n # add reference sequence track to tracklist.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Reference sequence\\\",\\n \\\"key\\\": \\\"Reference sequence\\\",\\n \\\"label\\\": \\\"Reference sequence\\\",\\n \\\"type\\\": \\\"SequenceTrack\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/IndexedFasta\\\",\\n \\\"urlTemplate\\\": \\\"%s.ref.fa\\\" % prefix,\\n \\\"refSeqOrder\\\": \\\"False\\\"})\\n tracklist['tracks'].append({\\\"category\\\": \\\"Consensus sequence\\\",\\n \\\"key\\\": \\\"Consensus sequence\\\",\\n \\\"label\\\": \\\"Consensus sequence\\\",\\n \\\"type\\\": \\\"SequenceTrack\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/IndexedFasta\\\",\\n \\\"urlTemplate\\\": \\\"%s.cons.fa\\\" % prefix,\\n \\\"refSeqOrder\\\": \\\"False\\\"})\\n # add bigwig track to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Coverage\\\",\\n \\\"label\\\": \\\"Coverage\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/Wiggle/XYPlot\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BigWig\\\",\\n \\\"autoscale\\\": \\\"local\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.bw\\\" % prefix\\n })\\n # add BAM Sequence Coverage to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Sequence reads (SNPs/Coverage)\\\",\\n \\\"label\\\": \\\"Sequence reads (SNPs/Coverage)\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/SNPCoverage\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BAM\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.capped.bam\\\" % prefix,\\n \\\"cacheMismatches\\\": \\\"True\\\",\\n \\\"chunkSizeLimit\\\": \\\"5000000\\\"\\n })\\n # add BAM Sequence Alignments to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Sequence data\\\",\\n \\\"key\\\": \\\"Sequence reads (Alignment)\\\",\\n \\\"label\\\": \\\"Sequence reads (Alignment)\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/Alignments2\\\",\\n \\\"storeClass\\\": \\\"JBrowse/Store/SeqFeature/BAM\\\",\\n \\\"urlTemplate\\\": \\\"%s.sorted.capped.bam\\\" % prefix,\\n # add bigwig histogram option\\n \\\"cacheMismatches\\\": \\\"True\\\",\\n \\\"chunkSizeLimit\\\": \\\"5000000\\\"\\n })\\n # add GFF3 file to trackList.json\\n tracklist['tracks'].append({\\\"category\\\": \\\"Annotation\\\",\\n \\\"key\\\": \\\"Genbank annotation\\\",\\n \\\"label\\\": \\\"Genbank annotation\\\",\\n \\\"type\\\": \\\"JBrowse/View/Track/CanvasFeatures\\\",\\n \\\"urlTemplate\\\": \\\"%s.gff3.gz\\\" % prefix,\\n \\\"style\\\": {\\n \\\"_defaultHistScale\\\": 4,\\n \\\"_defaultLabelScale\\\": 30,\\n \\\"_defaultDescriptionScale\\\": 120,\\n # Comma-separated list of case-insensitive feature tags to use\\n # for showing the feature's label.\\n # The first one found will be used. Default 'name,id'.\\n \\\"label\\\": \\\"product,id\\\",\\n # style→description\\tComma-separated list of case-insensitive\\n # feature tags to check for the feature's long description.\\n # The first one found will be used. Default 'note,description'.\\n # If blank no description is used.\\n \\\"description\\\": \\\"note, description\\\"\\n },\\n })\\n\\n json_path = os.path.join(input_dir, 'trackList.json')\\n with open(json_path, 'wt') as output_handle:\\n json_raw_str = json.dumps(tracklist, indent=4)\\n output_handle.write(json_raw_str)\\n return 'trackList.json'\",\n \"def generate_clips(input_dir, output_dir, duration=20, ext='.mkv'):\\n \\n i = [0,0,0,0]\\n \\n output_dirs = [os.path.join(output_dir, 'goals'),\\n os.path.join(output_dir, 'bg'),\\n os.path.join(output_dir, 'cards'),\\n os.path.join(output_dir, 'subs')]\\n\\n for dir in output_dirs:\\n if not os.path.exists(dir):\\n os.mkdir(dir)\\n print('Made directory ' + dir)\\n \\n \\n for path in input_dir:\\n print(path)\\n \\n with open(os.path.join(path, 'Labels.json')) as f:\\n file = json.load(f)\\n labels = parseLabels(file)\\n \\n # for each item in label, crop a specified length and save to output_dir\\n for timestamp, label in labels:\\n half = timestamp[0]\\n time = timestamp[1]\\n vid_name = os.path.join(path, half + ext)\\n\\n if time - 5 > 0:\\n\\n if label == 'soccer-ball':\\n # collect an instance of a goal\\n clip_video(vid_name, time - 5, duration, i[0], output_dirs[0])\\n i[0] += 1\\n\\n # collect an instance of a non-goal, if it does not overlap with another event\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n elif 'card' in label:\\n # collect an instance of a carding event\\n clip_video(vid_name, time - 4, duration, i[2], output_dirs[2])\\n i[2] += 1\\n\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n\\n elif 'substitution' in label:\\n # collect an instance of a carding event\\n clip_video(vid_name, time - 4, duration, i[3], output_dirs[3])\\n i[3] += 1\\n\\n if event_overlap(labels, half, time - 45, duration) == False and time - 45 > 0:\\n clip_video(vid_name, time - 45, duration, i[1], output_dirs[1])\\n i[1] += 1\\n\\n print('Saved clip from ' + path)\",\n \"def build_words_map(self, to_clip=True):\\n import clipboard\\n import json_utils\\n words_map = {}\\n rev_map = {}\\n rs = []\\n all_words=self.get_all_words()\\n for word in all_words:\\n key = self.get_norm_key(word)\\n if len(key) > 0:\\n if key in words_map:\\n words_map[key].append(word)\\n else:\\n words_map[key] = [word]\\n rev_map[word] = key\\n rs.append('%s %s' % (key, word))\\n\\n print('write to', self.target_file)\\n json_utils.write_json_to_file(self.target_file, words_map)\\n json_utils.write_json_to_file(self.target_file_rev, rev_map)\\n if to_clip:\\n print('copy to clipboard ...')\\n clipboard.copy('\\\\n'.join(rs))\\n print('done')\",\n \"def raging_fire():\\n\\n if editspin1.get() != '0': # season\\n select_values[0] = int(editspin1.get()) # modify the change\\n select_values[3] = \\\"{}\\\".format(datetime.datetime.now().date()) # update the modify date\\n with open('Other_title_categories.json', 'w') as f:\\n completeDict[curItem] = select_values\\n json.dump(other_categories_foData, f, indent=2)\\n print(\\\"done writing changes\\\")\\n\\n if editspin2.get() != '0': # episode\\n select_values[1] = int(editspin2.get())\\n select_values[3] = \\\"{}\\\".format(datetime.datetime.now().date()) # update the modify date\\n with open('Other_title_categories.json', 'w') as f:\\n completeDict[curItem] = select_values\\n json.dump(other_categories_foData, f, indent=2)\\n print(\\\"done writing changes\\\")\\n\\n if editentvar.get() != curItem: # name\\n removed_values = completeDict.pop(curItem) # remove the previous title and write the new one\\n completeDict[editentvar.get()] = removed_values\\n select_values[3] = \\\"{}\\\".format(datetime.datetime.now().date())\\n with open('Other_title_categories.json', 'w') as f:\\n completeDict[editentvar.get()] = select_values # set the values of the edited title\\n json.dump(other_categories_foData, f, indent=2)\\n print(\\\"done writing changes\\\")\\n\\n edittop.destroy()\",\n \"def test_make_json_advanced(self):\\n resources = get_test_resources()\\n output, filename = make_json(commit=\\\"1245\\\", exclude=[\\\"tei:note\\\", \\\"tei:orig\\\"], credit=\\\"PerseusDL\\\", **resources)\\n output = json.loads(output)\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"0\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Spero me secutum in libellis meis tale temperamen-\\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"1\\\"], \\\"Et comites longae quaeris habere viae, \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"1\\\"][\\\"3\\\"], \\\"Crede mihi, nimium Martia turba sapit. \\\",\\n \\\"Text passages should be parsed correctly and note removed\\\"\\n )\\n self.assertEqual(\\n output[\\\"text\\\"][\\\"1\\\"][\\\"0\\\"][\\\"0\\\"], \\\"Qui tecum cupis esse meos ubicumque libellos \\\",\\n \\\"Text passages should be parsed correctly\\\"\\n )\\n self.assertEqual(\\n filename, \\\"textgroup__work__lat.json\\\",\\n \\\"Filename should be created in a stable and understandable manner\\\"\\n )\\n self.assertEqual(\\n output[\\\"original-urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1\\\",\\n \\\"Original URN should be fed\\\"\\n )\\n self.assertEqual(\\n output[\\\"urn\\\"], \\\"urn:cts:latinLit:textgroup.work.version-lat1-simple\\\",\\n \\\"CLTK URN should be suffixed\\\"\\n )\\n self.assertEqual(\\n output[\\\"credit\\\"], \\\"PerseusDL\\\",\\n \\\"Credit should be empty by default\\\"\\n )\\n self.assertEqual(\\n output[\\\"meta\\\"], \\\"book-poem-line\\\",\\n \\\"meta should reflect the citation scheme\\\"\\n )\\n self.assertEqual(\\n output[\\\"author\\\"], \\\"textgroup\\\",\\n \\\"Author name should be the English textgroup name\\\"\\n )\\n self.assertEqual(\\n output[\\\"work\\\"], \\\"work\\\",\\n \\\"Work name should be the English work name\\\"\\n )\\n self.assertEqual(\\n output[\\\"edition\\\"], \\\"description\\\",\\n \\\"We should have the English description\\\"\\n )\\n self.assertEqual(\\n output[\\\"commit\\\"], \\\"1245\\\",\\n \\\"We should have the commit information\\\"\\n )\",\n \"def _filename_pre_data(self) -> dict:\\n key = []\\n remainder = \\\"\\\"\\n prework = {}\\n for i in self.draft_file:\\n if i == \\\"{\\\":\\n remainder = \\\"\\\"\\n elif i == \\\"}\\\":\\n key.append(remainder)\\n else:\\n remainder += i\\n list_filename = self.filename.split(\\\"_\\\")\\n for key, value in zip(key, list_filename):\\n prework[key] = value\\n self.pre_data = prework\",\n \"def test_get_pathless_raw_file_name_json(self):\\n\\n this_pathless_file_name = probsevere_io._get_pathless_raw_file_name(\\n unix_time_sec=VALID_TIME_UNIX_SEC,\\n file_extension=probsevere_io.JSON_FILE_EXTENSION)\\n\\n self.assertTrue(this_pathless_file_name == PATHLESS_JSON_FILE_NAME)\",\n \"def main():\\r\\n parent_dir = 'D:\\\\\\\\Profession\\\\\\\\Intern\\\\\\\\Assignments\\\\\\\\Codes\\\\\\\\Assignement Codes\\\\\\\\Part 2\\\\\\\\data_dumps'\\r\\n\\r\\n if not (os.path.isdir(parent_dir)):\\r\\n raise Exception(\\\"The directory doesn't exist\\\")\\r\\n\\r\\n directories = []\\r\\n\\r\\n for directory in os.listdir(parent_dir):\\r\\n directories.append(os.path.join(parent_dir, directory))\\r\\n\\r\\n # The group_dic represents the dictionary with keys equal to the unique dates in the directories\\r\\n # And the values represent a list of all files that have the same date prefix across the data_dumps\\r\\n group_dic = grouping(directories)\\r\\n\\r\\n # Moving Files into New Directory\\r\\n move(group_dic, parent_dir)\\r\\n print(\\\"Files Moved Successfully\\\")\",\n \"def main(filename):\\n with open(filename) as json_file:\\n data = json.load(json_file)\\n\\n course_dict = {}\\n course_dict['course_id'] = str(os.path.split(filename.strip('/'))[-1])\\n course_dict['blocks'] = build_course_map(data)\\n\\n filename = '%s' % course_dict['course_id']\\n filepath = os.path.join('../input/', filename)\\n\\n with open(filepath, 'w') as outfile:\\n json.dump(course_dict, outfile, indent=4)\",\n \"def clean_subreddit(filename):\\n\\n # Get name for processed file\\n regex = r\\\"([^\\\\/]+)(?=\\\\-all)\\\"\\n matches = re.search(regex, subreddit_folder)\\n new_file = matches.group(1)\\n\\n # Create list of columns to keep\\n keep_cols = ['id', 'created_utc', 'author', 'title',\\\\\\n 'score', 'num_comments', 'subreddit', 'link_flair_text']\\n\\n keep_cols_text = ['id', 'created_utc', 'author', 'selftext']\\n\\n # Create file name\\n processedfile_csv = \\\"data/processed/submissions/\\\" + new_file + \\\\\\n \\\"-metadata\\\" + \\\".csv\\\"\\n\\n processed_textfile_csv = \\\"data/processed/submissions/\\\" + new_file + \\\\\\n \\\"-text\\\" + \\\".csv\\\"\\n\\n # Create empty data frame\\n df_keep = pd.DataFrame()\\n df_keep_text = pd.DataFrame()\\n\\n # Read in json file\\n try:\\n data = pd.read_json(filename)\\n\\n # ValueError: Trailing data thrown if file is pretty indented\\n except ValueError:\\n data = pd.read_json(filename, lines = True)\\n\\n try:\\n df_keep = df_keep.append(data[keep_cols])\\n except KeyError:\\n keep_cols = ['id', 'created_utc', 'author', 'title',\\\\\\n 'score', 'num_comments', 'subreddit']\\n df_keep = df_keep.append(data[keep_cols])\\n\\n try:\\n df_keep_text = df_keep_text.append(data[keep_cols_text])\\n except KeyError:\\n keep_cols_text = ['id', 'created_utc', 'author']\\n df_keep_text = df_keep_text.append(data[keep_cols_text])\\n\\n\\n # Change date format\\n ## For metadata\\n df_keep['datetime_dv'] = pd.to_datetime(df_keep['created_utc'], unit = 's')# dv = derived\\n df_keep['date_dv'] = df_keep['datetime_dv'].dt.date\\n\\n # For text\\n df_keep_text['datetime_dv'] = pd.to_datetime(df_keep_text['created_utc'], unit = 's')# dv = derived\\n df_keep_text['date_dv'] = df_keep_text['datetime_dv'].dt.date\\n\\n\\n ##### Delimit by date #####\\n # Create mask of time slot\\n mask = (df_keep['date_dv'] >= start) & (df_keep['date_dv'] <= end) # inclusive on either end\\n mask_text = (df_keep_text['date_dv'] >= start) & (df_keep_text['date_dv'] <= end)\\n\\n # Only keep data within date frame\\n df_keep = df_keep.loc[mask]\\n df_keep_text = df_keep_text.loc[mask_text]\\n ############################\\n\\n\\n # Save to json\\n df_keep_text.to_csv(processed_textfile_csv, mode = \\\"w\\\")\\n df_keep.to_csv(processedfile_csv, mode = \\\"w\\\") # mode= w will overwrite previous file\\n print(len(df_keep_text.index))\\n print(processed_textfile_csv)\\n\\n\\n data = [] # force empty\",\n \"def test_raw_file_name_to_time_json_alternative(self):\\n\\n this_time_unix_sec = probsevere_io.raw_file_name_to_time(\\n ALTERNATIVE_JSON_FILE_NAME)\\n\\n self.assertTrue(this_time_unix_sec == VALID_TIME_UNIX_SEC)\",\n \"def process(self):\\n first_line = self.setup[\\\"first_line\\\"]\\n last_line = self.setup[\\\"last_line\\\"]\\n\\n self.logger.info(\\\"Using lines %s - %s\\\", first_line, last_line)\\n\\n path_temp = \\\"{}_\\\".format(self.path)\\n\\n with open(self.path, \\\"r\\\") as src, open(path_temp, \\\"w\\\") as dest:\\n lines = src.r..\\n copy_lines = lines[first_line-1:last_line]\\n dest.write(\\\"\\\".join(copy_lines))\\n\\n os.rename(path_temp, self.path)\",\n \"def _clean_up_project_file(self):\\n\\n print \\\"Reading in project file...\\\"\\n with open(self.project_file,'r') as f_in:\\n project_json = json.load(f_in)\\n\\n # Go through design_files references\\n configurations = project_json['Project']['Configurations']\\n n = len(configurations)\\n indices_to_delete = []\\n for i in range(n):\\n if not os.path.basename(configurations[i]) in self.design_files:\\n indices_to_delete.append(i)\\n\\n indices_to_delete.reverse()\\n for i in indices_to_delete:\\n del configurations[i]\\n\\n # Go through design_space_files references\\n design_space_models = project_json['Project']['DesignSpaceModels']\\n n = len(design_space_models)\\n indices_to_delete = []\\n for i in range(n):\\n if not os.path.basename(design_space_models[i]) in self.design_space_files:\\n indices_to_delete.append(i)\\n\\n indices_to_delete.reverse()\\n for i in indices_to_delete:\\n del design_space_models[i]\\n\\n # Go through test_bench_files references\\n #test_benches = project_json['Project']['TestBenches']\\n #n = len(test_benches)\\n #indices_to_delete = []\\n #for i in range(n):\\n # if not os.path.basename(test_benches[i]) in self.test_bench_files:\\n # indices_to_delete.append(i)\\n #\\n #for i in indices_to_delete.reverse():\\n # del test_benches[i]\\n\\n # Write out the new, reduced in size, project dictionary\\n with open(self.project_file,'wb') as f_out:\\n json.dump(project_json, f_out, indent=4)\\n\\n print \\\"Written out cleaned up project dictionary.\\\"\",\n \"def create_newfile():\\n date = datetime.today().strftime('%d_%m_%Y').replace(\\\" \\\", \\\"_\\\")\\n file_name = screen_name + '_' + date + \\\".json\\\"\\n with io.FileIO(file_name, \\\"w\\\") as file:\\n file.write(\\\"Json\\\")\\n file.close()\\n return file_name\",\n \"def cleanJson(filename):\\n saveFile = 'newFile.json'\\n\\n # check if file exists and exit if it does\\n if os.path.exists(saveFile):\\n return\\n\\n with open(filename) as f:\\n contents = f.readlines()\\n\\n with open('newFile.json', 'a') as outfile:\\n for line in contents:\\n # convert line from JSON to Python dictionary\\n dic = decode(line)\\n # convert dic to a string representing a json object\\n json_obj = json.dumps(dic)\\n outfile.write(json_obj) # write to outfile\\n outfile.write(\\\"\\\\n\\\")\",\n \"def transform_file(input_file_path: str, output_file_path: str):\\n\\n # Open json\\n with open(input_file_path, mode=\\\"r\\\") as in_file:\\n input_data = json.load(in_file)\\n\\n # Transform and write\\n with jsonlines.open(output_file_path, mode=\\\"w\\\", compact=True) as out_file:\\n for item in input_data[\\\"items\\\"]:\\n out_file.write(transform_item(item))\",\n \"def newJsonFile():\\n nonlocal currentFile\\n currentFile = join(rootFolder, 'tweetsRaw-' + str(now()) + '.json')\\n f = open(currentFile)\\n f.write('[\\\\n')\\n return f\",\n \"def write_to_json(data):\\n # Serializing json \\n json_object = json.dumps(data, indent = 4) \\n\\n date = datetime.now()\\n date_str = date.strftime(\\\"%y%m%d_%H%M\\\")\\n \\n # Writing to sample.json \\n with open(\\\"./intraday_data/json/i_data_{0}_{1}.json\\\".format(date_str, int(time.time())), \\\"w\\\") as outfile: \\n outfile.write(json_object)\",\n \"def load_clip_times(clip_list_file, path_to_data, start_times_file, output_dir, mouse_type):\\n print \\\"clip_list_file\\\", clip_list_file\\n pkl_file = open(clip_list_file, 'rb')\\n all_peak_times_dict = pickle.load(pkl_file)\\n all_peak_vals_dict = pickle.load(pkl_file)\\n all_local_times_dict = pickle.load(pkl_file)\\n all_interaction_start_times_dict = pickle.load(pkl_file)\\n all_interaction_end_times_dict = pickle.load(pkl_file)\\n all_start_times_dict = load_start_times(start_times_file)\\n\\n movie_info_dict = dict()\\n for name in all_peak_times_dict.keys():\\n movie_info = dict()\\n movie_info['movie_file'] = get_movie_file(name, path_to_data)\\n movie_info['output_file'] = get_output_file(name, output_dir)\\n movie_info['peak_times'] = all_peak_times_dict[name]\\n movie_info['peak_vals'] = all_peak_vals_dict[name]\\n # movie_info['local_times'] = all_local_times_dict[name]\\n movie_info['name'] = name\\n movie_info['start_time'] = all_start_times_dict[name]\\n movie_info['interaction_start'] = all_interaction_start_times_dict[name]\\n movie_info['interaction_end'] = all_interaction_end_times_dict[name]\\n movie_info['mouse_type'] = mouse_type\\n\\n movie_info_dict[name] = movie_info\\n return movie_info_dict\",\n \"def __cleaned(game, json):\\n link = game.link\\n title = \\\" - \\\".join(map(lambda x: x.strip(), game.title.split('-')))\\n date = datetime.datetime(*game.updated_parsed[:6])\\n\\n # convert date to timestamp\\n if json:\\n date = date.strftime('%a, %d %b %Y')\\n \\n return {'title': title, 'link': link, 'date': date}\",\n \"def updateCache(self):\\n for root, dirs, files in os.walk(cachedFilesPath):\\n for file in files:\\n if file.endswith(cachedFileExtensionSuffix):\\n path = os.getcwd()+'/'+cachedFilesPath+file\\n with open(path, mode='r') as f:\\n payload_json = f.read()\\n payload_obj=jsonpickle.decode(payload_json)\\n r= self.upload(payload_obj)\\n if isinstance(r, types.NoneType):\\n #do nothing\\n print(\\\"\\\")\\n else:\\n if r.status_code == 200 :\\n #uploaded!\\n if cacheArhive:\\n #move it to archive\\n dst=os.getcwd()+'/'+cachedArchivePath+file\\n shutil.move(path, dst)\\n print(\\\"archived log: \\\", file)\\n else:\\n #delete it\\n os.remove(path)\",\n \"def patch_files():\\n args = parser.parse_args()\\n doc = json.load(args.ORIGINAL)\\n patch = json.load(args.PATCH)\\n result = jsonpatch.apply_patch(doc, patch)\\n print(json.dumps(result, indent=args.indent))\",\n \"def write_new_date(self) -> None:\\n\\n with open(str(os.path.join(THIS_DIR, \\\"data_file.json\\\")), mode='r') as json_file:\\n data = json.load(json_file)\\n data[self.site] = str(self.get_last_image_date())\\n json_file.close()\\n with open(str(os.path.join(THIS_DIR, \\\"data_file.json\\\")), mode='w') as json_file:\\n json.dump(data, json_file)\\n json_file.close()\",\n \"def correct_naming(obsid, inst):\\n cobsid = str(int(float(obsid)))\\n if len(cobsid) == 5:\\n return \\n\\n lobsid = mcf.add_leading_zero(obsid, 5)\\n \\n for sdir in ['secondary', 'analysis']:\\n\\n cmd = 'ls /data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/hrcf* >' + zspace\\n os.system(cmd)\\n\\n data = mcf.read_data_file(zspace, remove=1)\\n for ent in data:\\n atemp = re.split('\\\\/', ent)\\n fname = atemp[-1]\\n mc = re.search(lobsid, fname)\\n if mc is not None:\\n continue\\n else:\\n atemp = re.split('hrcf', fname)\\n btemp = re.split('_', atemp[1])\\n sobs = btemp[0]\\n new = fname.replace(sobs, lobsid)\\n full = '/data/hrc/' + inst + '/' + lobsid + '/' + sdir + '/' + new\\n\\n cmd = 'mv ' + ent + ' ' + full\\n os.system(cmd)\",\n \"def _rebuildOcean(self, tk, templateFile = '', fields = '', id = '', shotNum = '', inprogressBar = ''):\\r\\n\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Deleting current Ocean now....', verbose = False)\\r\\n\\t\\tself._removeOcean()\\r\\n\\r\\n\\t\\t## Get all the publishes from shotgun now for the blocking or animation step as required..\\r\\n\\t\\tif self.app.get_setting('shotStep') == 'Blocking':\\r\\n\\t\\t\\tgetAnimVersionFolders = tk.paths_from_template(templateFile, {'Step' : 'Blck', 'id' : id, 'Shot' : shotNum})\\r\\n\\t\\telif self.app.get_setting('shotStep') == 'Animation':\\r\\n\\t\\t\\tgetAnimVersionFolders = tk.paths_from_template(templateFile, {'Step' : 'Anm', 'id' : id, 'Shot' : shotNum})\\r\\n\\r\\n\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'getAnimVersionFolders...%s' % getAnimVersionFolders, verbose = False)\\r\\n\\r\\n\\t\\t## Fix path for maya to read in properly\\r\\n\\t\\tif getAnimVersionFolders:\\r\\n\\t\\t\\t## now find the highest version folder number\\r\\n\\t\\t\\thighestVersionFolder = r'%s' % max(getAnimVersionFolders)\\r\\n\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'highestVersionFolder...%s' % highestVersionFolder, verbose = False)\\r\\n\\r\\n\\t\\t\\thighestVersionFolder = highestVersionFolder.replace('\\\\\\\\', '/')\\r\\n\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'highestVersionFolder replaced \\\\\\\\ with /...\\\\n%s' % highestVersionFolder, verbose = False)\\r\\n\\r\\n\\t\\t\\tversionNumber = highestVersionFolder.split('/')[-1]\\r\\n\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'versionNumber: %s' % versionNumber, verbose = False)\\r\\n\\r\\n\\t\\t\\tgetCacheFiles = os.listdir(highestVersionFolder)\\r\\n\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'getCacheFiles...\\\\n%s' % getCacheFiles, verbose = False)\\r\\n\\t\\t\\t##################################################################################################################\\r\\n\\t\\t\\t## APPLY OCEAN PRESET TO A NEW OCEAN\\r\\n\\t\\t\\tif 'publish/fx' in highestVersionFolder: ## The ocean preset.mel is saved out to the fx folder in the animation/publish/fx folders\\r\\n\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Loading ocean files now...', verbose = False)\\r\\n\\r\\n\\t\\t\\t\\t## Build the group if it doesn't already exist\\r\\n\\t\\t\\t\\tself._buildGroup('FX_CACHES_hrc', versionNumber)\\r\\n\\r\\n\\t\\t\\t\\t## No maya ocean in scene? Build a new one...\\r\\n\\t\\t\\t\\tif not cmds.objExists('oceanShader1'):\\r\\n\\t\\t\\t\\t\\tmel.eval(\\\"CreateOcean;\\\")\\r\\n\\r\\n\\t\\t\\t\\t\\t## Clean up the names\\r\\n\\t\\t\\t\\t\\t## NOTE we are not renaming the actual OCEAN SHADER here because in Marks scripts we are reconnecting like so\\r\\n\\t\\t\\t\\t\\t## cmds.disconnectAttr('oceanShader1.outColor', 'oceanShader1SG.surfaceShader')\\r\\n\\t\\t\\t\\t\\theightField = cmds.listRelatives(cmds.ls(selection = True)[0], parent = True, fullPath = True)[0]\\r\\n\\t\\t\\t\\t\\tcmds.rename(heightField, 'oceanPreviewPlane_prv')\\r\\n\\t\\t\\t\\t\\tcmds.rename('oceanPlane1', 'ocean_srf')\\r\\n\\t\\t\\t\\t\\tcmds.rename('oceanPreviewPlane1', 'oceanPreviewPlane_heightF')\\r\\n\\t\\t\\t\\t\\tcmds.parent('ocean_srf', 'FX_CACHES_hrc')\\r\\n\\t\\t\\t\\t\\tcmds.parent('oceanPreviewPlane_prv', 'FX_CACHES_hrc')\\r\\n\\t\\t\\t\\t\\tcmds.rename('oceanShader1', CONST.OCEANDISPSHADER)\\r\\n\\t\\t\\t\\t\\tcmds.rename('oceanShader1SG', '%sSG' % CONST.OCEANDISPSHADER)\\r\\n\\r\\n\\t\\t\\t\\t\\t## Lock translateY and rotation so that monkeys don't mess up with the ocean level\\r\\n\\t\\t\\t\\t\\ttoLock = ['translateY', 'rotateX', 'rotateY', 'rotateZ']\\r\\n\\t\\t\\t\\t\\tfor attr in toLock:\\r\\n\\t\\t\\t\\t\\t\\tcmds.setAttr('ocean_srf.%s' % attr, lock = True)\\r\\n\\r\\n\\t\\t\\t\\t\\t## Hard set the render tesselation\\r\\n\\t\\t\\t\\t\\tcmds.setAttr(\\\"ocean_srfShape.numberU\\\", 200)\\r\\n\\t\\t\\t\\t\\tcmds.setAttr(\\\"ocean_srfShape.numberV\\\", 200)\\r\\n\\r\\n\\t\\t\\t\\t\\tallOceans = cmds.ls(type= 'oceanShader')\\r\\n\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'allOceans: %s' % allOceans, verbose = False)\\r\\n\\r\\n\\t\\t\\t\\t\\t## now put the ocean in the right position\\r\\n\\t\\t\\t\\t\\tif cmds.objExists('fluids_hrc'):\\r\\n\\t\\t\\t\\t\\t\\tself._setOceanLocation()\\r\\n\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\tif cmds.objExists('ocean_srf') and cmds.objExists('oceanPreviewPlane_prv'):\\r\\n\\t\\t\\t\\t\\t\\t\\tif not cmds.isConnected('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX'):\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcmds.connectAttr('oceanPreviewPlane_prv.translateX', 'ocean_srf.translateX', f = True)\\r\\n\\t\\t\\t\\t\\t\\t\\tif not cmds.isConnected('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ'):\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tcmds.connectAttr('oceanPreviewPlane_prv.translateZ', 'ocean_srf.translateZ', f = True)\\r\\n\\t\\t\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\t\\t\\tcmds.warning('MISSING ocean_srf or oceanPreviewPlane_prv node from scene...')\\r\\n\\r\\n\\t\\t\\t\\tfor each in getCacheFiles:\\r\\n\\t\\t\\t\\t\\t## Now attach the preset to the maya ocean build a new one if it doesn't already exist\\r\\n\\t\\t\\t\\t\\tif each.endswith('.mel'): ## the ocean shader preset saved out\\r\\n\\t\\t\\t\\t\\t\\tpathToPreset = '%s/%s' % (highestVersionFolder, each)\\r\\n# presetVersion = each.split('/')\\r\\n\\r\\n\\t\\t\\t\\t\\t\\t## Now apply the exported preset to each ocean in the scene. There really should only be ONE\\r\\n\\t\\t\\t\\t\\t\\tfor eachOcean in allOceans:\\r\\n\\t\\t\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Add version number for ocean preset on Ocean_Hrc', verbose = False)\\r\\n\\t\\t\\t\\t\\t\\t\\tif cmds.objExists('FX_CACHES_hrc'):\\r\\n\\t\\t\\t\\t\\t\\t\\t\\tif not cmds.objExists('FX_CACHES_hrc.presetVersion'):\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcmds.addAttr('FX_CACHES_hrc', ln='presetVersion', dt='string')\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcmds.setAttr('FX_CACHES_hrc.presetVersion' , versionNumber, type='string')\\r\\n\\t\\t\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Applying ocean preset: %s to %s' % (pathToPreset, eachOcean), verbose = False)\\r\\n\\t\\t\\t\\t\\t\\t\\tmel.eval( 'applyPresetToNode \\\"%s\\\" \\\"\\\" \\\"\\\" \\\"%s\\\" 1;' %(eachOcean, pathToPreset) )\\r\\n\\t\\t\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean and presets assigned successfully...', verbose = False)\\r\\n\\r\\n\\t\\t\\t\\t\\t## Import ATOM\\r\\n\\t\\t\\t\\t\\tif each.endswith('.atom'):\\r\\n\\t\\t\\t\\t\\t\\tpathToPreset = '%s/%s' % (highestVersionFolder, each)\\r\\n\\t\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Transferring ocean shader\\\\'s animation from %s' % pathToPreset, verbose = False)\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tmel.eval('performImportAnim 1;')\\r\\n\\t\\t\\t\\t\\t\\tcmds.select(allOceans, replace = True)\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tcmds.file(pathToPreset,\\r\\n\\t\\t\\t\\t\\t\\ttype = 'atomImport',\\r\\n\\t\\t\\t\\t\\t\\ti = True,\\r\\n\\t\\t\\t\\t\\t\\tra = True,\\r\\n\\t\\t\\t\\t\\t\\tnamespace = 'oceanDisp_shader',\\r\\n\\t\\t\\t\\t\\t\\toptions = '; ; targetTime = 3; option = insert; match = hierarchy; selected = selectedOnly; search = ; replace = ; prefix = ; suffix = ; mapFile = ;',\\r\\n\\t\\t\\t\\t\\t\\t)\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tif cmds.window('OptionBoxWindow', exists = True):\\r\\n\\t\\t\\t\\t\\t\\t\\tcmds.deleteUI('OptionBoxWindow', window = True)\\r\\n\\r\\n\\t\\t\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean shader\\\\'s animation transferred successfully.', verbose = False)\\r\\n\\r\\n\\t\\t\\t\\tdebug(app = self.app, method = '_rebuildOcean', message = 'Ocean imported successfully...', verbose = False)\",\n \"def convert_to_json(basepath, sendto):\\n\\n logger = logging.getLogger('WikiLog')\\n\\n k = bucket.new_key(basepath)\\n\\n filenames = []\\n year = month = day = hrs = ''\\n\\n for key in bucket.list():\\n thisfile = key.name.encode('utf-8')\\n if 'projectviews' not in thisfile and 'sql' not in thisfile and '.gz' in thisfile and thisfile.startswith(basepath):\\n # S3 key name is of the format kt-wiki/pageviews/2016/2016-06/pageviews-20160601-000000.gz\\n # Split by / to get last element\\n filenames.append(thisfile)\\n logger.info(\\\"Processing file: {}\\\".format(thisfile))\\n fname = thisfile.split('/')\\n\\n # Get content from filename and save to local\\n # Split again to Grab year, month, day, hour value from filename\\n key.get_contents_to_filename('/home/ubuntu/WikiView/data/' + fname[-1])\\n fname1 = fname[-1]\\n data_time = fname1[:-3].split('-')\\n year, month, day, hrs = data_time[1][:4], data_time[1][4:6], data_time[1][-2:], data_time[-1]\\n\\n docname = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\\n dictlist = []\\n\\n # save file from s3 to local, read, write to json, push json to s3\\n with open(docname, 'w') as fp:\\n #\\n with gzip.open('/home/ubuntu/WikiView/data/'+fname[-1],'r') as fin:\\n for line in fin:\\n line = line.split(' ')\\n doc = {}\\n doc['ymdh'] = year + '-' + month + '-' + day + '-' + hrs\\n try:\\n # format: project, title, views, bytes ~ en Main_Page 242332 4737756101\\n prj, title, vcount = line[0], line[1], line[2]\\n doc['prj'] = prj\\n doc['title'] = title\\n doc['vcount'] = vcount\\n json.dump(doc,fp)\\n fp.write('\\\\n')\\n except:\\n logger.error('Error reading gzip file {} at line: {}'.format(thisfile, line))\\n pass\\n# sys.exc_clear()\\n\\n # Now, save the json file to \\n key_name = 'pageviews-' + year + '-' + month + '-' + day + '-' + hrs + '.json'\\n full_key_name = os.path.join(sendto, key_name)\\n k = bucket.new_key(full_key_name)\\n\\n logger.info(\\\"Sending json file to S3: {}\\\".format(docname))\\n k.set_contents_from_filename(key_name)\\n\\n # Remove temp file\\n logger.info(\\\"Removing temp file: {} {}\\\".format('/home/ubuntu/WikiView/data/', fname[-1]))\\n os.remove('/home/ubuntu/WikiView/data/'+fname[-1])\\n logger.info(\\\"Removing temp file: {}\\\".format(key_name))\\n os.remove(key_name)\\n logger.info('Finished!!!')\",\n \"def test_create_json(civic, diff):\\n test_date = '19980108'\\n civic._create_json(diff, test_date)\\n file_name = APP_ROOT / 'data' / 'civic' / 'delta' / f'civic_deltas' \\\\\\n f'_{test_date}.json'\\n assert file_name.exists()\\n os.remove(file_name)\\n assert not file_name.exists()\",\n \"def importFile(self):\\n\\n ## Backing up old CSV and JSON files before beginning import operations\\n if os.path.isfile(\\\"text_files/customers.csv\\\") and os.path.isfile(\\\"text_files/customers.json\\\"):\\n print(\\\"\\\\nCreating a backup of the existing customer .csv and .json files before overwriting\\\")\\n shutil.copy2(\\\"text_files/customers.csv\\\", \\\"text_files/customers.csv.backup\\\" + str(time.time()))\\n shutil.copy2(\\\"text_files/customers.json\\\", \\\"text_files/customers.json.backup\\\" + str(time.time()))\\n\\n ## Importing the text file for cleaning then converting to CSV\\n input_file = open(\\\"text_files/customer_export.txt\\\", \\\"r\\\")\\n output_file = open(\\\"text_files/customers.csv\\\", \\\"w\\\")\\n\\n ## A loop to clean and write the customer_export txt file to a CSV\\n for line in input_file:\\n clean_text = \\\"\\\"\\n check_line = line.replace(\\\"#\\\", \\\"\\\").replace(\\\",,\\\",\\\"\\\").split(\\\"|\\\")\\n for line in check_line:\\n if line != check_line[10]:\\n clean_text += line + \\\",\\\"\\n elif line == check_line[10]:\\n clean_text += line + \\\"\\\\n\\\"\\n output_file.write(clean_text)\\n\\n ## Closing TXT file and CSV file after formatting\\n input_file.close()\\n output_file.close()\\n\\n ## Opening the cleaned CSV file for conversion to Json\\n with open('text_files/customers.csv') as clean_csv:\\n ## Converting CSV file to Json\\n converted = csv.DictReader(clean_csv)\\n rows = list(converted)\\n\\n ## Writing converted CSV to Json file\\n with open('text_files/customers.json', 'w') as convert:\\n json.dump(rows, convert)\\n\\n ## Deleting all data currently in database before importing new file\\n db_connection.executeQuery(\\\"DELETE FROM CRM;DBCC CHECKIDENT ('CRM', RESEED, 0) DELETE FROM Mailings; DBCC CHECKIDENT ('Mailings', RESEED, 0) COMMIT\\\") \\n\\n ## Loading the newly created Json file\\n with open(\\\"text_files/customers.json\\\") as customers_json:\\n customers = json.load(customers_json)\\n\\n ## A loop to add the contents of the Json file to the database \\n print(\\\"Writing imported file to database please wait...\\\")\\n for key in customers:\\n db_connection.executeQuery(\\\"INSERT INTO dbo.CRM (f_name, l_name, company, address, city, county, state, zip, primary_phone, secondary_phone, email_address) VALUES ('\\\" + key[\\\"first_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"last_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"company_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"address\\\"] + \\\"', '\\\" + key[\\\"city\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"county\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"state\\\"] + \\\"', '\\\" + str(key[\\\"zip\\\"]) + \\\"', '\\\" + key[\\\"phone1\\\"] + \\\"', '\\\" + key[\\\"phone2\\\"] + \\\"' , '\\\" + key[\\\"email\\\"] + \\\"'); COMMIT\\\")\\n db_connection.executeQuery(\\\"INSERT INTO dbo.Mailings (name, company, address) VALUES ('\\\" + key[\\\"first_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\" \\\" + key[\\\"last_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"', '\\\" + key[\\\"company_name\\\"].replace(\\\"\\\\'\\\", \\\"\\\\'\\\\'\\\") + \\\"','\\\" + key[\\\"address\\\"] + \\\" \\\" + key[\\\"city\\\"] + \\\" \\\" + key[\\\"county\\\"] + \\\" \\\" + key[\\\"state\\\"] + \\\" \\\" + str(key[\\\"zip\\\"]) + \\\"'); COMMIT\\\") \\n\\n print(\\\"\\\\nFinished writing to file. Returning to main menu...\\\")\",\n \"def convert_schema(bco, filename, mapping_dict):\\n for item in mapping_dict['to_swap']:\\n value_list = mapping_dict['to_swap'][item]\\n for i in range(0, len(value_list)):\\n rename_dict_key_HELPER(bco, value_list[i]['index'],\\n value_list[i]['value']) # Change key name\\n\\n for item in mapping_dict['to_delete']:\\n value_list = mapping_dict['to_delete'][item]\\n for i in range(0, len(value_list)):\\n delete_key_HELPER(bco, value_list[i]['index'], value_list[i]['value']) # delete key\\n\\n for item in mapping_dict['to_add']:\\n value_list = mapping_dict['to_add'][item]\\n for i in range(0, len(value_list)):\\n set_key_in_dict_HELPER(bco, value_list[i]['index'], value_list[i]['value']) # add key\\n\\n new_bco = bco\\n try:\\n new_bco['provenance_domain'][\\n 'modified'] = datetime.now().isoformat() # change date to current\\n\\n temp_bco = dict(new_bco)\\n del temp_bco['object_id'], temp_bco['etag'], temp_bco['spec_version']\\n\\n new_bco['spec_version'] = \\\"https://w3id.org/ieee/ieee-2791-schema/2791object.json\\\"\\n new_bco[\\\"etag\\\"] = sha256(json.dumps(temp_bco).encode('utf-8')).hexdigest()\\n except KeyError: # Vital field was missing, will be caught by final error checker\\n pass\\n file = open(filename, \\\"w\\\")\\n json.dump(new_bco, file, indent=4)\",\n \"def beautify_json(self) -> None:\\n for letter in self.data:\\n for category in self.data[letter]:\\n self.data[letter][category] = str(self.data[letter][category.lower()])\\n self.save()\\n with open(dict_path, encoding='utf-8') as x:\\n data = x.read()\\n with open(dict_path, 'w', encoding='utf-8') as y:\\n data2 = data.replace('\\\"[', '[').replace(']\\\"', ']').replace(\\\"'\\\", '\\\"')\\n y.write(data2)\",\n \"def repairZeptoData(self, zeptoData):\\n # Check for duplicate slide records, for the same slide file.\\n slidePaths = set([slide[\\\"Slide\\\"] for slide in zeptoData[\\\"Slides\\\"]])\\n pathToSlideIds = {slidePath:[] for slidePath in slidePaths}\\n for slide in zeptoData[\\\"Slides\\\"]:\\n pathToSlideIds[slide[\\\"Slide\\\"]].append(slide[\\\"NumId\\\"])\\n\\n duplicateSlideIds = [(k, v) for (k, v) in pathToSlideIds.items() if len(v) != 1]\\n with open(lisaConfig.dataFolderPath + \\\"debugDuplicateSlideIDs.json\\\", \\\"w\\\") as fp:\\n json.dump(duplicateSlideIds, fp, indent=2)\\n\\n # Slides with \\\"enhaced\\\" style.\\n slidesWithEnhaced = [slide[\\\"NumId\\\"] for slide in zeptoData[\\\"Slides\\\"] if slide[\\\"Style\\\"] == \\\"Enhaced\\\"]\\n with open(lisaConfig.dataFolderPath + \\\"slidesWithEnhacedStyle.json\\\", \\\"w\\\") as fp:\\n json.dump(slidesWithEnhaced, fp, indent=2)\\n\\n for slide in zeptoData[\\\"Slides\\\"]:\\n # Style has Enhanced mis-spelled as Enhaced for some slides.\\n if slide[\\\"Style\\\"] == \\\"Enhaced\\\":\\n slide[\\\"Style\\\"] = \\\"Enhanced\\\"\\n\\n # Content has Limited which is mis-spelled as Light for some slides.\\n if slide[\\\"Content\\\"] == \\\"Light\\\" or not slide[\\\"Content\\\"]:\\n slide[\\\"Content\\\"] = \\\"Limited\\\"\\n\\n # Content has Medium which is mis-spelled as Moderate/Modeate for some slides.\\n if slide[\\\"Content\\\"] == \\\"Moderate\\\" or slide[\\\"Content\\\"] == \\\"Modeate\\\":\\n slide[\\\"Content\\\"] = \\\"Medium\\\"\\n\\n # Parts of tag data are corrupted. Fixing.\\n slideTagLists = []\\n for tag in slide[\\\"Tags\\\"]:\\n tag = tag.strip().lower()\\n if tag.count(\\\",\\\") >= 3:\\n slideTagLists.append(tag.split(\\\",\\\"))\\n elif tag.count(\\\" \\\") >= 3:\\n slideTagLists.append(tag.split(\\\" \\\"))\\n else:\\n slideTagLists.append([tag])\\n\\n # Force unqiueness.\\n slideTagsSet = set()\\n for tagList in slideTagLists:\\n for tag in tagList:\\n if tag:\\n slideTagsSet.add(tag)\\n\\n # Keep the list in canonical form.\\n slide[\\\"Tags\\\"] = sorted([tag.strip() for tag in slideTagsSet])\\n return zeptoData\",\n \"def transformZeptoData(self, zeptoData):\\n retval = {}\\n # Make all the latest concepts compatible with SlideDB system.\\n transformedConcepts = []\\n conceptsDict = {}\\n for latestConcept in zeptoData[\\\"Concepts\\\"]:\\n transformedConcept = {}\\n\\n # ID at the server can be obtained from zeptoId attribute.\\n # transformedSlide[\\\"parent\\\"] = self.baseURL + \\\"slidedb/constructs/\\\" + str(latestSlide[\\\"ConstructId\\\"]) + \\\"/\\\"\\n # zeptoSlideForAtto[\\\"enabled\\\"] = slide[\\\"Enabled\\\"]\\n transformedConcept[\\\"enabled\\\"] = True if latestConcept[\\\"Enabled\\\"] == \\\"Y\\\" else False\\n transformedConcept[\\\"name\\\"] = latestConcept[\\\"Name\\\"].strip()\\n transformedConcept[\\\"zeptoId\\\"] = latestConcept[\\\"NumId\\\"]\\n\\n conceptsDict[transformedConcept[\\\"zeptoId\\\"]] = transformedConcept\\n transformedConcepts.append(transformedConcept)\\n retval[\\\"Concepts\\\"] = transformedConcepts\\n\\n # Make all the latest subConcepts compatible with SlideDB system.\\n transformedSubConcepts = []\\n subConceptsDict = {}\\n for latestSubConcept in zeptoData[\\\"SubConcepts\\\"]:\\n transformedSubConcept = {}\\n # ID at the server can be obtained from zeptoId attribute.\\n transformedSubConcept[\\\"parent\\\"] = conceptsDict[int(latestSubConcept[\\\"Parent\\\"])]\\n transformedSubConcept[\\\"enabled\\\"] = True if latestSubConcept[\\\"Enabled\\\"] == \\\"Y\\\" else False\\n transformedSubConcept[\\\"name\\\"] = latestSubConcept[\\\"Name\\\"].strip()\\n transformedSubConcept[\\\"zeptoId\\\"] = latestSubConcept[\\\"NumId\\\"]\\n\\n subConceptsDict[transformedSubConcept[\\\"zeptoId\\\"]] = transformedSubConcept\\n transformedSubConcepts.append(transformedSubConcept)\\n\\n retval[\\\"SubConcepts\\\"] = transformedSubConcepts\\n\\n # Make all the latest subConcepts compatible with SlideDB system.\\n transformedConstructs = []\\n constructsDict = {}\\n for latestConstruct in zeptoData[\\\"Constructs\\\"]:\\n transformedConstruct = {}\\n\\n # ID at the server can be obtained from zeptoId attribute.\\n transformedConstruct[\\\"parent\\\"] = subConceptsDict[int(latestConstruct[\\\"Parent\\\"])]\\n transformedConstruct[\\\"enabled\\\"] = True if latestConstruct[\\\"Enabled\\\"] == \\\"Y\\\" else False\\n transformedConstruct[\\\"name\\\"] = latestConstruct[\\\"Name\\\"].strip()\\n transformedConstruct[\\\"zeptoId\\\"] = latestConstruct[\\\"NumId\\\"]\\n\\n constructsDict[transformedConstruct[\\\"zeptoId\\\"]] = transformedConstruct\\n transformedConstructs.append(transformedConstruct)\\n retval[\\\"Constructs\\\"] = transformedConstructs\\n\\n # Make all the latest slides compatible with SlideDB system.\\n transformedSlides = []\\n for latestSlide in zeptoData[\\\"Slides\\\"]:\\n transformedSlide = AttrDict()\\n\\n # ID at the server can be obtained from zeptoId attribute.\\n transformedSlide[\\\"parent\\\"] = constructsDict[int(latestSlide[\\\"Parent\\\"])]\\n transformedSlide[\\\"tags\\\"] = latestSlide[\\\"Tags\\\"]\\n\\n # zeptoSlideForAtto[\\\"enabled\\\"] = slide[\\\"Enabled\\\"]\\n transformedSlide[\\\"enabled\\\"] = True\\n transformedSlide[\\\"pptFile\\\"] = urllib.parse.quote(latestSlide[\\\"Slide\\\"], \\\"/:\\\")\\n transformedSlide[\\\"thumbnailFile\\\"] = urllib.parse.quote(latestSlide[\\\"Thumbnail\\\"], \\\"/:\\\")\\n transformedSlide[\\\"hasIcon\\\"] = True if latestSlide[\\\"Icon\\\"].lower() == \\\"yes\\\" else False\\n transformedSlide[\\\"hasImage\\\"] = True if latestSlide[\\\"Image\\\"].lower() == \\\"yes\\\" else False\\n transformedSlide[\\\"layout\\\"] = latestSlide[\\\"Layout\\\"]\\n transformedSlide[\\\"style\\\"] = latestSlide[\\\"Style\\\"]\\n transformedSlide[\\\"content\\\"] = latestSlide[\\\"Content\\\"]\\n transformedSlide[\\\"zeptoId\\\"] = latestSlide[\\\"NumId\\\"]\\n transformedSlide[\\\"zeptoDownloads\\\"] = latestSlide[\\\"Downloads\\\"]\\n transformedSlides.append(transformedSlide)\\n retval[\\\"Slides\\\"] = transformedSlides\\n\\n return retval\",\n \"def loadAndClean(jfile):\\n with open(jfile) as json_file:\\n data = json.load(json_file)[\\\"G15\\\"]\\n newDict = {}\\n # Print the type of data variable\\n \\n for entry in data:\\n\\n if \\\"version\\\" in data[entry] and data[entry][\\\"assessed_by\\\"] not in filterList:\\n\\n if data[entry][\\\"assessed_by\\\"] in dictTries:\\n dictTries[data[entry][\\\"assessed_by\\\"]].append(data[entry])\\n\\n \\n\\n if len(dictTries[data[entry][\\\"assessed_by\\\"]]) == 2:\\n ml = dictTries[data[entry][\\\"assessed_by\\\"]]\\n #vou querer calcular o maior \\n # comparisson = \\\"accuracy\\\"\\n comparisson = \\\"target_w_penalty\\\"\\n \\n if ml[0][comparisson] <= ml[1][comparisson]:\\n if ml[0][\\\"accuracy\\\"] > 90:\\n printSingle(ml[0])\\n newDict[entry] = ml[0]\\n\\n else:\\n if ml[1][\\\"accuracy\\\"] > 90:\\n printSingle(ml[1])\\n newDict[entry] = ml[1]\\n dictTries[data[entry][\\\"assessed_by\\\"]] = []\\n\\n else:\\n dictTries[data[entry][\\\"assessed_by\\\"]] = [data[entry]]\\n\\n\\n\\n # dictTries[data[\\\"assessed_by\\\"]]\\n\\n # newDict[entry] = data[entry]\\n # print(data[entry])\\n # print()\\n # printDict(newDict)\\n return newDict\",\n \"def autodel(): #i hate this code so much\\n today, tasks = datetime.today(), []\\n to_remove_indexes = []\\n deleted_tasks = 0\\n\\n with open(todofile, 'r') as todo:\\n tasks = todo.readlines()\\n for i, task in enumerate(tasks):\\n try:\\n task = json.loads(task)\\n except json.decoder.JSONDecodeError:\\n return False, False\\n if task['deadline'] == \\\"None\\\": #because i converted to string in adding\\n continue\\n dline = datetime.strptime(task['deadline'], \\\"%Y-%m-%d %H:%M:%S\\\")\\n if dline < today and not task['no_del']:\\n to_remove_indexes.append(i)\\n deleted_tasks += 1\\n\\n for index in to_remove_indexes[::-1]:\\n del tasks[index]\\n \\n with open(todofile, 'w') as todo:\\n for task in tasks:\\n todo.write(task)\\n \\n return deleted_tasks, True\",\n \"def test_rotate_filenames():\\n tmpdir = os.path.join(tempfile.gettempdir(), \\\"jade-test-tmp87alkj8ew\\\")\\n os.makedirs(tmpdir, exist_ok=True)\\n\\n data = {\\\"A\\\": 1, \\\"B\\\": 2}\\n json_file1 = os.path.join(tmpdir, \\\"a1.json\\\")\\n dump_data(data, json_file1)\\n\\n json_file2 = os.path.join(tmpdir, \\\"a2.json\\\")\\n dump_data(data, json_file2)\\n\\n rotate_filenames(tmpdir, \\\".json\\\")\\n\\n if os.path.exists(tmpdir):\\n shutil.rmtree(tmpdir)\",\n \"def _dumpJson(self, data, file):\\n name, ext = os.path.splitext(file)\\n tempFile = \\\"{0}.tmp\\\".format(name)\\n with open(tempFile, \\\"w\\\") as f:\\n json.dump(data, f, indent=4)\\n shutil.copyfile(tempFile, file)\\n os.remove(tempFile)\",\n \"def remove_conversion(tmp_path):\\n import masci_tools\\n\\n #We need to use the __file__ attribute, since we do not know, whether the package was installed with -e\\n package_root = Path(masci_tools.__file__).parent.resolve()\\n conversion_folder = package_root / Path('tools/conversions')\\n\\n shutil.move(os.fspath(conversion_folder / 'conversion_031_to_034.json'), os.fspath(tmp_path))\\n\\n try:\\n yield conversion_folder / 'conversion_031_to_034.json'\\n finally:\\n #Move the conversion back\\n shutil.copy(os.fspath(tmp_path / 'conversion_031_to_034.json'), os.fspath(conversion_folder))\",\n \"def main():\\n parser = ArgumentParser(\\n description='Category Filter: Filter a List of Categories from a JSON')\\n parser.add_argument('json_file_path', help='JSON file path')\\n parser.add_argument('out_file', help='Output filename')\\n args = parser.parse_args()\\n\\n ann_file = open(args.json_file_path)\\n category_names = [\\\"sports ball\\\", \\\"cell phone\\\", \\\"couch\\\", \\\"elephant\\\", \\\"tie\\\", \\\"spoon\\\", \\\"skis\\\", \\\"apple\\\", \\\"giraffe\\\", \\\"laptop\\\", \\\"tennis racket\\\", \\\"sink\\\", \\\"dog\\\", \\\"fork\\\", \\\"cat\\\", \\\"teddy bear\\\", \\\"train\\\", \\\"skateboard\\\", \\\"toilet\\\", \\\"sandwich\\\", \\\"bed\\\", \\\"keyboard\\\", \\\"baseball glove\\\", \\\"baseball bat\\\", \\\"airplane\\\", \\\"oven\\\", \\\"hot dog\\\", \\\"refrigerator\\\", \\\"frisbee\\\", \\\"mouse\\\", \\\"fire hydrant\\\", \\\"stop sign\\\", \\\"bear\\\", \\\"snowboard\\\", \\\"parking meter\\\", \\\"toothbrush\\\", \\\"microwave\\\", \\\"scissors\\\", \\\"hair drier\\\", \\\"toaster\\\"]\\n\\n json_coco = json.load(ann_file)\\n new_json = deepcopy(json_coco)\\n\\n for ann in json_coco['annotations']:\\n if return_cat_name(json_coco, ann['category_id']) in category_names:\\n new_json['annotations'].remove(ann)\\n\\n for cat in json_coco['categories']:\\n if cat['name'] in category_names:\\n new_json['categories'].remove(cat)\\n\\n output = open(args.out_file, \\\"w\\\")\\n json.dump(new_json, output)\\n output.close()\",\n \"def helperCompare(stubName):\\n\\n # input and expected output file paths\\n inputFile = os.path.join(FOLDER_PATH, \\\"examples/{}.txt\\\".format(stubName))\\n outputFile = os.path.join(FOLDER_PATH, \\\"examples/expected_output/{}.json\\\".format(stubName))\\n print(\\\"testing file: {}\\\".format(inputFile))\\n\\n # read expected output\\n with open(outputFile) as f:\\n expectedJson = json.load(f) # expected output\\n\\n # produce actual output\\n bookList = ClippyKindle.parseClippings(inputFile) # list of Book objects\\n outData = []\\n for book in bookList:\\n # book.sort(removeDups=False) # (sorting/removing duplicates)\\n outData.append(book.toDict())\\n # write output to file for reference\\n with open(os.path.join(TMP_PATH, \\\"{}.json\\\".format(stubName)), 'w') as f:\\n json.dump(outData, f, indent=2) # write indented json to file (for reference)\\n\\n assert(json.dumps(outData, sort_keys=True) == json.dumps(expectedJson, sort_keys=True))\",\n \"def main(args):\\r\\n print(\\\"Anonymizing ...\\\")\\r\\n print(args)\\r\\n\\r\\n file_loc = args.file\\r\\n origdata = pd.read_csv(file_loc, sep=',', low_memory=False)\\r\\n\\r\\n print(origdata)\\r\\n\\r\\n print(args.col_customer)\\r\\n\\r\\n ID_field = args.col_customer #TBU CustomerID field name\\r\\n TS_field = args.col_time #TBU TS field name \\r\\n\\r\\n sub = origdata.loc[:,:] #Uncomment for applying on complete dataset\\r\\n\\r\\n def anonymizeID(data,ID_field):\\r\\n df=pd.DataFrame(data.loc[:,ID_field])\\r\\n df2=df.applymap(lambda x: ((HMAC.new(b\\\"key\\\", bytes(x), MD5)).hexdigest()))\\r\\n return df2.loc[:,ID_field]\\r\\n\\r\\n def shiftTimeForTrace(data,TS_field):\\r\\n # print(df.head())\\r\\n df=pd.DataFrame(data.loc[:,TS_field])\\r\\n df2 = df.loc[:,TS_field].apply(lambda x: pd.to_datetime(x)) \\r\\n # print(df2.head())\\r\\n rand_days = random.randint(-5,5) #range can be updated\\r\\n df2 = df2 + pd.DateOffset(days=rand_days)\\r\\n # print(df2.head())\\r\\n return df2\\r\\n\\r\\n #OG subset for reference\\r\\n print(sub.head())\\r\\n\\r\\n # sub1=sub.sort_values(by=ID_field)\\r\\n sub1 = sub.loc[:,:]\\r\\n uniqueIDs = list(sub[ID_field].unique())\\r\\n # sub2 = sub.loc[:,TS_field].apply(lambda x: pd.to_datetime(x))\\r\\n for ID in uniqueIDs:\\r\\n sub3=sub1.loc[sub1[ID_field] == ID]\\r\\n sub3.loc[:,TS_field]=shiftTimeForTrace(sub3,TS_field)\\r\\n # print(sub1.loc[sub1[ID_field] == ID][TS_field])\\r\\n # print(pd.DataFrame(sub3[TS_field]))\\r\\n sub1.loc[sub1[ID_field] == ID,TS_field] = pd.DataFrame(sub3[TS_field])\\r\\n\\r\\n # Results post TS shift\\r\\n print(sub1.head())\\r\\n\\r\\n sub4 = sub1.loc[:,:]\\r\\n sub4.loc[:,ID_field] = anonymizeID(sub4,ID_field)\\r\\n\\r\\n #Results post ID anonymization\\r\\n print(sub4.head())\\r\\n sub4.to_csv('out.csv',index=False)\",\n \"def createMasks(inputFolderName=\\\"Masks_From_VolumeTracing\\\", outputFolderName=\\\"Masks_From_VolumeTracing_Lines_From_VolumeTracing\\\"):\\n\\n root, df = loader.dataModules()\\n\\n PATH_TO_RAW_FRAMES_PARENT_DIR = os.path.join(root, inputFolderName) # frames path\\n PATH_TO_OUTPUT_DIR = os.path.join(root, outputFolderName) # frames path\\n \\n os.makedirs(PATH_TO_OUTPUT_DIR, exist_ok=True) # creates ground truth mask parent directory\\n\\n print(\\\"Drawing lines on each mask from VolumeTracings\\\")\\n for i in tqdm(range(len(df))): # iterates through each row of data frame\\n videoName = df.iloc[i, 0] # name of video\\n frameNumber = df.iloc[i, 1] # timing for clip\\n\\n frameName = videoName + \\\".avi_\\\" + str(frameNumber) + \\\".png\\\" # concatenate video name with frame number as file name\\n PATH_TO_RAW_FRAME = os.path.join(PATH_TO_RAW_FRAMES_PARENT_DIR, frameName)\\n PATH_TO_OUTPUT_RAW_FRAME = os.path.join(PATH_TO_OUTPUT_DIR, frameName)\\n\\n image = cv2.imread(\\\"/Users/ishan/Downloads/Untraced.png\\\") # read in the image from the specified frame path\\n if os.path.exists(PATH_TO_RAW_FRAME) and videoName == \\\"0X16A6CEDE7F61E211\\\" and int(frameNumber) == 131: # checks if frame exists\\n x1 = list(literal_eval(df.iloc[i, 2])) # x1 coords\\n y1 = list(literal_eval(df.iloc[i, 3])) # y1 coords\\n x2 = list(literal_eval(df.iloc[i, 4])) # x2 coords\\n y2 = list(literal_eval(df.iloc[i, 5])) # y2 coords\\n\\n for coord in range(len(x1)): # iterate through each coordinate\\n if coord is 0: # gets the perpendicular/long line\\n longLine1stCoords = (int(x1[coord]), int(y1[coord]))\\n longLine2ndCoords = (int(x2[coord]), int(y2[coord]))\\n else: # draws the parallel lines\\n cv2.line(image, (int(x1[coord]), int(y1[coord])), (int(x2[coord]), int(y2[coord])), (255, 255, 255), 1)\\n \\n cv2.line(image, longLine1stCoords, longLine2ndCoords, (255, 255, 255), 1) # Drawing the perpendicular/long line in different color\\n\\n cv2.imwrite(\\\"/Users/ishan/Downloads/Traced.png\\\", image)\",\n \"def remove_useless_file(rootPath):\\n all_file_paddle_list = get_all_paddle_file(rootPath)\\n ut_file_map_new = {}\\n ut_file_map = \\\"%s/build/ut_file_map.json\\\" % rootPath\\n with open(ut_file_map, 'r') as load_f:\\n load_dict = json.load(load_f)\\n for key in load_dict:\\n if key in all_file_paddle_list:\\n ut_file_map_new[key] = load_dict[key]\\n\\n with open(\\\"%s/build/ut_file_map.json\\\" % rootPath, \\\"w\\\") as f:\\n json.dump(ut_file_map_new, f, indent=4)\\n print(\\\"remove_useless_file ut_file_map success!!\\\")\",\n \"def _prep_roidb_entry(self, entry):\\n im_path = os.path.join(self.root, 'images', self.img_dir_name, entry['file_name'])\\n assert os.path.exists(im_path), 'Image \\\\'{}\\\\' not found'.format(im_path)\\n entry['image'] = im_path\\n entry['flipped'] = False\\n # empty placeholders\\n entry['bboxes'] = np.empty((0, 4), dtype=np.float32)\\n entry['gt_classes'] = np.empty((0), dtype=np.int32)\\n # remove unwanted fields that come from the json file\\n for k in ['date_captured', 'coco_url', 'license', 'url', 'file_name', 'flickr_url']:\\n if k in entry:\\n del entry[k]\",\n \"def fix_image_dict(folder, image_dict):\\n image_pattern = os.path.join(LOCAL_IMAGE_PATH, \\\"*.*\\\")\\n for file_path in glob.glob(image_pattern):\\n file_name = os.path.basename(file_path)\\n if file_name not in image_dict:\\n image_dict[file_name] = [replace_underscore(os.path.splitext(file_name)[0])]\",\n \"def repair_json(in_file, out_file, path_to_img):\\n with open(in_file, 'rb') as f:\\n data = f.readlines()\\n\\n # delete all \\\\n characters\\n data = map(lambda x: x.rstrip(), data)\\n\\n # make one JSON object per row\\n json_rows = []\\n start = -1\\n while True:\\n try:\\n start = data.index('{', start + 1)\\n end = data.index('}', start)\\n row = ''.join(data[start:end+1])\\n row = re.sub(\\\"\\\\\\\"Bmp\\\\\\\"\\\", \\\"\\\\\\\"Image\\\\\\\"\\\", row)\\n row = re.sub(\\\".bmp\\\", \\\".jpg\\\", row)\\n json_rows.append(row)\\n start = end\\n except ValueError:\\n break\\n\\n # join all JSON objects into one comme delimited string enclosed in square brackets\\n data_join_str = \\\"[\\\" + ','.join(json_rows) + \\\"]\\\"\\n\\n # create JSON object\\n repaired_json = json.loads(data_join_str)\\n for x in repaired_json:\\n f = os.path.join(path_to_img, x['Image'])\\n print x['Image']\\n if not os.path.isfile(f):\\n repaired_json.remove(x)\\n # remove out_file if it exists\\n try:\\n os.remove(out_file)\\n except OSError:\\n pass\\n except IOError:\\n pass\\n print 'dumping...'\\n with open(out_file, 'w+') as f:\\n json.dump(repaired_json, f)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57587606","0.55869764","0.53467065","0.52671915","0.5242644","0.5208656","0.51642597","0.5124621","0.50885236","0.5050152","0.5046206","0.5035444","0.5032294","0.5019946","0.50142884","0.5002037","0.49930683","0.49280834","0.49243683","0.49133766","0.49003282","0.4877886","0.4842393","0.48398814","0.48219723","0.47899738","0.4788335","0.47642553","0.47533542","0.4750333","0.4729129","0.47268188","0.472621","0.4723863","0.4722257","0.47198817","0.47140262","0.47136134","0.47094977","0.4708888","0.469185","0.4689006","0.4685417","0.4679309","0.46786612","0.46735668","0.46732292","0.46644995","0.46596593","0.46589565","0.4651095","0.4644768","0.46378705","0.46329495","0.4623121","0.46200806","0.46169314","0.4612782","0.46123278","0.4611764","0.46094236","0.46056026","0.45998415","0.45988917","0.4597877","0.45946452","0.4592026","0.45885637","0.45844603","0.45830914","0.4581891","0.45788598","0.45765156","0.45745823","0.45745796","0.45696306","0.45646924","0.45590144","0.45573887","0.45531282","0.4551581","0.4548412","0.4548064","0.454516","0.45434552","0.45407736","0.45382816","0.45380616","0.45377412","0.45351022","0.4530407","0.45299357","0.45297748","0.4525784","0.4525589","0.45217708","0.45168972","0.45156386","0.45152834","0.45072916"],"string":"[\n \"0.57587606\",\n \"0.55869764\",\n \"0.53467065\",\n \"0.52671915\",\n \"0.5242644\",\n \"0.5208656\",\n \"0.51642597\",\n \"0.5124621\",\n \"0.50885236\",\n \"0.5050152\",\n \"0.5046206\",\n \"0.5035444\",\n \"0.5032294\",\n \"0.5019946\",\n \"0.50142884\",\n \"0.5002037\",\n \"0.49930683\",\n \"0.49280834\",\n \"0.49243683\",\n \"0.49133766\",\n \"0.49003282\",\n \"0.4877886\",\n \"0.4842393\",\n \"0.48398814\",\n \"0.48219723\",\n \"0.47899738\",\n \"0.4788335\",\n \"0.47642553\",\n \"0.47533542\",\n \"0.4750333\",\n \"0.4729129\",\n \"0.47268188\",\n \"0.472621\",\n \"0.4723863\",\n \"0.4722257\",\n \"0.47198817\",\n \"0.47140262\",\n \"0.47136134\",\n \"0.47094977\",\n \"0.4708888\",\n \"0.469185\",\n \"0.4689006\",\n \"0.4685417\",\n \"0.4679309\",\n \"0.46786612\",\n \"0.46735668\",\n \"0.46732292\",\n \"0.46644995\",\n \"0.46596593\",\n \"0.46589565\",\n \"0.4651095\",\n \"0.4644768\",\n \"0.46378705\",\n \"0.46329495\",\n \"0.4623121\",\n \"0.46200806\",\n \"0.46169314\",\n \"0.4612782\",\n \"0.46123278\",\n \"0.4611764\",\n \"0.46094236\",\n \"0.46056026\",\n \"0.45998415\",\n \"0.45988917\",\n \"0.4597877\",\n \"0.45946452\",\n \"0.4592026\",\n \"0.45885637\",\n \"0.45844603\",\n \"0.45830914\",\n \"0.4581891\",\n \"0.45788598\",\n \"0.45765156\",\n \"0.45745823\",\n \"0.45745796\",\n \"0.45696306\",\n \"0.45646924\",\n \"0.45590144\",\n \"0.45573887\",\n \"0.45531282\",\n \"0.4551581\",\n \"0.4548412\",\n \"0.4548064\",\n \"0.454516\",\n \"0.45434552\",\n \"0.45407736\",\n \"0.45382816\",\n \"0.45380616\",\n \"0.45377412\",\n \"0.45351022\",\n \"0.4530407\",\n \"0.45299357\",\n \"0.45297748\",\n \"0.4525784\",\n \"0.4525589\",\n \"0.45217708\",\n \"0.45168972\",\n \"0.45156386\",\n \"0.45152834\",\n \"0.45072916\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7519383"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85180,"cells":{"query":{"kind":"string","value":"Plots the piezo trace from piezo 0 and PMT pulse sizes near the acoustic signal on one figure. The green line indicates the time of acoustic t0. The red line indicates the time and size of the PMT t0 chosen by Matt's analysis. The yellow lines indicate the times and sizes of other PMT pulses. Also plots in separate windows the PMT traces for pulses 500 microseconds or less before acoustic t0."},"document":{"kind":"string","value":"def PMTandPiezoPlot(datadir,run,event,gain): \n en = event\n mu = gain\n e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)\n print(e[\"fastDAQ\"].keys())\n cgate = e[\"fastDAQ\"][\"CAMgate\"]\n dcam = np.diff(cgate)\n \n p0=e[\"fastDAQ\"][\"Piezo1\"]\n p1 = e[\"fastDAQ\"][\"Piezo2\"]\n fdt = e[\"fastDAQ\"][\"time\"]\n runreconpath = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\"%run\n pmtdiffs = []\n diffs = []\n \n camOnTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] < -0.5]\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\n print(len(camOnTimes))\n print(len(camOffTimes))\n \n acousticfilename = runreconpath+\"AcousticAnalysis_%s.bin\"%run\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\n bubt0 = a[\"bubble_t0\"]\n \n pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n tracetimes = pmttracetime - pmtalign\n at0 = bubt0[en,0]\n at0_1 = bubt0[en,1]\n \n allxyzfname = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\"\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\n indices = [i for i,x in enumerate(xyzf[\"runid\"]) if str(x[0])+\"_\"+str(x[1]) == run]\n xyz_reconstructed = True\n if len(indices) > 0:\n runposreco = {\"ev\":[xyzf[\"ev\"][indices]],\"x\":[xyzf[\"bubX\"][indices]],\n \"y\":[xyzf[\"bubY\"][indices]],\"z\":[xyzf[\"bubZ\"][indices]]}\n z = runposreco[\"z\"][0][int(int(en))]\n else:\n print(\"no handscan?\")\n z = 1.5\n xyz_reconstructed = False\n lag_expected = (-23.387649*z - 261.020495)*1e-6 # fit from other analysis\n t0_expected_p0 = at0 + lag_expected\n t0_expected_p1 = at0_1 + lag_expected\n \n i=0\n candidates = []\n candidate_times=[]\n for t in (tracetimes-at0):\n \n if t<0.2 and t>-0.2:\n lastCamOff = 0\n for k in range(len(camOffTimes)):\n if t+at0 > camOffTimes[k]:\n lastCamOff = camOffTimes[k]\n elif t+at0 < camOffTimes[k]:\n break\n if t+at0-lastCamOff > 25e-6:\n \n pmtdiffs.append(t)\n trace = np.fabs(e[\"PMTtraces\"][\"traces\"][i][0])\n if max(trace) == 128:\n trace = pi.stitchTraces(trace,np.fabs(e[\"PMTtraces\"][\"traces\"][i][1]))\n dt = e[\"PMTtraces\"][\"dt\"][i][0]\n #baseline = np.mean(trace[0:50])\n #trace = trace - baseline\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt)\n \n if phe != None:\n phe /= mu\n candidates.append(phe)\n candidate_times.append(t)\n i+=1\n candidate_phe = 0\n the_index = 0\n i=0\n near_trace_indices = []\n for t in candidate_times:\n if t > -500e-6 and t <0:\n near_trace_indices.append(list(tracetimes-at0).index(t))\n if candidates[i]>candidate_phe:\n candidate_phe = candidates[i]\n the_index = i\n i+=1\n \n if len(candidates) != 0:\n if max(candidates)>0:\n diffs.append(candidate_times[candidates.index(max(candidates))])\n fig,ax1 = plt.subplots()\n ax2 = ax1.twinx()\n ax1.plot(fdt,p0,'b',alpha=0.6, label = 'piezo 0')\n ax1.plot(fdt,p1,'k',alpha=0.2, label= 'piezo 1')\n for i in range(len(candidates)):\n if i == the_index:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'r',lw=4)\n else:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'y',lw=4)\n #ax2.plot([min(candidate_times),max(candidate_times)],[0,0],linewidth=2)\n ax1.plot([at0,at0],[-0.5,0.5],'b',linewidth=2, label = 'acoustic t0, p0')\n ax1.plot([at0_1,at0_1],[-0.5,0.5],'k',linewidth=2, label = 'acoustic t0, p1')\n \"\"\"\n if xyz_reconstructed:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1')\n else:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0, center of chamber')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1, center of chamber')\n \"\"\"\n ax1.plot(fdt,cgate,'c')\n ax1.plot(fdt[:-1],dcam,'m')\n ax2.set_ylabel('pmt signal (phe)',fontsize=20)\n ax1.set_xlabel('time (s)',fontsize=20)\n ax1.set_ylabel('Acoustic signa(V)',fontsize=20)\n ax1.set_ylim([min(p1),max(p1)])\n ax2.set_xlim([-0.1,0.1])\n #ax2.set_ylim([0,5])\n ax1.legend()\n plt.show\n \n for j in near_trace_indices:\n trace = e[\"PMTtraces\"][\"traces\"][j][0]\n dt = e[\"PMTtraces\"][\"dt\"]\n dt_tr = dt[j][0]\n tPMT = np.arange(len(trace))*dt_tr\n plt.figure()\n plt.plot(tPMT,trace)\n plt.xlabel(\"t (s)\")\n plt.ylabel(\"PMT signal\")\n plt.show\n \n plt.figure()\n plt.plot(e[\"fastDAQ\"][\"time\"],e[\"fastDAQ\"][\"VetoCoinc\"])\n plt.ylabel(\"Veto Coincidence signal\",fontsize=18)\n plt.xlabel(\"time (s)\")\n plt.show"},"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 plots(self, events=None, title=None):\n data = self.data\n P = PH.regular_grid(3 , 1, order='columnsfirst', figsize=(8., 6), showgrid=False,\n verticalspacing=0.08, horizontalspacing=0.08,\n margins={'leftmargin': 0.07, 'rightmargin': 0.20, 'topmargin': 0.03, 'bottommargin': 0.1},\n labelposition=(-0.12, 0.95))\n scf = 1e12\n ax = P.axarr\n ax = ax.ravel()\n PH.nice_plot(ax)\n for i in range(1,2):\n ax[i].get_shared_x_axes().join(ax[i], ax[0])\n # raw traces, marked with onsets and peaks\n tb = self.timebase[:len(data)]\n ax[0].plot(tb, scf*data, 'k-', linewidth=0.75, label='Data') # original data\n ax[0].plot(tb[self.onsets], scf*data[self.onsets], 'k^', \n markersize=6, markerfacecolor=(1, 1, 0, 0.8), label='Onsets')\n if len(self.onsets) is not None:\n# ax[0].plot(tb[events], data[events], 'go', markersize=5, label='Events')\n# ax[0].plot(tb[self.peaks], self.data[self.peaks], 'r^', label=)\n ax[0].plot(tb[self.smpkindex], scf*np.array(self.smoothed_peaks), 'r^', label='Smoothed Peaks')\n ax[0].set_ylabel('I (pA)')\n ax[0].set_xlabel('T (s)')\n ax[0].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n \n # deconvolution trace, peaks marked (using onsets), plus threshold)\n ax[1].plot(tb[:self.Crit.shape[0]], self.Crit, label='Deconvolution') \n ax[1].plot([tb[0],tb[-1]], [self.sdthr, self.sdthr], 'r--', linewidth=0.75, \n label='Threshold ({0:4.2f}) SD'.format(self.sdthr))\n ax[1].plot(tb[self.onsets]-self.idelay, self.Crit[self.onsets], 'y^', label='Deconv. Peaks')\n if events is not None: # original events\n ax[1].plot(tb[:self.Crit.shape[0]][events], self.Crit[events],\n 'ro', markersize=5.)\n ax[1].set_ylabel('Deconvolution')\n ax[1].set_xlabel('T (s)')\n ax[1].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n# print (self.dt, self.template_tmax, len(self.template))\n # averaged events, convolution template, and fit\n if self.averaged:\n ax[2].plot(self.avgeventtb[:len(self.avgevent)], scf*self.avgevent, 'k', label='Average Event')\n maxa = np.max(self.sign*self.avgevent)\n #tpkmax = np.argmax(self.sign*self.template)\n if self.template is not None:\n maxl = int(np.min([len(self.template), len(self.avgeventtb)]))\n temp_tb = np.arange(0, maxl*self.dt, self.dt)\n #print(len(self.avgeventtb[:len(self.template)]), len(self.template))\n ax[2].plot(self.avgeventtb[:maxl], scf*self.sign*self.template[:maxl]*maxa/self.template_amax, \n 'r-', label='Template')\n # compute double exp based on rise and decay alone\n # print('res rise: ', self.res_rise)\n # p = [self.res_rise.x[0], self.res_rise.x[1], self.res_decay.x[1], self.res_rise.x[2]]\n # x = self.avgeventtb[:len(self.avg_best_fit)]\n # y = self.doubleexp(p, x, np.zeros_like(x), risepower=4, fixed_delay=0, mode=0)\n # ax[2].plot(x, y, 'b--', linewidth=1.5)\n tau1 = np.power(10, (1./self.risepower)*np.log10(self.tau1*1e3)) # correct for rise power\n tau2 = self.tau2*1e3\n ax[2].plot(self.avgeventtb[:len(self.avg_best_fit)], scf*self.avg_best_fit, 'c--', linewidth=2.0,\n label='Best Fit:\\nRise Power={0:.2f}\\nTau1={1:.3f} ms\\nTau2={2:.3f} ms\\ndelay: {3:.3f} ms'.\n format(self.risepower, self.res_rise.x[1]*1e3, self.res_decay.x[1]*1e3, self.bfdelay*1e3))\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.rise_fit, 'g--', linewidth=1.0,\n # label='Rise tau {0:.2f} ms'.format(self.res_rise.x[1]*1e3))\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.decay_fit, 'm--', linewidth=1.0,\n # label='Decay tau {0:.2f} ms'.format(self.res_decay.x[1]*1e3))\n if title is not None:\n P.figure_handle.suptitle(title)\n ax[2].set_ylabel('Averaged I (pA)')\n ax[2].set_xlabel('T (s)')\n ax[2].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\n if self.fitted:\n print('measures: ', self.risetenninety, self.decaythirtyseven)\n mpl.show()","def overviewCommand(self):\n plt.figure(11)\n plt.clf()\n ax = plt.subplot(211)\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*self.raw['OPDC'].data.field('FUOFFSET'),\n color='r', label='FUOFFSET',\n linewidth=1, alpha=1) \n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\n self.raw['OPDC'].data.field('PSP')),\n color='r', linewidth=3, alpha=0.5,\n label=self.DLtrack+'-PSP')\n plt.legend()\n plt.subplot(212, sharex=ax)\n plt.plot(self.raw['OPDC'].data.field('TIME'),\n 1e6*self.raw['OPDC'].data.field('FUOFFSET')-\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\n self.raw['OPDC'].data.field('PSP')),\n color='k', label='$\\Delta$',\n linewidth=1, alpha=1) \n \n signal = self.raw['OPDC'].data.field('FUOFFSET')\n plt.figure(12)\n plt.clf()\n ax2 = plt.subplot(111)\n Fs = 1e6/np.diff(self.raw['OPDC'].data.field('TIME')).mean()\n print Fs\n ax2.psd(signal[:50000], NFFT=5000, Fs=Fs, label='FUOFFSET',scale_by_freq=0)\n plt.legend()","def timePiePlot(self, pctM=0.04):\n names = ['Voronoi Tesselation', 'Connectivity of Cluster Cells']\n dict = {}\n for i,j in zip(names, self.times):\n dict[i] = j\n\n total = sum(dict.values())\n title = 'Time Consumption per Step of Voronoi Analysis - Total [s]= ' + str(round(total, 3))\n labels = []\n values = []\n for v in dict.keys():\n if dict[v] / total > pctM:\n labels.append(v + ' - ' + str(round(dict[v], 3)) + ' (' + str(round(dict[v] * 100 / total, 2)) + ' %)')\n else:\n labels.append(v)\n values.append(dict[v] / total)\n labdis = 1.07\n cmap = plt.get_cmap(\"plasma\")\n c = np.arange(len(dict.keys())) / len(dict.keys())\n colors = cmap(c)\n\n fig = plt.figure()\n fig.set_size_inches(12, 7)\n plt.title(title, fontsize=22)\n plt.pie(dict.values(), labels=labels, shadow=True, startangle=0, labeldistance=labdis, colors=colors)\n plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.","def plot_overview(cube=nro_12co,\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\n scalebar_color=\"white\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\n pmax=99.75, cbar_label=r\"Peak T$_{\\rm MB}$ [K]\",\n circle_color='white', circle_linewidth=1, circle_style=\"solid\", return_fig=False, show=True,\n title=r\"$^{12}$CO Peak T$_{MB}$\", recenter=False, ra=None, dec=None, radius=None):\n try:\n cube = SpectralCube.read(cube)\n except ValueError:\n pass\n\n if mode == \"peak\":\n image = (cube.max(axis=0) * scale_factor).hdu\n \n\n if mode == \"mom0\":\n image = (cube.moment0() * scale_factor).hdu\n\n\n\n fig = FITSFigure(image)\n if show:\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\n pmax=pmax, interpolation='none')\n fig.tick_labels.set_yformat(\"dd:mm\")\n fig.tick_labels.set_xformat(\"hh:mm\")\n #fig.hide_yaxis_label()\n #fig.hide_ytick_labels()\n plt.title(title)\n plt.xlabel(\"RA (J2000)\")\n plt.ylabel(\"DEC (J2000)\")\n\n if show_shells:\n shell_list = get_shells(region_file=region_file)\n for i, shell in enumerate(shell_list):\n if shells_highlight:\n if i+1 in shells_highlight:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\n facecolor='none', linewidth=3)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n else:\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\n facecolor='none', linewidth=circle_linewidth)\n\n #RECENTER\n if recenter:\n fig.recenter(ra, dec, radius)\n\n\n #SCALEBAR\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\n fig.scalebar.set_label(\"{} pc\".format(scalebar_pc))\n\n fig.add_colorbar()\n cb = fig.colorbar\n cb.set_axis_label_text(cbar_label)\n\n if return_fig:\n return fig\n else:\n fig.save(plotname, dpi=600)","def plot_tail(infile):\n\n # Read file\n xs, ys = {}, {}\n for line in infile:\n fields = line.split()\n run = int(fields[0])\n time = float(fields[1])\n running = int(fields[2])\n if run not in xs:\n xs[run] = []\n ys[run] = []\n xs[run].append(time)\n ys[run].append(running)\n min_time = min(min(r) for r in xs.values())\n max_time = max(max(r) for r in xs.values())\n max_y = max(max(r) for r in ys.values())\n\n # Create output directory\n if cmdline.outdir:\n try: os.makedirs(cmdline.outdir)\n except OSError as e:\n if e.errno != errno.EEXIST: raise\n\n # Plot it\n frame_width = 1920\n frame_height = 1080\n dpi = 96.0\n axis_width = 2\n mpl.rcParams['axes.linewidth'] = axis_width\n using_gui = (cmdline.frames == 1 and not cmdline.batch)\n timestep = (max_time - min_time)/float(cmdline.frames)\n shown_time = min_time\n for frame in xrange(1, cmdline.frames + 1):\n print('frame {}/{}'.format(frame, cmdline.frames), file=sys.stderr)\n shown_time += timestep\n #fig = plt.figure()\n fig, ax = plt.subplots()\n fig.set_size_inches(frame_width/float(dpi), frame_height/float(dpi))\n #ax = plt.Axes(fig, [0, 0, 1, 1])\n #fig.add_axes(ax)\n #ax.set_axis_off()\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n ax.get_xaxis().set_ticks([min_time, max_time])\n ax.set_xticklabels(['', ''])\n ax.xaxis.set_tick_params(width=axis_width)\n ax.get_yaxis().set_ticks([])\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.spines['bottom'].set_bounds(min_time, max_time)\n plt.xlim([min_time, max_time])\n plt.ylim([-0.03*max_y, 1.05*max_y])\n #plt.axis('off')\n plt.tick_params(left='off', bottom='on')\n fontprop = fm.FontProperties(fname=cmdline.font) if cmdline.font else None\n plt.xlabel('Time', labelpad=20, fontsize=36, fontproperties=fontprop)\n plt.ylabel('Tasks Running', labelpad=40, fontsize=36, fontproperties=fontprop)\n\n global line_color\n for run in xs:\n times = [x for x in xs[run] if x <= shown_time]\n plt.plot(times, ys[run][:len(times)], color=line_color, lw=6, label='Run {}'.format(run))\n if len(xs) > 1:\n plt.legend(loc='upper right')\n if cmdline.frames > 1:\n outfile = cmdline.outdir + ('/' if cmdline.outdir and cmdline.outdir != '' else '') + 'frame-{}.png'.format(frame)\n plt.savefig(outfile, format='png', dpi=dpi)\n elif cmdline.outfile:\n plt.savefig(cmdline.outfile, format='png', bbox_inches='tight', dpi=dpi)\n if not using_gui:\n plt.close(plt.gcf())\n if using_gui:\n plt.show()","def plot(self):\n\n # initialize outside the loop to avoid memory leak\n\n plot_a = None\n\n # initial plotting scales\n vmin = 0\n vmax = 0\n pmin = 0\n pmax = 0\n\n sr = self.dio.get_properties(self.channel)['samples_per_second']\n\n if self.control.verbose:\n print 'sample rate: ', sr\n\n # initial time info\n display_lag = 60\n b = self.dio.get_bounds(self.channel)\n\n if self.control.verbose:\n print 'data bounds: ', b\n\n if self.control.start:\n dtst0 = dateutil.parser.parse(self.control.start)\n st0 = (dtst0 - datetime.datetime(1970, 1,\n 1, tzinfo=pytz.utc)).total_seconds()\n st0 = int(st0 * sr)\n else:\n st0 = int(b[0])\n\n if self.control.end:\n dtst0 = dateutil.parser.parse(self.control.end)\n et0 = (dtst0 - datetime.datetime(1970, 1,\n 1, tzinfo=pytz.utc)).total_seconds()\n et0 = int(et0 * sr)\n else:\n et0 = int(b[1])\n\n if self.control.verbose:\n\n print 'start sample st0: ', st0\n print 'end sample et0: ', et0\n\n blocks = self.control.bins * self.control.frames\n\n samples_per_stripe = self.control.num_fft * \\\n self.control.integration * self.control.decimation\n total_samples = blocks * samples_per_stripe\n\n if total_samples > (et0 - st0):\n print 'Insufficient samples for %d samples per stripe and %d blocks between %ld and %ld' % (samples_per_stripe, blocks, st0, et0)\n return\n\n stripe_stride = (et0 - st0) / blocks\n\n bin_stride = stripe_stride / self.control.bins\n\n start_sample = st0\n\n print 'first ', start_sample\n\n # get metadata\n # this could be done better to ensure we catch frequency or sample rate\n # changes\n mdt = self.dio.read_metadata(st0, et0, self.channel)\n try:\n md = mdt[mdt.keys()[0]]\n cfreq = md['center_frequencies'].ravel()[self.sub_channel]\n except (IndexError, KeyError):\n cfreq = 0.0\n\n if self.control.verbose:\n print 'processing info : ', self.control.frames, self.control.bins, samples_per_stripe, bin_stride\n\n for p in numpy.arange(self.control.frames):\n sti_psd_data = numpy.zeros(\n [self.control.num_fft, self.control.bins], numpy.float)\n sti_times = numpy.zeros([self.control.bins], numpy.complex128)\n\n for b in numpy.arange(self.control.bins):\n\n if self.control.verbose:\n print 'read vector :', self.channel, start_sample, samples_per_stripe\n\n d_vec = self.dio.read_vector(\n start_sample, samples_per_stripe, self.channel)\n data = d_vec[:, self.sub_channel]\n\n if self.control.decimation > 1:\n data = scipy.signal.decimate(data, self.control.decimation)\n sample_freq = sr / self.control.decimation\n else:\n sample_freq = sr\n\n if self.control.mean:\n detrend_fn = matplotlib.mlab.detrend_mean\n else:\n detrend_fn = matplotlib.mlab.detrend_none\n\n try:\n psd_data, freq_axis = matplotlib.mlab.psd(\n data, NFFT=self.control.num_fft, Fs=float(sample_freq), detrend=detrend_fn, scale_by_freq=False)\n except:\n traceback.print_exc(file=sys.stdout)\n\n sti_psd_data[:, b] = numpy.real(\n 10.0 * numpy.log10(numpy.abs(psd_data) + 1E-12))\n\n sti_times[b] = start_sample / sr\n\n start_sample += stripe_stride\n\n # Now Plot the Data\n ax = self.subplots[p]\n\n # determine image x-y extent\n extent = (\n 0,\n self.control.bins,\n numpy.min(freq_axis) / 1e3,\n numpy.max(freq_axis) / 1e3,\n )\n\n # determine image color extent in log scale units\n Pss = sti_psd_data\n vmin = numpy.real(numpy.median(Pss) - 6.0)\n vmax = numpy.real(numpy.median(\n Pss) + (numpy.max(Pss) - numpy.median(Pss)) * 0.61803398875 + 50.0)\n\n if self.control.zaxis:\n vmin = int(string.split(self.control.zaxis, ':')[0])\n vmax = int(string.split(self.control.zaxis, ':')[1])\n else:\n vmin = numpy.real(numpy.median(Pss) - 6.0)\n vmax = numpy.real(numpy.median(\n Pss) + (numpy.max(Pss) - numpy.median(Pss)) * 0.61803398875 + 50.0)\n\n im = ax.imshow(sti_psd_data, cmap='jet', origin='lower', extent=extent,\n interpolation='nearest', vmin=vmin, vmax=vmax, aspect='auto')\n\n ax.set_ylabel('f (kHz)', fontsize=8)\n\n # plot dates\n\n tick_spacing = numpy.arange(\n self.control.bins / 8, self.control.bins, self.control.bins / 8)\n ax.set_xticks(tick_spacing)\n tick_labels = []\n\n for s in tick_spacing:\n tick_time = sti_times[s]\n\n if tick_time == 0:\n tick_string = ''\n else:\n gm_tick_time = time.gmtime(numpy.real(tick_time))\n tick_string = '%02d:%02d:%02d' % (\n gm_tick_time[3], gm_tick_time[4], gm_tick_time[5])\n tick_labels.append(tick_string)\n\n ax.set_xticklabels(tick_labels)\n\n # set the font sizes\n tl = ax.get_xticklabels()\n\n for tk in tl:\n tk.set_size(8)\n del tl\n\n tl = ax.get_yticklabels()\n\n for tk in tl:\n tk.set_size(8)\n del tl\n\n print 'last ', start_sample\n\n # create a time stamp\n start_time = st0 / sr\n srt_time = time.gmtime(start_time)\n sub_second = int(round((start_time - int(start_time)) * 100))\n\n timestamp = \"%d-%02d-%02d %02d:%02d:%02d.%02d UT\" % (srt_time[0], srt_time[\n 1], srt_time[2], srt_time[3], srt_time[4], srt_time[5], sub_second)\n\n self.f.suptitle('%s %s %4.2f MHz (%s)' % (\n self.control.title, timestamp, cfreq / 1E6, self.control.path), fontsize=10)\n\n # ax.legend(fontsize=8)\n ax.set_xlabel('time (UTC)', fontsize=8)\n\n # fixup ticks\n\n tl = ax.get_xticklabels()\n for tk in tl:\n tk.set_size(8)\n del tl\n tl = ax.get_yticklabels()\n for tk in tl:\n tk.set_size(8)\n del tl\n\n self.gridspec.update()\n\n self.f.tight_layout()\n\n self.f.subplots_adjust(top=0.95, right=0.88)\n cax = self.f.add_axes([0.9, 0.12, 0.02, 0.80])\n self.f.colorbar(im, cax=cax)\n if self.control.outname:\n fname, ext = os.path.splitext(self.control.outname)\n if ext == '':\n ext = '.png'\n print \"Save plot as {}\".format(fname+ext)\n matplotlib.pyplot.savefig(fname+ext)\n if self.control.appear or not self.control.outname:\n print \"Show plot\"\n matplotlib.pyplot.show()","def plot_slices(hists, slice_width, fibre_pos):\n pmt_info = rat.utility().GetPMTInfo()\n # Find max angle\n max_angle = 0\n pmtIDs = hists.keys()\n for pmtID in pmtIDs:\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\n if angle > max_angle:\n max_angle = angle\n print max_angle\n\n # Step between 0 and max_angle in slices of slice_width\n # create a plot of all pmt time spectra within each slice\n ROOT.gStyle.SetPalette(1) \n cuts = np.arange(0., max_angle+slice_width, slice_width)\n for i, cut in enumerate(cuts): \n tmpHists = []\n if i > 0:\n low_range = cuts[i-1]\n hi_range = cuts[i]\n s = ROOT.THStack(\"stack\", \"Slice: %1.1f - %1.1f deg\" % (low_range, hi_range)) \n count = 0\n for pmtID in pmtIDs:\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\n if angle > low_range and angle < hi_range:\n #print pmtID\n count = count + 1\n hists[pmtID].SetLineColor(count)\n s.Add(hists[pmtID])\n print \"Drawing...\"\n s.Draw(\"nostack\")\n s.GetHistogram().GetXaxis().SetTitle(\"Time (ns)\")\n #s.Write()\n #c1.BuildLegend(0.5, 0.2, 0.88, 0.88)\n c1.Update()\n c1.Modified()\n c1.Print(\"./results/slices/Slice_%1.1f.png\" % low_range)\n s.Delete()\n #time.sleep(1)","def main():\n\n r = np.arange(-90, 90, 2)\n tilt = 22.5\n\n with ptcmd.PTCMD(baud=57600) as controller:\n\n controller.home()\n\n for pan_angle in r:\n\n current_position = controller.get_position()\n pan_steps, tilt_steps, pan_rate, tilt_rate = system.move_to_angle(pan_angle, tilt, current_position[0], current_position[1], base_rate = 1000)\n controller.sync(pan_rate, pan_steps, tilt_rate, tilt_steps)\n controller.wait('all')\n\n time.sleep(2)\n\n distances = []\n for i in range(0,12):\n time.sleep(1)\n distances.append(controller.get_analog_sensor(1))\n\n distances.sort()\n distance = sum(distances[1:-1]) / len(distances[1:-1])\n\n x = math.sin(pan_angle*math.pi/180) * distance\n y = math.cos(pan_angle*math.pi/180) * distance\n\n print(distances, distance, pan_angle, x, y)\n\n plt.plot(x, y, 'b+')\n\n plt.show()","def comp_time_plot(p1=database['K+'], p2=database['pi+'], pmax=80, plot=True):\r\n dt = []\r\n p_range = np.linspace(10, pmax, 1000)\r\n m1 = p1.mass\r\n m2 = p2.mass\r\n for p in p_range:\r\n t1_per_m = 76.273/(beta(p, m1)*gamma(p, m1)*c)\r\n t2_per_m = 76.273/(beta(p, m2)*gamma(p, m2)*c)\r\n dt.append(abs(t1_per_m - t2_per_m)*1e12)\r\n dt_12_5 = dt[np.argmin(abs(p_range-12.5))]\r\n dt_75 = dt[np.argmin(abs(p_range-75))]\r\n ratio = dt_12_5/dt_75\r\n if plot==True:\r\n fig = plt.figure(figsize=[10, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n ax.plot(p_range, dt, 'b', label=r'$\\Delta t$')\r\n ax.axvline(12.5, color='r', label='p=12.5 GeV')\r\n ax.axvline(75, color='g', label='p=75 GeV')\r\n ax.set_xlim(10, pmax)\r\n ax.set_ylim(0)\r\n ax.set_xlabel('p / GeV', fontsize=20)\r\n# ax.set_yscale('log')\r\n ax.set_ylabel(r'$\\Delta t$ / ps', fontsize=20)\r\n title = f'{p1.name} to {p2.name} '\r\n title += r'$\\Delta t$ dependancy on particle momenta'\r\n ax.set_title(title, fontsize=20)\r\n ax.legend(fontsize=20)\r\n text = 'dt(12.5) = {0:.2f} ps, '.format(dt_12_5)\r\n text += 'dt(75) = {0:.2f} ps, '.format(dt_75)\r\n text += 'ratio = {0:.3f}'.format(ratio)\r\n plt.show()\r\n print(text)\r\n return [dt_12_5, dt_75, ratio]","def main():\n font = {'family' : 'normal',\n 'weight' : 'normal',\n 'size' : 18}\n\n matplotlib.rc('font', **font)\n\n ###Plot overviews\n\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full.png\",\n# show_shells=False,title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n \n plot_overview(plotname=\"../paper/figs/12co_nroonly_peak_full_shells.png\", show_shells=True,\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\n title=r\"\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\n )\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_mom0_cometary.png\",\n # show_shells=False, title=r\"Combined Integrated $^{12}$CO\",\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000,\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(plotname=\"12co_nroonly_mom0_cometary.png\", show_shells=False,\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\n # scale_factor=1./1000, title=r\"NRO Integrated $^{12}$CO\",\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\"12co_combined_peak_full_shells.png\",\n # show_shells=True, shells_highlight=shells_score3, title=r\"Combined $^{12}$CO Peak T$_{MB}$\",\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\n\n # return\n\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\n\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\n\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\n\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\n\n planck_herschel_file = '../catalogs/planck_herschel.fits'\n\n region_file = '../shell_candidates/AllShells.reg'\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\n\n obaf_file = 'stars_obaf.txt'\n yso_file = \"../catalogs/spitzer_orion.fit\"\n\n obaf = ascii.read(obaf_file)\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\"b'\") for sp in obaf['SP_TYPE']])\n yso = fits.open(yso_file)[1].data\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\n\n # for nshell in range(19,43):\n # shell = shell_list[nshell-1]\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n # #Check whether shell is in each mips image coverage.\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\n \n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\n # hdu = mips_l1641_hdu\n # else:\n # hdu = mips_onc_hdu\n\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\n\n\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\n\n spec_cube = SpectralCube.read(cube_file)\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\n vel_grid = spec_cube.spectral_axis\n pad_factor = 1.5\n\n #plot_overview(show_shells=True)\n #plot_overview(plotname=\"12co_nro_peak.png\", show_shells=False)\n #plot_overview(cube=\"/Volumes/Untitled/13co_pix_2.cm.fits\", plotname=\"13co_combined_peak.png\", show_shells=False)\n #return\n #channel_vmax = [12.9, 14]\n for nshell in range(17,18):\n shell = shell_list[nshell-1]\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\n\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\n #print(l1641_xy)\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\n ir_hdu = ir_l1641_hdu\n else:\n ir_hdu = ir_onc_hdu\n\n #Extract sub_cube around shell.\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\n (abs(dec_grid - dec) < radius * pad_factor)\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n\n #Integrate between vmin and vmax.\n mom0_hdu = sub_cube.moment0().hdu\n\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\n # (abs(dec_grid - dec) < radius)\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\n\n #Calculate contour levels.\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\n #print(\"sigma: {}\".format(sigma))\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\n #print(\"delta_vel: {}\".format(delta_vel))\n mom0_sigma = sigma * delta_vel\n #print(mom0_sigma) \n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\n\n #Get source coordinates.\n\n\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \"12CO\", shell.vmin.value, shell.vmax.value),\n # return_fig=False,\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\n # cbar_label=\"Counts\", cmap='inferno',\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\n # source_labels=[obaf_label, yso_label], dpi=300\n # )\n\n #cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n \n \n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\n # vmin=None, vmax=None, max_chans=12,\n # #cbar_label=\"Counts\",\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\n\n # angle = 90*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\n # width=7.5*u.arcsec, angle=angle,\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\n # stretch='linear', auto_scale=True, dpi=900.)\n \n\n\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\n\n\n #movie(test=False, labels=False) \n\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\n # region_file = '../nro_maps/SouthShells.reg'\n # N = 2 # Number of shell candidates to plot\n # shell_list = get_shells(region_file=region_file)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # #cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n\n # for n in range(1,2):\n # shell = shell_list[n]\n # for deg in np.linspace(0, 180, 13):\n # angle = deg*u.deg\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\n # width=7.5*u.arcsec, angle=105*u.deg,\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\n # stretch='linear', auto_scale=True)\n\n # cube_file = \"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\n\n # cube_file = \"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\"\n # for n in range(N):\n # shell = shell_list[n]\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')","def apolco(a,minfeh=-3,out=None) :\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\n fig=vscat(a[apo],marker='o',density=True)\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\n if out is not None : \n fig[0].savefig(out+'_1.png')\n plt.close()\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\n print('matched {:d} stars'.format(len(i1)))\n fig,ax=plots.multi(1,2)\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\Delta$ VHELIO_AVG',xt='S/N')\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\Delta$ VSCATTER',xt='S/N')\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\n ax[0].set_xlabel(r'$\\Delta$ VHELIO_AVG')\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\n ax[1].set_xlabel(r'$\\Delta$ VSCATTER')\n if out is not None : \n fig.savefig(out+'_2.png')\n plt.close()","def generatePlot(data):\n addendum = \"\"\n destination = \"D:\\\\Research\\\\scripts\\\\Results\\\\FullSet1\\\\$FilteredPlots\\\\take 4\\\\\"\n if len(data.detections.smallIncrease) != 0:\n addendum = \"small increases\\\\\"\n if len(data.detections.smallDecrease) != 0:\n addendum = \"small decreases\\\\\"\n if len(data.detections.largeIncrease) != 0:\n addendum = \"large increases\\\\\"\n if len(data.detections.largeDecrease) != 0:\n addendum = \"large decreases\\\\\"\n if addendum == \"\":\n addendum = \"no decreases\\\\\"\n \n plt.figure(1)\n plt.subplot(211)\n #print np.min(data.magdata), np.max(data.magdata)\n axes = plt.gca()\n axes.set_title(\"Year: '{year}, Day: {day}\".format(year=data.calendarDay[:2], day=data.calendarDay[3:] ))\n axes.set_ylim([np.min(data.magdata)-1.2,np.max(data.magdata)+0.25])\n axes.set_ylabel(r'$\\mathbf{B}$ (nT)' )\n\n #plot formatting\n formats = dates.DateFormatter('%H:%M:%S')\n axes.xaxis.set_major_locator(dates.MinuteLocator())\n axes.xaxis.set_major_formatter(formats)\n \n br, = pp.plot(dates.date2num(data.timestamps),[row[0] for row in data.magdata],label='$B_r$')\n bt, = pp.plot(dates.date2num(data.timestamps),[row[1] for row in data.magdata],label='$B_t$')\n bn, = pp.plot(dates.date2num(data.timestamps),[row[2] for row in data.magdata],label='$B_n$')\n b0, = pp.plot(dates.date2num(data.timestamps),[row[3] for row in data.magdata],label='$B_0$')\n print len(data.detections.rotationBoundary)\n if len(data.detections.rotationBoundary) == 1:\n rotation, = pp.plot([dates.date2num(data.detections.rotationBoundary), dates.date2num(data.detections.rotationBoundary)], [np.min(data.magdata)-1,np.max(data.magdata)+0.25], linestyle='--', color = 'm', alpha = 0.4, label='$RB$')\n else:\n for index, value in enumerate(data.detections.rotationBoundary):\n rotation, = pp.plot([dates.date2num(value), dates.date2num(value)], [np.min(data.magdata)-1,np.max(data.magdata)+0.25], linestyle='--', color = 'm', alpha = 0.4, label='$RB$')\n if len(data.detections.rotationBoundary) != 0:\n pp.legend(handles=[br,bt,bn,b0,rotation], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\n else:\n pp.legend(handles=[br,bt,bn,b0], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\n\n start, end = axes.get_xlim()\n axes.xaxis.set_ticks(np.arange(start, end, (end-start)/5))\n \n \n\n plt.subplot(212)\n axes2 = plt.gca()\n #plot formatting\n formats = dates.DateFormatter('%H:%M:%S')\n axes2.xaxis.set_major_locator(dates.MinuteLocator())\n axes2.xaxis.set_major_formatter(formats)\n axes2.set_ylabel(r'$\\theta$ (deg)' )\n rotations, = pp.plot(dates.date2num(data.detections.rotationTimeTags),data.detections.rotations)\n #pp.legend(handles=[rotations], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\n \n\n outplotname = 'Plot ' + str(len(os.listdir(destination+addendum)) + 1)+ ' ' + data.timestamps[0].strftime('%y-%j-%H%M%S') + '.pdf'\n completename = os.path.join(destination+addendum,outplotname)\n plt.savefig(completename, bboxinches='tight')\n plt.clf()\n\n outplotname = 'Plot ' + str(len(os.listdir(destination+'rawdata\\\\'+addendum)) + 1)+ ' ' + data.timestamps[0].strftime('%y-%j-%H%M%S') + ' rawdata.csv'\n completename1 = os.path.join(destination+'rawdata\\\\'+addendum,outplotname)\n generateDataFile(data.rawdata,completename1)\n\n print \"Done generating plot...\"","def _plot_arm(self):\n fig, axs = plt.subplots()\n fig.show()\n axs.cla()\n axs.axis([-1, 2.5, -1, 2.5])\n axs.plot([0], [0], 'o')\n config_plots = []\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 1000):\n axs.plot([0, self._x_1[t_step]], [0, self._y_1[t_step]])\n axs.plot(self._x_1[t_step], self._y_1[t_step], 'o')\n axs.plot(\n [self._x_1[t_step], self._x_2[t_step]],\n [self._y_1[t_step], self._y_2[t_step]]\n )\n axs.plot(self._x_2[t_step], self._y_2[t_step], 'o')\n axs.plot(\n [self._x_2[t_step], self._x_e[t_step]],\n [self._y_2[t_step], self._y_e[t_step]]\n )\n axs.plot(self._x_e[t_step], self._y_e[t_step], 'ro')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 0],\n self._obj_coords_plot[t_step, 1, 0], 'g+')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 1],\n self._obj_coords_plot[t_step, 1, 1], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 2],\n self._obj_coords_plot[t_step, 1, 2], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 3],\n self._obj_coords_plot[t_step, 1, 3], 'g.')\n axs.plot(\n self._obj_coords_plot[t_step, 0, 4],\n self._obj_coords_plot[t_step, 1, 4], 'g.')\n plt.axis('off')\n plt.pause(1 / self._plot_fps)\n fig.canvas.draw()\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n config_plots.append(image.reshape(\n fig.canvas.get_width_height()[::-1] + (3, )))\n\n # Draw and create image\n return config_plots","def plot_bp_exptimes(self, plot_spectrum = True, title = None, ylims = (1.0, 1e7),\n cc = [\"C0\", \"C2\", \"C3\"], iremove = []):\n\n # Reshape exposure times\n tmp = self.tpbpcs_rect.T\n\n # Calculate clean spectrum\n output = self.complete_spectrum_time()\n spectrum = output[2]\n\n fig, ax2 = plt.subplots(figsize = (16,5))\n\n if title is not None:\n ax2.set_title(title)\n\n icount = 0\n for ichan in range(len(CHANNELS)):\n\n data = []\n positions = []\n widths = []\n\n for j in range(len(self.bp_names[self.bp_chan == ichan])):\n\n nanmask = np.isfinite(tmp[icount,:])\n\n data.append(tmp[icount,nanmask])\n positions.append(np.mean(spectrum[0][icount]))\n widths.append(spectrum[0][icount][-1] - spectrum[0][icount][0] + np.mean(spectrum[1][icount][:]))\n color1 = cc[ichan]\n\n comp_str = \"$%i \\%%$\" %(100.*self.frac_bias_bp[icount])\n comp_str2 = \"$\\mathbf{%i {\\%%}}$\" %(100.*self.frac_bias_bp[icount])\n comp_str3 = \"$\\mathbf{%i}$\" %(100.*self.frac_bias_bp[icount])\n #ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\n # ha = \"center\", va = \"top\", fontsize = 12, color = \"w\")\n q_l, q_50, q_h, q_m, q_p = nsig_intervals(tmp[icount,nanmask], intvls=[0.25, 0.5, 0.75])\n #ax2.text(positions[j], ylims[1], comp_str2,\n # ha = \"center\", va = \"top\", color = color1, fontsize = 12)\n ax2.text(positions[j], q_50 + q_p, comp_str3,\n ha = \"center\", va = \"bottom\", color = color1)\n\n #ax2.plot(self.bandpasses[icount], [q_50, q_50], color = color1, zorder = 120, ls = \"dashed\")\n\n icount += 1\n\n positions = np.array(positions)\n widths = np.array(widths)\n bp1 = ax2.boxplot(data, sym = '', widths = widths, showfliers = False,\n boxprops = {\"color\" : color1, \"alpha\" : 0.5},\n whiskerprops = {\"color\" : color1, \"linewidth\" : 2.0},\n capprops = {\"color\" : color1, \"linewidth\" : 0.0},\n medianprops = {\"color\" : \"w\", \"linewidth\" : 2.0},\n patch_artist=True, positions = positions, whis = [5, 95]);\n\n for patch in bp1['boxes']:\n patch.set_facecolor(color1)\n\n if plot_spectrum:\n\n ax = ax2.twinx()\n ax2.set_zorder(100)\n ax2.patch.set_visible(False)\n\n ax.set_xlabel(\"Wavelength [$\\mu$m]\")\n ax.set_ylabel(r\"Planet-Star Flux Ratio ($\\times 10^{-10}$)\", rotation = 270, labelpad = 25)\n for i in range(len(self.bp_names)):\n if i not in iremove:\n pass\n #ax.plot(spectrum[0][i], 1e10*spectrum[3][i], \"o\", ms = 4.0, alpha = 0.65, color = \"w\", zorder = 80)\n #ax.errorbar(spectrum[0][i], 1e10*spectrum[3][i], yerr=1e10*spectrum[4][i], fmt = \"o\", ms = 2.0, alpha = 0.65, color = \"k\", zorder = 80)\n #ax.axvspan(drmA.bandpasses[i][0], drmA.bandpasses[i][1], alpha = 0.2, color = cc[drmA.bp_chan[i]])\n\n self.cn.telescope.lammin = 0.2\n self.cn.telescope.lammax = 2.0\n self.cn.telescope.resolution = 140.\n # Re-do count rate calcs for true Earth spectrum\n self.cn.run_count_rates(self.AHR, self.LAMHR, self.FSTAR)\n l1, = ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \"purple\", zorder = 0, lw = 4.0, alpha = 1.)\n l2, = ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \"w\", zorder = 0, lw = 2.0, alpha = 0.65)\n ax.set_ylim(bottom=0.0)\n ax.legend([(l1, l2)], [(\"Modern Earth\")], framealpha = 0.0)\n\n # Label Molecules\n ax.text(0.27, 1.55, \"O$_3$\", ha = \"center\", va = \"center\")\n ax.text(0.6, 1.25, \"O$_3$\", ha = \"center\", va = \"center\")\n ax.text(0.68, 1.35, \"O$_2$\", ha = \"center\", va = \"center\")\n ax.text(0.76, 1.45, \"O$_2$\", ha = \"center\", va = \"center\")\n ax.text(0.96, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\")\n ax.text(1.15, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\")\n ax.text(1.4, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\")\n ax.text(1.9, 1.45, \"H$_2$O\", ha = \"center\", va = \"center\")\n ax.text(1.6, 1.25, \"CO$_2$\", ha = \"center\", va = \"center\")\n\n ax2.set_ylabel(\"Science Time [hrs]\")\n #ax2.set_title(r\"All %i targets (S/N$\\approx$%i)\" %(Ndraw, wantSNR))\n ax2.set_yscale(\"log\")\n\n ax2.set_xlabel(\"Wavelength [$\\mu$m]\")\n ax2.set_ylim(bottom = ylims[0], top = ylims[1])\n\n ax2.set_xticks([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\n ax2.set_xticklabels([\"$0.2$\", \"$0.4$\", \"$0.6$\", \"$0.8$\", \"$1.0$\", \"$1.2$\", \"$1.4$\", \"$1.6$\", \"$1.8$\", \"$2.0$\"])\n ax2.set_xlim(0.1, 2.1)\n #ax2.set_xlim(0.4, 1.0)\n\n #fig.savefig(\"/Users/Jake/Dropbox/Astronomy/UW/Astrobio/Research Rotation/LUVOIR/figures/drm_bp10_science_time_%s.pdf\" %drm.architecture, bbox_inches = \"tight\")\n\n return fig","def plotTI():\n min_dl = dlam[dlam != 0].min()\n S = int(0.4/min_dl)\n fig = pl.figure(figsize = (8,6))\n ax = fig.add_subplot(1,1,1)\n ax.spines['bottom'].set_position('zero')\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n\n for k, spine in ax.spines.items():\n spine.set_zorder(12.2)\n\n xs, ndx, dx = [0], 0, 0.001\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\n min_y, max_y = 0, 0\n\n lines = tuple()\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\n lv_names2 = []\n for j in range(n_components):\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\n\n for j in range(n_components):\n\n y = ave_dhdl[:,j]\n if not (y == 0).all():\n\n # Get the coordinates.\n lj = lchange[:,j]\n x = lv[:,j][lj]\n y = y[lj]/P.beta_report\n\n if 'TI' in P.methods:\n # Plot the TI integration area.\n ss = 'TI'\n for i in range(len(x)-1):\n min_y = min(y.min(), min_y)\n max_y = max(y.max(), max_y)\n #pl.plot(x,y)\n if i%2==0:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\n\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\n # Plot the TI-CUBIC interpolation curve.\n ss += ' and TI-CUBIC'\n xnew = numpy.arange(0, 1+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\n\n else:\n # Plot the TI-CUBIC integration area.\n ss = 'TI-CUBIC'\n for i in range(len(x)-1):\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\n ynew = cubspl[j].interpolate(y, xnew)\n ynew[0], ynew[-1] = y[i], y[i+1]\n min_y = min(ynew.min(), min_y)\n max_y = max(ynew.max(), max_y)\n if i%2==0:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\n else:\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\n\n # Store the abscissa values and update the subplot index.\n xs += (x+ndx).tolist()[1:]\n ndx += 1\n\n # Make sure the tick labels are not overcrowded.\n xs = numpy.array(xs)\n dl_mat = numpy.array([xs-i for i in xs])\n ri = range(len(xs))\n\n def getInd(r=ri, z=[0]):\n primo = r[0]\n min_dl=ndx*0.02*2**(primo>10)\n if dl_mat[primo].max()<min_dl:\n return z\n for i in r:\n for j in range(len(xs)):\n if dl_mat[i,j]>min_dl:\n z.append(j)\n return getInd(ri[j:], z)\n\n xt = [i if (i in getInd()) else '' for i in range(K)]\n pl.xticks(xs[1:], xt[1:], fontsize=10)\n pl.yticks(fontsize=10)\n #ax = pl.gca()\n #for label in ax.get_xticklabels():\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\n\n # Remove the abscissa ticks and set up the axes limits.\n for tick in ax.get_xticklines():\n tick.set_visible(False)\n pl.xlim(0, ndx)\n min_y *= 1.01\n max_y *= 1.01\n pl.ylim(min_y, max_y)\n\n for i,j in zip(xs[1:], xt[1:]):\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\n if ndx>1:\n lenticks = len(ax.get_ymajorticklabels()) - 1\n if min_y<0: lenticks -= 1\n if lenticks < 5:\n from matplotlib.ticker import AutoMinorLocator as AML\n ax.yaxis.set_minor_locator(AML())\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\n pl.ylabel(r'$\\mathrm{\\langle{\\frac{ \\partial U } { \\partial \\lambda }}\\rangle_{\\lambda}\\/%s}$' % P.units, fontsize=20, color='#151B54')\n pl.annotate('$\\mathit{\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\n if not P.software.title()=='Sire':\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\n for l in lege.legendHandles:\n l.set_linewidth(10)\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\n pl.close(fig)\n return","def plot_examples(cms):\r\n data = amp_axis\r\n\r\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\r\n for [ax, cmap] in zip(axs, cms):\r\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\r\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\r\n \r\n ax.set_ylabel('Time of Flight [\\u03bcs]') #set label for y axis\r\n ax.set_xlabel('Time [min]') #set label for x axis\r\n \r\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\r\n ax.hlines(9.555, 0, stop_time, colors = 'white') \r\n \r\n plt.show()","def check_plots(tracklist_subset, tracklist):\n\n for trial in tracklist_subset: # Iterates over all available trials\n\n # Scale time for colormap\n scaled_time = (tracklist[trial]['data'].index.values -\n tracklist[trial]['data'].index.values.min()) / \\\n tracklist[trial]['data'].index.values.ptp()\n timemax = max(tracklist[trial]['data'].index.values)\n data = tracklist[trial]['data']\n colors = plt.cm.cubehelix(scaled_time)\n m = cm.ScalarMappable(cmap=cm.cubehelix)\n m.set_array(tracklist[trial]['data'].index.values)\n\n # filename = str(trial) + '.pdf'\n\n fig = plt.figure(figsize=(20, 20))\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\n tracklist[trial]['behavior'])\n\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\n ax1.set_title('Pt 1 Position')\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\n ys=tracklist[trial]['data']['pt1y_smth'],\n zs=tracklist[trial]['data']['pt1z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax1.autoscale(enable=True, tight=True)\n ax1.set_xlabel('X position')\n ax1.set_ylabel('Y position')\n ax1.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax2 = fig.add_subplot(4, 2, 3)\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\n ax2.tick_params('y', colors='b')\n\n ax3 = fig.add_subplot(4, 2, 5)\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\n ax3.tick_params('y', colors='b')\n\n ax4 = fig.add_subplot(4, 2, 7)\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\n ax4.tick_params('y', colors='b')\n\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\n ax5.set_title('Pt 2 Position')\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\n ys=tracklist[trial]['data']['pt2y_smth'],\n zs=tracklist[trial]['data']['pt2z_smth'],\n zdir='z', s=3, c=colors, marker='o',\n edgecolor='none') # 3D Scatter plot\n ax5.autoscale(enable=True, tight=True)\n ax5.set_xlabel('X position')\n ax5.set_ylabel('Y position')\n ax5.set_zlabel('Z position')\n plt.colorbar(m, shrink=0.5, aspect=10)\n\n ax6 = fig.add_subplot(4, 2, 4)\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\n ax6.tick_params('y', colors='b')\n\n ax7 = fig.add_subplot(4, 2, 6)\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\n ax7.tick_params('y', colors='b')\n\n ax8 = fig.add_subplot(4, 2, 8)\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\n ax8.tick_params('y', colors='b')\n\n plt.show()","def one_period_plot():\n file = \"Data/matfiles/20131221.mat\"\n object = MatReader(file)\n\n NeA = object.NeA\n latA = object.latA\n times = object.secondsA\n mlt = object.mltA\n ind1 = 2606 #lat inds\n ind2 = 13940 #lat inds\n \n ind1 = 3197 #mlat inds\n ind2 = 14390 #mlat inds\n \n T = ind2 - ind1\n ind1 += int(T/2)\n ind2 += int(T/2)\n\n latA = latA[ind1:ind2]\n NeA = NeA[ind1:ind2]\n # NeA = object.meanie(NeA, 5)\n times = times[ind1:ind2]\n mlt = mlt[ind1:ind2]\n mlt = hour_round(mlt)\n\n lats = np.zeros_like(latA)\n lats[0] = latA[0]\n for i in range(len(latA)-1):\n dlat = latA[i+1] - latA[i]\n if dlat < 0:\n lats[i+1] = lats[i] - dlat\n else:\n lats[i+1] = lats[i] + dlat\n\n lats += 90\n\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\n # plt.plot(lats, NeA, \".\", markersize = 1)\n # plt.plot([0, 0], [0, np.max(NeA)], \"k\")\n # plt.plot([30, 30], [0, np.max(NeA)], \"k\")\n # plt.plot([60, 60], [0, np.max(NeA)], \"k\")\n # plt.plot([120, 120],[0, np.max(NeA)], \"k\")\n # plt.plot([150, 150], [0, np.max(NeA)], \"k\")\n # plt.plot([167, 167], [0, np.max(NeA)], \"k\")\n # plt.plot([193, 193], [0, np.max(NeA)], \"k\")\n # plt.plot([210, 210], [0, np.max(NeA)], \"k\")\n # plt.plot([240, 244], [0, np.max(NeA)], \"k\")\n # plt.plot([300, 300], [0, np.max(NeA)], \"k\")\n # plt.plot([330, 330], [0, np.max(NeA)], \"k\")\n # plt.plot([360, 360], [0, np.max(NeA)], \"k\")\n # plt.xticks(xticks)\n # plt.xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n # plt.ylabel(\"Electron density [cm$^{-1}$]\")\n # plt.title(\"One SWARM satellite period\")\n # plt.grid(\"on\", axis = \"x\", xdata = gridticks)\n #adding letters\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\n y = np.zeros_like(x) - np.max(NeA)/40\n s = [\"S\", \"B\", \"A\", \"B\", \"C\", \"D\", \"C\", \"B\", \"A\", \"B\", \"S\"]\n # for i in range(len(x)):\n # plt.text(x[i], y[i], s[i], fontsize = 10)\n # plt.savefig(\"Figures/swarm_period.pdf\")\n # plt.show()\n\n # plt.plot(times, latA)\n # plt.plot(times, mlt)\n # plt.show()\n print(lats[0])\n print(lats[-1])\n \n fig, ax = plt.subplots()\n ax.plot(lats, NeA, \".\", markersize = 1)\n ax.set_xticks(xticks, minor=False)\n ax.set_xticks([167, 193], minor=True)\n ax.xaxis.grid(True, which = \"major\")\n ax.xaxis.grid(True, which = \"minor\")\n for i in range(len(x)):\n ax.text(x[i], y[i], s[i], fontsize = 10)\n ax.set_xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n ax.set_ylabel(\"Electron density [cm$^{-1}$]\")\n ax.set_title(\"One Swarm satellite period\")\n # plt.savefig(\"Figures/swarm_period.pdf\")\n plt.show()\n plt.plot(mlt, NeA)\n plt.show()\n plt.plot(mlt, lats)\n plt.show()","def plotCurrentTimeAnticipatory(s, ne,nc, gs):\n fig, ax = plt.subplots()\n ax.set_title('time: {0}'.format(s.time))\n for c in range(nc):\n carTemp = s.cars.getObject(c)\n ax.scatter(carTemp.position[0], carTemp.position[1], c='k', alpha=0.5)\n ax.scatter([], [], c='b', marker='*', label='Opened not commited')\n ax.scatter([], [], c='b', label='Opened commited')\n ax.scatter([], [], c='r', label='Canceled')\n ax.scatter([], [], c='g', label='Closed')\n for i in range(ne):\n eventTemp = s.events.getObject(i)\n if eventTemp.status == Status.OPENED_COMMITED:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', alpha=0.7)\n elif eventTemp.status == Status.OPENED_NOT_COMMITED:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', marker='*', alpha=0.7)\n elif (eventTemp.status == Status.CLOSED):\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='g', alpha=0.2)\n elif (eventTemp.status == Status.CANCELED):\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='r', alpha=0.2)\n else:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='y', alpha=0.2)\n ax.set_xlim([-1, gs + 1])\n ax.set_ylim([-1, gs + 1])\n ax.grid(True)\n plt.legend()\n # Used to return the plot as an image rray\n fig.canvas.draw() # draw the canvas, cache the renderer\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n return image","def plotSnakingTimeline(\n self, pklfile=\"./\", outspecfile=\"./\", PPoutpath=\"./\", folder=\"./\"\n ):\n DRM, outspec = self.loadFiles(pklfile, outspecfile)\n\n allModes = outspec[\"observingModes\"]\n mode1 = [\n mode\n for mode in allModes\n if \"detectionMode\" in mode.keys() or \"detection\" in mode.keys()\n ]\n assert len(mode1) >= 1, \"This needs to be enhanced\"\n mode = mode1[0]\n if not \"timeMultiplier\" in mode.keys():\n mode[\"timeMultiplier\"] = 1.0\n\n LD = np.arange(len(DRM[\"DRM\"]))\n arrival_times = [DRM[\"DRM\"][i][\"arrival_time\"].value for i in LD]\n sumOHTIME = (\n outspec[\"settlingTime\"]\n + outspec[\"starlightSuppressionSystems\"][0][\"ohTime\"]\n )\n det_times = [\n DRM[\"DRM\"][i][\"det_time\"].value * (mode[\"timeMultiplier\"]) + sumOHTIME\n for i in LD\n ]\n det_timesROUNDED = [\n round(\n DRM[\"DRM\"][i][\"det_time\"].value * (mode[\"timeMultiplier\"]) + sumOHTIME,\n 1,\n )\n for i in LD\n ]\n ObsNums = [DRM[\"DRM\"][i][\"ObsNum\"] for i in LD]\n y_vals = np.zeros(len(det_times)).tolist()\n char_times = [\n DRM[\"DRM\"][i][\"char_time\"].value * (1.0 + outspec[\"charMargin\"])\n + sumOHTIME * (DRM[\"DRM\"][i][\"char_time\"].value > 0.0)\n for i in LD\n ]\n OBdurations = np.asarray(outspec[\"OBendTimes\"]) - np.asarray(\n outspec[\"OBstartTimes\"]\n )\n\n # print(sum(det_times))\n # print(sum(char_times))\n # This is just testing stuff for now\n # from pylab import *\n arr = [DRM[\"DRM\"][i][\"arrival_time\"].value for i in np.arange(len(DRM[\"DRM\"]))]\n dt = [DRM[\"DRM\"][i][\"det_time\"].value + 1.0 for i in np.arange(len(DRM[\"DRM\"]))]\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n colors = [\"red\", \"blue\"]\n for i in np.arange(len(arr)):\n ax.barh(\n 1.0,\n dt[i],\n align=\"center\",\n left=arr[i],\n color=colors[int(i) % len(colors)],\n )\n plt.show(block=False)\n\n # Check if plotting font #########################################################\n tmpfig = plt.figure(figsize=(20, 5), num=0)\n ax = tmpfig.add_subplot(111)\n t = ax.text(\n 0,\n 0,\n \"Obs# , d\",\n ha=\"center\",\n va=\"center\",\n rotation=\"vertical\",\n fontsize=8,\n )\n r = tmpfig.canvas.get_renderer()\n bb = t.get_window_extent(renderer=r)\n Obstxtwidth = bb.width # Width of text\n Obstxtheight = bb.height # height of text\n FIGwidth, FIGheight = tmpfig.get_size_inches() * tmpfig.dpi\n # plt.show(block=False)\n plt.close()\n daysperpixelapprox = (\n max(arrival_times) / FIGwidth\n ) # approximate #days per pixel\n if mean(det_times) * 0.8 / daysperpixelapprox > Obstxtwidth:\n ObstextBool = True\n else:\n ObstextBool = False\n\n tmpfig = plt.figure(figsize=(25, 5), num=0)\n ax = tmpfig.add_subplot(111)\n t = ax.text(\n 0,\n 0,\n \"OB# , dur.= d\",\n ha=\"center\",\n va=\"center\",\n rotation=\"horizontal\",\n fontsize=12,\n )\n r = tmpfig.canvas.get_renderer()\n bb = t.get_window_extent(renderer=r)\n OBtxtwidth = bb.width # Width of text\n OBtxtheight = bb.height # height of text\n FIGwidth, FIGheight = tmpfig.get_size_inches() * tmpfig.dpi\n # plt.show(block=False)\n plt.close()\n if mean(OBdurations) * 0.8 / daysperpixelapprox > OBtxtwidth:\n OBtextBool = True\n else:\n OBtextBool = False\n #################################################################################\n\n ######################################################################\n # Finds arrival times that occur within that year\n ObsNumsL = list()\n det_timesL = list()\n char_timesL = list()\n arrival_timesL = list()\n truthArr = list()\n for i in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\n truthArr = (np.asarray(arrival_times) >= 365.25 * np.float(i)) * (\n np.asarray(arrival_times) < 365.25 * np.float(i + 1.0)\n )\n arrival_timesL.append([arrival_times[ii] for ii in np.where(truthArr)[0]])\n det_timesL.append([det_times[ii] for ii in np.where(truthArr)[0]])\n char_timesL.append([char_times[ii] for ii in np.where(truthArr)[0]])\n ObsNumsL.append([ObsNums[ii] for ii in np.where(truthArr)[0]])\n #######################################################################\n\n #######################################################################\n # Plotting\n colors = \"rb\" #'rgbwmc'\n patch_handles = []\n fig = plt.figure(\n figsize=(20, 3 + int(np.ceil(max(arrival_times) / 365.25)) / 2.0)\n )\n self.prettyPlot()\n ax = fig.add_subplot(111)\n\n char_color = (0.0 / 255.0, 128 / 255.0, 0 / 255.0)\n\n # Plot individual blocks\n # Plot All Detection Observations for Year\n for iyr in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\n ind = 0\n obs = 0\n for (det_time, l, char_time, arrival_times_yr) in zip(\n det_timesL[iyr], ObsNumsL[iyr], char_timesL[iyr], arrival_timesL[iyr]\n ):\n # print det_time, l\n patch_handles.append(\n ax.barh(\n int(np.ceil(max(arrival_times) / 365.25)) - iyr,\n det_time,\n align=\"center\",\n left=arrival_times_yr - 365.25 * iyr,\n color=colors[int(obs) % len(colors)],\n )\n )\n if not char_time == 0.0:\n ax.barh(\n int(np.ceil(max(arrival_times) / 365.25)) - iyr,\n char_time,\n align=\"center\",\n left=arrival_times_yr + det_time - 365.25 * iyr,\n color=char_color,\n )\n ind += 1\n obs += 1\n patch = patch_handles[-1][0]\n bl = patch.get_xy()\n x = 0.5 * patch.get_width() + bl[0]\n y = 0.5 * patch.get_height() + bl[1]\n if ObstextBool:\n ax.text(\n x,\n y,\n \"Obs#%d, %dd\" % (l, det_time),\n ha=\"center\",\n va=\"center\",\n rotation=\"vertical\",\n fontsize=8,\n )\n\n # Set Plot Xlimit so the end of the timeline is at the end of the figure box\n ax.set_xlim([None, 365.25])\n\n # Plot Asthetics\n y_pos = (\n np.arange(int(np.ceil(max(arrival_times) / 365.25))) + 1\n ) # Number of xticks to have\n\n yticklabels = list()\n for i in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\n yticklabels.append(\n str(int(np.ceil(max(arrival_times) / 365.25)) - i) + \"yr\"\n )\n ax.set_yticks(y_pos)\n ax.set_yticklabels(yticklabels, fontsize=30)\n # ax.set_yticklabels(('3yr','2yr','1yr'),fontsize=30)\n ax.xaxis.set_tick_params(labelsize=30)\n ax.set_xlabel(\n \"Time Since Start of Mission Year (days)\", weight=\"bold\", fontsize=30\n )\n plt.title(\n \"Mission Timeline for runName: \"\n + folder.split(\"/\")[-1]\n + \"\\nand pkl file: \"\n + os.path.basename(pklfile).split(\".\")[0],\n weight=\"bold\",\n fontsize=12,\n )\n plt.tight_layout()\n plt.show(block=False)\n\n DT = datetime.datetime\n date = str(DT.now()) # ,\"utf-8\")\n date = \"\".join(\n c + \"_\" for c in re.split(\"-|:| \", date)[0:-1]\n ) # Removes seconds from date\n fname = \"TimelineSnake_\" + folder.split(\"/\")[-1] + \"_\" + date\n plt.savefig(os.path.join(PPoutpath, fname + \".png\"))\n plt.savefig(os.path.join(PPoutpath, fname + \".svg\"))\n plt.savefig(os.path.join(PPoutpath, fname + \".eps\"))\n plt.savefig(os.path.join(PPoutpath, fname + \".pdf\"))","def plot_tempogram_and_pulse(tempogram, pulse, oenv, sr_, hop_length, plot_pulse=True):\n tempogram = tempogram.numpy()\n librosa.display.specshow(np.abs(tempogram), sr=sr_, hop_length=hop_length,\n x_axis='time', y_axis='fourier_tempo', cmap='magma')\n plt.show()\n peaks = find_local_maxima(tf.clip_by_value(pulse, clip_value_min=0.1,\n clip_value_max=1.))[1:]\n if plot_pulse:\n oenv = oenv.numpy()\n pulse = pulse.numpy()\n plt.plot(oenv, color=\"black\")\n plt.plot(pulse, color=\"blue\")\n plt.plot(peaks, pulse[peaks.numpy()], \"ro\")\n plt.show()","def test3():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def plot_timestep(self, survey, rot_deg=0, markersize=5):\n xyz = self._rotate_xy(np.loadtxt(self.xyzpaths[survey]), rot_deg)\n\n plt.clf()\n fig1 = plt.figure(1)\n ax = fig1.add_subplot(111)\n\n sc = ax.scatter(xyz[:,0], xyz[:,1], c = xyz[:,2],\n marker = 'o',\n s = markersize, lw = 0,\n cmap = 'viridis')\n\n fig1.colorbar(sc)\n ax.axis('equal')\n ax.set_title('Raw data for survey {0}'.format(survey))\n ax.set_xlabel('X coordinate')\n ax.set_ylabel('Y coordinate')\n plt.show()\n return ax","def plot_time_slices(self):\n U = self.r.u[:, 15:-15, :]\n T = range(U.shape[2])\n kwarglist = [dict(t=t,\n index=self.index,\n U=U,\n levels=self.levels,\n fname=self.time_slice_path(t))\n for t in T]\n util.parallel_process(plot_time_slice, kwarglist=kwarglist)","def PlotWakeModel(x_table, y_table, z_table, wake_speeds, params):\n axes = pyplot.figure().add_subplot(1, 1, 1, projection='3d')\n\n # To display the wing in the hovering orientation, the axes are\n # rotated such that the x and z axes are flipped and the y axis is\n # inverted.\n\n # Plot slices of the wake speeds at each point in x_table.\n ys, zs = np.meshgrid(y_table, z_table, indexing='ij')\n for i in range(len(x_table)):\n axes.contourf(zs, -ys, np.squeeze(wake_speeds[i, :, :]), 20,\n zdir='z', offset=x_table[i], alpha=0.2, cmap=pyplot.cm.jet)\n\n # Plot rotor disks.\n for rotor in params['rotors']:\n rotor_disk = matplotlib.patches.Circle(\n (rotor['pos'][2], -rotor['pos'][1]), rotor['radius'], alpha=0.3,\n color='k')\n axes.add_patch(rotor_disk)\n mplot3d.art3d.pathpatch_2d_to_3d(rotor_disk, z=rotor['pos'][0], zdir='z')\n\n # Plot panels.\n for panel in params['panels']:\n vertices_s = np.array([\n [panel['chord'] * 0.25, panel['span'] / 2.0, 0.0],\n [panel['chord'] * 0.25, -panel['span'] / 2.0, 0.0],\n [-panel['chord'] * 0.75, -panel['span'] / 2.0, 0.0],\n [-panel['chord'] * 0.75, panel['span'] / 2.0, 0.0]\n ])\n vertices_b = np.dot(panel['dcm_b2s'].T, vertices_s.T).T + panel['pos_b']\n vertices = np.dot([[0.0, 0.0, 1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]],\n vertices_b.T).T\n rect = mplot3d.art3d.Poly3DCollection([vertices])\n rect.set_color('k')\n rect.set_alpha(0.3)\n axes.add_collection3d(rect)\n\n # Set axes properties.\n axes.set_xlabel('z')\n axes.set_ylabel('y')\n axes.set_zlabel('x')\n axes.set_xlim((-5.0, 5.0))\n axes.set_ylim((-15.0, 15.0))\n axes.set_zlim((-10.0, 2.0))\n axes.invert_yaxis()","def figure_2():\n from matplotlib.animation import FuncAnimation\n from collections import OrderedDict\n\n plt.rc(\"font\", **{\n \"family\": \"sans-serif\",\n \"sans-serif\": [\"Helvetica\"],\n })\n plt.rc(\"text\", usetex=True)\n plt.rc(\"lines\", linewidth=1)\n plt.rc(\"axes\", grid=True)\n plt.rc(\"grid\", linestyle=\"--\", alpha=0.8)\n\n exp_list = os.listdir(BASE_DATA_DIR)\n exp_list.remove(\"tmp\")\n exp_list.remove(\"mrac-nullagent\")\n\n data = {exp: get_data(exp) for exp in exp_list}\n\n fig, ax = plt.subplots(figsize=[16, 9])\n plt.xlabel(\"Time, sec\")\n\n linekw = dict(linewidth=1, alpha=0.3)\n\n def make_line(label, *args):\n ln, = plt.plot([], [], label=label, *args, **linekw)\n return ln\n\n time_list = [data[exp][\"time\"] for exp in exp_list]\n time = time_list[np.argmin(list(map(len, time_list)))]\n lines = [\n (\n make_line(\"Command\", \"k--\"),\n data[\"fecmrac-nullagent\"][\"cmd\"]\n ),\n (\n make_line(r\"$x_{r,1}$\", \"k\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"reference_system\"][:, 0]\n ),\n (\n make_line(r\"$x_{r,2}$\", \"k\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"reference_system\"][:, 1]\n ),\n (\n make_line(r\"FE-CMRAC $x_{1}$\", \"r-.\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(r\"FE-CMRAC $x_{2}$\", \"r-.\"),\n data[\"fecmrac-nullagent\"][\"state\"][\"main_system\"][:, 1],\n ),\n (\n make_line(r\"RL-CMRAC $x_{1}$\", \"b-.\"),\n data[\"rlcmrac-sac\"][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(r\"RL-CMRAC $x_{2}$\", \"b-.\"),\n data[\"rlcmrac-sac\"][\"state\"][\"main_system\"][:, 1],\n ),\n ]\n\n dist_lines = {\n \"rlcmrac-sac\": plt.vlines(\n [], [], [],\n colors=FORMATTING[\"rlcmrac-sac\"][\"color\"],\n alpha=1,\n label=\"RL-CMRAC\",\n ),\n \"fecmrac-nullagent\": plt.vlines(\n [], [], [],\n colors=FORMATTING[\"fecmrac-nullagent\"][\"color\"],\n alpha=1,\n label=\"FE-CMRAC\",\n ),\n }\n memory_time_diff = np.diff(data[\"fecmrac-nullagent\"][\"memory\"][\"time\"])\n\n plt.legend(handles=dist_lines.values())\n\n def to_segments(xs, ys):\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\n\n def init():\n states = np.hstack([\n data[exp][\"state\"][\"main_system\"].ravel() for exp in exp_list\n ])\n ylim_max = states.max()\n ylim_min = states.min()\n ylim_btw = 1.2 * (ylim_max - ylim_min)\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\n\n ax.set_xlim(0, time[-1])\n ax.set_ylim(ylim_min, ylim_max)\n return [line for line, _ in lines] + list(dist_lines.values())\n\n def update(frame):\n for line, line_data in lines:\n line.set_data(time[:frame], line_data[:frame])\n\n # Update FE-CMRAC\n if frame > 0 and memory_time_diff[frame-1] != 0:\n ta_idx = np.argmax(\n time > data[\"fecmrac-nullagent\"][\"memory\"][\"time\"][frame]\n )\n dist_time = time[:ta_idx]\n dist_k = data[\"fecmrac-nullagent\"][\"k\"][:ta_idx]\n dist = [\n -np.exp(-np.trapz(dist_k[i:], dist_time[i:]))\n for i in range(len(dist_time))\n ]\n segments = to_segments(dist_time, dist)\n dist_lines[\"fecmrac-nullagent\"].set_segments(segments)\n\n # Update RL-CMRAC\n dist_time = data[\"rlcmrac-sac\"][\"memory\"][\"t\"][frame]\n dist = 100 * data[\"rlcmrac-sac\"][\"dist\"][frame]\n segments = to_segments(dist_time, dist)\n dist_lines[\"rlcmrac-sac\"].set_segments(segments)\n return [line for line, _ in lines] + list(dist_lines.values())\n\n anim = FuncAnimation(\n fig, update, init_func=init,\n frames=range(0, len(time), 10), interval=10\n )\n # plt.show()\n anim.save(os.path.join(args.save_dir, \"dist-movie.mp4\"))","def makePlot(timeStamp):\n\n #-------------------------------------------------------------------------\n # Create figure and axes\n #-------------------------------------------------------------------------\n\n width = 12 # inches\n height = 8 # inches\n fig = plt.figure(figsize=(width, height))\n\n # We'll use gridspec to create axes in rectangular 6-by-5 lattice\n import matplotlib.gridspec as gridspec\n nrows = 6\n ncols = 5\n Grid = gridspec.GridSpec(nrows, ncols)\n\n # axis for elevation time series\n axElev = fig.add_subplot(Grid[:2, :2]) # first 2 rows, first 2 columns\n # axis for slab\n axSlab = fig.add_subplot(Grid[:2, 2:]) # first 2 rows, columns > 2\n # and the transects\n axTran1 = fig.add_subplot(Grid[2:4, :]) # rows 2,3,4, all columns\n # rows 5,6,7, all columns, share x/y axis with previous (sets same ticks\n # etc)\n axTran2 = fig.add_subplot(Grid[4:6, :], sharex=axTran1, sharey=axTran1)\n\n # gridspec allows to tune the spacing between plots (unit is fraction of\n # font size)\n boundary_pad = 3.5\n horizontal_pad = 0.2\n vertical_pad = 1.0\n # figure area left,bottom,right,top in normalized coordinates [0,1]\n bounds = [0, 0, 1, 1]\n Grid.tight_layout(\n fig,\n pad=boundary_pad,\n w_pad=horizontal_pad,\n h_pad=vertical_pad,\n rect=bounds)\n\n #-------------------------------------------------------------------------\n # Create plots\n #-------------------------------------------------------------------------\n\n # for all avaiable colormaps see ( '_r' reverses the colormap )\n # http://matplotlib.org/examples/color/colormaps_reference.html\n colormap = plt.get_cmap('Spectral_r')\n colormap_kine = plt.get_cmap('gist_heat')\n\n # slab\n salt_clim = [0, 32]\n ncontours = 16\n # bouding box for slab [xmin,xmax,ymin,ymax] in model x,y coordinates\n estuarybbox = [330000, 360000, 284500, 297500]\n dia = slabSnapshotDC(\n clabel='Salinity',\n unit='psu',\n clim=salt_clim,\n cmap=colormap)\n dia.setAxes(axSlab)\n dia.addSample(slabDC, timeStamp=timeStamp, plotType='contourf',\n bbox=estuarybbox, N=ncontours)\n # overrides default format for colorbar floats\n dia.showColorBar(format='%.2g')\n #dia.addTitle('in case you want a custom title')\n # get transect (x,y) coordinates from the transectDC\n transectXYCoords = generateTransectFromDataContainer(transectDC_salt, 0)[4]\n # plot transect on the map (thin black on thick white)\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\n color='w', linewidth=2.0)\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\n color='k', linewidth=1.0)\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(\n staX,\n staY,\n label=station,\n printLabel=True,\n marker='*')\n # add text to plot. x,y are in normalized axis coordinates [0,1]\n dia.ax.text(0.05, 0.98, 'custom text', fontsize=fontsize,\n verticalalignment='top', horizontalalignment='left',\n transform=dia.ax.transAxes)\n\n # elevation time series\n # define the time range to plot\n elevStartTime = datetime.datetime(2012, 5, 4, 0, 0)\n elevEndTime = datetime.datetime(2012, 5, 5, 0, 15)\n elevMeanTime = elevStartTime + (elevEndTime - elevStartTime) / 2\n elevLim = [-1.5, 2.5]\n dia = timeSeriesPlotDC2(\n xlabel=elevMeanTime.strftime('%Y %b %d'),\n ylim=elevLim)\n dia.setAxes(axElev)\n #dia.addShadedRange( timeStamp, timeStamp+datetime.timedelta(seconds=30), facecolor='IndianRed')\n dia.addShadedRange(\n timeStamp,\n timeStamp,\n edgecolor='IndianRed',\n facecolor='none',\n linewidth=2)\n tag = elevDC.getMetaData('tag')\n dia.addSample(\n elevDC.timeWindow(\n elevStartTime,\n elevEndTime),\n label=tag,\n color='k')\n dia.addTitle('Elevation ({0:s}) [m]'.format(\n elevDC.getMetaData('location').upper()))\n # adjust the number of ticks in x/y axis\n dia.updateXAxis(maxticks=5)\n dia.updateYAxis(maxticks=3, prune='lower')\n\n # transects\n dia = transectSnapshotDC(\n clabel='Salinity',\n unit='psu',\n cmap=colormap,\n clim=salt_clim)\n dia.setAxes(axTran1)\n #transectDC_salt.data *= 1e-3\n dia.addSample(transectDC_salt, timeStamp, N=ncontours)\n dia.addTitle('')\n dia.showColorBar()\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(staX, staY, label=station, color='k',\n linewidth=1.5, linestyle='dashed')\n # do not show x axis ticks and label for this plot\n dia.hideXTicks()\n\n dia = transectSnapshotDC(clabel='TKE', unit='m2s-1', logScale=True,\n clim=[-7, -2], climIsLog=True, cmap=colormap_kine)\n dia.setAxes(axTran2)\n dia.addSample(transectDC_kine, timeStamp, N=ncontours)\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(staX, staY, label=station, color='k',\n linewidth=1.5, linestyle='dashed')\n dia.addTitle('')\n dia.showColorBar()\n dia.updateXAxis(maxticks=15)\n dia.updateYAxis(maxticks=6)\n\n #-------------------------------------------------------------------------\n # Save to disk\n #-------------------------------------------------------------------------\n dateStr = timeStamp.strftime('%Y-%m-%d_%H-%M')\n filename = '_'.join([imgPrefix, dateStr])\n saveFigure(\n imgDir,\n filename,\n imgFiletype,\n verbose=True,\n dpi=200,\n bbox_tight=True)\n plt.close()","def figure3():\n\n plot_settings = {'y_limits': [-75, -50],\n 'x_limits': None,\n 'y_ticks': [-75, -70, -65, -60, -55, -50],\n 'locator_size': 2.5,\n 'y_label': 'Voltage (mV)',\n 'x_ticks': [],\n 'scale_size': 2,\n 'x_label': \"\",\n 'scale_loc': 3,\n 'figure_name': 'figure_3',\n 'legend': ['0.1 $\\mu$S', '0.125 $\\mu$S', '0.15 $\\mu$S'],\n 'legend_size': 8,\n 'legend_location': 4,\n 'y_on': True}\n line_styles = ['-', 'dotted', '-.']\n\n plt.figure(figsize=(5, 3))\n plt.subplot(1, 2, 1) # Generate subplot 1 (left)\n for ix, g_t_bar in enumerate([0.1, 0.125, 0.15]):\n t, y = solver(6, g_t_bar=g_t_bar, t_start=0.5)\n plt.plot(t, y[:, 0], c='k', linestyle=line_styles[ix])\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(1, 2, 2) # Generate subplot 2 (right)\n for ix, i_bias_on in enumerate([0, -0.1, -0.2]):\n \"\"\"\n First step (hyperpolarizing)\n \"\"\"\n t1 = 1000\n duration = t1\n\n t, y_hold = solver(t1, duration=duration, i_bias_on=i_bias_on)\n y_0 = y_hold[-1, :] # Create new initial conditions\n\n \"\"\"\n Second step (current pulse)\n \"\"\"\n t1 = 20\n t, y = solver(t1, t_start=0, y_hold=y_0)\n v = y[:, 0]\n\n \"\"\"\n Append the end of the first step onto the second step (for plotting purposes)\n \"\"\"\n len_pre = 100\n t = np.concatenate((np.linspace(-len_pre * np.diff(t)[0], -np.diff(t)[0], len_pre), t))\n v_bar = np.concatenate((y_hold[-len_pre:, 0], v))\n v_bar = v_bar - v_bar[0] + -7.16300325e+01 # Align solution to initial condition of the \"standard simulation\"\n\n plt.plot(t, v_bar, c='k', linestyle=line_styles[ix])\n\n plot_settings['y_ticks'] = []\n plot_settings['y_label'] = \"\"\n plot_settings['x_limits'] = [-1, 20]\n plot_settings['legend'] = ['-72 mV', '-75 mV', '-78 mV']\n plot_settings['scale_size'] = 5\n plot_settings['legend_location'] = 1\n alter_figure(plot_settings, close=True)","def figure_3():\n from matplotlib.animation import FuncAnimation\n from collections import OrderedDict\n\n plt.rc(\"font\", **{\n \"family\": \"sans-serif\",\n \"sans-serif\": [\"Helvetica\"],\n })\n plt.rc(\"text\", usetex=True)\n plt.rc(\"lines\", linewidth=1)\n plt.rc(\"axes\", grid=True)\n plt.rc(\"grid\", linestyle=\"--\", alpha=0.8)\n\n exp1 = \"rlcmrac-sac\"\n exp2 = \"clcmrac-nullagent\"\n exp_list = [exp1, exp2]\n\n data = {exp: get_data(exp) for exp in exp_list}\n\n fig, ax = plt.subplots(figsize=[16, 9])\n plt.xlabel(\"Time, sec\")\n\n linekw = dict(linewidth=1, alpha=0.3)\n\n def make_line(label, *args):\n ln, = plt.plot([], [], label=label, *args, **linekw)\n return ln\n\n time_list = [data[exp][\"time\"] for exp in exp_list]\n time = time_list[np.argmin(list(map(len, time_list)))]\n\n sample_data = list(data.values())[0]\n lines = [\n (\n make_line(\"Command\", \"k--\"),\n sample_data[\"cmd\"]\n ),\n (\n make_line(r\"$x_{r,1}$\", \"k\"),\n sample_data[\"state\"][\"reference_system\"][:, 0]\n ),\n (\n make_line(r\"$x_{r,2}$\", \"k\"),\n sample_data[\"state\"][\"reference_system\"][:, 1]\n ),\n (\n make_line(FORMATTING[exp2][\"label\"] + r\" $x_{1}\", \"r-.\"),\n data[exp2][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(FORMATTING[exp2][\"label\"] + r\" $x_{2}\", \"r-.\"),\n data[exp2][\"state\"][\"main_system\"][:, 1],\n ),\n (\n make_line(FORMATTING[exp1][\"label\"] + r\" $x_{1}\", \"b-.\"),\n data[exp1][\"state\"][\"main_system\"][:, 0],\n ),\n (\n make_line(FORMATTING[exp1][\"label\"] + r\" $x_{2}\", \"b-.\"),\n data[exp1][\"state\"][\"main_system\"][:, 1],\n ),\n ]\n\n dist_lines = {\n k: plt.vlines(\n [], [], [],\n colors=FORMATTING[k][\"color\"],\n alpha=1,\n label=FORMATTING[k][\"label\"],\n )\n for k in exp_list\n }\n\n plt.legend(handles=dist_lines.values())\n\n def to_segments(xs, ys):\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\n\n def init():\n states = np.hstack([\n data[exp][\"state\"][\"main_system\"].ravel() for exp in exp_list\n ])\n ylim_max = states.max()\n ylim_min = states.min()\n ylim_btw = 1.2 * (ylim_max - ylim_min)\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\n\n ax.set_xlim(0, time[-1])\n ax.set_ylim(ylim_min, ylim_max)\n return [line for line, _ in lines] + list(dist_lines.values())\n\n def update(frame):\n for line, line_data in lines:\n line.set_data(time[:frame], line_data[:frame])\n\n # Update\n for i, exp in enumerate(exp_list):\n dist_time = data[exp][\"memory\"][\"t\"][frame]\n if i == 0:\n dist = 100 * data[exp][\"dist\"][frame]\n else:\n dist = [-1] * len(dist_time)\n\n segments = to_segments(dist_time, dist)\n dist_lines[exp].set_segments(segments)\n\n return [line for line, _ in lines] + list(dist_lines.values())\n\n anim = FuncAnimation(\n fig, update, init_func=init,\n frames=range(0, len(time), 10), interval=10\n )\n # plt.show()\n anim.save(os.path.join(args.save_dir, \"dist-movie.mp4\"))","def plot_data(heart_filt, pace_filt):\n\n plt.figure(1)\n plt.plot(heart_filt, pace_filt)\n plt.show()","def figure8():\n\n plot_settings = {'y_limits': [15, 60],\n 'x_limits': None,\n 'y_ticks': [20, 30, 40, 50, 60],\n 'locator_size': 5,\n 'y_label': 'ISI (ms)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_8',\n 'legend': ['First ISI', 'Second ISI'],\n 'legend_size': 8,\n 'y_on': True,\n 'legend_location': 4}\n\n g_t_bars = np.linspace(0.02, 0.2, 10)\n isi = np.zeros((len(g_t_bars), 2))\n\n for ix, g_t_bar in enumerate(g_t_bars):\n t, y = solver(200, t_start=15, duration=260, g_t_bar=g_t_bar)\n t_spike, f = spike_times(t, y[:, 0])\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_t_bars[3], 35, 0, 11, head_width=0, head_length=0, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[3], 46, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[3], 35, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Acceleration\", (0.1, 35), fontsize=8)\n plt.gca().annotate(\"Adaptation\", (0.01, 46), fontsize=8)\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n g_n_bars = np.linspace(0.02, 0.2, 10)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_n_bar in enumerate(g_n_bars):\n t, y = solver(200, g_n_bar=g_n_bar, duration=260, t_start=15, g_t_bar=0.02)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_n_bars[3], 30, 0, 10, head_width=0, head_length=0, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[3], 40, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[3], 30, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Acceleration\", (0.1, 30), fontsize=8)\n plt.gca().annotate(\"Adaptation\", (0.015, 40), fontsize=8)\n plot_settings['y_ticks'] = []\n plot_settings['y_label'] = \"\"\n plot_settings['y_on'] = False\n plot_settings['legend_location'] = 4\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n g_t_bars = np.linspace(0.02, 0.16, 8)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_t_bar in enumerate(g_t_bars):\n t, y = solver(200, g_t_bar=g_t_bar, duration=260, t_start=15, ca_type=1)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_t_bars[2], 25, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_t_bars[4], 25, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Adaptation\", (0.06, 25), fontsize=8)\n\n plot_settings['y_limits'] = [0, 45]\n plot_settings['y_ticks'] = [0, 10, 20, 30, 40]\n plot_settings['locator_size'] = 5\n plot_settings['y_label'] = 'ISI (ms)'\n plot_settings['y_on'] = True\n plot_settings['legend_location'] = 3\n alter_figure(plot_settings)\n\n plt.subplot(2, 2, 4)\n g_n_bars = np.linspace(0.02, 0.16, 8)\n isi = np.zeros((len(g_t_bars), 2))\n for ix, g_n_bar in enumerate(g_n_bars):\n t, y = solver(200, duration=260, t_start=15, g_n_bar=g_n_bar, g_t_bar=0.02, ca_type=2)\n t_spike, f = spike_times(t, y[:, 0])\n\n isi[ix, 0] = t_spike[1] - t_spike[0]\n isi[ix, 1] = t_spike[2] - t_spike[1]\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\n\n \"\"\"\n Annotate plot\n \"\"\"\n plt.gca().arrow(g_n_bars[2], 20, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().arrow(g_n_bars[4], 20, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\n plt.gca().annotate(\"Adaptation\", (0.06, 20), fontsize=8)\n\n plot_settings['y_ticks'] = []\n plot_settings['y_label'] = ''\n plot_settings['y_on'] = False\n plot_settings['legend_location'] = 2\n alter_figure(plot_settings, close=True)","def PlotTimes(metadata, data):\n\n gp = Gnuplot.Gnuplot(persist=1)\n gp('set data style impulses')\n gp('set xtics 1')\n gp.clear()\n gp.xlabel('seconds')\n gp.ylabel('duration in second')\n gp.title(metadata.AsTitle())\n styles = {}\n line_style = 1\n\n for dataset in data:\n x = numpy.array(dataset.time, dtype='float_')\n if not dataset.name in styles:\n styles[dataset.name] = line_style\n line_style += 1\n d = Gnuplot.Data(x, dataset.data,\n title=dataset.name,\n with_='impulses ls %d' % styles[dataset.name])\n else: # no need to repeat a title that exists already.\n d = Gnuplot.Data(x, dataset.data,\n with_='impulses ls %d' % styles[dataset.name])\n\n gp.replot(d)\n gp.hardcopy('/tmp/%s-%s-%f.png' %\n (metadata.name, metadata.kernel, metadata.duration),\n terminal='png')","def plot_time_frames(self):\n\n fig = plt.figure()\n plt.grid(True)\n\n plt.ylim([-1.5,1.5])\n plt.xlim([0,1])\n\n for key in self.timeframes.keys():\n if key == 0:\n plt.plot(self.x, self.timeframes[key], label=\"time: \" + str(round(key*self.dt, 3)), linewidth=5)\n else:\n plt.plot(self.x, self.timeframes[key], label=\"time: \" + str(round(key*self.dt, 3)))\n\n plt.title(\"Wave at different times\")\n plt.legend(loc=\"upper right\")\n plt.show()\n\n # fig.savefig('results/pics_wave/vibrating_string_'+ self.type + '.png', dpi=150)","def plot_fig44a_wlc_inhomo_test7():\n\n fig, ax = plt.subplots(figsize=(default_width, default_height))\n #paramters from calculation, all in nm\n a = 5 #looping radius\n DEL = 15.3 #spacing between nucleosomes\n MINUS1NUC = -83.3 #distance between -1 nuc and TSS\n PLUS1NUC = 0\n NNUC = 50 #number of nucleosomes on each side of TSS\n LPB = 0.34 #nm per basepair (as used in calculation)\n\n Llinks = np.concatenate(([245], np.tile(45, 49)))\n Rlinks = np.tile(45, 49)\n #plot as negative distance from TSS in bp\n unwrap=0\n ldna_Llinks = -1*convert.genomic_length_from_links_unwraps(Llinks, unwraps=unwrap)\n ldna_Rlinks = convert.genomic_length_from_links_unwraps(Rlinks, unwraps=unwrap)\n x = np.concatenate((ldna_Llinks[::-1], [0], ldna_Rlinks))\n y = np.loadtxt('csvs/Sarah/pnucsite_test7.txt')\n ax.plot(x, y, '-o', markersize=3, color=teal_flucts)\n plt.xlabel(r'Distance from TSS (bp)')\n plt.ylabel(r'$P_\\mathrm{loop}(a=5\\mathrm{nm}; L)\\;\\;\\;(\\mathrm{nm}^{-3})$')\n plt.subplots_adjust(left=0.16, bottom=0.19, top=0.98, right=0.96)\n plt.yscale('log')\n #plt.ylim([10**-3, 10**-0.4])\n plt.xlim([-10000, 10000])\n plt.savefig(f'plots/thesis/fig44a_wlc-inhomo-looping.pdf', bbox_inches='tight')","def plot_tariff(self):\n\t\tplt.figure(1)\n\t\tplt.cla() # clear the plotting window to allow for re-plotting\n\n\t\tif self.chargetypetoplot.get() == 'energy':\n\t\t\ttoplot = []\n\t\t\tenergy_filter = ('energy' == self.data[\"Charge\"]) | ('Energy' == self.data[\"Charge\"])\n\t\t\tfor mo in range(1, 13):\n\t\t\t\tmonth_filter = (mo >= self.data[\"Start Month\"]) & (mo <= self.data[\"End Month\"])\n\t\t\t\ttemp = self.data.loc[(energy_filter & month_filter), :]\n\t\t\t\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \"Value\"])\n\t\t\t\t\t\t\t for hr in range(1, 25)])\n\t\t\tim = plt.imshow(toplot, interpolation='nearest')\n\t\t\tplt.xticks(ticks=[i-.5 for i in range(25)],\n\t\t\t\t\t labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)], rotation=45)\n\t\t\tplt.yticks(ticks=[i-0.5 for i in range(13)],\n\t\t\t\t\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',\n\t\t\t\t\t\t\t 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''], va='top')\n\n\t\t\t# get the colors of the values, according to the\n\t\t\t# colormap used by imshow\n\t\t\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\n\t\t\tcolors = [im.cmap(im.norm(value)) for value in values]\n\t\t\t# create a patch (proxy artist) for every color\n\t\t\tpatches = [mpatches.Patch(color=colors[i], label=\"${:1.5}/kWh\".format(values[i]))\n\t\t\t\t\t for i in range(len(values))]\n\t\t\t# put those patched as legend-handles into the legend\n\t\t\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\"upper right\", borderaxespad=0.)\n\t\t\tplt.title('Energy Price Heatmap')\n\t\telse:\n\t\t\ttoplot = []\n\t\t\tdemand_filter = ('demand' == self.data[\"Charge\"]) | ('Demand' == self.data[\"Charge\"])\n\t\t\tfor mo in range(1, 13):\n\t\t\t\tmonth_filter = (mo >= self.data[\"Start Month\"]) & (mo <= self.data[\"End Month\"])\n\t\t\t\ttemp = self.data.loc[(demand_filter & month_filter), :]\n\t\t\t\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \"Value\"]) for hr in\n\t\t\t\t\t\t\t range(1, 25)])\n\t\t\tim = plt.imshow(toplot, interpolation='nearest')\n\t\t\tplt.xticks(ticks=[i - .5 for i in range(25)], labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)],\n\t\t\t\t\t rotation=45)\n\t\t\tplt.yticks(ticks=[i - 0.5 for i in range(13)],\n\t\t\t\t\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''],\n\t\t\t\t\t va='top')\n\n\t\t\t# get the colors of the values, according to the\n\t\t\t# colormap used by imshow\n\t\t\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\n\t\t\tcolors = [im.cmap(im.norm(value)) for value in values]\n\t\t\t# create a patch (proxy artist) for every color\n\t\t\tpatches = [mpatches.Patch(color=colors[i], label=\"${:1.5}/kW\".format(values[i])) for i in\n\t\t\t\t\t range(len(values))]\n\t\t\t# put those patched as legend-handles into the legend\n\t\t\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\"upper right\", borderaxespad=0.)\n\t\t\tplt.title('Demand Price Heatmap')\n\n\t\tself.chart_type.draw()\n\n\t\treturn 0","def showPlot1():\n\n interested_in = list(range(5,30,5))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on room size')\n xlabel('area of the room (tiles)')\n ylabel('mean time (clocks)')\n show()","def tracer_movie(datadir = 'data/', tracerFile = 'tracers.dat',\n fixedFile = 'fixed_points.dat', zlim = [],\n head_size = 3, hm = 1,\n imageDir = './', movieFile = 'fixed_points.mpg',\n fps = 5.0, bitrate = 1800):\n \n import pylab as plt\n\n # read the mapping and the fixed point positions\n tracers, mapping, t = pc.read_tracers(datadir = datadir, fileName = tracerFile, zlim = zlim, head_size = head_size)\n fixed = pc.read_fixed_points(datadir = datadir, fileName = fixedFile, hm = hm)\n\n # read the parameters for the domain boundaries\n params = pc.read_param(quiet = True)\n domain = [params.xyz0[0], params.xyz1[0], params.xyz0[1], params.xyz1[1]]\n\n # determine the how much faster the fixed pints have been written out than the color mapping\n advance = np.ceil(float(len(fixed.t))/len(mapping[0,0,:,0]))\n\n # determine the colors for the fixed points\n colors = np.zeros(np.shape(fixed.q) + (3,))\n colors[:,:,:] = 0.\n print(np.shape(colors))\n for j in range(len(colors[:,0,0])):\n for k in range(len(colors[0,:,0])):\n if fixed.q[j,k] >= 0:\n colors[j,k,1] = colors[j,k,2] = (1-fixed.q[j,k]/np.max(np.abs(fixed.q[:,k])))\n colors[j,k,0] = fixed.q[j,k]/np.max(np.abs(fixed.q[:,k]))\n else:\n colors[j,k,0] = colors[j,k,1] = (1+fixed.q[j,k]/np.max(np.abs(fixed.q[:,k])))\n colors[j,k,2] = -fixed.q[j,k]/np.max(np.abs(fixed.q[:,k]))\n\n # prepare the plot\n width = 6\n height = 6\n plt.rc(\"figure.subplot\", left=(60/72.27)/width)\n plt.rc(\"figure.subplot\", right=(width-20/72.27)/width)\n plt.rc(\"figure.subplot\", bottom=(50/72.27)/height)\n plt.rc(\"figure.subplot\", top=(height-20/72.27)/height)\n figure = plt.figure(figsize=(width, height))\n\n for k in range(len(fixed.x[0,:])):\n dots = plt.plot(fixed.x[0,k], fixed.y[0,k], 'o', c = colors[0,k,:])\n image = plt.imshow(zip(*mapping[:,::-1,0,:]), interpolation = 'nearest', extent = domain)\n j = 0\n frameName = imageDir + 'images%06d.png'%j\n imageFiles = []\n imageFiles.append(frameName)\n figure.savefig(frameName)\n\n for j in range(1,len(fixed.t)):\n #time.sleep(0.5)\n figure.clear()\n for k in range(len(fixed.x[j,:])):\n dots = plt.plot(fixed.x[j,k], fixed.y[j,k], 'o', c = colors[j,k,:])\n image = plt.imshow(zip(*mapping[:,::-1,np.floor(j/advance),:]), interpolation = 'nearest', extent = domain)\n frameName = imageDir + 'images%06d.png'%j\n imageFiles.append(frameName)\n figure.savefig(frameName)\n\n # convert the images into a mpg file\n mencodeCommand = \"mencoder 'mf://\"+imageDir+\"images*.png' -mf type=png:fps=\"+np.str(fps)+\" -ovc lavc -lavcopts vcodec=mpeg4:vhq:vbitrate=\"+np.str(bitrate)+\" -ffourcc MP4S -oac copy -o \"+movieFile\n os.system(mencodeCommand)\n\n # remove the image files\n for fname in imageFiles:\n os.remove(fname)","def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\r\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\r\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \r\n if listOfNames==None:\r\n listOfNames = listOfFilesToPlot\r\n if listOfColors==None:\r\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\r\n \r\n fig = pylab.figure(figsize=figsize)\r\n ax = fig.add_subplot(111, projection='3d')\r\n\r\n yTotal = len(listOfFilesToPlot)\r\n top = 0.0\r\n\r\n if not (subtractRef is None):\r\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\r\n #zsRef = list(numpy.array(zsRef)-fixedOffset\r\n zNorm = max(zsRef[len(zsRef)/2:])\r\n zsRef = numpy.array(zsRef)/zNorm\r\n \r\n for i,f in enumerate(listOfFilesToPlot):\r\n [xs, zs, name] = qMS.readMSSpectraFile(f)\r\n if fixedOffset:\r\n off = zs[len(zs)/2]\r\n print off\r\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\r\n zs = list(numpy.array(zs)-off)\r\n ys = [yTotal-i]*len(xs)\r\n ys = numpy.array(ys)*yScale\r\n if normalizeToN15:\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n if not (subtractRef is None):\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\r\n zs = zs*zNorm\r\n #xs = xs[:len(xs)/2]\r\n #ys = ys[:len(ys)/2]\r\n #zs = zs[:len(zs)/2]\r\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\r\n if (scaleP is True) and (i==scaleI):\r\n zs = numpy.array(zs)*scaleVal\r\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\r\n top = max([top, float(max(zs))])\r\n\r\n\r\n ax.w_xaxis.pane.set_visible(False)\r\n ax.w_yaxis.pane.set_visible(False)\r\n ax.w_zaxis.pane.set_visible(False)\r\n\r\n if gridLines: \r\n ax.w_xaxis.gridlines.set_linewidth(1)\r\n ax.w_yaxis.gridlines.set_linewidth(1)\r\n ax.w_zaxis.gridlines.set_linewidth(1)\r\n \r\n else:\r\n ax.w_xaxis.gridlines.set_visible(False)\r\n ax.w_yaxis.gridlines.set_visible(False)\r\n ax.w_zaxis.gridlines.set_visible(False)\r\n\r\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\r\n\r\n ax.w_xaxis.line.set_linewidth(1)\r\n ax.w_yaxis.line.set_linewidth(1)\r\n ax.w_zaxis.line.set_linewidth(1)\r\n \r\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\r\n ax.set_zlim3d([0, top])\r\n ax.set_ylim3d(yMin, yMax)\r\n ax.set_yticks(range(1,yTotal+1))\r\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\r\n ax.set_xlim3d([xMin, xMax])\r\n \r\n if noTicks:\r\n ax.set_zticks([])\r\n ax.set_xticks([])\r\n ax.set_yticks([])\r\n\r\n ax.set_xlabel(xlabel)\r\n ax.set_zlabel(zlabel)\r\n\r\n ax.view_init(15, -60)\r\n if legend:\r\n pylab.legend(loc=legendLoc)\r\n \r\n pylab.tight_layout()\r\n return ax","def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\n\tplt.figure()\n\n\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\n\n\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\n\t#y = np.zeros_like(x)\n\tx = coords[:,0]\n\ty = np.zeros_like(x)\n\n\t# NOTE: plot elastic solution by passing dictionary as showelastic\n\t# Plot analytic elastic solution (t=0)\n\t#print(benchmark)\n\tif len(benchmark)>=1:\n\t\tur = zeros_like(x)\n\t\tuz = np.zeros_like(x)\n\t\tfor b in benchmark:\n\t\t\turi,uzi = m.calc_mogi_dp(x,y,**params)\n\t\t\tur += uri\n\t\t\tuz += uzi\n\t\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\n\n\t# Convert units\n\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\n\tur = data[:,:,0]\n\tuz = data[:,:,2]\n\tx = x / xscale\n\tur = ur / yscale #cm\n\tuz = uz / yscale #cm\n\ttimes = times / tscale\n\t#times = times / 8.64e4 #days\n\t#times = times / 31536000 #years\n\n\t#plots = np.arange(0,times.size,skip)\n\t#print(plots.size)\n\t#way to cycle through markers if plotting many lines\n\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\n\t#way to use gradually changing colors from a colormap\n\t#color = plt.cm.jet(1.0*i/plots.size)\n\tindplots = np.arange(times.size-1)\n\tprint(indplots)\n\tindplots = indplots[skip]\n\tprint(indplots)\n\tfor i in indplots:\n\t\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\n\t\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\n\t#print uz[i]\n\t#print uz[i-1]\n\n\tif title:\n\t\tplt.title(title)\n\telse:\n\t\tplt.title(pointsh5)\n\n\tplt.axhline(color='k',linestyle='dashed')\n\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.show()\n\tplt.legend(title='{}'.format(get_unit(tscale)))\n\tplt.grid()","def trajectories(self):\n # OPTIMIZE: take too much time due to too much solver call\n alpha_min = self.search_alpha_min()\n alpha_finder = self.FOV_img/2\n\n if self.display_trajectories is True:\n plt.figure('Trajectories plan')\n plt.clf() #clear the graph to avoir superposing data from the same set (can be deactivated if need to superpose)\n ax = plt.subplot(111, projection='polar') #warning if use python in ligne (!= graphical) graphs got superposed\n ax.set_title(\"light trajectories close to a black hole\\n\", va='bottom')\n ax.set_xlabel('R(UA)')\n plt.ylabel('phi(°)\\n\\n\\n\\n', rotation=0)\n ax.set_rlim((0, 4*self.D))\n ax.set_rlabel_position(-90)\n\n seen_angle = np.array([])\n deviated_angle = np.array([])\n\n booli = False # avoid points from the first loop to exceed points from the second loop\n points = 40 # careful with this if using kind=linear\n\n for i in range(6):\n # print(alpha_finder)\n\n for alpha in np.linspace(alpha_finder, alpha_min,\n num=points, endpoint=booli):\n r, phi = self.solver(alpha)\n\n if r[-1] > 1.1*self.Rs: # if not capture by black hole\n seen_angle = np.append(seen_angle, 180-alpha)\n dev_angle = phi[-1] + math.asin(self.D/r[-1]*math.sin(phi[-1]))\n dev_angle = math.degrees(dev_angle)\n deviated_angle = np.append(deviated_angle, dev_angle)\n Ci = 'C'+str(i)\n\n if self.display_trajectories is True:\n ax.plot(phi, r, Ci) # plot one trajectory\n\n if self.kind == 'linear':\n alpha_finder = alpha_min + (alpha_finder - alpha_min)/(points/3 + 1) # start a more precise cycle from last point\n\n else:\n alpha_finder = alpha_min + (alpha_finder - alpha_min)/(points + 1) # start a more precise cycle from last point\n\n points = 10 # careful with this if using kind=linear\n\n if i == 4:\n booli = True # allow to display the last point\n\n if self.display_trajectories is True:\n # plt.savefig('trajectories.png', format='png', dpi=1000, bbox_inches='tight')\n plt.draw()\n\n return seen_angle, deviated_angle","def experimental_report(environment, species, time_series,path=None,events=None):\n\n\n M = len(environment)+1\n L = int(np.ceil(1 + len(time_series)/2))\n fig = plt.figure(figsize=(5*M,5*L))\n \n colormaps = [\"Greens\",\"bwr\",\"Blues\",\"Oranges\",\"RdPu\",\"Reds\"]\n for i,(k,v) in enumerate(environment):\n plt.subplot(L,M,i+1)\n plt.imshow(v,\n interpolation='None',\n cmap=colormaps[i%len(colormaps)],\n vmin=0,vmax=1,\n aspect=\"equal\")\n plt.xticks([])\n plt.yticks([])\n plt.title(k)\n plt.colorbar(orientation=\"horizontal\", fraction=0.045)\n plt.subplot(L,M,M)\n niches(species,path=path)\n\n colors = [\"blue\",\"green\",\"brown\",\"purple\",\"red\"]\n host = [host_subplot(L*100+10+2+j, axes_class=AA.Axes) for j in range(L-1)]\n\n\n for i,(k,v) in enumerate(time_series):\n #if False and i%2 != 0:\n # ax = host[int(i/2)].twinx()\n #else:\n ax = host[int(i/2)]\n ax.set_ylabel(k)\n if len(v) == 2:\n T = len(v[0])\n ax.plot(v[0],\n label=k,\n color=colors[i%len(colors)],\n linewidth=2)\n ax.fill_between(range(len(v[0])),\n v[0]-v[1], v[0]+v[1],\n alpha=0.3,\n color=colors[i%len(colors)])\n else:\n T = len(v)\n ax.plot(range(len(v)),v, color=colors[i%len(colors)], label=k)\n \n \n for h in host:\n h.set_xlim((0,T-1))\n h.legend()\n h.set_xlabel(\"Time\")\n \n h.set_ymargin(0.05)\n h.autoscale(enable=True, axis=u'both', tight=False)\n\n if events is not None:\n h.vlines(events,*h.get_ylim(),alpha=0.1)","def plot(\n ecg, \n sample_rate = 500, \n title = 'ECG 12', \n lead_index = lead_index, \n lead_order = None,\n style = None,\n columns = 2,\n row_height = 6,\n show_lead_name = True,\n show_grid = True,\n show_separate_line = True,\n ):\n\n if not lead_order:\n lead_order = list(range(0,len(ecg)))\n secs = len(ecg[0])/sample_rate\n leads = len(lead_order)\n rows = ceil(leads/columns)\n # display_factor = 2.5\n display_factor = 1\n line_width = 0.5\n fig, ax = plt.subplots(figsize=(secs*columns * display_factor, rows * row_height / 5 * display_factor))\n display_factor = display_factor ** 0.5\n fig.subplots_adjust(\n hspace = 0, \n wspace = 0,\n left = 0, # the left side of the subplots of the figure\n right = 1, # the right side of the subplots of the figure\n bottom = 0, # the bottom of the subplots of the figure\n top = 1\n )\n\n fig.suptitle(title)\n\n x_min = 0\n x_max = columns*secs\n y_min = row_height/4 - (rows/2)*row_height\n y_max = row_height/4\n\n if (style == 'bw'):\n color_major = (0.4,0.4,0.4)\n color_minor = (0.75, 0.75, 0.75)\n color_line = (0,0,0)\n else:\n color_major = (1,0,0)\n color_minor = (1, 0.7, 0.7)\n color_line = (0,0,0.7)\n\n if(show_grid):\n ax.set_xticks(np.arange(x_min,x_max,0.2)) \n ax.set_yticks(np.arange(y_min,y_max,0.5))\n\n ax.minorticks_on()\n \n ax.xaxis.set_minor_locator(AutoMinorLocator(5))\n\n ax.grid(which='major', linestyle='-', linewidth=0.5 * display_factor, color=color_major)\n ax.grid(which='minor', linestyle='-', linewidth=0.5 * display_factor, color=color_minor)\n\n ax.set_ylim(y_min,y_max)\n ax.set_xlim(x_min,x_max)\n\n\n for c in range(0, columns):\n for i in range(0, rows):\n if (c * rows + i < leads):\n y_offset = -(row_height/2) * ceil(i%rows)\n # if (y_offset < -5):\n # y_offset = y_offset + 0.25\n\n x_offset = 0\n if(c > 0):\n x_offset = secs * c\n if(show_separate_line):\n ax.plot([x_offset, x_offset], [ecg[t_lead][0] + y_offset - 0.3, ecg[t_lead][0] + y_offset + 0.3], linewidth=line_width * display_factor, color=color_line)\n\n \n t_lead = lead_order[c * rows + i]\n \n step = 1.0/sample_rate\n if(show_lead_name):\n ax.text(x_offset + 0.07, y_offset - 0.5, lead_index[t_lead], fontsize=9 * display_factor)\n ax.plot(\n np.arange(0, len(ecg[t_lead])*step, step) + x_offset, \n ecg[t_lead] + y_offset,\n linewidth=line_width * display_factor, \n color=color_line\n )","def plot_trajectories_XYZ(t_start,t_stop):\n \n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\n \n index_start = np.where(time == t_start)[0][0]\n index_end = np.where(time == t_stop)[0][0]\n \n time = time[index_start:index_end+1]\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\n \n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\n \n plt.figure('Trajectories')\n plt.subplot(311)\n plt.plot(time,ankle_l_trajectory[:,0])\n plt.plot(time,ankle_r_trajectory[:,0])\n #plt.title('Trajectory of the X component')\n plt.xlabel('Time [s]')\n plt.ylabel('X Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(312)\n plt.plot(time,ankle_l_trajectory[:,1])\n plt.plot(time,ankle_r_trajectory[:,1])\n #plt.title('Trajectory of the Y component')\n plt.xlabel('Time [s]')\n plt.ylabel('Y Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n plt.subplot(313)\n plt.plot(time,ankle_l_trajectory[:,2])\n plt.plot(time,ankle_r_trajectory[:,2])\n #plt.title('Trajectory of the Z component')\n plt.xlabel('Time [s]')\n plt.ylabel('Z Position [cm]')\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\n \n# plt.suptitle('Decomposition of the trajectories of the hind feet')\n return","def plot_frames(beads, sim, ti, tf, savebase, save_eps):\n \n ### normalize variables for plotting purposes\n \n lx = sim.lx/sim.bl\n ly = sim.ly/sim.bl\n \n ### set general plot properties\n\n savebase += 'eps_' + str(sim.eps) + '_fp_' + str(sim.fp) + '_areak_' + str(sim.areak) + '/'\n os.system(\"mkdir -p \" + savebase)\n quant_steps = 2056\n norm = mpl.colors.Normalize(vmin=0, vmax=sim.ncells) \n downlim = -2\n uplim = lx+2\n num_ticks = 5\n ax_len = 1.0 # Length of one subplot square box\n ax_b = 0.0 # Beginning/offset of the subplot in the box\n ax_sep = 0.0 # Separation length between two subplots\n total_subplots_in_x = 1 # Total number of subplots \n fig = plt.figure()\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \n ax0 = subp.addSubplot()\n \n ### plot the frames\n \n for step in range(ti, tf):\n \n ### normalize variables for plotting purposes\n \n beads.xi[step, 0, :] /= sim.bl\n beads.xi[step, 1, :] /= sim.bl\n \n time = step*sim.dt\n print 'Step / Total : ', step, tf\n \n ### plot \n\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \n ax0 = subp.addSubplot()\n \n line0 = ax0.scatter(beads.xi[step, 0, :], beads.xi[step, 1, :], s=1, c=beads.cid, \\\n cmap=plt.cm.get_cmap('jet',quant_steps), \\\n edgecolors='None', alpha=0.7, vmin=0, vmax=sim.ncells, \\\n norm=norm, rasterized=True)\n \n ax0.axis('scaled')\n \n ### title\n \n ax0.set_title(\"$t/\\\\tau_{D}$ = \" + \"{0:.2f}\".format(time/sim.tau_D) + \\\n \", $t/\\\\tau_{A}$ = \" + \"{0:.2f}\".format(time/sim.tau_A), fontsize=30)\n \n ### labels\n \n ax0.set_xlabel(\"$x/r_{0}$\", fontsize=40)\n ax0.set_ylabel(\"$y/r_{0}$\", fontsize=40)\n\n ### limits\n\n ax0.set_xlim((downlim, uplim))\n ax0.set_ylim((downlim, uplim))\n \n ### ticks\n \n ax0.xaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\n ax0.yaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\n ax0.tick_params(axis='both', which='major', labelsize=30)\n \n ### save\n\n savepath1 = savebase + \"frame-\" + \"{0:05d}\".format(int(step)) + \".png\"\n if save_eps:\n savepath2 = savebase + \"frame-\" + \"{0:05d}\".format(int(step)) + \".eps\"\n \n plt.savefig(savepath1, dpi=200, bbox_inches='tight', pad_inches=0.08)\n if save_eps:\n plt.savefig(savepath2, dpi=200, bbox_inches='tight', pad_inches=0.08) \n fig.clf() \n \n return","def trajectory1(self):\r\n\r\n trackt = [] # particle trajectory,\r\n trackx = [] # particle trajectory\r\n an = [] # analitical s**2 + x**2 = t**2\r\n s1 = [] # s = 10; s = 0, light\r\n s2 = [] # s = 20;\r\n s3 = [] # s = 40;\r\n for i in range(0, len(self.dt.obs.obt_g)):\r\n trackt.append(float(i))\r\n trackx.append(self.dt.x[i])\r\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\r\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\r\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\r\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\r\n\r\n # plots:\r\n\r\n (fig, ax) = plt.subplots() # figsize=(7,5)\r\n\r\n # trajectory\r\n\r\n ax.plot(\r\n trackx,\r\n trackt,\r\n marker='+',\r\n linewidth=1,\r\n linestyle='-',\r\n color='green',\r\n label='treck',\r\n )\r\n\r\n # measurement t\r\n # ax.plot(self.dt.x, self.dt.t, marker=\"+\", linestyle=\" \", color=\"blue\", label=\"result of measurement\")\r\n\r\n ax.plot(\r\n self.dt.x,\r\n self.dt.t,\r\n marker='o',\r\n linestyle=' ',\r\n color='black',\r\n label='result of measurement',\r\n )\r\n\r\n # analitical t\r\n\r\n ax.plot(self.dt.x, an, linestyle='-', color='red',\r\n label='continuum')\r\n\r\n # light trajectory\r\n\r\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\r\n label='s=0 (light)')\r\n\r\n # s(x) curves\r\n\r\n ax.plot(\r\n trackx,\r\n s1,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=1.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s2,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=2.0',\r\n )\r\n ax.plot(\r\n trackx,\r\n s3,\r\n linestyle=':',\r\n linewidth=1,\r\n color='k',\r\n label='s=4.0',\r\n )\r\n\r\n # error of measurement t\r\n\r\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\r\n\r\n # signature on the horizontal x-axis\r\n\r\n ax.set_xlabel('x in metres')\r\n xm = -1.0\r\n for i in range(len(self.dt.x)):\r\n if self.dt.x[i] > xm:\r\n xm = self.dt.x[i]\r\n stepx = round(xm / float(len(self.dt.x)), 1)\r\n xm = round(xm + stepx, 1)\r\n ax.set_xlim([0.0, xm])\r\n\r\n # signature on vertical y axis\r\n\r\n ax.set_ylabel('t in metres of light time ')\r\n ym = -1.0\r\n for i in range(len(self.dt.t)):\r\n if self.dt.t[i] > ym:\r\n ym = self.dt.t[i]\r\n stepy = round(ym / float(len(self.dt.t)), 1)\r\n ym = round(ym + stepy, 1)\r\n ax.set_ylim([0.0, ym])\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\r\n\r\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.xaxis.set_major_locator(locatorx)\r\n\r\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\r\n\r\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\r\n\r\n # Set the locator for the main labels\r\n\r\n ax.yaxis.set_major_locator(locatory)\r\n\r\n ax.grid()\r\n\r\n # show legend\r\n\r\n ax.legend(loc='upper left')\r\n\r\n # show drawing\r\n\r\n plt.show()","def app(ngr=100,c2a=1.6235):\n import matplotlib.pyplot as plt\n\n ## small donuts\n # plt.gcf().clf()\n grs = main(mu=0,ngrains=ngr,tilt_1=30.,sigma=15)\n plt.gcf().savefig('small_doughnut.pdf',bbox_inches='tight')\n plt.gcf().clf()\n f = gen_file(lab='sm_doughnut',ngr=ngr)\n write_gr(f,grs)\n\n ## Big donuts\n grs = main(mu=0,ngrains=ngr,tilt_1=50.,sigma=15)\n plt.gcf().savefig('big_doughnut.pdf',bbox_inches='tight')\n plt.gcf().clf()\n f = gen_file(lab='big_doughnut',ngr=ngr)\n write_gr(f,grs)\n\n ## twin tilts (30).\n gr1=main(mu=0,ngrains=ngr/2,tilts_about_ax1=30.,sigma=45)\n plt.gcf().clf()\n gr2=main(mu=0,ngrains=ngr/2,tilts_about_ax1=-30.,sigma=45)\n plt.gcf().clf()\n grs =[]\n for i in range(len(gr1)):\n grs.append(gr1[i])\n grs.append(gr2[i])\n grs=np.array(grs)\n mypf=upf.polefigure(grains=grs,csym='hexag',cdim=[1,1,c2a])\n mypf.pf_new(poles=[[0,0,0,1],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\n plt.gcf().savefig('t30.pdf',bbox_inches='tight')\n f = gen_file(lab='dbl_lets_30',ngr=ngr)\n write_gr(f,grs)\n\n ## twin tilts (50).\n gr1=main(mu=0,ngrains=ngr/2,tilts_about_ax1=50.,sigma=45)\n plt.gcf().clf()\n gr2=main(mu=0,ngrains=ngr/2,tilts_about_ax1=-50.,sigma=45)\n plt.gcf().clf()\n gr =[]\n for i in range(len(gr1)):\n gr.append(gr1[i])\n gr.append(gr2[i])\n gr=np.array(gr)\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\n mypf.pf_new(poles=[[0,0,0,1],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\n plt.gcf().savefig('t50.pdf',bbox_inches='tight')\n plt.gcf().clf()\n f = gen_file(lab='dbl_lets_50',ngr=ngr)\n write_gr(f,gr)","def plot_ave(pulse, trap, ToP):\n time_array = np.linspace(0, pulse.t * trap.N, trap.N + 1)\n # fig, ax = plt.subplots()\n all_trial_n, all_trial_n_ave = trap.sideband_cool_sch(pulse, ave = True)\n if ToP == 'a':\n plt.plot(time_array * 1e3, all_trial_n_ave, label = pulse.t)\n if ToP == 'b':\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'magenta', linewidth = 3, label = 'Monte Carlo')\n if ToP == 'c':\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'b')\n if ToP == 'd':\n if trap.no_decay == True and trap.off_resonant_excite == False:\n plt.plot(time_array * 1e3, all_trial_n_ave, label = 'Decay to carrier')\n if trap.no_decay == False and trap.off_resonant_excite == False:\n plt.plot(time_array * 1e3, all_trial_n_ave, \n label = 'Decay to %s sideband'%(trap.sideband))\n if trap.no_decay == False and trap.off_resonant_excite == True:\n plt.plot(time_array * 1e3, all_trial_n_ave, \n label = 'Decay to %s sideband, off-resonant excite'%(trap.sideband))\n # plt.xlabel('time / ms')\n # plt.ylabel('Phonon State')\n # plt.legend()","def showPlot3():\n interested_in = [(20,20),(25,16),(40,10),(50,8),(80,5),(100,4)]\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(2, 1.0, item[0], item[1], 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot([1,1.56,4,6.25,16,25], proc_sim_data)\n title('Dependence of cleaning time on room shape')\n xlabel('ratio of width to height')\n ylabel('mean time (clocks)')\n show()","def plot_stress_time(F_tot, response_t, coords, t_range):\n section = np.where((t>t_range[0]) & (t<t_range[1]))[0]\n fig, ax1 = plt.subplots(figsize=[15,5])\n ax2 = ax1.twinx()\n# ax1.set_title('Load and response at '+str(coords),fontsize = 14)\n ax1.set_xlim(t_range)\n ax1.set_xlabel('t [s]')\n resp = ax1.plot(t[section], response_t[section]/10**6, color=\"#00A6D6\",\n label='Equivalent gate stress')\n ax1.set_ylabel('Stress [MPa]', fontsize=12)\n d_max = 1.2*max(response_t[section])/10**6\n d_mean = np.mean(response_t[section])/10**6\n ax1.set_ylim(d_mean-d_max,d_max)\n ax1.legend()\n\n force = ax2.plot(t[section], F_tot[section]/1000, color=\"#c3312f\", label = 'Wave force')\n ax2.set_ylabel('Integrated wave force [$kN/m$]', fontsize = 12)\n F_lim = 1.2*max(F_tot[section])/1000\n F_mean = np.mean(F_tot[section]/1000)\n ax2.set_ylim(F_mean-F_lim,F_lim)\n\n lines = resp + force\n labs = [l.get_label() for l in lines]\n ax1.grid(lw=0.25)\n ax1.legend(lines,labs, fontsize = 12)\n return fig","def plot(self):\n\t\t\t\n\t\tfig,p1=_plt.subplots(4,sharex=True)\n\t\tp1[0].plot(self.time*1e3,self.eRogA,label='Rogowski A')\n\t\tp1[1].plot(self.time*1e3,self.eRogB,label='Rogowski B')\n\t\tp1[2].plot(self.time*1e3,self.eRogC,label='Rogowski C')\n\t\tp1[3].plot(self.time*1e3,self.eRogD,label='Rogowski D')\n\t\t_plot.finalizeSubplot(p1,xlabel='Time (ms)',ylabel='Current (A)')\n\t\t_plot.finalizeFigure(fig,title=self.title)\n\t\t\n\t\treturn p1","def plottrace_paper(moviedict, figw, figh, figdpi, fontsz, border, xlabel, ylabel, yaxisticks, \n xaxisticks, labels, lw, fs):\n \n for movie, val in moviedict.iteritems():\n os.chdir(movie)\n condition, xlim, color, inum = val\n \n fontv = matplotlib.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\n fontv.set_size(fontsz)\n \n print(movie)\n td = dil.load_params()\n x, roi_cols = dil.load_results(RESULTS_FILE)\n start = int(td['startshort'])\n end = int(td['endshort'])\n \n \n fig1 = plt.figure(figsize=(figw*xlim/0.6, figh), dpi=figdpi, facecolor='w', edgecolor='k')\n \n xlen = len(x[roi_cols['Mean1']][start:end])\n #print(xlen)\n xvals = np.arange(0, float(xlen)/fs, 1/float(fs))\n #print(xvals)\n \n \n ycib = x[roi_cols['Mean1']][start:end]\n ycib = [v - np.mean(ycib) for v in ycib]\n #print(ycib)\n \n ylab = x[roi_cols['Mean2']][start:end]\n ylab = [v - np.mean(ylab) for v in ylab]\n ylab = [v + 70 for v in ylab]\n \n # Plots the traces\n \n plt.plot(xvals, ylab, label='proboscis tip', linewidth=lw, color='k')\n plt.plot(xvals, ycib, label='cibarium', linewidth=lw, color='b')\n \n \n \n \n \n \n \n if labels == 'yes':\n plt.title(td['condition'], fontproperties=fontv, horizontalalignment='left')\n \n #Plots legend and removes the border around it.\n legend=plt.legend()\n #legend = plt.legend(bbox_to_anchor = (1.5, 1.6))\n legend.draw_frame(False)\n ltext = legend.get_texts() \n plt.setp(ltext, fontproperties=fontv) \n \n ax = plt.gca()\n \n #Uncomment lines below to display without top and right borders.\n \n if border == 'no':\n for loc, spine in ax.spines.iteritems():\n if loc in ['left','bottom']:\n pass\n elif loc in ['right','top']:\n spine.set_color('none') # don't draw spine\n else:\n raise ValueError('unknown spine location: %s'%loc)\n \n \n #Uncomment lines below to display ticks only where there are borders.\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n \n # Specifies the number of tickmarks/labels on the yaxis.\n #ax.yaxis.set_major_locator(matplotlib.ticker.MaxNLocator(yaxisticks)) \n ## Removes tick labels and ticks from xaxis.\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\n \n if labels == 'yes':\n plt.ylabel(ylabel, fontsize=fontsz, labelpad=12)\n fig1.figsize = (6, 3)\n \n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower \n #lefthand corner of the figure.\n fig1.subplots_adjust(bottom=0.3)\n fig1.subplots_adjust(left=0.05)\n fig1.subplots_adjust(right=0.95)\n fig1.subplots_adjust(top=0.95)\n \n #ax.xaxis.set_major_locator(matplotlib.ticker.MaxNLocator(XAXISTICKS)) \n \n #Specifies axis labels and axis tick label sizes.\n plt.xlabel(xlabel, fontproperties=fontv)\n plt.ylabel(ylabel, fontproperties=fontv)\n plt.xticks([0, 0.2, 0.4, 0.6], fontproperties=fontv)\n plt.xlim( (0, xlim+0.05) )\n #plt.yticks(fontproperties=fontv)\n \n \n \n # Saves the figures in plots/plots.\n if labels == 'no':\n plotfolder = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath('.'))),\n 'plots')\n makenewdir(plotfolder)\n figname = os.path.join(plotfolder, movie + '_trace_nolab')\n plt.savefig(figname+'.svg', dpi=FIGDPI, format='svg')\n plt.savefig(figname+'.png', dpi=FIGDPI, format='png')\n os.chdir('../')\n\n if labels == 'yes':\n plotfolder = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath('.'))),\n 'plots')\n makenewdir(plotfolder)\n figname = os.path.join(plotfolder, movie + '_trace')\n plt.savefig(figname+'.svg', dpi=FIGDPI, format='svg')\n plt.savefig(figname+'.png', dpi=FIGDPI, format='png')\n os.chdir('../')","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def lick_piezo():\n lp_raw = read_npy_file('lickPiezo.raw.npy')\n lp_timestamps = read_npy_file('lickPiezo.timestamps.npy')\n lp_rate = get_rate(lp_timestamps)\n lick_piezo_ts = TimeSeries(\n name='lickPiezo',\n starting_time=lp_timestamps[0, 1],\n rate=lp_rate,\n data=np.ravel(lp_raw),\n unit='V',\n description='Voltage values from a thin-film piezo connected to the '\n 'lick spout, so that values are proportional to deflection '\n 'of the spout and licks can be detected as peaks of the signal.'\n )\n nwb_file.add_acquisition(lick_piezo_ts)","def plot_1():\n p_files = []\n filename = \"energy_data_2D_80\"\n for file in sorted(os.listdir(folder)):\n if file.startswith(filename):\n p_files.append(os.path.join(folder,file))\n T_list = []\n fig, ax = plt.subplots()\n for p_file in p_files[3::3]:\n T = (os.path.splitext(os.path.basename(p_file))[0]).split('_',4)[4]\n #print(T)\n E = []\n t = []\n if (T not in T_list):\n T_list.append(T)\n with open(p_file) as csvfile:\n lines = csv.reader(csvfile, delimiter=' ')\n sweep = 0\n for row in lines:\n E.append(float(row[0]))\n t.append(sweep)\n sweep += 1\n ax.plot(t[0:200], E[0:200],label=\"T = \"+format(T[0:3]))\n ax.set_title(\"Energy per bond vs Time\")\n ax.set_ylabel(\"e / J\")\n ax.set_xlabel(\"t / sweeps\")\n ax.legend()\n\n fig.savefig(folder2+\"energy_vs_time.png\")\n fig.savefig(texfolder+\"energy_vs_time.pdf\")","def plot_ocp_momentum(self, figsize: Tuple[int, int] = (5, 5),\n ax: plt.axes = None):\n\n if not ax:\n fig, ax = plt.subplots(1, figsize=figsize)\n fig.suptitle(\"One Cycle Momentum with Tail\")\n\n ax.plot(self.steps_list, self.momentum_list, label=\"1cycle Momentum\")\n\n ax.set_xlabel(\"Steps\")\n ax.set_ylabel(\"Momentum\")\n\n return ax","def plot_muscle_activations_with_patches(side,t_start,t_stop):\n \n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\n\n index_start = np.where(time == t_start)[0][0]\n index_end = np.where(time == t_stop)[0][0]\n \n time = time[index_start:index_end+1]\n muscle_rh_activations = muscle_rh_activations[index_start:index_end+1,:]\n muscle_lh_activations = muscle_lh_activations[index_start:index_end+1,:]\n \n gait = foot_r_contact[index_start:index_end+1,:]\n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\n if side =='right':\n muscle_activations = muscle_rh_activations\n elif side == 'left':\n muscle_activations = muscle_lh_activations \n else:\n return\n \n plt.figure('Muscle activations')\n ax = plt.subplot(421)\n plt.plot(time,muscle_activations[:,0],'r')\n plt.title('Muscle PMA')\n #plt.xlabel('Time [s]')\n plt.ylabel('Muscle activation')\n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n\n ax = plt.subplot(422)\n plt.plot(time,muscle_activations[:,1],'r')\n plt.title('Muscle CF')\n #plt.xlabel('Time [s]')\n #plt.ylabel('Muscle activation') \n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n\n ax = plt.subplot(423) \n plt.plot(time,muscle_activations[:,2],'r')\n plt.title('Muscle SM')\n #plt.xlabel('Time [s]')\n plt.ylabel('Muscle activation')\n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n \n ax = plt.subplot(424) \n plt.plot(time,muscle_activations[:,3],'r')\n plt.title('Muscle POP')\n #plt.xlabel('Time [s]')\n #plt.ylabel('Muscle activation') \n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n \n ax = plt.subplot(425) \n plt.plot(time,muscle_activations[:,4],'r')\n plt.title('Muscle RF')\n# plt.xlabel('Time [s]')\n plt.ylabel('Muscle activation') \n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n\n ax = plt.subplot(426) \n plt.plot(time,muscle_activations[:,5],'r')\n plt.title('Muscle TA')\n# plt.xlabel('Time [s]')\n #plt.ylabel('Muscle activation') \n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n \n ax = plt.subplot(427) \n plt.plot(time,muscle_activations[:,6],'r')\n plt.title('Muscle SOL')\n plt.xlabel('Time [s]')\n plt.ylabel('Muscle activation') \n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n \n ax = plt.subplot(428) \n plt.plot(time,muscle_activations[:,7],'r')\n plt.title('Muscle LG')\n plt.xlabel('Time [s]')\n for t, g in enumerate(gait):\n for l, gait_l in enumerate(g):\n if gait_l:\n add_patch(ax, time[t], -300, width=0.01, height=150)\n \n plt.subplots_adjust(hspace=0.5)\n #plt.ylabel('Muscle activation') \n# plt.suptitle('Decomposition of the trajectories of the hind feet')\n \n# plt.suptitle('Muscle activations of the '+ side + ' limb')\n plt.show()\n return","def index_shift_plot():\n file = \"Data/matfiles/20131221.mat\"\n object = MatReader(file)\n thing = object.shifted == False\n assert thing, \"shifter must be commented out\"\n \n start = 1920 #index of 16 minutes\n stop = 3120 #index of 26 minutes\n \n NeA = object.NeA[start:stop]\n NeB = object.NeB[start:stop]\n NeC = object.NeC[start:stop]\n NeA = object.meanie(NeA, 5)\n NeB = object.meanie(NeB, 5)\n NeC = object.meanie(NeC, 5)\n \n secondsA = object.secondsA[start:stop]\n secondsB = object.secondsB[start:stop]\n secondsC = object.secondsC[start:stop]\n \n plt.plot(secondsB, NeB, \"r\")\n plt.plot(secondsB, NeA, \"g\")\n plt.plot(secondsB, NeC, \"b\")\n plt.xlabel(\"Seconds since midnight UTC of satellite B\")\n plt.ylabel(\"Electron density [cm$^{-3}$]\")\n plt.legend([\"Satellite B\", \"Satellite A\", \"Satellite C\"])\n plt.title(\"Electron density data before index-shift\")\n plt.savefig(\"Figures/preshift_example.pdf\")\n plt.show()\n \n object.shifter()\n NeA = object.NeA[start:stop]\n NeB = object.NeB[start:stop]\n NeC = object.NeC[start:stop]\n NeA = object.meanie(NeA, 5)\n NeB = object.meanie(NeB, 5)\n NeC = object.meanie(NeC, 5)\n \n secondsA = object.secondsA[start:stop]\n secondsB = object.secondsB[start:stop]\n secondsC = object.secondsC[start:stop]\n \n plt.plot(secondsB, NeB, \"r\")\n plt.plot(secondsB, NeA, \"g\")\n plt.plot(secondsB, NeC, \"b\")\n plt.xlabel(\"Seconds since midnight UTC of satellite B\")\n plt.ylabel(\"Electron density [cm$^{-3}$]\")\n plt.legend([\"Satellite B\", \"Satellite A\", \"Satellite C\"])\n plt.title(\"Electron density data after index-shift\")\n plt.savefig(\"Figures/postshift_example.pdf\")\n plt.show()","def oneplot(moviedict, toplotdict, figw, figh, figdpi, fontsz, border, ylabel, ylim, time, ymin, \n lw):\n print(toplotdict.keys())\n \n fontv = mpl.font_manager.FontProperties()\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \n # similar (just slightly narrower).\n fontv = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\n fontv.set_size(fontsz)\n \n fonti = mpl.font_manager.FontProperties()\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \n #similar (just slightly narrower).\n fonti = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/ariali.ttf')\n fonti.set_size(fontsz)\n \n fig1 = plt.figure(figsize=(figw, figh), dpi=figdpi, facecolor='w', edgecolor='k')\n \n #Plots data on one graph with parameters specified in the moviedict directory.\n for k, v in moviedict.iteritems():\n print(k)\n cond1, offset, color, inum = v\n xvals = toplotdict[k][0]\n data = toplotdict[k][1] + offset\n condition = cond1\n \n\n plt.plot(xvals, data, color, linewidth=0.75, label=condition)\n print(condition)\n #if k == 'mov_20110113_180524':\n #plt.text(0.5, offset+7, inum+condition, horizontalalignment='left', \n #fontproperties=fontv)\n #else:\n #plt.text(0.5, offset+9, inum+condition, horizontalalignment='left', \n #fontproperties=fontv)\n \n # Plots text labels\n \n if k == 'mov_20101130_200030':\n plt.text(0.03, offset+6, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.11, offset+6.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n if k == 'mov_20101130_201605':\n plt.text(0.03, offset+5, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.125, offset+5.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n if k == 'mov_20101213_193258':\n plt.text(0.03, offset+3, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.137, offset+3.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n\n ax = plt.gca()\n\n ## Plots legend.\n #legend = plt.legend()\n ### Manipulates order of the legend entries.\n ##handles, labels = ax.get_legend_handles_labels()\n ##handles2 = handles[0], handles[2], handles[1], handles[3]\n ##labels2 = labels[0], labels[2], labels[1], labels[3]\n ##legend = ax.legend(handles2, labels2, bbox_to_anchor=(0, 0, 1, 1), \n ##transform=plt.gcf().transFigure)\n ### Changes legend font to fontsz.\n #ltext = legend.get_texts()\n #plt.setp(ltext, fontsize=fontsz)\n ### Removes border around the legend.\n #legend.draw_frame(False)\n \n \n #Uncomment lines below to display without top and right borders.\n if border == 'no':\n for loc, spine in ax.spines.iteritems():\n if loc in ['left','bottom']:\n pass\n elif loc in ['right','top']:\n spine.set_color('none') # don't draw spine\n else:\n raise ValueError('unknown spine location: %s'%loc)\n \n #Uncomment lines below to display ticks only where there are borders.\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n ## Removes tick labels and ticks from yaxis.\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\n \n # Specifies axis labels and axis tick label sizes.\n plt.xlabel(XLABEL, fontproperties=fontv, labelpad=4)\n plt.ylabel(ylabel, fontproperties=fontv, labelpad=4)\n plt.xticks(fontproperties=fontv)\n plt.yticks(fontproperties=fontv)\n \n # Specifies axis limits.\n plt.axis( [0, time, ymin, ylim])\n \n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower lefthand corner of the figure.\n fig1.subplots_adjust(top=0.95)\n fig1.subplots_adjust(left=0.15)\n #fig1.subplots_adjust(right=0.95)\n fig1.subplots_adjust(bottom=0.15)","def test4():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\t#Voigt\n\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def drawAxes(t):\r\n t.speed(0)\r\n t.pd()\r\n t.forward(500)\r\n t.back(500)","def plot_pretty():\n\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\n plt.style.use('seaborn-deep')\n\n black = '#2B2B2D'\n red = '#E90039'\n orange = '#FF1800'\n white = '#FFFFFF'\n yellow = '#FF9900'\n\n plt.figure(figsize=(12.8, 9.6))\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\n\n plt.gcf().set_facecolor(black)\n\n plt.subplot(2, 3, 1)\n plt.plot(ts, ys[:, 2], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\n plt.title(r'$C_{FA}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 2)\n plt.plot(ts, ys[:, 0], color=orange)\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\n plt.title(r'$C_{G}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 3)\n plt.plot(ts, ys[:, 3], color=orange)\n plt.title(r'$C_{E}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 4)\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\n plt.title(r'$F_{m, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 5)\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\n plt.title(r'$F_{G, in}$')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n plt.subplot(2, 3, 6)\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 1],\n color=red\n )\n plt.plot(\n numpy.arange(dt_control, end_time, dt_control),\n biass[:, 0],\n color=yellow\n )\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\n plt.title('bias')\n plt.xlim([0, ts[-1]])\n plt.gca().set_facecolor(black)\n\n # plt.suptitle('Closedloop bioreactor without noise')\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n plt.savefig('no_noise_pretty.png', transparent=True)\n plt.show()","def plot_timeres(timeres):\n tint = 24 / timeres\n step = 255 / (tint + 1)\n\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n mxcont = np.max(cont)\n\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\n # cont[i,j]*(circlesize/scale), \"#FF0000\")\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\n # minLon+((j+1.5)/normLon), 30, \"#FF0000\")\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n stime = time.localtime(np.int32(self.dataset[i][2]))\n evtime = stime[3]\n if (evtime / timeres) == t:\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)","def onTimer(self, evt): \r\n # restore the clean background, saved at the beginning \r\n self.canvas.restore_region(self.bg) \r\n # update the data \r\n self.r1 = self.r1[1:] + [t1.getRatio()] \r\n self.r2 = self.r2[1:] + [t2.getRatio()]\r\n self.v1 = self.v1[1:] + [t1.getSpeed()] \r\n self.v2 = self.v2[1:] + [t2.getSpeed()] \r\n \r\n # update the plot \r\n self.pr1.set_ydata(self.r1) \r\n self.pr2.set_ydata(self.r2)\r\n self.pv1.set_ydata(self.v1) \r\n self.pv2.set_ydata(self.v2) \r\n # just draw the \"animated\" objects \r\n self.ax.draw_artist(self.pr1) \r\n self.ax.draw_artist(self.pr2)\r\n self.ax.draw_artist(self.pv1) \r\n self.ax.draw_artist(self.pv2) \r\n self.canvas.blit(self.ax.bbox)","def OneDynSpectraPlot(Data, Vmin, Vmax, Suptitle, CBarLabel, no_of_spectra, TimeScale,\n frequency, FreqPointsNum, colormap, Xlabel, fig_file_name,\n currentDate, currentTime, Software_version, customDPI):\n\n fig, axarr = plt.subplots(1, 1, figsize=(16.0, 7.0))\n im0 = axarr.imshow(np.flipud(Data), aspect='auto', vmin=Vmin, vmax=Vmax,\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\n rc('font', size=8, weight='bold')\n axarr.set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=0.96)\n\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=8, fontweight='bold')\n cbar = fig.colorbar(im0, ax=axarr, pad=0.005)\n cbar.ax.tick_params(labelsize=8)\n cbar.set_label(CBarLabel, fontsize=9, fontweight='bold')\n text = axarr.get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeScale[k]\n\n ticks_loc = axarr.get_xticks().tolist() # <---- Added to suppress warning\n axarr.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr.set_xticklabels(text, fontsize=8, fontweight='bold')\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=8, fontweight='bold')\n axarr.set_xlabel(Xlabel, fontsize=10, fontweight='bold')\n fig.text(0.72, 0.04, 'Processed ' + currentDate + ' at ' + currentTime,\n fontsize=6, fontweight='bold', transform=plt.gcf().transFigure)\n fig.text(0.09, 0.04, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\n fontsize=6, fontweight='bold', transform=plt.gcf().transFigure)\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\n plt.close('all')\n return","def plot_events(ax, MD):\n\n coord_vars = ['CT_at_HB', 'CT_out_HB']\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\n all_vars = coord_vars + ingestion_vars\n\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\n \n names = ['M', 'M', 'F', 'F', 'W', 'W']\n idx = [2, 0, 0, 1, 0, 1]\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\n\n offsets = [-3, -5, -9, -11, -14, -16]\n height = 1.\n \n print \"plotting events..\"\n\n\n for c, name in enumerate(all_vars):\n\n # load\n if not hasattr(MD, name):\n MD.load(name)\n\n events = getattr(MD, name) / 3600. - 7 \n\n offset = offsets[c]\n color = colors[c]\n label = str(events.shape[0]) + ' ' + labels[c]\n\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\n label += ' events'\n\n if name in coord_vars:\n \n ax.scatter(\n events, offset * np.ones(events.shape[0]),\n c=color,\n marker='|',\n linewidths=1,\n edgecolors=None\n )\n \n\n elif name in ingestion_vars:\n\n for x in events: \n event_patch = patches.Rectangle(\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\n linewidth=0.001,\n fc=color, \n ec=color\n ) \n ax.add_patch(event_patch) \n\n # event descritpion\n ax.text(31, offset, label, color=color, \n fontsize=7, ha='left', va='bottom'\n )","def showPlot2():\n interested_in = list(range(1,10))\n proc_sim_data = []\n for item in interested_in:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n plot(interested_in, proc_sim_data)\n title('Dependence of cleaning time on number of robots')\n xlabel('number of robots (tiles)')\n ylabel('mean time (clocks)')\n show()","def figure2():\n # sim_data_XPP = pd.read_csv(\"XPP.dat\", delimiter=\" \", header=None) # Load the XPP simulation\n\n plot_settings = {'y_limits': [-25, 0],\n 'x_limits': None,\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\n 'locator_size': 2.5,\n 'y_label': 'Current (nA)',\n 'x_ticks': [],\n 'scale_size': 0,\n 'x_label': \"\",\n 'scale_loc': 4,\n 'figure_name': 'figure_2',\n 'legend': ['I-Na', 'I-NaP'],\n 'legend_size': 8,\n 'y_on': True}\n\n t, y = solver(100) # Integrate solution\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\n\n \"\"\"\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\n \"\"\"\n g_na_bar = 0.7\n g_nap_bar = 0.05\n g_k_bar = 1.3\n g_p_bar = 0.05\n g_leak = 0.005\n g_a_bar = 1.0\n e_na = 60\n e_k = -80\n e_leak = -50\n e_ca = 40\n g_t_bar = 0.1\n g_n_bar = 0.05\n g_sk_bar = 0.3\n\n \"\"\"\n Calculate currents used in the plot\n \"\"\"\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\n i_k = g_k_bar * (n ** 4) * (v - e_k)\n i_leak = g_leak * (v - e_leak)\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\n i_p = g_p_bar * m_p * (v - e_ca)\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\n i_a = g_a_bar * m_a * h_a * (v - e_k)\n\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\n\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\n plt.plot(t[t_short], i_na[t_short], 'k-')\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\n plt.plot(t, i_t + i_n + i_p, 'k-')\n plt.plot(t, i_t, c='k', linestyle='dotted')\n plt.plot(t, i_p, 'k--')\n plt.plot(t, i_n, 'k-.')\n\n plot_settings['y_limits'] = [-2.5, 0]\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\n plot_settings['locator_size'] = 0.25\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\n plt.plot(t[t_short], i_k[t_short], 'k-')\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\n\n plot_settings['y_limits'] = [0, 25]\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\n plot_settings['locator_size'] = 2.5\n plot_settings['y_label'] = \"Current (nA)\"\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\n plot_settings['scale_size'] = 2\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings) # Alter figure for publication\n\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\n\n plt.plot(t, i_sk, 'k-')\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\n\n plot_settings['y_limits'] = [0, 1]\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\n plot_settings['locator_size'] = 0.2\n plot_settings['y_label'] = \"\"\n plot_settings['legend'] = ['I-SK']\n plot_settings['scale_size'] = 20\n plot_settings['scale_loc'] = 2\n alter_figure(plot_settings, close=True) # Alter figure for publication","def TwoDynSpectraPlot(Data_Ch_A, Data_Ch_B, VminA, VmaxA, VminB, VmaxB, Suptitle,\n CBarLabelA, CBarLabelB, no_of_spectra,\n TimeFigureScale, TimeScale, frequency,\n FreqPointsNum, colormap, TitleA, TitleB, fig_file_name,\n currentDate, currentTime, Software_version, customDPI):\n fig, axarr = plt.subplots(2, 1, figsize=(16.0, 9.0))\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.08)\n im0 = axarr[0].imshow(np.flipud(Data_Ch_A), aspect='auto', vmin=VminA, vmax=VmaxA,\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\n rc('font', size=8, weight='bold')\n\n ticks_loc = axarr[0].get_yticks().tolist() # <---- Added to suppress warning\n axarr[0].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[0].set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\n axarr[0].set_yticklabels(axarr[0].get_yticks(), fontsize=8, fontweight='bold')\n cbar = fig.colorbar(im0, ax=axarr[0], pad=0.005)\n cbar.ax.tick_params(labelsize=8)\n cbar.set_label(CBarLabelA, fontsize=9, fontweight='bold')\n text = axarr[0].get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = ' '\n\n ticks_loc = axarr[0].get_xticks().tolist() # <---- Added to suppress warning\n axarr[0].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[0].set_xticklabels(text)\n axis_copy = axarr[0].twiny()\n axis_copy.set_xlim(0, no_of_spectra)\n text = axis_copy.get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeFigureScale[k]\n\n ticks_loc = axis_copy.get_xticks().tolist() # <---- Added to suppress warning\n axis_copy.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axis_copy.set_xticklabels(text, fontsize=8, fontweight='bold')\n axarr[0].set_title(TitleA, fontsize=10, fontweight='bold', style='italic', y=1.05)\n im1 = axarr[1].imshow(np.flipud(Data_Ch_B), aspect='auto', vmin=VminB, vmax=VmaxB,\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\n # frequency[FreqPointsNum-1]\n\n ticks_loc = axarr[1].get_xticks().tolist() # <---- Added to suppress warning\n axarr[1].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n ticks_loc = axarr[1].get_yticks().tolist() # <---- Added to suppress warning\n axarr[1].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n\n axarr[1].set_xlabel('UTC Time, HH:MM:SS.msec', fontsize=10, fontweight='bold')\n axarr[1].set_ylabel('Frequency, MHz', fontsize=10, fontweight='bold')\n cbar = fig.colorbar(im1, ax=axarr[1], pad=0.005)\n cbar.set_label(CBarLabelB, fontsize=9, fontweight='bold')\n cbar.ax.tick_params(labelsize=8)\n text = axarr[1].get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeScale[k]\n axarr[1].set_xticklabels(text, fontsize=8, fontweight='bold')\n axarr[1].set_yticklabels(axarr[1].get_yticks(), fontsize=8, fontweight='bold')\n axarr[1].set_title(TitleB, fontsize=10, fontweight='bold', style='italic', y=1.00)\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=1.01)\n fig.subplots_adjust(top=0.91)\n fig.text(0.72, 0.065, 'Processed ' + currentDate + ' at ' + currentTime,\n fontsize=6, transform=plt.gcf().transFigure)\n fig.text(0.1, 0.065, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\n fontsize=6, transform=plt.gcf().transFigure)\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\n plt.close('all')\n return 0","def showPlot4():\n overall_data = []\n per_to_clean = [round(x * 0.1,1) for x in range(0,10)]\n number_of_robots = list(range(1,6))\n for per in per_to_clean:\n proc_sim_data = []\n for item in number_of_robots:\n len_sim_data = []\n raw_sim_data = runSimulation(item, 1.0, 25, 25, per, 10, Robot, False)\n for mes in raw_sim_data:\n len_sim_data.append(len(mes))\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\n overall_data.append(proc_sim_data)\n plot(per_to_clean, overall_data)\n title('cleaning time vs. percentage cleaned')\n xlabel('percentage clean')\n ylabel('mean time (clocks)')\n show()","def setplot(plotdata):\n#-------------------------- \n\n\n from pyclaw.plotters import colormaps, geoplot\n\n plotdata.clearfigures() # clear any old figures,axes,items data\n\n def set_drytol(current_data):\n # The drytol parameter is used in masking land and water and\n # affects what color map is used for cells with small water depth h.\n # The cell will be plotted as dry if h < drytol.\n # The best value to use often depends on the application and can\n # be set here (measured in meters):\n current_data.user.drytol = 1.e-4\n\n\n plotdata.beforeframe = set_drytol\n\n # To plot gauge locations on pcolor or contour plot, use this as\n # an afteraxis function:\n\n def addgauges(current_data):\n from pyclaw.plotters import gaugetools\n gaugetools.plot_gauge_locations(current_data.plotdata, \\\n gaugenos='all', format_string='ko', add_labels=True)\n \n\n #-----------------------------------------\n # Figure for imshow plot\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='imshow', figno=0)\n plotfigure.show = False\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('imshow')\n plotaxes.title = 'Surface'\n plotaxes.scaled = True\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.02\n plotitem.imshow_cmax = 0.02\n plotitem.add_colorbar = True\n plotitem.amr_gridlines_show = [0,0,0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0,0,0]\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = 'auto'\n\n \n\n #-----------------------------------------\n # Figure for imshow plot\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Surface and Gauge 1', figno=20)\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('imshow')\n plotaxes.axescmd = \"axes([.1,.5,.8,.4])\"\n plotaxes.title = 'Surface'\n plotaxes.scaled = True\n plotaxes.afteraxes = addgauges\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.03\n plotitem.imshow_cmax = 0.03\n plotitem.add_colorbar = True\n plotitem.amr_gridlines_show = [0,0,0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0,0,0]\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = 'auto'\n\n\n # Gauge trace:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.show = False\n plotaxes.axescmd = \"axes([.1,.1,.8,.3])\"\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = [-0.02, 0.05]\n plotaxes.title = 'Gauge 1'\n\n # Plot surface as blue curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_gauge_trace')\n plotitem.plot_var = 3\n plotitem.plotstyle = 'b-'\n plotitem.gaugeno = 1\n\n\n #-----------------------------------------\n # Figure for zoom\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Zoom', figno=10)\n #plotfigure.show = False\n plotfigure.kwargs = {'figsize':[7,7]}\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes('monai')\n #plotaxes.axescmd = 'axes([0.0,0.1,0.6,0.6])'\n plotaxes.title = 'Monai Valley'\n plotaxes.scaled = True\n #plotaxes.xlimits = [4.0, 5.2]\n #plotaxes.ylimits = [1.3, 2.5]\n plotaxes.xlimits = [4.7, 5.2]\n plotaxes.ylimits = [1.5, 2.2]\n\n # Water\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n #plotitem.plot_var = geoplot.surface\n plotitem.plot_var = geoplot.surface_or_depth\n plotitem.imshow_cmap = geoplot.tsunami_colormap\n plotitem.imshow_cmin = -0.02\n plotitem.imshow_cmax = 0.02\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0]\n plotitem.amr_gridedges_show = [1]\n\n # Land\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\n plotitem.plot_var = geoplot.land\n plotitem.imshow_cmap = geoplot.land_colors\n plotitem.imshow_cmin = 0.0\n plotitem.imshow_cmax = 0.05\n plotitem.add_colorbar = False\n plotitem.amr_gridlines_show = [0]\n\n # Add contour lines of bathymetry:\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = geoplot.topo\n from numpy import arange, linspace\n plotitem.contour_levels = arange(-0.02, 0., .0025)\n plotitem.amr_contour_colors = ['k'] # color on each level\n plotitem.kwargs = {'linestyles':'solid'}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n \n # Add contour lines of topography:\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = geoplot.topo\n from numpy import arange, linspace\n plotitem.contour_levels = arange(0., .2, .01)\n plotitem.amr_contour_colors = ['w'] # color on each level\n plotitem.kwargs = {'linestyles':'solid'}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n\n # Add dashed contour line for current shoreline\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\n plotitem.plot_var = 0\n plotitem.contour_levels = [0.002]\n plotitem.amr_contour_colors = ['k'] # color on each level\n plotitem.kwargs = {'linestyles':'dashed','linewidths':2}\n plotitem.amr_contour_show = [1] # show contours only on finest level\n plotitem.gridlines_show = 0\n plotitem.gridedges_show = 0\n plotitem.show = True\n\n\n\n\n #-----------------------------------------\n # Figures for gauges\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='Surface & topo', figno=300, \\\n type='each_gauge')\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.xlimits = [0,25]\n plotaxes.ylimits = [-0.02, 0.05]\n plotaxes.title = 'Surface'\n\n # Plot surface as blue curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n plotitem.plot_var = 3\n plotitem.plotstyle = 'b-'\n\n # Plot topo as green curve:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n\n def gaugetopo(current_data):\n q = current_data.q\n h = q[:,0]\n eta = q[:,3]\n topo = eta - h\n return topo\n \n plotitem.plot_var = gaugetopo\n plotitem.clf_each_gauge = False\n plotitem.plotstyle = 'g-'\n def afteraxes(current_data):\n from pylab import plot, legend, loadtxt\n t = current_data.t\n plot(t, 0*t, 'k')\n gaugeno = current_data.gaugeno\n \n if gaugeno in [5,7,9]:\n col = (gaugeno-3)/2\n plot(labgage[:,0],0.01*labgage[:,col],'r')\n legend(('GeoClaw','topography','sea level','lab data'),loc='upper left')\n else:\n legend(('GeoClaw','topography','sea level'),loc='upper right')\n \n \n\n plotaxes.afteraxes = afteraxes\n\n\n #-----------------------------------------\n # Figure for grids alone\n #-----------------------------------------\n plotfigure = plotdata.new_plotfigure(name='grids', figno=2)\n plotfigure.show = False\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.xlimits = [0,1]\n plotaxes.ylimits = [0,1]\n plotaxes.title = 'grids'\n plotaxes.scaled = True\n\n # Set up for item on these axes:\n plotitem = plotaxes.new_plotitem(plot_type='2d_grid')\n plotitem.amr_grid_bgcolor = ['#ffeeee', '#eeeeff', '#eeffee']\n plotitem.amr_gridlines_show = [1,1,0] \n plotitem.amr_gridedges_show = [1] \n\n #-----------------------------------------\n \n # Parameters used only when creating html and/or latex hardcopy\n # e.g., via pyclaw.plotters.frametools.printframes:\n\n plotdata.printfigs = True # print figures\n plotdata.print_format = 'png' # file format\n #plotdata.print_framenos = [4,6,8,10,12]\n plotdata.print_framenos = [5,7,9,11,13]\n plotdata.print_gaugenos = [0,5,7,9] # list of gauges to print\n plotdata.print_fignos = 'all' # list of figures to print\n plotdata.html = True # create html files of plots?\n plotdata.html_homelink = '../README.html' # pointer for top of index\n plotdata.latex = True # create latex file of plots?\n plotdata.latex_figsperline = 2 # layout of plots\n plotdata.latex_framesperline = 1 # layout of plots\n plotdata.latex_makepdf = False # also run pdflatex?\n\n return plotdata","def plotspec(ant,freq=True,test=False):\n snap.write_int('rst',1)\n snap.write_int('antenna',ant);\n snap.write_int('rst',0)\n\n ## Test\n if (test):\n if ant in [2,3,6,7,10,11]:\n test = (np.linspace(256,511,num=256,dtype='uint64')**2)*(ACC_LEN/256)\n else:\n test = (np.linspace(0,255,num=256,dtype='uint64')**2)*(ACC_LEN/256)\n plt.plot(test,'.',label='test')\n \n ## Wait for vector to get accumulated\n time.sleep(ACC_LEN/(512*200e6)*1e3)\n arr = struct.unpack('>256Q',snap.read('spectrum',8*256))\n if (freq):\n plt.plot(FREQ,arr,'.-',lw=1,label='%s'%ANT_LABELS[ant])\n plt.xlim(FREQ.max(), FREQ.min())\n else:\n plt.plot(arr,lw=2,label='%s'%ANT_LABELS[ant])","def plot_figure5():\n column_titles = [\"50 - 150m\", \"0 - 10km\", \"Ratio\"]\n\n plot_item0 = {\n 'data': p_integral_mean[0, :, :]*1e-6,\n 'contour_line_levels': np.linspace(0, .31, 21)[::4],\n 'contour_fill_levels': np.linspace(0, .31, 21),\n 'colorbar_ticks': np.linspace(0, .31, 21)[::4],\n 'colorbar_tick_fmt': '{:.2f}',\n 'colorbar_label': '[$MWm/m^2$]',\n }\n plot_item1 = {\n 'data': p_integral_mean[1, :, :]*1e-6,\n 'contour_line_levels': np.linspace(0, 65, 21)[::4],\n 'contour_fill_levels': np.linspace(0, 65, 21),\n 'colorbar_ticks': np.linspace(0, 65, 21)[::4],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': '[$MWm/m^2$]',\n }\n plot_item2 = {\n 'data': plot_item1['data']/plot_item0['data'],\n 'log_scale': True,\n 'contour_line_levels': [300., 600.],\n 'contour_fill_levels': np.logspace(np.log10(100.0), np.log10(6700.0), num=16),\n 'colorbar_ticks': [100., 300., 1000., 3000.],\n 'colorbar_tick_fmt': '{:.0f}',\n 'colorbar_label': 'Increase factor [-]',\n }\n\n plot_items = [plot_item0, plot_item1, plot_item2]\n\n eval_contour_fill_levels(plot_items)\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)","def plotOfSlice(self,index=0):\n\t\tj=index;\n\t\t[n,m]=_np.shape(self._data)\n\t\ty=_np.zeros(n);\n\t\tfor i in range(0,n):\n\t\t\ty[i]=self._data[i][j]*1e4\n\t\tp1=_plot.plot(title='t=%.3f ms. %s ' % (self.time[j]*1000, self.title),\n\t\t\t\t\t shotno=self.shotno)\n\t\ttheta=_np.linspace(self._theta[0],self._theta[-1],100)\n#\t\tm0Fit=self._x[0,j]\n\t\tm1Fit=self._x[0,j]+self._x[1,j]*_np.sin(theta)+self._x[2,j]*_np.cos(theta)\n\t\tm2Fit=self._x[0,j]+self._x[3,j]*_np.sin(2*theta)+self._x[4,j]*_np.cos(2*theta)\n\t\tm3Fit=self._x[0,j]+self._x[5,j]*_np.sin(3*theta)+self._x[6,j]*_np.cos(3*theta)\n\t\tm4Fit=self._x[0,j]+self._x[7,j]*_np.sin(4*theta)+self._x[8,j]*_np.cos(4*theta)\n\t\tm5Fit=self._x[0,j]+self._x[9,j]*_np.sin(5*theta)+self._x[10,j]*_np.cos(5*theta)\n\t\tfitTotal=(-4.)*self._x[0,j]+m1Fit+m2Fit+m3Fit+m4Fit+m5Fit # the -4 corrects for the 4 extra offsets added from the preview 5 fits\n\t\t\n\t\tp1.addTrace(yData=y,xData=self._theta,\n\t\t\t\t\tlinestyle='',marker='.',yLegendLabel='raw')\n\t\tp1.addTrace(yData=m1Fit,xData=theta,\n\t\t\t\t\tyLegendLabel='m=1')\n\t\tp1.addTrace(yData=m2Fit,xData=theta,\n\t\t\t\t\tyLegendLabel='m=2')\n\t\tp1.addTrace(yData=m3Fit,xData=theta,\n\t\t\t\t\tyLegendLabel='m=3')\n\t\tp1.addTrace(yData=m4Fit,xData=theta,\n\t\t\t\t\tyLegendLabel='m=4')\n\t\tp1.addTrace(yData=m5Fit,xData=theta,\n\t\t\t\t\tyLegendLabel='m=5')\n\t\tp1.addTrace(yData=fitTotal,xData=theta,\n\t\t\t\t\tyLegendLabel='m=1-5')\n\t\treturn p1","def plot_time_slice(index, t, U, fname, levels):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n title = 'Time slice {r} {t:0>4d}'.format(r=index, t=t)\n ax.set_title(title)\n U = U[:, :, t]\n contourf = ax.contourf(U, levels)\n fig.colorbar(contourf)\n util.makedirs_p(os.path.dirname(fname))\n fig.savefig(fname)","def cplot(self, figure, i, n):\n xx, yy = np.meshgrid(range(self.L), range(self.L))\n ax = figure.add_subplot(2,2,n)\n plt.setp(ax.get_yticklabels(), visible=False)\n plt.setp(ax.get_xticklabels(), visible=False) \n plt.pcolormesh(xx, yy, self.config, cmap=plt.cm.RdBu);\n plt.title('Time=%d'%i, fontsize=20)\n plt.xlabel('X', fontsize=12)\n plt.ylabel('Y',fontsize=12) \n plt.axis('tight') \n self.ax = ax","def plot(self, noTLS, path_plots, interactive):\n fig = plt.figure(figsize=(10,12))\n ax1 = fig.add_subplot(4, 1, 1)\n ax2 = fig.add_subplot(4, 1, 2)\n ax3 = fig.add_subplot(4, 2, 5)\n ax4 = fig.add_subplot(4, 2, 6)\n ax5 = fig.add_subplot(4, 2, 7)\n ax6 = fig.add_subplot(4, 2, 8)\n\n # First panel: data from each sector\n colors = self._get_colors(self.nlc)\n for i, lci in enumerate(self.alllc):\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\n ax1.legend(fontsize='small', ncol=4)\n\n # Second panel: Detrended light curve\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\n color='black',\n label='Detrended')\n\n # Third panel: BLS\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\n mean_SR = np.mean(self.BLS.power)\n std_SR = np.std(self.BLS.power)\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\n SDE = (best_power - mean_SR)/std_SR\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\n for n in range(2, 10):\n if n*self.BLS.period_max <= max(self.BLS.period.value):\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n sx, ex = ax3.get_xlim()\n sy, ey = ax3.get_ylim()\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.2f\\nDepth = %.4f\\nDuration = %.2f d\\nSDE = %.3f' %\n (self.BLS.period_max, self.BLS.t0_max,\n self.BLS.depth_max, self.BLS.duration_max, SDE))\n\n\n # Fourth panel: lightcurve folded to the best period from the BLS\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\n marker='.', alpha=0.5)\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\n\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\n duration=self.BLS.duration_max,\n transit_time=self.BLS.t0_max)\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\n ax4.set_xlim(-l, l)\n h = max(lc_model.flux)\n l = min(lc_model.flux)\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\n del lc_model, lc_model_folded, r1, dt1\n\n\n if not noTLS:\n # Fifth panel: TLS periodogram\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\n for n in range(2, 10):\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\"dashed\")\n ax5.set_ylabel(r'SDE')\n ax5.set_xlabel('Period (days)')\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\n ax5.set_xlim(0, max(self.tls.periods))\n\n period_tls = self.tls.period\n T0_tls = self.tls.T0\n depth_tls = self.tls.depth\n duration_tls = self.tls.duration\n FAP_tls = self.tls.FAP\n\n sx, ex = ax5.get_xlim()\n sy, ey = ax5.get_ylim()\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\n 'P$_{MAX}$ = %.3f d\\nT0 = %.1f\\nDepth = %.4f\\nDuration = %.2f d\\nFAP = %.4f' %\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\n\n # Sixth panel: folded light curve to the best period from the TLS\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\n alpha=0.5, ls='None', markersize=0.7)\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\n nbins = int(50*0.5/l)\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\n x0=0.0, nbins=nbins, useBinCenter=True)\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\n ax6.set_xlim(0.5-l, 0.5+l)\n h = max(self.tls.model_folded_model)\n l = min(self.tls.model_folded_model)\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\n ax6.set_xlabel('Phase')\n ax6.set_ylabel('Relative flux')\n del r1, dt1\n\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\n if interactive:\n plt.show()\n plt.close('all')\n del fig","def plot(model, results, filename):\n\n # c = model.compartments.get_one(id='c')\n #\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\n #\n pops = results.get('populations')\n time = pops.index\n pop_rna_1 = pops['rna_1[c]']\n pop_rna_2 = pops['rna_2[c]']\n pop_rna_3 = pops['rna_3[c]']\n\n pop_atp = pops['atp[c]']\n pop_gtp = pops['gtp[c]']\n pop_utp = pops['ctp[c]']\n pop_ctp = pops['utp[c]']\n\n pop_amp = pops['amp[c]']\n pop_gmp = pops['gmp[c]']\n pop_ump = pops['cmp[c]']\n pop_cmp = pops['ump[c]']\n\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\n\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\n\n axes1[0].plot(time / 3600, pop_rna_1)\n axes1[0].plot(time / 3600, pop_rna_2)\n axes1[0].plot(time / 3600, pop_rna_3)\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\n axes1[0].set_ylim((0., 10.0))\n axes1[0].legend(loc='upper right')\n\n axes1[1].plot(time / 3600, pop_atp)\n axes1[1].plot(time / 3600, pop_gtp)\n axes1[1].plot(time / 3600, pop_utp)\n axes1[1].plot(time / 3600, pop_ctp)\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[1].set_ylim((0., 10.0))\n axes1[1].legend(loc='upper right')\n\n axes1[2].plot(time / 3600, pop_amp)\n axes1[2].plot(time / 3600, pop_gmp)\n axes1[2].plot(time / 3600, pop_ump)\n axes1[2].plot(time / 3600, pop_cmp)\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\n # axes1[2].set_ylim((0., 10.0))\n axes1[2].legend(loc='upper right')\n\n fig1.savefig(filename.format('species'))\n pyplot.close(fig1)","def plotTrajectory(xydata, colordata = 'time', cmap = cm.jet, size = 20, ax = None, line = True):\n \n if isinstance(colordata, basestring) and colordata in ['time']:\n c = np.linspace(0, len(xydata[:,0]), len(xydata[:,0]));\n else:\n c = colordata;\n \n if ax is None:\n ax = plt.gca();\n s = ax.scatter(xydata[:,0], xydata[:,1], c = c, cmap = cmap, s = size, marker = 'o', lw = 0);\n if isinstance(line, basestring):\n ax.plot(xydata[:,0], xydata[:,1], color = line); \n \n ax.get_figure().colorbar(s, ax = ax);\n return ax","def plotCombinedIncludingOceanFloors(self):\n self.CombinedPlotHelper(minc=70,maxc=170,num=50)","def plot_traj(ax,traj,style,color,label,mode, timestep = None):\n x = []\n y = []\n i = 0.0\n # traj = traj +zs [traj[0]]\n for co in traj:\n rotX, rotY, rotZ = quaternion_to_euler(co[4], co[5], co[6], co[7])\n if mode == 'xy':\n x.append(co[0+1])\n y.append(co[1+1])\n if mode == 'xz':\n x.append(co[0+1])\n y.append(co[2+1])\n if mode == 'yz':\n x.append(co[1+1])\n y.append(co[2+1])\n\n if mode == 'rotx':\n x.append(i)\n y.append(rotX)\n if mode == 'roty':\n x.append(i)\n y.append(rotY)\n if mode == 'rotz':\n x.append(i)\n y.append(rotZ)\n\n if mode == 'ax':\n x.append(i)\n y.append(co[1])\n if mode == 'ay':\n x.append(i)\n y.append(co[2])\n if mode == 'az':\n x.append(i)\n y.append(co[3])\n i += timestep\n\n ax.plot(x,y,style,color=color,label=label)","def OneDynSpectraPlotPhD(Data, Vmin, Vmax, Suptitle, CBarLabel, no_of_spectra, TimeScale,\n frequency, FreqPointsNum, colormap, Xlabel, fig_file_name,\n currentDate, currentTime, Software_version, customDPI):\n\n fig, axarr = plt.subplots(1, 1, figsize=(16.0, 7.0))\n im0 = axarr.imshow(np.flipud(Data), aspect='auto', vmin=Vmin, vmax=Vmax,\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\n rc('font', size=14, weight='bold')\n # plt.rcParams[\"font.family\"] = \"Times New Roman\" # !!! NEW !!!\n axarr.set_ylabel('Частота, МГц', fontweight='bold', fontsize=14)\n #fig.suptitle(Suptitle, fontsize = 10, fontweight = 'bold', x = 0.46, y = 0.96)\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=14, fontweight='bold')\n cbar = fig.colorbar(im0, ax=axarr, pad=0.005)\n cbar.ax.tick_params(labelsize=14)\n cbar.set_label(CBarLabel, fontsize=14, fontweight='bold')\n text = axarr.get_xticks().tolist()\n for i in range(len(text)-1):\n k = int(text[i])\n text[i] = TimeScale[k]\n # text[i] = TimeScale[k][0:20]\n\n ticks_loc = axarr.get_xticks().tolist() # <---- Added to suppress warning\n axarr.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\n axarr.set_xticklabels(text, fontsize=12, fontweight='bold')\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=12, fontweight='bold')\n axarr.set_xlabel(Xlabel, fontsize=14, fontweight='bold')\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\n plt.close('all')\n return","def plot(self):\n\t\tself.plotOfSpect()","def pf_plot(pf, t):\n xx = pf.XS[t, :, 0]\n yy = pf.XS[t, :, 1]\n ww = pf.WS[t, :]\n plt.scatter(xx, yy, s=ww * 5000)","def update_plot(axes):\n axes.clear()\n\n i = C.i\n C.i += di # globale Zählvariable erhöhen\n if C.i >= len(tt):\n time.sleep(2)\n C.i = 0\n\n t = tt[i]\n q1 = qq1[i]\n q2 = qq2[i]\n q3 = qq3[i]\n CCframe(q1, q2, q3)\n\n # Ausgabe der aktuellen Zeit\n pl.text(0.06, 0.05, \"t = %3.2fs\" % t, transform = axes.transAxes)\n pl.axis([-3, 3, -3, 3])\n axes.figure.canvas.draw()","def plot_array(self):\n locations = np.array([getattr(pulsar, 'location') for pulsar in self.pulsars])\n fig = plt.figure()\n ax = plt.subplot(111, projection=\"hammer\")\n for location in locations:\n plt.plot(location.ra, location.dec, '.', color='b')\n return fig","def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\n plot_density=True, plot_showers=False):\n\n\n\n ### Plot Sun-centered geocentric ecliptic plots ###\n\n lambda_list = []\n beta_list = []\n vg_list = []\n sol_list = []\n\n shower_no_list = []\n shower_obj_dict = {}\n\n hypo_count = 0\n jd_min = np.inf\n jd_max = 0\n for traj in traj_list:\n\n # Reject all hyperbolic orbits\n if traj.orbit.e > 1:\n hypo_count += 1\n continue\n\n # Compute Sun-centered longitude\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\n\n beta_list.append(traj.orbit.B_g)\n vg_list.append(traj.orbit.v_g/1000)\n sol_list.append(np.degrees(traj.orbit.la_sun))\n\n # Track first and last observation\n jd_min = min(jd_min, traj.jdt_ref)\n jd_max = max(jd_max, traj.jdt_ref)\n\n\n\n if plot_showers:\n\n # Perform shower association and track the list of all showers\n shower_obj = associateShowerTraj(traj)\n\n # If the trajectory was associated, sort it to the appropriate shower\n if shower_obj is not None:\n if shower_obj.IAU_no not in shower_no_list:\n shower_no_list.append(shower_obj.IAU_no)\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\n else:\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\n\n\n\n # Compute mean shower radiant for all associated showers\n shower_obj_list = []\n if plot_showers and shower_obj_dict:\n for shower_no in shower_obj_dict:\n\n # Check if there are enough shower members for plotting\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\n continue\n\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\n\n # Init a new shower object\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\n\n shower_obj_list.append(shower_obj_mean)\n\n\n\n print(\"Hyperbolic percentage: {:.2f}%\".format(100*hypo_count/len(traj_list)))\n\n # Compute the range of solar longitudes\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\n\n\n\n # Plot SCE vs Vg\n if plot_vg:\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"$V_g$ (km/s)\", dir_path, plot_name + \"_vg.png\", \\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n\n\n # Plot SCE vs Sol\n if plot_sol:\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\n \"Sun-centered geocentric ecliptic coordinates\", \"Solar longitude (deg)\", dir_path, \\\n plot_name + \"_sol.png\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\n \n\n \n # Plot SCE orbit density\n if plot_density:\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \n \"Sun-centered geocentric ecliptic coordinates\", \"Count\", dir_path, plot_name + \"_density.png\", \\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)","def plotOfOneChannel(self, i=0):\n p1=_plot.plot(xLabel='time [ms]',yLabel=r'a.u.',title=self.title,\n\t\t\t\t\t shotno=[self.shotno],subtitle='%d' %i);\n\t\t\n\t\t# smoothed data\n p1.addTrace(yData=self.data[i],xData=self.time*1000,\n\t\t\t\t\tyLegendLabel=str(i)) \n\t\t\t\n return p1","def plot_fig43b_spreading_yeast():\n fig, ax = plt.subplots(figsize=(default_width, default_height))\n y = np.loadtxt('csvs/ratio_lp50a10ad5hp0.0067379_yeast.txt')\n links35 = np.tile(35, 44)\n Rlinks = np.array([47, 21, 18, 15, 20, 17])\n Llinks = np.array([245, 30, 26, 15, 23, 35])\n #links to right of methylation site (50 in total)\n Rlinks = np.concatenate((Rlinks, links35))\n #links to left of methylation site (50 in total)\n Llinks = np.concatenate((Llinks, links35))\n #cumulative chain length including burried basepairs\n unwrap = 0\n #plot as positive distance from TSS in bp\n ldna_Rlinks = convert.genomic_length_from_links_unwraps(Rlinks, unwraps=unwrap) #max WLC chain length in bp\n #plot as negative distance from TSS in bp\n ldna_Llinks = -1*convert.genomic_length_from_links_unwraps(Llinks, unwraps=unwrap) #max WLC chain length in bp\n x = np.concatenate((ldna_Llinks[::-1], ldna_Rlinks))\n ax.plot(x, y, color='k')\n ax.set_xlabel(r'Distance from TSS (bp)')\n ax.set_ylabel('Relative enrichment')\n #plot inset using Crabtree data\n axins = inset_axes(ax, width=\"40%\", height=\"40%\", \n bbox_to_anchor=(.1, .1, .8, .8),\n bbox_transform=ax.transAxes, loc=2)\n xcrabtree = np.array([-10256, -3077, -2241, -1485, -739, -309, -169, 489, 1746, 3087, 4400, 5300])\n REday0 = np.array([0.27, 0.13, 0.46, 0.12, 0.17, 0.33, 0.33, 0.31, 0.32, 0.27, 0.21, 0.33])\n REday5 = np.array([0.19, 0.40, 0.89, 1.55, 0.97, 1.25, 2.25, 3.57, 3.03, 2.09, 1.12, 0.14])\n ycrabtree = REday5/np.mean(REday0)\n axins.plot(xcrabtree, ycrabtree)\n axins.set_xlim([-10000, 10000])\n ax.set_xlim([-10000, 10000])\n #axins.set_ylabel('Relative enrichment', fontsize=8)\n #axins.set_xlabel('Distance from TSS (bp)', fontsize=8)\n plt.subplots_adjust(left=0.16, bottom=0.19, top=0.98, right=0.96)\n plt.savefig(f'plots/thesis/fig43b_spreading-TSS-yeast.pdf', bbox_inches='tight')","def plot_limit(bolo_name, list_mass, analysis_type, exposure, detector_mass = 0.6):\n\n d_graph = {}\n list_color = [kOrange-8, kGreen+2, kBlue-7, kRed, kBlack, kMagenta, kAzure+10, kGreen-3, kOrange-9]\n\n for index, heat_fraction in enumerate([\"0.3\",\"0.4\",\"0.5\",\"0.8\",\"1\"]):\n d_graph[heat_fraction] = get_simulated_event_limit(bolo_name, list_mass, analysis_type, \"_\" + heat_fraction, exposure, detector_mass = 0.6)\n d_graph[heat_fraction].SetName(heat_fraction)\n PyRPl.process_TGraph(d_graph[heat_fraction], color = list_color[index])\n\n gr_edw_poisson = get_limit_graph(\"./Text_files/edw3_ana_1.5_0_5_poisson.txt\", 2, kBlack)\n gr_edw_low = get_limit_graph(\"./Text_files/Published_limits/edw_lowmass_2012.txt\", 2, kRed)\n gr_edw_low.SetLineStyle(7)\n gr_cdms = get_limit_graph(\"./Text_files/Published_limits/cdms_limit.txt\", 2, kBlue)\n\n h = TH1F(\"h\", \"\", 100, 3,25)\n PyRPl.process_TH1(h, X_title = \"Mass (GeV)\", Y_title = \"#sigma (pb)\", X_title_size = .06, Y_title_size = .06, X_title_offset = .98, Y_title_offset = .95)\n\n\n gr_edw_low.SetName(\"gr_edw_low\")\n gr_edw_poisson.SetName(\"gr_edw_poisson\")\n gr_cdms.SetName(\"gr_cdms\")\n\n cc = TCanvas(\"cc\", \"cc\")\n gPad.SetLogy()\n gPad.SetLogx()\n h.SetMaximum(1E-1)\n h.SetMinimum(4E-8)\n h.Draw()\n\n gr_cdms.Draw(\"sameC\")\n gr_edw_poisson.Draw(\"sameC\")\n gr_edw_low.Draw(\"sameC\")\n\n for index, heat_fraction in enumerate([\"0.3\",\"0.4\",\"0.5\",\"0.8\",\"1\"]):\n d_graph[heat_fraction].Draw(\"sameC\")\n\n leg =TLegend(0.564,0.584,0.83,0.857)\n leg.AddEntry(\"gr_cdms\", \"SCDMS\" , \"l\")\n leg.AddEntry(\"gr_edw_low\", \"EDW II\" , \"l\")\n leg.AddEntry(\"gr_edw_poisson\", \"EDW III Poisson\" , \"l\")\n for index, heat_fraction in enumerate([\"0.3\",\"0.4\",\"0.5\",\"0.8\",\"1\"]):\n leg.AddEntry( d_graph[heat_fraction].GetName(), heat_fraction , \"l\")\n\n leg.SetFillColor(kWhite)\n leg.SetLineColor(kWhite)\n leg.Draw()\n raw_input()","def setplot(plotdata):\n#-------------------------- \n\n\n plotdata.clearfigures() # clear any old figures,axes,items data\n\n # Figure for q[0]\n plotfigure = plotdata.new_plotfigure(name='Pressure', figno=1)\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.axescmd = 'subplot(211)'\n \n #plotaxes.xlimits = [0.,150.]\n plotaxes.ylimits = [-1.,1.0]\n plotaxes.title = 'Pressure'\n\n # Set up for item on these axes:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n plotitem.plot_var = 0\n plotitem.plotstyle = '-o'\n plotitem.color = 'b'\n plotitem.show = True # show on plot?\n plotitem.kwargs = {'linewidth':2,'markersize':5}\n \n\n\n # Set up for axes in this figure:\n plotaxes = plotfigure.new_plotaxes()\n plotaxes.axescmd = 'subplot(212)'\n plotaxes.xlimits = 'auto'\n plotaxes.ylimits = [-1.,1.]\n plotaxes.title = 'Velocity'\n\n # Set up for item on these axes:\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\n plotitem.plot_var = 1\n plotitem.plotstyle = '-'\n plotitem.color = 'b'\n plotitem.show = True # show on plot?\n plotitem.kwargs = {'linewidth':3,'markersize':5}\n \n\n # Parameters used only when creating html and/or latex hardcopy\n # e.g., via visclaw.frametools.printframes:\n\n plotdata.printfigs = True # print figures\n plotdata.print_format = 'png' # file format\n plotdata.print_framenos = 'all' # list of frames to print\n plotdata.print_fignos = 'all' # list of figures to print\n plotdata.html = True # create html files of plots?\n plotdata.html_homelink = '../README.html'\n plotdata.latex = True # create latex file of plots?\n plotdata.latex_figsperline = 2 # layout of plots\n plotdata.latex_framesperline = 1 # layout of plots\n plotdata.latex_makepdf = False # also run pdflatex?\n\n return plotdata","def gaze_ethoplot(anglearrays,title,show = True,save = False):\n colors = ['red','blue']\n labels = ['fish1 gaze', 'fish2 gaze']\n fig,ax = plt.subplots(2,1,sharex = True)\n for i in range(2):\n anglearray = anglearrays[i]\n inds = np.arange(len(anglearray))\n color = colors[i]\n ax[0].plot(anglearray,color = color,linewidth = 1,alpha = 0.5,label = labels[i])\n boolean = anglearray.apply(lambda x: 1 if x > 140 else 0) \n [ax[1].axvline(x = j,alpha = 0.2,color = color) for j in inds if boolean[j] == 1]\n\n ax[0].set_ylabel('relative angle (degrees)')\n ax[1].set_ylabel('threshold crossing')\n ax[1].set_xlabel('time (frame)')\n ax[0].set_title(title)\n\n ax[0].legend(loc = 1)## in the upper right; faster than best. \n\n if save == True:\n plt.savefig(title + '.png')\n \n if show == True:\n plt.show()","def animate(input_filename):\n # With matplotlib, it's much, much faster to just update the properties\n # of a display object than it is to create a new one, so we'll just update\n # the data and position of the same objects throughout this animation...\n\n infile = paw_file(input_filename)\n\n # Since we're making an animation with matplotlib, we need \n # ion() instead of show()...\n plt.ion()\n fig = plt.figure()\n ax = fig.add_subplot(111)\n fig.suptitle(input_filename)\n\n # Make an image based on the first frame that we'll update later\n # (The first frame is never actually displayed)\n im = ax.imshow(infile.next()[1])\n\n # Make 4 rectangles that we can later move to the position of each paw\n rects = [Rectangle((0,0), 1,1, fc='none', ec='red') for i in range(4)]\n [ax.add_patch(rect) for rect in rects]\n\n title = ax.set_title('Time 0.0 ms')\n\n # Process and display each frame\n for time, frame in infile:\n paw_slices = find_paws(frame)\n\n # Hide any rectangles that might be visible\n [rect.set_visible(False) for rect in rects]\n\n # Set the position and size of a rectangle for each paw and display it\n for slice, rect in zip(paw_slices, rects):\n dy, dx = slice\n rect.set_xy((dx.start, dy.start))\n rect.set_width(dx.stop - dx.start + 1)\n rect.set_height(dy.stop - dy.start + 1)\n rect.set_visible(True)\n\n # Update the image data and title of the plot\n title.set_text('Time %0.2f ms' % time)\n im.set_data(frame)\n im.set_clim([frame.min(), frame.max()])\n fig.canvas.draw()","def plot_timeres(timeres):\n tint = 24 / len(timeres.intervals)\n step = 255 / (tint + 1)\n\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n\n # if distrib:\n # cont = cont / np.max(cont)\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=cont[i] * circlesize,\n # line_color='#FF0000',\n # fill_color='#110000')\n # else:\n # for i in range(cont.shape[0]):\n # if cont[i] > 0.01:\n # cx = cluster.cluster_centers_[i][0]\n # cy = cluster.cluster_centers_[i][1]\n # mymap.circle_marker(location=[cx, cy],\n # radius=30,\n # line_color='#FF0000',\n # fill_color='#110000')\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros(cluster.num_clusters())\n for i in range(self.dataset.shape[0]):\n posy = self.dataset[i][0]\n posx = self.dataset[i][1]\n ejem = np.array([[posy, posx]]).reshape(1,-1)\n ncl = cluster.predict(ejem)\n ncl = ncl[0]\n\n _, evtime = timeres.discretize(self.dataset[i][2])\n\n if evtime == t:\n if distrib:\n cont[ncl] += 1\n else:\n cont[ncl] = 1\n if distrib:\n cont = cont / np.max(cont)\n for i in range(cont.shape[0]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=cont[i] * circlesize,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i] > 0.01:\n cx = cluster.cluster_centers_[i][0]\n cy = cluster.cluster_centers_[i][1]\n mymap.circle_marker(location=[cx, cy],\n radius=30,\n line_color=pltcolors[t],\n fill_color=pltcolors[t], #'#110000',\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)","def _plot_particle_level_spectra_with_matplotlib(ep_analyses: AnalysesBase,\n output_name: str,\n output_info: analysis_objects.PlottingOutputWrapper,\n general_labels: Dict[str, str],\n plot_labels: plot_base.PlotLabels) -> None:\n # Setup\n fig, ax = plt.subplots(figsize = (8, 6))\n # Diamond, square, up triangle, circle\n markers = [\"D\", \"s\", \"^\", \"o\"]\n colors = [\"black\", \"blue\", \"green\", \"red\"]\n # Label axes\n plot_labels.apply_labels(ax)\n\n # Plot the actual hists. The inclusive orientation will be plotted first.\n particle_level_max_pt = 0\n for analysis, color, marker in zip(ep_analyses.values(), colors, markers):\n # Store this value for convenience. It is the same for all orientations.\n particle_level_max_pt = analysis.task_config[\"particle_level_spectra\"][\"particle_level_max_pt\"]\n\n # For inclusive, use open markers that are plotted on top of all points.\n additional_args = {}\n if analysis.reaction_plane_orientation == params.ReactionPlaneOrientation.inclusive:\n additional_args.update({\n \"fillstyle\": \"none\",\n \"zorder\": 10,\n })\n\n # Convert and plot hist\n h = histogram.Histogram1D.from_existing_hist(analysis.particle_level_spectra)\n ax.errorbar(\n h.x, h.y,\n xerr = (h.bin_edges[1:] - h.bin_edges[:-1]) / 2,\n yerr = h.errors,\n label = analysis.reaction_plane_orientation.display_str(),\n color = color,\n marker = marker,\n linestyle = \"\",\n **additional_args\n )\n\n # Final presentation settings\n # Axis ticks\n ax.xaxis.set_major_locator(matplotlib.ticker.MultipleLocator(base = 10))\n ax.xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(base = 2))\n tick_shared_args = {\n \"axis\": \"both\",\n \"bottom\": True,\n \"left\": True,\n }\n ax.tick_params(\n which = \"major\",\n # Size of the axis mark labels\n labelsize = 15,\n length = 8,\n **tick_shared_args,\n )\n ax.tick_params(\n which = \"minor\",\n length = 4,\n **tick_shared_args,\n )\n # Limits\n ax.set_xlim(0, particle_level_max_pt)\n # Unfortunately, MPL doesn't calculate restricted log limits very nicely, so we\n # we have to set the values by hand.\n # We grab the value from the last analysis object - the value will be the same for all of them.\n y_limits = analysis.task_config[\"particle_level_spectra\"][\"y_limits\"]\n ax.set_ylim(y_limits[0], y_limits[1])\n ax.set_yscale(\"log\")\n # Legend\n ax.legend(\n loc = \"lower left\",\n frameon = False,\n fontsize = 18,\n )\n # Combine the general labels and then plot them.\n label = \"\\n\".join(general_labels.values())\n # The label is anchored in the upper right corner.\n ax.text(0.95, 0.95, s = label,\n horizontalalignment = \"right\",\n verticalalignment = \"top\",\n multialignment = \"right\",\n fontsize = 18,\n transform = ax.transAxes)\n fig.tight_layout()\n\n # Finally, save and cleanup\n output_name += \"_mpl\"\n plot_base.save_plot(output_info, fig, output_name)\n plt.close(fig)","def make_plot(d0,t0,d1,t1,d2,t2,d3,t3,suptitle,path_out):\n fig0 = plt.figure(1,(10.,7.))\n grid = ImageGrid(fig0, 111, # similar to subplot(111)\n nrows_ncols = (2, 2), # creates 2x2 grid of axes\n axes_pad=0.4, # pad between axes in inch.\n share_all=True, # share axes\n cbar_mode='each')\n \n im = grid[0].pcolor(d0)\n grid[0].set_title(t0)\n grid.cbar_axes[0].colorbar(im)\n grid[0].axis([0,d0.shape[1],0,d0.shape[0]])\n \n im = grid[1].pcolor(d1)\n grid[1].set_title(t1)\n grid.cbar_axes[1].colorbar(im)\n grid[0].axis([0,d1.shape[1],0,d1.shape[0]])\n \n im = grid[2].pcolor(d2)\n grid[2].set_title(t2)\n grid.cbar_axes[2].colorbar(im)\n grid[0].axis([0,d2.shape[1],0,d2.shape[0]])\n \n im = grid[3].pcolor(d3)\n grid[3].set_title(t3) \n grid.cbar_axes[3].colorbar(im)\n grid[0].axis([0,d3.shape[1],0,d3.shape[0]])\n\n \n fig0.suptitle(suptitle,fontsize=18)\n \n fig0.savefig(path_out, dpi=300)\n fig0.clf()\n return","def plot_results_traj_3d(p_x, p_y, p_z, xmin, xmax, ymin, ymax, zmin, zmax):\n fig, ax = plt.subplots(2 , 2, figsize = (10, 10))\n \n for p in np.arange(0, p_x.shape[0], step = 1): \n for t in np.arange(0, p_x.shape[1], step = 1): \n ax[0,0].plot(t, p_x[p, t], 'rx') \n ax[0,1].plot(t, p_y[p, t], 'gx') \n ax[1,0].plot(t, p_z[p, t], 'bx') \n ax[1,1].plot(t, p_x[p, t], 'rx') \n ax[1,1].plot(t, p_y[p, t], 'gx') \n ax[1,1].plot(t, p_z[p, t], 'bx') \n for a in ax.flat: \n a.set(xlabel = 'Time steps', ylabel = 'Position')\n ax[0,0].set_title('X (pix)') \n ax[0,0].set_ylim([xmin, xmax]) \n ax[0,1].set_title('Y (pix)') \n ax[0,1].set_ylim([ymin, ymax]) \n ax[1,0].set_title('Z (pix)') \n ax[1,0].set_ylim([zmin, zmax])\n ax[1,1].set_title('Positions combined') \n ax[1,1].set_ylim([np.array([xmin, ymin, zmin]).min(), np.array([xmax, ymax, zmax]).max()])","def making_plot(sample_points_x_y_nonZero, gauge_volume, y_upper_imit, y_lower_limit,\n sample_height=10, sample_width=5., min_color=None, max_color = None):\n if sample_points_x_y_nonZero.size==0:\n print \"the array does not have a non zero gauge volume\"\n\n\n else:\n\n xS, yS=sample_points_x_y_nonZero\n X,Y= np.meshgrid(xS,yS)\n\n gauge_volume=np.array(gauge_volume)\n\n Z = griddata((xS,yS), gauge_volume, (X,Y), method='nearest')\n\n plt.figure()\n # r=plt.contour( X, Y,Z)\n # plt.clabel(r, inline=1, fontsize=10)\n plt.pcolormesh(X, Y, Z, cmap = plt.get_cmap('rainbow'),vmin=min_color, vmax=max_color )\n plt.xlabel('points along sample width (mm)')\n plt.ylabel('points along sample height (mm)')\n plt.ylim(y_lower_limit,y_upper_imit)\n plt.colorbar()\n plt.axhline(y=-sample_height/2., color='r', linestyle='-')\n plt.axhline(y=sample_height/2., color='r', linestyle='-')\n plt.axvline(x=- sample_width/2., color='r', linestyle='-')\n plt.axvline(x= sample_width/2., color='r', linestyle='-')\n # plt.scatter(xS,yS ,marker = 'o', c = 'b', s = 5, zorder = 10)\n plt.savefig(os.path.join(thisdir, '../figures/{sample}.png'.format(sample='gauge_volume')))\n plt.show()","def plot_vanHove_dt(comp,conn,start,step_size,steps):\n \n (fin,) = conn.execute(\"select fout from comps where comp_key = ?\",comp).fetchone()\n (max_step,) = conn.execute(\"select max_step from vanHove_prams where comp_key = ?\",comp).fetchone()\n Fin = h5py.File(fin,'r')\n g = Fin[fd('vanHove',comp[0])]\n\n temp = g.attrs['temperature']\n dtime = g.attrs['dtime']\n\n\n # istatus = plots.non_i_plot_start()\n \n fig = mplt.figure()\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\n dims = figure_out_grid(steps)\n \n plt_count = 1\n outs = []\n tmps = []\n for j in range(start,start+step_size*steps, step_size):\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\n if len(count) < 50:\n plt_count += 1\n continue\n #count = count/np.sum(count)\n \n sp_arg = dims +(plt_count,)\n ax = fig.add_subplot(*sp_arg)\n ax.grid(True)\n\n \n alpha = _alpha2(edges,count)\n \n ax.set_ylabel(r'$\\log{P(N)}$')\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\n ax.set_title(r'$\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\n ax.set_xlim(x_lim)\n plt_count += 1\n\n mplt.draw()\n\n # plots.non_i_plot_start(istatus)\n\n del g\n Fin.close()\n del Fin","def plot_iou_over_time(path, iou, bboxes, bboxes_noisy):\r\n capture = cv2.VideoCapture(path)\r\n success = True\r\n rescaling_factor = 0.25\r\n margin = 0\r\n while success:\r\n success, frame = capture.read()\r\n current_frame = int(capture.get(cv2.CAP_PROP_POS_FRAMES))\r\n print('frame: ', current_frame)\r\n\r\n plt.subplot(2, 1, 1)\r\n plt.imshow(cv2.resize(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), (0,0), fx=rescaling_factor, fy=rescaling_factor))\r\n if str(current_frame) in bboxes.keys():\r\n for bbox in bboxes[str(current_frame)]:\r\n rect = pat.Rectangle((bbox[1]*rescaling_factor, bbox[2]*rescaling_factor),\r\n bbox[3]*rescaling_factor, bbox[4]*rescaling_factor,\r\n linewidth=1, edgecolor='r', facecolor='none')\r\n plt.gca().add_patch(rect)\r\n if str(current_frame) in bboxes_noisy.keys():\r\n for bbox_noisy in bboxes_noisy[str(current_frame)]:\r\n rect = pat.Rectangle((bbox_noisy[1]*rescaling_factor, bbox_noisy[2]*rescaling_factor),\r\n bbox_noisy[3]*rescaling_factor, bbox_noisy[4]*rescaling_factor,\r\n linewidth=1, edgecolor='b', facecolor='none')\r\n plt.gca().add_patch(rect)\r\n plt.subplot(2, 1, 2)\r\n if current_frame > 150: margin = current_frame - 150\r\n plt.plot(iou[margin:current_frame])\r\n plt.show(block=False)\r\n\r\n plt.pause(0.0001)\r\n plt.clf()\r\n\r\n capture.release()","def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\n action_legend_location=None):\n\n #get location of files\n running_reward_file, _, actions_file = \\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\n\n #font size\n matplotlib.rcParams.update({'font.size': 14, \"text.usetex\": True,\n 'text.latex.preamble' : r'\\usepackage{amsmath}\\usepackage{physics}'})\n\n #create the axis (subplots)\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\n reward_ax = fig.add_subplot(gs[0, :])\n prot_0_ax = fig.add_subplot(gs[1, 0])\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\n prot_final_ax = fig.add_subplot(gs[2, :])\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \n\n #set the reward axis\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\n custom_color = \"black\", lines_to_mark = [nearest_int(act_0/actions_per_log),\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\n custom_mark_color=\"black\",ylim=reward_ylim,ylabel=reward_ylabel,\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\n legend_labels=reward_legend_labels)\n\n #set the three actions axis\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\n two_xticks=True)\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_1,ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_2, ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\n\n #set the final protocol axis\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\n actions_ylim=large_action_ylim,plot_to_file_line=None,\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\n linewidth = prot_linewidth, xlabel=\"$t[dt]$\",extra_cycles=extra_cycles,\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\n legend_text=action_legend_text, legend_location=action_legend_location)\n\n #add the (a) (b) (c) labels\n reward_ax.text(-0.11,-0.38, r'\\textbf{(a)}', transform=reward_ax.transAxes )\n prot_0_ax.text(-0.4,-0.55, r'\\textbf{(b)}', transform=prot_0_ax.transAxes )\n prot_final_ax.text(-0.11,-0.38, r'\\textbf{(c)}', transform=prot_final_ax.transAxes )\n\n #save if necessary\n if plot_file_name is not None:\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\n plot_file_name = os.path.join(plot_folder, plot_file_name)\n plt.savefig(plot_file_name)\n\n #show\n plt.show()"],"string":"[\n \"def plots(self, events=None, title=None):\\n data = self.data\\n P = PH.regular_grid(3 , 1, order='columnsfirst', figsize=(8., 6), showgrid=False,\\n verticalspacing=0.08, horizontalspacing=0.08,\\n margins={'leftmargin': 0.07, 'rightmargin': 0.20, 'topmargin': 0.03, 'bottommargin': 0.1},\\n labelposition=(-0.12, 0.95))\\n scf = 1e12\\n ax = P.axarr\\n ax = ax.ravel()\\n PH.nice_plot(ax)\\n for i in range(1,2):\\n ax[i].get_shared_x_axes().join(ax[i], ax[0])\\n # raw traces, marked with onsets and peaks\\n tb = self.timebase[:len(data)]\\n ax[0].plot(tb, scf*data, 'k-', linewidth=0.75, label='Data') # original data\\n ax[0].plot(tb[self.onsets], scf*data[self.onsets], 'k^', \\n markersize=6, markerfacecolor=(1, 1, 0, 0.8), label='Onsets')\\n if len(self.onsets) is not None:\\n# ax[0].plot(tb[events], data[events], 'go', markersize=5, label='Events')\\n# ax[0].plot(tb[self.peaks], self.data[self.peaks], 'r^', label=)\\n ax[0].plot(tb[self.smpkindex], scf*np.array(self.smoothed_peaks), 'r^', label='Smoothed Peaks')\\n ax[0].set_ylabel('I (pA)')\\n ax[0].set_xlabel('T (s)')\\n ax[0].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n \\n # deconvolution trace, peaks marked (using onsets), plus threshold)\\n ax[1].plot(tb[:self.Crit.shape[0]], self.Crit, label='Deconvolution') \\n ax[1].plot([tb[0],tb[-1]], [self.sdthr, self.sdthr], 'r--', linewidth=0.75, \\n label='Threshold ({0:4.2f}) SD'.format(self.sdthr))\\n ax[1].plot(tb[self.onsets]-self.idelay, self.Crit[self.onsets], 'y^', label='Deconv. Peaks')\\n if events is not None: # original events\\n ax[1].plot(tb[:self.Crit.shape[0]][events], self.Crit[events],\\n 'ro', markersize=5.)\\n ax[1].set_ylabel('Deconvolution')\\n ax[1].set_xlabel('T (s)')\\n ax[1].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n# print (self.dt, self.template_tmax, len(self.template))\\n # averaged events, convolution template, and fit\\n if self.averaged:\\n ax[2].plot(self.avgeventtb[:len(self.avgevent)], scf*self.avgevent, 'k', label='Average Event')\\n maxa = np.max(self.sign*self.avgevent)\\n #tpkmax = np.argmax(self.sign*self.template)\\n if self.template is not None:\\n maxl = int(np.min([len(self.template), len(self.avgeventtb)]))\\n temp_tb = np.arange(0, maxl*self.dt, self.dt)\\n #print(len(self.avgeventtb[:len(self.template)]), len(self.template))\\n ax[2].plot(self.avgeventtb[:maxl], scf*self.sign*self.template[:maxl]*maxa/self.template_amax, \\n 'r-', label='Template')\\n # compute double exp based on rise and decay alone\\n # print('res rise: ', self.res_rise)\\n # p = [self.res_rise.x[0], self.res_rise.x[1], self.res_decay.x[1], self.res_rise.x[2]]\\n # x = self.avgeventtb[:len(self.avg_best_fit)]\\n # y = self.doubleexp(p, x, np.zeros_like(x), risepower=4, fixed_delay=0, mode=0)\\n # ax[2].plot(x, y, 'b--', linewidth=1.5)\\n tau1 = np.power(10, (1./self.risepower)*np.log10(self.tau1*1e3)) # correct for rise power\\n tau2 = self.tau2*1e3\\n ax[2].plot(self.avgeventtb[:len(self.avg_best_fit)], scf*self.avg_best_fit, 'c--', linewidth=2.0,\\n label='Best Fit:\\\\nRise Power={0:.2f}\\\\nTau1={1:.3f} ms\\\\nTau2={2:.3f} ms\\\\ndelay: {3:.3f} ms'.\\n format(self.risepower, self.res_rise.x[1]*1e3, self.res_decay.x[1]*1e3, self.bfdelay*1e3))\\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.rise_fit, 'g--', linewidth=1.0,\\n # label='Rise tau {0:.2f} ms'.format(self.res_rise.x[1]*1e3))\\n # ax[2].plot(self.avgeventtb[:len(self.decay_fit)], self.sign*scf*self.decay_fit, 'm--', linewidth=1.0,\\n # label='Decay tau {0:.2f} ms'.format(self.res_decay.x[1]*1e3))\\n if title is not None:\\n P.figure_handle.suptitle(title)\\n ax[2].set_ylabel('Averaged I (pA)')\\n ax[2].set_xlabel('T (s)')\\n ax[2].legend(fontsize=8, loc=2, bbox_to_anchor=(1.0, 1.0))\\n if self.fitted:\\n print('measures: ', self.risetenninety, self.decaythirtyseven)\\n mpl.show()\",\n \"def overviewCommand(self):\\n plt.figure(11)\\n plt.clf()\\n ax = plt.subplot(211)\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*self.raw['OPDC'].data.field('FUOFFSET'),\\n color='r', label='FUOFFSET',\\n linewidth=1, alpha=1) \\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\\n self.raw['OPDC'].data.field('PSP')),\\n color='r', linewidth=3, alpha=0.5,\\n label=self.DLtrack+'-PSP')\\n plt.legend()\\n plt.subplot(212, sharex=ax)\\n plt.plot(self.raw['OPDC'].data.field('TIME'),\\n 1e6*self.raw['OPDC'].data.field('FUOFFSET')-\\n 1e6*(self.raw['OPDC'].data.field(self.DLtrack)-\\n self.raw['OPDC'].data.field('PSP')),\\n color='k', label='$\\\\Delta$',\\n linewidth=1, alpha=1) \\n \\n signal = self.raw['OPDC'].data.field('FUOFFSET')\\n plt.figure(12)\\n plt.clf()\\n ax2 = plt.subplot(111)\\n Fs = 1e6/np.diff(self.raw['OPDC'].data.field('TIME')).mean()\\n print Fs\\n ax2.psd(signal[:50000], NFFT=5000, Fs=Fs, label='FUOFFSET',scale_by_freq=0)\\n plt.legend()\",\n \"def timePiePlot(self, pctM=0.04):\\n names = ['Voronoi Tesselation', 'Connectivity of Cluster Cells']\\n dict = {}\\n for i,j in zip(names, self.times):\\n dict[i] = j\\n\\n total = sum(dict.values())\\n title = 'Time Consumption per Step of Voronoi Analysis - Total [s]= ' + str(round(total, 3))\\n labels = []\\n values = []\\n for v in dict.keys():\\n if dict[v] / total > pctM:\\n labels.append(v + ' - ' + str(round(dict[v], 3)) + ' (' + str(round(dict[v] * 100 / total, 2)) + ' %)')\\n else:\\n labels.append(v)\\n values.append(dict[v] / total)\\n labdis = 1.07\\n cmap = plt.get_cmap(\\\"plasma\\\")\\n c = np.arange(len(dict.keys())) / len(dict.keys())\\n colors = cmap(c)\\n\\n fig = plt.figure()\\n fig.set_size_inches(12, 7)\\n plt.title(title, fontsize=22)\\n plt.pie(dict.values(), labels=labels, shadow=True, startangle=0, labeldistance=labdis, colors=colors)\\n plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\",\n \"def plot_overview(cube=nro_12co,\\n region_file='../shell_candidates/AllShells.reg', mode='peak', plotname='12co_peak_shells.png',\\n interactive=False, show_shells=True, shells_highlight=None, dist=orion_dist, vmin=None, vmax=None,\\n scalebar_color=\\\"white\\\", scalebar_pc = 1., scale_factor=1., pmin=0.25,\\n pmax=99.75, cbar_label=r\\\"Peak T$_{\\\\rm MB}$ [K]\\\",\\n circle_color='white', circle_linewidth=1, circle_style=\\\"solid\\\", return_fig=False, show=True,\\n title=r\\\"$^{12}$CO Peak T$_{MB}$\\\", recenter=False, ra=None, dec=None, radius=None):\\n try:\\n cube = SpectralCube.read(cube)\\n except ValueError:\\n pass\\n\\n if mode == \\\"peak\\\":\\n image = (cube.max(axis=0) * scale_factor).hdu\\n \\n\\n if mode == \\\"mom0\\\":\\n image = (cube.moment0() * scale_factor).hdu\\n\\n\\n\\n fig = FITSFigure(image)\\n if show:\\n fig.show_colorscale(cmap='viridis', vmin=vmin, vmax=vmax, pmin=pmin,\\n pmax=pmax, interpolation='none')\\n fig.tick_labels.set_yformat(\\\"dd:mm\\\")\\n fig.tick_labels.set_xformat(\\\"hh:mm\\\")\\n #fig.hide_yaxis_label()\\n #fig.hide_ytick_labels()\\n plt.title(title)\\n plt.xlabel(\\\"RA (J2000)\\\")\\n plt.ylabel(\\\"DEC (J2000)\\\")\\n\\n if show_shells:\\n shell_list = get_shells(region_file=region_file)\\n for i, shell in enumerate(shell_list):\\n if shells_highlight:\\n if i+1 in shells_highlight:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle='solid', edgecolor=circle_color,\\n facecolor='none', linewidth=3)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n else:\\n fig.show_circles(shell.ra.value, shell.dec.value, shell.radius.value, linestyle=circle_style, edgecolor=circle_color,\\n facecolor='none', linewidth=circle_linewidth)\\n\\n #RECENTER\\n if recenter:\\n fig.recenter(ra, dec, radius)\\n\\n\\n #SCALEBAR\\n fig.add_scalebar(206265 * scalebar_pc / (dist.to(u.pc).value * 3600), color=scalebar_color)\\n fig.scalebar.set_label(\\\"{} pc\\\".format(scalebar_pc))\\n\\n fig.add_colorbar()\\n cb = fig.colorbar\\n cb.set_axis_label_text(cbar_label)\\n\\n if return_fig:\\n return fig\\n else:\\n fig.save(plotname, dpi=600)\",\n \"def plot_tail(infile):\\n\\n # Read file\\n xs, ys = {}, {}\\n for line in infile:\\n fields = line.split()\\n run = int(fields[0])\\n time = float(fields[1])\\n running = int(fields[2])\\n if run not in xs:\\n xs[run] = []\\n ys[run] = []\\n xs[run].append(time)\\n ys[run].append(running)\\n min_time = min(min(r) for r in xs.values())\\n max_time = max(max(r) for r in xs.values())\\n max_y = max(max(r) for r in ys.values())\\n\\n # Create output directory\\n if cmdline.outdir:\\n try: os.makedirs(cmdline.outdir)\\n except OSError as e:\\n if e.errno != errno.EEXIST: raise\\n\\n # Plot it\\n frame_width = 1920\\n frame_height = 1080\\n dpi = 96.0\\n axis_width = 2\\n mpl.rcParams['axes.linewidth'] = axis_width\\n using_gui = (cmdline.frames == 1 and not cmdline.batch)\\n timestep = (max_time - min_time)/float(cmdline.frames)\\n shown_time = min_time\\n for frame in xrange(1, cmdline.frames + 1):\\n print('frame {}/{}'.format(frame, cmdline.frames), file=sys.stderr)\\n shown_time += timestep\\n #fig = plt.figure()\\n fig, ax = plt.subplots()\\n fig.set_size_inches(frame_width/float(dpi), frame_height/float(dpi))\\n #ax = plt.Axes(fig, [0, 0, 1, 1])\\n #fig.add_axes(ax)\\n #ax.set_axis_off()\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n ax.get_xaxis().set_ticks([min_time, max_time])\\n ax.set_xticklabels(['', ''])\\n ax.xaxis.set_tick_params(width=axis_width)\\n ax.get_yaxis().set_ticks([])\\n ax.spines['right'].set_visible(False)\\n ax.spines['top'].set_visible(False)\\n ax.spines['left'].set_visible(False)\\n ax.spines['bottom'].set_bounds(min_time, max_time)\\n plt.xlim([min_time, max_time])\\n plt.ylim([-0.03*max_y, 1.05*max_y])\\n #plt.axis('off')\\n plt.tick_params(left='off', bottom='on')\\n fontprop = fm.FontProperties(fname=cmdline.font) if cmdline.font else None\\n plt.xlabel('Time', labelpad=20, fontsize=36, fontproperties=fontprop)\\n plt.ylabel('Tasks Running', labelpad=40, fontsize=36, fontproperties=fontprop)\\n\\n global line_color\\n for run in xs:\\n times = [x for x in xs[run] if x <= shown_time]\\n plt.plot(times, ys[run][:len(times)], color=line_color, lw=6, label='Run {}'.format(run))\\n if len(xs) > 1:\\n plt.legend(loc='upper right')\\n if cmdline.frames > 1:\\n outfile = cmdline.outdir + ('/' if cmdline.outdir and cmdline.outdir != '' else '') + 'frame-{}.png'.format(frame)\\n plt.savefig(outfile, format='png', dpi=dpi)\\n elif cmdline.outfile:\\n plt.savefig(cmdline.outfile, format='png', bbox_inches='tight', dpi=dpi)\\n if not using_gui:\\n plt.close(plt.gcf())\\n if using_gui:\\n plt.show()\",\n \"def plot(self):\\n\\n # initialize outside the loop to avoid memory leak\\n\\n plot_a = None\\n\\n # initial plotting scales\\n vmin = 0\\n vmax = 0\\n pmin = 0\\n pmax = 0\\n\\n sr = self.dio.get_properties(self.channel)['samples_per_second']\\n\\n if self.control.verbose:\\n print 'sample rate: ', sr\\n\\n # initial time info\\n display_lag = 60\\n b = self.dio.get_bounds(self.channel)\\n\\n if self.control.verbose:\\n print 'data bounds: ', b\\n\\n if self.control.start:\\n dtst0 = dateutil.parser.parse(self.control.start)\\n st0 = (dtst0 - datetime.datetime(1970, 1,\\n 1, tzinfo=pytz.utc)).total_seconds()\\n st0 = int(st0 * sr)\\n else:\\n st0 = int(b[0])\\n\\n if self.control.end:\\n dtst0 = dateutil.parser.parse(self.control.end)\\n et0 = (dtst0 - datetime.datetime(1970, 1,\\n 1, tzinfo=pytz.utc)).total_seconds()\\n et0 = int(et0 * sr)\\n else:\\n et0 = int(b[1])\\n\\n if self.control.verbose:\\n\\n print 'start sample st0: ', st0\\n print 'end sample et0: ', et0\\n\\n blocks = self.control.bins * self.control.frames\\n\\n samples_per_stripe = self.control.num_fft * \\\\\\n self.control.integration * self.control.decimation\\n total_samples = blocks * samples_per_stripe\\n\\n if total_samples > (et0 - st0):\\n print 'Insufficient samples for %d samples per stripe and %d blocks between %ld and %ld' % (samples_per_stripe, blocks, st0, et0)\\n return\\n\\n stripe_stride = (et0 - st0) / blocks\\n\\n bin_stride = stripe_stride / self.control.bins\\n\\n start_sample = st0\\n\\n print 'first ', start_sample\\n\\n # get metadata\\n # this could be done better to ensure we catch frequency or sample rate\\n # changes\\n mdt = self.dio.read_metadata(st0, et0, self.channel)\\n try:\\n md = mdt[mdt.keys()[0]]\\n cfreq = md['center_frequencies'].ravel()[self.sub_channel]\\n except (IndexError, KeyError):\\n cfreq = 0.0\\n\\n if self.control.verbose:\\n print 'processing info : ', self.control.frames, self.control.bins, samples_per_stripe, bin_stride\\n\\n for p in numpy.arange(self.control.frames):\\n sti_psd_data = numpy.zeros(\\n [self.control.num_fft, self.control.bins], numpy.float)\\n sti_times = numpy.zeros([self.control.bins], numpy.complex128)\\n\\n for b in numpy.arange(self.control.bins):\\n\\n if self.control.verbose:\\n print 'read vector :', self.channel, start_sample, samples_per_stripe\\n\\n d_vec = self.dio.read_vector(\\n start_sample, samples_per_stripe, self.channel)\\n data = d_vec[:, self.sub_channel]\\n\\n if self.control.decimation > 1:\\n data = scipy.signal.decimate(data, self.control.decimation)\\n sample_freq = sr / self.control.decimation\\n else:\\n sample_freq = sr\\n\\n if self.control.mean:\\n detrend_fn = matplotlib.mlab.detrend_mean\\n else:\\n detrend_fn = matplotlib.mlab.detrend_none\\n\\n try:\\n psd_data, freq_axis = matplotlib.mlab.psd(\\n data, NFFT=self.control.num_fft, Fs=float(sample_freq), detrend=detrend_fn, scale_by_freq=False)\\n except:\\n traceback.print_exc(file=sys.stdout)\\n\\n sti_psd_data[:, b] = numpy.real(\\n 10.0 * numpy.log10(numpy.abs(psd_data) + 1E-12))\\n\\n sti_times[b] = start_sample / sr\\n\\n start_sample += stripe_stride\\n\\n # Now Plot the Data\\n ax = self.subplots[p]\\n\\n # determine image x-y extent\\n extent = (\\n 0,\\n self.control.bins,\\n numpy.min(freq_axis) / 1e3,\\n numpy.max(freq_axis) / 1e3,\\n )\\n\\n # determine image color extent in log scale units\\n Pss = sti_psd_data\\n vmin = numpy.real(numpy.median(Pss) - 6.0)\\n vmax = numpy.real(numpy.median(\\n Pss) + (numpy.max(Pss) - numpy.median(Pss)) * 0.61803398875 + 50.0)\\n\\n if self.control.zaxis:\\n vmin = int(string.split(self.control.zaxis, ':')[0])\\n vmax = int(string.split(self.control.zaxis, ':')[1])\\n else:\\n vmin = numpy.real(numpy.median(Pss) - 6.0)\\n vmax = numpy.real(numpy.median(\\n Pss) + (numpy.max(Pss) - numpy.median(Pss)) * 0.61803398875 + 50.0)\\n\\n im = ax.imshow(sti_psd_data, cmap='jet', origin='lower', extent=extent,\\n interpolation='nearest', vmin=vmin, vmax=vmax, aspect='auto')\\n\\n ax.set_ylabel('f (kHz)', fontsize=8)\\n\\n # plot dates\\n\\n tick_spacing = numpy.arange(\\n self.control.bins / 8, self.control.bins, self.control.bins / 8)\\n ax.set_xticks(tick_spacing)\\n tick_labels = []\\n\\n for s in tick_spacing:\\n tick_time = sti_times[s]\\n\\n if tick_time == 0:\\n tick_string = ''\\n else:\\n gm_tick_time = time.gmtime(numpy.real(tick_time))\\n tick_string = '%02d:%02d:%02d' % (\\n gm_tick_time[3], gm_tick_time[4], gm_tick_time[5])\\n tick_labels.append(tick_string)\\n\\n ax.set_xticklabels(tick_labels)\\n\\n # set the font sizes\\n tl = ax.get_xticklabels()\\n\\n for tk in tl:\\n tk.set_size(8)\\n del tl\\n\\n tl = ax.get_yticklabels()\\n\\n for tk in tl:\\n tk.set_size(8)\\n del tl\\n\\n print 'last ', start_sample\\n\\n # create a time stamp\\n start_time = st0 / sr\\n srt_time = time.gmtime(start_time)\\n sub_second = int(round((start_time - int(start_time)) * 100))\\n\\n timestamp = \\\"%d-%02d-%02d %02d:%02d:%02d.%02d UT\\\" % (srt_time[0], srt_time[\\n 1], srt_time[2], srt_time[3], srt_time[4], srt_time[5], sub_second)\\n\\n self.f.suptitle('%s %s %4.2f MHz (%s)' % (\\n self.control.title, timestamp, cfreq / 1E6, self.control.path), fontsize=10)\\n\\n # ax.legend(fontsize=8)\\n ax.set_xlabel('time (UTC)', fontsize=8)\\n\\n # fixup ticks\\n\\n tl = ax.get_xticklabels()\\n for tk in tl:\\n tk.set_size(8)\\n del tl\\n tl = ax.get_yticklabels()\\n for tk in tl:\\n tk.set_size(8)\\n del tl\\n\\n self.gridspec.update()\\n\\n self.f.tight_layout()\\n\\n self.f.subplots_adjust(top=0.95, right=0.88)\\n cax = self.f.add_axes([0.9, 0.12, 0.02, 0.80])\\n self.f.colorbar(im, cax=cax)\\n if self.control.outname:\\n fname, ext = os.path.splitext(self.control.outname)\\n if ext == '':\\n ext = '.png'\\n print \\\"Save plot as {}\\\".format(fname+ext)\\n matplotlib.pyplot.savefig(fname+ext)\\n if self.control.appear or not self.control.outname:\\n print \\\"Show plot\\\"\\n matplotlib.pyplot.show()\",\n \"def plot_slices(hists, slice_width, fibre_pos):\\n pmt_info = rat.utility().GetPMTInfo()\\n # Find max angle\\n max_angle = 0\\n pmtIDs = hists.keys()\\n for pmtID in pmtIDs:\\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\\n if angle > max_angle:\\n max_angle = angle\\n print max_angle\\n\\n # Step between 0 and max_angle in slices of slice_width\\n # create a plot of all pmt time spectra within each slice\\n ROOT.gStyle.SetPalette(1) \\n cuts = np.arange(0., max_angle+slice_width, slice_width)\\n for i, cut in enumerate(cuts): \\n tmpHists = []\\n if i > 0:\\n low_range = cuts[i-1]\\n hi_range = cuts[i]\\n s = ROOT.THStack(\\\"stack\\\", \\\"Slice: %1.1f - %1.1f deg\\\" % (low_range, hi_range)) \\n count = 0\\n for pmtID in pmtIDs:\\n angle = taf.fibre_to_pmt_angle(fibre_pos, pmt_info.GetPosition(pmtID))\\n if angle > low_range and angle < hi_range:\\n #print pmtID\\n count = count + 1\\n hists[pmtID].SetLineColor(count)\\n s.Add(hists[pmtID])\\n print \\\"Drawing...\\\"\\n s.Draw(\\\"nostack\\\")\\n s.GetHistogram().GetXaxis().SetTitle(\\\"Time (ns)\\\")\\n #s.Write()\\n #c1.BuildLegend(0.5, 0.2, 0.88, 0.88)\\n c1.Update()\\n c1.Modified()\\n c1.Print(\\\"./results/slices/Slice_%1.1f.png\\\" % low_range)\\n s.Delete()\\n #time.sleep(1)\",\n \"def main():\\n\\n r = np.arange(-90, 90, 2)\\n tilt = 22.5\\n\\n with ptcmd.PTCMD(baud=57600) as controller:\\n\\n controller.home()\\n\\n for pan_angle in r:\\n\\n current_position = controller.get_position()\\n pan_steps, tilt_steps, pan_rate, tilt_rate = system.move_to_angle(pan_angle, tilt, current_position[0], current_position[1], base_rate = 1000)\\n controller.sync(pan_rate, pan_steps, tilt_rate, tilt_steps)\\n controller.wait('all')\\n\\n time.sleep(2)\\n\\n distances = []\\n for i in range(0,12):\\n time.sleep(1)\\n distances.append(controller.get_analog_sensor(1))\\n\\n distances.sort()\\n distance = sum(distances[1:-1]) / len(distances[1:-1])\\n\\n x = math.sin(pan_angle*math.pi/180) * distance\\n y = math.cos(pan_angle*math.pi/180) * distance\\n\\n print(distances, distance, pan_angle, x, y)\\n\\n plt.plot(x, y, 'b+')\\n\\n plt.show()\",\n \"def comp_time_plot(p1=database['K+'], p2=database['pi+'], pmax=80, plot=True):\\r\\n dt = []\\r\\n p_range = np.linspace(10, pmax, 1000)\\r\\n m1 = p1.mass\\r\\n m2 = p2.mass\\r\\n for p in p_range:\\r\\n t1_per_m = 76.273/(beta(p, m1)*gamma(p, m1)*c)\\r\\n t2_per_m = 76.273/(beta(p, m2)*gamma(p, m2)*c)\\r\\n dt.append(abs(t1_per_m - t2_per_m)*1e12)\\r\\n dt_12_5 = dt[np.argmin(abs(p_range-12.5))]\\r\\n dt_75 = dt[np.argmin(abs(p_range-75))]\\r\\n ratio = dt_12_5/dt_75\\r\\n if plot==True:\\r\\n fig = plt.figure(figsize=[10, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n ax.plot(p_range, dt, 'b', label=r'$\\\\Delta t$')\\r\\n ax.axvline(12.5, color='r', label='p=12.5 GeV')\\r\\n ax.axvline(75, color='g', label='p=75 GeV')\\r\\n ax.set_xlim(10, pmax)\\r\\n ax.set_ylim(0)\\r\\n ax.set_xlabel('p / GeV', fontsize=20)\\r\\n# ax.set_yscale('log')\\r\\n ax.set_ylabel(r'$\\\\Delta t$ / ps', fontsize=20)\\r\\n title = f'{p1.name} to {p2.name} '\\r\\n title += r'$\\\\Delta t$ dependancy on particle momenta'\\r\\n ax.set_title(title, fontsize=20)\\r\\n ax.legend(fontsize=20)\\r\\n text = 'dt(12.5) = {0:.2f} ps, '.format(dt_12_5)\\r\\n text += 'dt(75) = {0:.2f} ps, '.format(dt_75)\\r\\n text += 'ratio = {0:.3f}'.format(ratio)\\r\\n plt.show()\\r\\n print(text)\\r\\n return [dt_12_5, dt_75, ratio]\",\n \"def main():\\n font = {'family' : 'normal',\\n 'weight' : 'normal',\\n 'size' : 18}\\n\\n matplotlib.rc('font', **font)\\n\\n ###Plot overviews\\n\\n# plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full.png\\\",\\n# show_shells=False,title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n# dist=orion_dist, vmin=None, vmax=None, scalebar_color='white',\\n# scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n \\n plot_overview(plotname=\\\"../paper/figs/12co_nroonly_peak_full_shells.png\\\", show_shells=True,\\n dist=orion_dist, vmin=None, vmax=None, scalebar_color='black', scale_factor = 1.,\\n title=r\\\"\\\", shells_highlight=best_shells, circle_style='dotted', circle_linewidth=1.5,\\n scalebar_pc=1. #,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325\\n )\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_mom0_cometary.png\\\",\\n # show_shells=False, title=r\\\"Combined Integrated $^{12}$CO\\\",\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000,\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(plotname=\\\"12co_nroonly_mom0_cometary.png\\\", show_shells=False,\\n # dist=orion_dist, scalebar_color='white', pmax=93., mode='mom0',\\n # scale_factor=1./1000, title=r\\\"NRO Integrated $^{12}$CO\\\",\\n # scalebar_pc=0.2,recenter=True, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # plot_overview(cube='../combined_maps/12co_pix_2.cm.fits', plotname=\\\"12co_combined_peak_full_shells.png\\\",\\n # show_shells=True, shells_highlight=shells_score3, title=r\\\"Combined $^{12}$CO Peak T$_{MB}$\\\",\\n # dist=orion_dist, vmin=None, vmax=None, scalebar_color='white', circle_style='dotted',\\n # scalebar_pc=1.,recenter=False, ra=83.99191, dec=-5.6611303, radius=0.117325)\\n\\n # return\\n\\n mips_l1641_file = '../catalogs/MIPS_L1641a_24um.fits'\\n mips_onc_file = '../catalogs/MIPS_ONC_24um.fits'\\n\\n irac1_l1641_file = '../catalogs/IRAC_L1641_ch1_merged_clean.fits'\\n irac1_onc_file = '../catalogs/IRAC_ONC_ch1_merged_clean.fits'\\n\\n irac2_l1641_file = '../catalogs/IRAC_L1641_ch2_merged_clean.fits'\\n irac2_onc_file = '../catalogs/IRAC_ONC_ch2_merged_clean.fits'\\n\\n irac4_l1641_file = '../catalogs/IRAC_L1641_ch4_merged_clean_northup.fits'\\n irac4_onc_file = '../catalogs/IRAC_ONC_ch4_merged_clean_northup.fits'\\n\\n planck_herschel_file = '../catalogs/planck_herschel.fits'\\n\\n region_file = '../shell_candidates/AllShells.reg'\\n vrange_file = '../shell_candidates/AllShells_vrange.txt'\\n shell_list = get_shells(region_file=region_file, velocity_file=vrange_file)\\n\\n obaf_file = 'stars_obaf.txt'\\n yso_file = \\\"../catalogs/spitzer_orion.fit\\\"\\n\\n obaf = ascii.read(obaf_file)\\n obaf_ra, obaf_dec, obaf_label = np.array(obaf['RA']), np.array(obaf['DEC']), np.array([sp.strip(\\\"b'\\\") for sp in obaf['SP_TYPE']])\\n yso = fits.open(yso_file)[1].data\\n yso_ra, yso_dec, yso_label = yso['RAJ2000'], yso['DEJ2000'], yso['Cl']\\n\\n # for nshell in range(19,43):\\n # shell = shell_list[nshell-1]\\n # ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n # #Check whether shell is in each mips image coverage.\\n # l1641_xy = WCS(mips_l1641_hdu).all_world2pix(ra, dec, 0)\\n \\n # if (l1641_xy[0] >= 0) & (l1641_xy[0] <= mips_l1641_hdu.shape[1]) & \\\\\\n # (l1641_xy[1] >= 0) & (l1641_xy[1] <= mips_l1641_hdu.shape[0]):\\n # hdu = mips_l1641_hdu\\n # else:\\n # hdu = mips_onc_hdu\\n\\n # plot_stamp(map=hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=1.5, contour_map=None, contour_levels=5., source_ra=None, source_dec=None, source_lists=None, \\n # source_colors='cyan', plotname='{}shell{}_stamp.png'.format('MIPS',nshell), return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist, cbar_label=r'counts',\\n # auto_scale=True, auto_scale_mode='min/max', auto_scale_pad_factor=1., vmin=0, vmax=3000)\\n\\n\\n #cube_file = '../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits'\\n cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n ir_l1641_hdu = fits.open(irac4_l1641_file)[0]\\n ir_onc_hdu = fits.open(irac4_onc_file)[0]\\n\\n spec_cube = SpectralCube.read(cube_file)\\n ra_grid = spec_cube.spatial_coordinate_map[1].to(u.deg).value\\n dec_grid = spec_cube.spatial_coordinate_map[0].to(u.deg).value\\n vel_grid = spec_cube.spectral_axis\\n pad_factor = 1.5\\n\\n #plot_overview(show_shells=True)\\n #plot_overview(plotname=\\\"12co_nro_peak.png\\\", show_shells=False)\\n #plot_overview(cube=\\\"/Volumes/Untitled/13co_pix_2.cm.fits\\\", plotname=\\\"13co_combined_peak.png\\\", show_shells=False)\\n #return\\n #channel_vmax = [12.9, 14]\\n for nshell in range(17,18):\\n shell = shell_list[nshell-1]\\n ra, dec, radius = shell.ra.value, shell.dec.value, shell.radius.value\\n\\n l1641_xy = WCS(ir_l1641_hdu).wcs_world2pix(ra, dec, 0)\\n #print(l1641_xy)\\n if (l1641_xy[0] >= 0) & (l1641_xy[0] <= ir_l1641_hdu.shape[1]) & \\\\\\n (l1641_xy[1] >= 0) & (l1641_xy[1] <= ir_l1641_hdu.shape[0]):\\n ir_hdu = ir_l1641_hdu\\n else:\\n ir_hdu = ir_onc_hdu\\n\\n #Extract sub_cube around shell.\\n subcube_mask = (abs(ra_grid - ra) < radius * pad_factor) &\\\\\\n (abs(dec_grid - dec) < radius * pad_factor)\\n sub_cube = spec_cube.with_mask(subcube_mask).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n\\n #Integrate between vmin and vmax.\\n mom0_hdu = sub_cube.moment0().hdu\\n\\n # mask_inshell = (abs(ra_grid - ra) < radius) &\\\\\\n # (abs(dec_grid - dec) < radius)\\n # subcube_inshell = spec_cube.with_mask(mask_inshell).minimal_subcube().spectral_slab(shell.vmin, shell.vmax)\\n # mom0_hdu_inshell = subcube_inshell.moment0().hdu\\n\\n #Calculate contour levels.\\n empty_channel = spec_cube.closest_spectral_channel(500*u.Unit('m/s'))\\n sigma = np.nanstd(spec_cube[empty_channel][subcube_mask]).value\\n #print(\\\"sigma: {}\\\".format(sigma))\\n delta_vel = (sub_cube.spectral_extrema[1] - sub_cube.spectral_extrema[0]).value\\n #print(\\\"delta_vel: {}\\\".format(delta_vel))\\n mom0_sigma = sigma * delta_vel\\n #print(mom0_sigma) \\n #contour_levels = np.linspace(5.*mom0_sigma, np.nanmax(mom0_hdu_inshell.data), 12)\\n contour_levels = np.linspace(28.*mom0_sigma, 45.*mom0_sigma, 6 )\\n\\n #Get source coordinates.\\n\\n\\n # plot_stamp(map=ir_hdu, ra=ra, dec=dec, radius=radius, circle_color='red',\\n # pad_factor=pad_factor, contour_map=mom0_hdu, contour_levels=contour_levels, contour_color='white',\\n # plotname='{}shell{}_{}{}to{}_stamp.png'.format('8µm', nshell, \\\"12CO\\\", shell.vmin.value, shell.vmax.value),\\n # return_fig=False,\\n # stretch='linear', plot_simbad_sources=False, dist=orion_dist,\\n # auto_scale=True, auto_scale_mode='median', auto_scale_pad_factor=0.8, auto_scale_nsigma=4.,\\n # cbar_label=\\\"Counts\\\", cmap='inferno',\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', 'None'], source_sizes=[300,50],\\n # source_labels=[obaf_label, yso_label], dpi=300\\n # )\\n\\n #cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n \\n \\n # plot_channels(cube=cube_file, ra=ra, dec=dec, radius=radius,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(nshell)+'.png', chan_step=2, plot_simbad_sources=False,\\n # vmin=None, vmax=None, max_chans=12,\\n # #cbar_label=\\\"Counts\\\",\\n # source_ra=[obaf_ra, yso_ra], source_dec=[obaf_dec, yso_dec],\\n # source_colors=['white', 'red'], source_markers=['*', '+'], source_sizes=[200,15], dpi=300)\\n\\n # angle = 90*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[shell.vmin - 1*u.km/u.s, shell.vmax + 1*u.km/u.s], length=shell.radius*4.,\\n # width=7.5*u.arcsec, angle=angle,\\n # pad_factor=1., plotname='12co_pv_shell'+str(nshell)+'_angle'+str(angle.value)+'.png',\\n # stretch='linear', auto_scale=True, dpi=900.)\\n \\n\\n\\n #simbad_brightstars(output='stars_obaf.txt', output_format='ascii', replace_ra='deg')\\n\\n\\n #movie(test=False, labels=False) \\n\\n #cube_file = '../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits'\\n # region_file = '../nro_maps/SouthShells.reg'\\n # N = 2 # Number of shell candidates to plot\\n # shell_list = get_shells(region_file=region_file)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # #cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n\\n # for n in range(1,2):\\n # shell = shell_list[n]\\n # for deg in np.linspace(0, 180, 13):\\n # angle = deg*u.deg\\n # pv = plot_pv(cube=cube_file, ra_center=shell.ra, dec_center=shell.dec,\\n # vel=[4*u.km/u.s, 8*u.km/u.s], length=shell.radius*2.*4.,\\n # width=7.5*u.arcsec, angle=105*u.deg,\\n # pad_factor=1., plotname='12co_pv_shell'+str(n+1)+'_angle'+str(angle.value)+'morev.png', return_subplot=True,\\n # stretch='linear', auto_scale=True)\\n\\n # cube_file = \\\"../nro_maps/12CO_20161002_FOREST-BEARS_spheroidal_xyb_grid7.5_0.099kms.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='12co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\\n\\n # cube_file = \\\"../nro_maps/13CO_20161011_FOREST-BEARS_xyb_spheroidal_dV0.11kms_YS.fits\\\"\\n # for n in range(N):\\n # shell = shell_list[n]\\n # plot_channels(cube=cube_file, ra=shell.ra.value, dec=shell.dec.value, radius=shell.radius.value,\\n # source_lists=None, stretch='linear', pad_factor=1.5, vel_min=shell.vmin.value, vel_max=shell.vmax.value,\\n # plotname='13co_channels_shell'+str(n+1)+'.png', chan_step=2, plot_simbad_sources=True, simbad_color='blue')\",\n \"def apolco(a,minfeh=-3,out=None) :\\n apo=np.where((a['TELESCOPE'] == 'apo25m') & (a['RV_FEH']>minfeh) )[0]\\n fig=vscat(a[apo],marker='o',density=True)\\n lco=np.where((a['TELESCOPE'] == 'lco25m') & (a['RV_FEH']>minfeh) )[0]\\n vscat(a[lco],fig=fig,ls=':',marker='+',density=True)\\n if out is not None : \\n fig[0].savefig(out+'_1.png')\\n plt.close()\\n i1,i2=match.match(a['APOGEE_ID'][apo],a['APOGEE_ID'][lco])\\n print('matched {:d} stars'.format(len(i1)))\\n fig,ax=plots.multi(1,2)\\n #plots.plotp(ax[0,0],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-3,3],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[0,1],a['SNR'][apo[i1]],a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],yr=[-50,50],yt=r'$\\\\Delta$ VHELIO_AVG',xt='S/N')\\n #plots.plotp(ax[1,0],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-0.5,0.5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n #plots.plotp(ax[1,1],a['SNR'][apo[i1]],a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],yr=[-5,5],yt=r'$\\\\Delta$ VSCATTER',xt='S/N')\\n ax[0].hist(a['VHELIO_AVG'][apo[i1]]-a['VHELIO_AVG'][lco[i2]],bins=np.arange(-0.5,0.5,0.02),histtype='step')\\n ax[0].set_xlabel(r'$\\\\Delta$ VHELIO_AVG')\\n ax[1].hist(a['VSCATTER'][apo[i1]]-a['VSCATTER'][lco[i2]],bins=np.arange(-0.25,0.25,0.01),histtype='step')\\n ax[1].set_xlabel(r'$\\\\Delta$ VSCATTER')\\n if out is not None : \\n fig.savefig(out+'_2.png')\\n plt.close()\",\n \"def generatePlot(data):\\n addendum = \\\"\\\"\\n destination = \\\"D:\\\\\\\\Research\\\\\\\\scripts\\\\\\\\Results\\\\\\\\FullSet1\\\\\\\\$FilteredPlots\\\\\\\\take 4\\\\\\\\\\\"\\n if len(data.detections.smallIncrease) != 0:\\n addendum = \\\"small increases\\\\\\\\\\\"\\n if len(data.detections.smallDecrease) != 0:\\n addendum = \\\"small decreases\\\\\\\\\\\"\\n if len(data.detections.largeIncrease) != 0:\\n addendum = \\\"large increases\\\\\\\\\\\"\\n if len(data.detections.largeDecrease) != 0:\\n addendum = \\\"large decreases\\\\\\\\\\\"\\n if addendum == \\\"\\\":\\n addendum = \\\"no decreases\\\\\\\\\\\"\\n \\n plt.figure(1)\\n plt.subplot(211)\\n #print np.min(data.magdata), np.max(data.magdata)\\n axes = plt.gca()\\n axes.set_title(\\\"Year: '{year}, Day: {day}\\\".format(year=data.calendarDay[:2], day=data.calendarDay[3:] ))\\n axes.set_ylim([np.min(data.magdata)-1.2,np.max(data.magdata)+0.25])\\n axes.set_ylabel(r'$\\\\mathbf{B}$ (nT)' )\\n\\n #plot formatting\\n formats = dates.DateFormatter('%H:%M:%S')\\n axes.xaxis.set_major_locator(dates.MinuteLocator())\\n axes.xaxis.set_major_formatter(formats)\\n \\n br, = pp.plot(dates.date2num(data.timestamps),[row[0] for row in data.magdata],label='$B_r$')\\n bt, = pp.plot(dates.date2num(data.timestamps),[row[1] for row in data.magdata],label='$B_t$')\\n bn, = pp.plot(dates.date2num(data.timestamps),[row[2] for row in data.magdata],label='$B_n$')\\n b0, = pp.plot(dates.date2num(data.timestamps),[row[3] for row in data.magdata],label='$B_0$')\\n print len(data.detections.rotationBoundary)\\n if len(data.detections.rotationBoundary) == 1:\\n rotation, = pp.plot([dates.date2num(data.detections.rotationBoundary), dates.date2num(data.detections.rotationBoundary)], [np.min(data.magdata)-1,np.max(data.magdata)+0.25], linestyle='--', color = 'm', alpha = 0.4, label='$RB$')\\n else:\\n for index, value in enumerate(data.detections.rotationBoundary):\\n rotation, = pp.plot([dates.date2num(value), dates.date2num(value)], [np.min(data.magdata)-1,np.max(data.magdata)+0.25], linestyle='--', color = 'm', alpha = 0.4, label='$RB$')\\n if len(data.detections.rotationBoundary) != 0:\\n pp.legend(handles=[br,bt,bn,b0,rotation], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\\n else:\\n pp.legend(handles=[br,bt,bn,b0], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\\n\\n start, end = axes.get_xlim()\\n axes.xaxis.set_ticks(np.arange(start, end, (end-start)/5))\\n \\n \\n\\n plt.subplot(212)\\n axes2 = plt.gca()\\n #plot formatting\\n formats = dates.DateFormatter('%H:%M:%S')\\n axes2.xaxis.set_major_locator(dates.MinuteLocator())\\n axes2.xaxis.set_major_formatter(formats)\\n axes2.set_ylabel(r'$\\\\theta$ (deg)' )\\n rotations, = pp.plot(dates.date2num(data.detections.rotationTimeTags),data.detections.rotations)\\n #pp.legend(handles=[rotations], loc='lower left', ncol=4, fancybox=True, framealpha=0.5)\\n \\n\\n outplotname = 'Plot ' + str(len(os.listdir(destination+addendum)) + 1)+ ' ' + data.timestamps[0].strftime('%y-%j-%H%M%S') + '.pdf'\\n completename = os.path.join(destination+addendum,outplotname)\\n plt.savefig(completename, bboxinches='tight')\\n plt.clf()\\n\\n outplotname = 'Plot ' + str(len(os.listdir(destination+'rawdata\\\\\\\\'+addendum)) + 1)+ ' ' + data.timestamps[0].strftime('%y-%j-%H%M%S') + ' rawdata.csv'\\n completename1 = os.path.join(destination+'rawdata\\\\\\\\'+addendum,outplotname)\\n generateDataFile(data.rawdata,completename1)\\n\\n print \\\"Done generating plot...\\\"\",\n \"def _plot_arm(self):\\n fig, axs = plt.subplots()\\n fig.show()\\n axs.cla()\\n axs.axis([-1, 2.5, -1, 2.5])\\n axs.plot([0], [0], 'o')\\n config_plots = []\\n for t_step in range(0, int(self._t_sim / self._dt) + 1, 1000):\\n axs.plot([0, self._x_1[t_step]], [0, self._y_1[t_step]])\\n axs.plot(self._x_1[t_step], self._y_1[t_step], 'o')\\n axs.plot(\\n [self._x_1[t_step], self._x_2[t_step]],\\n [self._y_1[t_step], self._y_2[t_step]]\\n )\\n axs.plot(self._x_2[t_step], self._y_2[t_step], 'o')\\n axs.plot(\\n [self._x_2[t_step], self._x_e[t_step]],\\n [self._y_2[t_step], self._y_e[t_step]]\\n )\\n axs.plot(self._x_e[t_step], self._y_e[t_step], 'ro')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 0],\\n self._obj_coords_plot[t_step, 1, 0], 'g+')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 1],\\n self._obj_coords_plot[t_step, 1, 1], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 2],\\n self._obj_coords_plot[t_step, 1, 2], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 3],\\n self._obj_coords_plot[t_step, 1, 3], 'g.')\\n axs.plot(\\n self._obj_coords_plot[t_step, 0, 4],\\n self._obj_coords_plot[t_step, 1, 4], 'g.')\\n plt.axis('off')\\n plt.pause(1 / self._plot_fps)\\n fig.canvas.draw()\\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\\n config_plots.append(image.reshape(\\n fig.canvas.get_width_height()[::-1] + (3, )))\\n\\n # Draw and create image\\n return config_plots\",\n \"def plot_bp_exptimes(self, plot_spectrum = True, title = None, ylims = (1.0, 1e7),\\n cc = [\\\"C0\\\", \\\"C2\\\", \\\"C3\\\"], iremove = []):\\n\\n # Reshape exposure times\\n tmp = self.tpbpcs_rect.T\\n\\n # Calculate clean spectrum\\n output = self.complete_spectrum_time()\\n spectrum = output[2]\\n\\n fig, ax2 = plt.subplots(figsize = (16,5))\\n\\n if title is not None:\\n ax2.set_title(title)\\n\\n icount = 0\\n for ichan in range(len(CHANNELS)):\\n\\n data = []\\n positions = []\\n widths = []\\n\\n for j in range(len(self.bp_names[self.bp_chan == ichan])):\\n\\n nanmask = np.isfinite(tmp[icount,:])\\n\\n data.append(tmp[icount,nanmask])\\n positions.append(np.mean(spectrum[0][icount]))\\n widths.append(spectrum[0][icount][-1] - spectrum[0][icount][0] + np.mean(spectrum[1][icount][:]))\\n color1 = cc[ichan]\\n\\n comp_str = \\\"$%i \\\\%%$\\\" %(100.*self.frac_bias_bp[icount])\\n comp_str2 = \\\"$\\\\mathbf{%i {\\\\%%}}$\\\" %(100.*self.frac_bias_bp[icount])\\n comp_str3 = \\\"$\\\\mathbf{%i}$\\\" %(100.*self.frac_bias_bp[icount])\\n #ax2.text(positions[j], np.median(tmp[icount,:]) + 5.*np.std(tmp[icount,:]), comp_str2,\\n # ha = \\\"center\\\", va = \\\"top\\\", fontsize = 12, color = \\\"w\\\")\\n q_l, q_50, q_h, q_m, q_p = nsig_intervals(tmp[icount,nanmask], intvls=[0.25, 0.5, 0.75])\\n #ax2.text(positions[j], ylims[1], comp_str2,\\n # ha = \\\"center\\\", va = \\\"top\\\", color = color1, fontsize = 12)\\n ax2.text(positions[j], q_50 + q_p, comp_str3,\\n ha = \\\"center\\\", va = \\\"bottom\\\", color = color1)\\n\\n #ax2.plot(self.bandpasses[icount], [q_50, q_50], color = color1, zorder = 120, ls = \\\"dashed\\\")\\n\\n icount += 1\\n\\n positions = np.array(positions)\\n widths = np.array(widths)\\n bp1 = ax2.boxplot(data, sym = '', widths = widths, showfliers = False,\\n boxprops = {\\\"color\\\" : color1, \\\"alpha\\\" : 0.5},\\n whiskerprops = {\\\"color\\\" : color1, \\\"linewidth\\\" : 2.0},\\n capprops = {\\\"color\\\" : color1, \\\"linewidth\\\" : 0.0},\\n medianprops = {\\\"color\\\" : \\\"w\\\", \\\"linewidth\\\" : 2.0},\\n patch_artist=True, positions = positions, whis = [5, 95]);\\n\\n for patch in bp1['boxes']:\\n patch.set_facecolor(color1)\\n\\n if plot_spectrum:\\n\\n ax = ax2.twinx()\\n ax2.set_zorder(100)\\n ax2.patch.set_visible(False)\\n\\n ax.set_xlabel(\\\"Wavelength [$\\\\mu$m]\\\")\\n ax.set_ylabel(r\\\"Planet-Star Flux Ratio ($\\\\times 10^{-10}$)\\\", rotation = 270, labelpad = 25)\\n for i in range(len(self.bp_names)):\\n if i not in iremove:\\n pass\\n #ax.plot(spectrum[0][i], 1e10*spectrum[3][i], \\\"o\\\", ms = 4.0, alpha = 0.65, color = \\\"w\\\", zorder = 80)\\n #ax.errorbar(spectrum[0][i], 1e10*spectrum[3][i], yerr=1e10*spectrum[4][i], fmt = \\\"o\\\", ms = 2.0, alpha = 0.65, color = \\\"k\\\", zorder = 80)\\n #ax.axvspan(drmA.bandpasses[i][0], drmA.bandpasses[i][1], alpha = 0.2, color = cc[drmA.bp_chan[i]])\\n\\n self.cn.telescope.lammin = 0.2\\n self.cn.telescope.lammax = 2.0\\n self.cn.telescope.resolution = 140.\\n # Re-do count rate calcs for true Earth spectrum\\n self.cn.run_count_rates(self.AHR, self.LAMHR, self.FSTAR)\\n l1, = ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \\\"purple\\\", zorder = 0, lw = 4.0, alpha = 1.)\\n l2, = ax.plot(self.cn.lam, 1e10*self.cn.Cratio, color = \\\"w\\\", zorder = 0, lw = 2.0, alpha = 0.65)\\n ax.set_ylim(bottom=0.0)\\n ax.legend([(l1, l2)], [(\\\"Modern Earth\\\")], framealpha = 0.0)\\n\\n # Label Molecules\\n ax.text(0.27, 1.55, \\\"O$_3$\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(0.6, 1.25, \\\"O$_3$\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(0.68, 1.35, \\\"O$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(0.76, 1.45, \\\"O$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(0.96, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(1.15, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(1.4, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(1.9, 1.45, \\\"H$_2$O\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n ax.text(1.6, 1.25, \\\"CO$_2$\\\", ha = \\\"center\\\", va = \\\"center\\\")\\n\\n ax2.set_ylabel(\\\"Science Time [hrs]\\\")\\n #ax2.set_title(r\\\"All %i targets (S/N$\\\\approx$%i)\\\" %(Ndraw, wantSNR))\\n ax2.set_yscale(\\\"log\\\")\\n\\n ax2.set_xlabel(\\\"Wavelength [$\\\\mu$m]\\\")\\n ax2.set_ylim(bottom = ylims[0], top = ylims[1])\\n\\n ax2.set_xticks([0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0])\\n ax2.set_xticklabels([\\\"$0.2$\\\", \\\"$0.4$\\\", \\\"$0.6$\\\", \\\"$0.8$\\\", \\\"$1.0$\\\", \\\"$1.2$\\\", \\\"$1.4$\\\", \\\"$1.6$\\\", \\\"$1.8$\\\", \\\"$2.0$\\\"])\\n ax2.set_xlim(0.1, 2.1)\\n #ax2.set_xlim(0.4, 1.0)\\n\\n #fig.savefig(\\\"/Users/Jake/Dropbox/Astronomy/UW/Astrobio/Research Rotation/LUVOIR/figures/drm_bp10_science_time_%s.pdf\\\" %drm.architecture, bbox_inches = \\\"tight\\\")\\n\\n return fig\",\n \"def plotTI():\\n min_dl = dlam[dlam != 0].min()\\n S = int(0.4/min_dl)\\n fig = pl.figure(figsize = (8,6))\\n ax = fig.add_subplot(1,1,1)\\n ax.spines['bottom'].set_position('zero')\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n\\n for k, spine in ax.spines.items():\\n spine.set_zorder(12.2)\\n\\n xs, ndx, dx = [0], 0, 0.001\\n colors = ['r', 'g', '#7F38EC', '#9F000F', 'b', 'y']\\n min_y, max_y = 0, 0\\n\\n lines = tuple()\\n ## lv_names2 = [r'$Coulomb$', r'$vdWaals$'] ## for the paper\\n lv_names2 = []\\n for j in range(n_components):\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n lv_names2.append(r'$%s$' % P.lv_names[j].capitalize())\\n\\n for j in range(n_components):\\n\\n y = ave_dhdl[:,j]\\n if not (y == 0).all():\\n\\n # Get the coordinates.\\n lj = lchange[:,j]\\n x = lv[:,j][lj]\\n y = y[lj]/P.beta_report\\n\\n if 'TI' in P.methods:\\n # Plot the TI integration area.\\n ss = 'TI'\\n for i in range(len(x)-1):\\n min_y = min(y.min(), min_y)\\n max_y = max(y.max(), max_y)\\n #pl.plot(x,y)\\n if i%2==0:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(x[i:i+2]+ndx, 0, y[i:i+2], color=colors[ndx], alpha=0.5)\\n xlegend = [-100*wnum for wnum in range(len(lv_names2))]\\n pl.plot(xlegend, [0*wnum for wnum in xlegend], ls='-', color=colors[ndx], label=lv_names2[ndx]) ## for the paper\\n\\n if 'TI-CUBIC' in P.methods and not cubspl[j]==0:\\n # Plot the TI-CUBIC interpolation curve.\\n ss += ' and TI-CUBIC'\\n xnew = numpy.arange(0, 1+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n pl.plot(xnew+ndx, ynew, color='#B6B6B4', ls ='-', solid_capstyle='round', lw=3.0)\\n\\n else:\\n # Plot the TI-CUBIC integration area.\\n ss = 'TI-CUBIC'\\n for i in range(len(x)-1):\\n xnew = numpy.arange(x[i], x[i+1]+dx, dx)\\n ynew = cubspl[j].interpolate(y, xnew)\\n ynew[0], ynew[-1] = y[i], y[i+1]\\n min_y = min(ynew.min(), min_y)\\n max_y = max(ynew.max(), max_y)\\n if i%2==0:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=1.0)\\n else:\\n pl.fill_between(xnew+ndx, 0, ynew, color=colors[ndx], alpha=0.5)\\n\\n # Store the abscissa values and update the subplot index.\\n xs += (x+ndx).tolist()[1:]\\n ndx += 1\\n\\n # Make sure the tick labels are not overcrowded.\\n xs = numpy.array(xs)\\n dl_mat = numpy.array([xs-i for i in xs])\\n ri = range(len(xs))\\n\\n def getInd(r=ri, z=[0]):\\n primo = r[0]\\n min_dl=ndx*0.02*2**(primo>10)\\n if dl_mat[primo].max()<min_dl:\\n return z\\n for i in r:\\n for j in range(len(xs)):\\n if dl_mat[i,j]>min_dl:\\n z.append(j)\\n return getInd(ri[j:], z)\\n\\n xt = [i if (i in getInd()) else '' for i in range(K)]\\n pl.xticks(xs[1:], xt[1:], fontsize=10)\\n pl.yticks(fontsize=10)\\n #ax = pl.gca()\\n #for label in ax.get_xticklabels():\\n # label.set_bbox(dict(fc='w', ec='None', alpha=0.5))\\n\\n # Remove the abscissa ticks and set up the axes limits.\\n for tick in ax.get_xticklines():\\n tick.set_visible(False)\\n pl.xlim(0, ndx)\\n min_y *= 1.01\\n max_y *= 1.01\\n pl.ylim(min_y, max_y)\\n\\n for i,j in zip(xs[1:], xt[1:]):\\n pl.annotate(('%.2f' % (i-1.0 if i>1.0 else i) if not j=='' else ''), xy=(i, 0), xytext=(i, 0.01), size=10, rotation=90, textcoords=('data', 'axes fraction'), va='bottom', ha='center', color='#151B54')\\n if ndx>1:\\n lenticks = len(ax.get_ymajorticklabels()) - 1\\n if min_y<0: lenticks -= 1\\n if lenticks < 5:\\n from matplotlib.ticker import AutoMinorLocator as AML\\n ax.yaxis.set_minor_locator(AML())\\n pl.grid(which='both', color='w', lw=0.25, axis='y', zorder=12)\\n pl.ylabel(r'$\\\\mathrm{\\\\langle{\\\\frac{ \\\\partial U } { \\\\partial \\\\lambda }}\\\\rangle_{\\\\lambda}\\\\/%s}$' % P.units, fontsize=20, color='#151B54')\\n pl.annotate('$\\\\mathit{\\\\lambda}$', xy=(0, 0), xytext=(0.5, -0.05), size=18, textcoords='axes fraction', va='top', ha='center', color='#151B54')\\n if not P.software.title()=='Sire':\\n lege = ax.legend(prop=FP(size=14), frameon=False, loc=1)\\n for l in lege.legendHandles:\\n l.set_linewidth(10)\\n pl.savefig(os.path.join(P.output_directory, 'dhdl_TI.pdf'))\\n pl.close(fig)\\n return\",\n \"def plot_examples(cms):\\r\\n data = amp_axis\\r\\n\\r\\n fig, axs = plt.subplots(1, 2, figsize=(30, 8)) #create two plots\\r\\n for [ax, cmap] in zip(axs, cms):\\r\\n psm = ax.pcolormesh(time_axis, tof_axis, data, cmap=cmap, rasterized=True, vmin = 250) #specify axis and minimum amplitude value to show on the graph\\r\\n fig.colorbar(psm, ax=ax, label = 'Amplitude') #define the legend of the amplitude data\\r\\n \\r\\n ax.set_ylabel('Time of Flight [\\\\u03bcs]') #set label for y axis\\r\\n ax.set_xlabel('Time [min]') #set label for x axis\\r\\n \\r\\n ax.hlines(8.744, 0, stop_time, colors = 'white') #create two white lines for the safe operating range for ToF\\r\\n ax.hlines(9.555, 0, stop_time, colors = 'white') \\r\\n \\r\\n plt.show()\",\n \"def check_plots(tracklist_subset, tracklist):\\n\\n for trial in tracklist_subset: # Iterates over all available trials\\n\\n # Scale time for colormap\\n scaled_time = (tracklist[trial]['data'].index.values -\\n tracklist[trial]['data'].index.values.min()) / \\\\\\n tracklist[trial]['data'].index.values.ptp()\\n timemax = max(tracklist[trial]['data'].index.values)\\n data = tracklist[trial]['data']\\n colors = plt.cm.cubehelix(scaled_time)\\n m = cm.ScalarMappable(cmap=cm.cubehelix)\\n m.set_array(tracklist[trial]['data'].index.values)\\n\\n # filename = str(trial) + '.pdf'\\n\\n fig = plt.figure(figsize=(20, 20))\\n fig.suptitle(tracklist[trial]['sequence'] + ' ' +\\n tracklist[trial]['behavior'])\\n\\n ax1 = fig.add_subplot(4, 2, 1, projection='3d')\\n ax1.set_title('Pt 1 Position')\\n ax1.scatter3D(xs=tracklist[trial]['data']['pt1x_smth'],\\n ys=tracklist[trial]['data']['pt1y_smth'],\\n zs=tracklist[trial]['data']['pt1z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax1.autoscale(enable=True, tight=True)\\n ax1.set_xlabel('X position')\\n ax1.set_ylabel('Y position')\\n ax1.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax2 = fig.add_subplot(4, 2, 3)\\n ax2.plot(data.index.values, data['pt1y_v_smth'], 'bo')\\n ax2.set_ylabel('Y velocity (cm/s)', color='b')\\n ax2.tick_params('y', colors='b')\\n\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax3.plot(data.index.values, data['pt1_net_v'], 'bo')\\n ax3.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax3.tick_params('y', colors='b')\\n\\n ax4 = fig.add_subplot(4, 2, 7)\\n ax4.plot(data.index.values, data['pt1_net_a'], 'bo')\\n ax4.set_ylabel('Net accel (cm/s2)', color='b')\\n ax4.tick_params('y', colors='b')\\n\\n ax5 = fig.add_subplot(4, 2, 2, projection='3d')\\n ax5.set_title('Pt 2 Position')\\n ax5.scatter3D(xs=tracklist[trial]['data']['pt2x_smth'],\\n ys=tracklist[trial]['data']['pt2y_smth'],\\n zs=tracklist[trial]['data']['pt2z_smth'],\\n zdir='z', s=3, c=colors, marker='o',\\n edgecolor='none') # 3D Scatter plot\\n ax5.autoscale(enable=True, tight=True)\\n ax5.set_xlabel('X position')\\n ax5.set_ylabel('Y position')\\n ax5.set_zlabel('Z position')\\n plt.colorbar(m, shrink=0.5, aspect=10)\\n\\n ax6 = fig.add_subplot(4, 2, 4)\\n ax6.plot(data.index.values, data['pt2y_v_smth'], 'bo')\\n ax6.set_ylabel('Y velocity (cm/s)', color='b')\\n ax6.tick_params('y', colors='b')\\n\\n ax7 = fig.add_subplot(4, 2, 6)\\n ax7.plot(data.index.values, data['pt2_net_v'], 'bo')\\n ax7.set_ylabel('Net Velocity (cm/s)', color='b')\\n ax7.tick_params('y', colors='b')\\n\\n ax8 = fig.add_subplot(4, 2, 8)\\n ax8.plot(data.index.values, data['pt2_net_a'], 'bo')\\n ax8.set_ylabel('Net accel (cm/s2)', color='b')\\n ax8.tick_params('y', colors='b')\\n\\n plt.show()\",\n \"def one_period_plot():\\n file = \\\"Data/matfiles/20131221.mat\\\"\\n object = MatReader(file)\\n\\n NeA = object.NeA\\n latA = object.latA\\n times = object.secondsA\\n mlt = object.mltA\\n ind1 = 2606 #lat inds\\n ind2 = 13940 #lat inds\\n \\n ind1 = 3197 #mlat inds\\n ind2 = 14390 #mlat inds\\n \\n T = ind2 - ind1\\n ind1 += int(T/2)\\n ind2 += int(T/2)\\n\\n latA = latA[ind1:ind2]\\n NeA = NeA[ind1:ind2]\\n # NeA = object.meanie(NeA, 5)\\n times = times[ind1:ind2]\\n mlt = mlt[ind1:ind2]\\n mlt = hour_round(mlt)\\n\\n lats = np.zeros_like(latA)\\n lats[0] = latA[0]\\n for i in range(len(latA)-1):\\n dlat = latA[i+1] - latA[i]\\n if dlat < 0:\\n lats[i+1] = lats[i] - dlat\\n else:\\n lats[i+1] = lats[i] + dlat\\n\\n lats += 90\\n\\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\\n # plt.plot(lats, NeA, \\\".\\\", markersize = 1)\\n # plt.plot([0, 0], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([30, 30], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([60, 60], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([120, 120],[0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([150, 150], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([167, 167], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([193, 193], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([210, 210], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([240, 244], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([300, 300], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([330, 330], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([360, 360], [0, np.max(NeA)], \\\"k\\\")\\n # plt.xticks(xticks)\\n # plt.xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n # plt.ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n # plt.title(\\\"One SWARM satellite period\\\")\\n # plt.grid(\\\"on\\\", axis = \\\"x\\\", xdata = gridticks)\\n #adding letters\\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\\n y = np.zeros_like(x) - np.max(NeA)/40\\n s = [\\\"S\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"C\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"S\\\"]\\n # for i in range(len(x)):\\n # plt.text(x[i], y[i], s[i], fontsize = 10)\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n # plt.show()\\n\\n # plt.plot(times, latA)\\n # plt.plot(times, mlt)\\n # plt.show()\\n print(lats[0])\\n print(lats[-1])\\n \\n fig, ax = plt.subplots()\\n ax.plot(lats, NeA, \\\".\\\", markersize = 1)\\n ax.set_xticks(xticks, minor=False)\\n ax.set_xticks([167, 193], minor=True)\\n ax.xaxis.grid(True, which = \\\"major\\\")\\n ax.xaxis.grid(True, which = \\\"minor\\\")\\n for i in range(len(x)):\\n ax.text(x[i], y[i], s[i], fontsize = 10)\\n ax.set_xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n ax.set_ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n ax.set_title(\\\"One Swarm satellite period\\\")\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n plt.show()\\n plt.plot(mlt, NeA)\\n plt.show()\\n plt.plot(mlt, lats)\\n plt.show()\",\n \"def plotCurrentTimeAnticipatory(s, ne,nc, gs):\\n fig, ax = plt.subplots()\\n ax.set_title('time: {0}'.format(s.time))\\n for c in range(nc):\\n carTemp = s.cars.getObject(c)\\n ax.scatter(carTemp.position[0], carTemp.position[1], c='k', alpha=0.5)\\n ax.scatter([], [], c='b', marker='*', label='Opened not commited')\\n ax.scatter([], [], c='b', label='Opened commited')\\n ax.scatter([], [], c='r', label='Canceled')\\n ax.scatter([], [], c='g', label='Closed')\\n for i in range(ne):\\n eventTemp = s.events.getObject(i)\\n if eventTemp.status == Status.OPENED_COMMITED:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', alpha=0.7)\\n elif eventTemp.status == Status.OPENED_NOT_COMMITED:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', marker='*', alpha=0.7)\\n elif (eventTemp.status == Status.CLOSED):\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='g', alpha=0.2)\\n elif (eventTemp.status == Status.CANCELED):\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='r', alpha=0.2)\\n else:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='y', alpha=0.2)\\n ax.set_xlim([-1, gs + 1])\\n ax.set_ylim([-1, gs + 1])\\n ax.grid(True)\\n plt.legend()\\n # Used to return the plot as an image rray\\n fig.canvas.draw() # draw the canvas, cache the renderer\\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\\n image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\\n return image\",\n \"def plotSnakingTimeline(\\n self, pklfile=\\\"./\\\", outspecfile=\\\"./\\\", PPoutpath=\\\"./\\\", folder=\\\"./\\\"\\n ):\\n DRM, outspec = self.loadFiles(pklfile, outspecfile)\\n\\n allModes = outspec[\\\"observingModes\\\"]\\n mode1 = [\\n mode\\n for mode in allModes\\n if \\\"detectionMode\\\" in mode.keys() or \\\"detection\\\" in mode.keys()\\n ]\\n assert len(mode1) >= 1, \\\"This needs to be enhanced\\\"\\n mode = mode1[0]\\n if not \\\"timeMultiplier\\\" in mode.keys():\\n mode[\\\"timeMultiplier\\\"] = 1.0\\n\\n LD = np.arange(len(DRM[\\\"DRM\\\"]))\\n arrival_times = [DRM[\\\"DRM\\\"][i][\\\"arrival_time\\\"].value for i in LD]\\n sumOHTIME = (\\n outspec[\\\"settlingTime\\\"]\\n + outspec[\\\"starlightSuppressionSystems\\\"][0][\\\"ohTime\\\"]\\n )\\n det_times = [\\n DRM[\\\"DRM\\\"][i][\\\"det_time\\\"].value * (mode[\\\"timeMultiplier\\\"]) + sumOHTIME\\n for i in LD\\n ]\\n det_timesROUNDED = [\\n round(\\n DRM[\\\"DRM\\\"][i][\\\"det_time\\\"].value * (mode[\\\"timeMultiplier\\\"]) + sumOHTIME,\\n 1,\\n )\\n for i in LD\\n ]\\n ObsNums = [DRM[\\\"DRM\\\"][i][\\\"ObsNum\\\"] for i in LD]\\n y_vals = np.zeros(len(det_times)).tolist()\\n char_times = [\\n DRM[\\\"DRM\\\"][i][\\\"char_time\\\"].value * (1.0 + outspec[\\\"charMargin\\\"])\\n + sumOHTIME * (DRM[\\\"DRM\\\"][i][\\\"char_time\\\"].value > 0.0)\\n for i in LD\\n ]\\n OBdurations = np.asarray(outspec[\\\"OBendTimes\\\"]) - np.asarray(\\n outspec[\\\"OBstartTimes\\\"]\\n )\\n\\n # print(sum(det_times))\\n # print(sum(char_times))\\n # This is just testing stuff for now\\n # from pylab import *\\n arr = [DRM[\\\"DRM\\\"][i][\\\"arrival_time\\\"].value for i in np.arange(len(DRM[\\\"DRM\\\"]))]\\n dt = [DRM[\\\"DRM\\\"][i][\\\"det_time\\\"].value + 1.0 for i in np.arange(len(DRM[\\\"DRM\\\"]))]\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n colors = [\\\"red\\\", \\\"blue\\\"]\\n for i in np.arange(len(arr)):\\n ax.barh(\\n 1.0,\\n dt[i],\\n align=\\\"center\\\",\\n left=arr[i],\\n color=colors[int(i) % len(colors)],\\n )\\n plt.show(block=False)\\n\\n # Check if plotting font #########################################################\\n tmpfig = plt.figure(figsize=(20, 5), num=0)\\n ax = tmpfig.add_subplot(111)\\n t = ax.text(\\n 0,\\n 0,\\n \\\"Obs# , d\\\",\\n ha=\\\"center\\\",\\n va=\\\"center\\\",\\n rotation=\\\"vertical\\\",\\n fontsize=8,\\n )\\n r = tmpfig.canvas.get_renderer()\\n bb = t.get_window_extent(renderer=r)\\n Obstxtwidth = bb.width # Width of text\\n Obstxtheight = bb.height # height of text\\n FIGwidth, FIGheight = tmpfig.get_size_inches() * tmpfig.dpi\\n # plt.show(block=False)\\n plt.close()\\n daysperpixelapprox = (\\n max(arrival_times) / FIGwidth\\n ) # approximate #days per pixel\\n if mean(det_times) * 0.8 / daysperpixelapprox > Obstxtwidth:\\n ObstextBool = True\\n else:\\n ObstextBool = False\\n\\n tmpfig = plt.figure(figsize=(25, 5), num=0)\\n ax = tmpfig.add_subplot(111)\\n t = ax.text(\\n 0,\\n 0,\\n \\\"OB# , dur.= d\\\",\\n ha=\\\"center\\\",\\n va=\\\"center\\\",\\n rotation=\\\"horizontal\\\",\\n fontsize=12,\\n )\\n r = tmpfig.canvas.get_renderer()\\n bb = t.get_window_extent(renderer=r)\\n OBtxtwidth = bb.width # Width of text\\n OBtxtheight = bb.height # height of text\\n FIGwidth, FIGheight = tmpfig.get_size_inches() * tmpfig.dpi\\n # plt.show(block=False)\\n plt.close()\\n if mean(OBdurations) * 0.8 / daysperpixelapprox > OBtxtwidth:\\n OBtextBool = True\\n else:\\n OBtextBool = False\\n #################################################################################\\n\\n ######################################################################\\n # Finds arrival times that occur within that year\\n ObsNumsL = list()\\n det_timesL = list()\\n char_timesL = list()\\n arrival_timesL = list()\\n truthArr = list()\\n for i in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\\n truthArr = (np.asarray(arrival_times) >= 365.25 * np.float(i)) * (\\n np.asarray(arrival_times) < 365.25 * np.float(i + 1.0)\\n )\\n arrival_timesL.append([arrival_times[ii] for ii in np.where(truthArr)[0]])\\n det_timesL.append([det_times[ii] for ii in np.where(truthArr)[0]])\\n char_timesL.append([char_times[ii] for ii in np.where(truthArr)[0]])\\n ObsNumsL.append([ObsNums[ii] for ii in np.where(truthArr)[0]])\\n #######################################################################\\n\\n #######################################################################\\n # Plotting\\n colors = \\\"rb\\\" #'rgbwmc'\\n patch_handles = []\\n fig = plt.figure(\\n figsize=(20, 3 + int(np.ceil(max(arrival_times) / 365.25)) / 2.0)\\n )\\n self.prettyPlot()\\n ax = fig.add_subplot(111)\\n\\n char_color = (0.0 / 255.0, 128 / 255.0, 0 / 255.0)\\n\\n # Plot individual blocks\\n # Plot All Detection Observations for Year\\n for iyr in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\\n ind = 0\\n obs = 0\\n for (det_time, l, char_time, arrival_times_yr) in zip(\\n det_timesL[iyr], ObsNumsL[iyr], char_timesL[iyr], arrival_timesL[iyr]\\n ):\\n # print det_time, l\\n patch_handles.append(\\n ax.barh(\\n int(np.ceil(max(arrival_times) / 365.25)) - iyr,\\n det_time,\\n align=\\\"center\\\",\\n left=arrival_times_yr - 365.25 * iyr,\\n color=colors[int(obs) % len(colors)],\\n )\\n )\\n if not char_time == 0.0:\\n ax.barh(\\n int(np.ceil(max(arrival_times) / 365.25)) - iyr,\\n char_time,\\n align=\\\"center\\\",\\n left=arrival_times_yr + det_time - 365.25 * iyr,\\n color=char_color,\\n )\\n ind += 1\\n obs += 1\\n patch = patch_handles[-1][0]\\n bl = patch.get_xy()\\n x = 0.5 * patch.get_width() + bl[0]\\n y = 0.5 * patch.get_height() + bl[1]\\n if ObstextBool:\\n ax.text(\\n x,\\n y,\\n \\\"Obs#%d, %dd\\\" % (l, det_time),\\n ha=\\\"center\\\",\\n va=\\\"center\\\",\\n rotation=\\\"vertical\\\",\\n fontsize=8,\\n )\\n\\n # Set Plot Xlimit so the end of the timeline is at the end of the figure box\\n ax.set_xlim([None, 365.25])\\n\\n # Plot Asthetics\\n y_pos = (\\n np.arange(int(np.ceil(max(arrival_times) / 365.25))) + 1\\n ) # Number of xticks to have\\n\\n yticklabels = list()\\n for i in np.arange(int(np.ceil(max(arrival_times) / 365.25))):\\n yticklabels.append(\\n str(int(np.ceil(max(arrival_times) / 365.25)) - i) + \\\"yr\\\"\\n )\\n ax.set_yticks(y_pos)\\n ax.set_yticklabels(yticklabels, fontsize=30)\\n # ax.set_yticklabels(('3yr','2yr','1yr'),fontsize=30)\\n ax.xaxis.set_tick_params(labelsize=30)\\n ax.set_xlabel(\\n \\\"Time Since Start of Mission Year (days)\\\", weight=\\\"bold\\\", fontsize=30\\n )\\n plt.title(\\n \\\"Mission Timeline for runName: \\\"\\n + folder.split(\\\"/\\\")[-1]\\n + \\\"\\\\nand pkl file: \\\"\\n + os.path.basename(pklfile).split(\\\".\\\")[0],\\n weight=\\\"bold\\\",\\n fontsize=12,\\n )\\n plt.tight_layout()\\n plt.show(block=False)\\n\\n DT = datetime.datetime\\n date = str(DT.now()) # ,\\\"utf-8\\\")\\n date = \\\"\\\".join(\\n c + \\\"_\\\" for c in re.split(\\\"-|:| \\\", date)[0:-1]\\n ) # Removes seconds from date\\n fname = \\\"TimelineSnake_\\\" + folder.split(\\\"/\\\")[-1] + \\\"_\\\" + date\\n plt.savefig(os.path.join(PPoutpath, fname + \\\".png\\\"))\\n plt.savefig(os.path.join(PPoutpath, fname + \\\".svg\\\"))\\n plt.savefig(os.path.join(PPoutpath, fname + \\\".eps\\\"))\\n plt.savefig(os.path.join(PPoutpath, fname + \\\".pdf\\\"))\",\n \"def plot_tempogram_and_pulse(tempogram, pulse, oenv, sr_, hop_length, plot_pulse=True):\\n tempogram = tempogram.numpy()\\n librosa.display.specshow(np.abs(tempogram), sr=sr_, hop_length=hop_length,\\n x_axis='time', y_axis='fourier_tempo', cmap='magma')\\n plt.show()\\n peaks = find_local_maxima(tf.clip_by_value(pulse, clip_value_min=0.1,\\n clip_value_max=1.))[1:]\\n if plot_pulse:\\n oenv = oenv.numpy()\\n pulse = pulse.numpy()\\n plt.plot(oenv, color=\\\"black\\\")\\n plt.plot(pulse, color=\\\"blue\\\")\\n plt.plot(peaks, pulse[peaks.numpy()], \\\"ro\\\")\\n plt.show()\",\n \"def test3():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\tp_dict = {'Bfield':500,'rb85frac':1,'Btheta':87*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':100,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def plot_timestep(self, survey, rot_deg=0, markersize=5):\\n xyz = self._rotate_xy(np.loadtxt(self.xyzpaths[survey]), rot_deg)\\n\\n plt.clf()\\n fig1 = plt.figure(1)\\n ax = fig1.add_subplot(111)\\n\\n sc = ax.scatter(xyz[:,0], xyz[:,1], c = xyz[:,2],\\n marker = 'o',\\n s = markersize, lw = 0,\\n cmap = 'viridis')\\n\\n fig1.colorbar(sc)\\n ax.axis('equal')\\n ax.set_title('Raw data for survey {0}'.format(survey))\\n ax.set_xlabel('X coordinate')\\n ax.set_ylabel('Y coordinate')\\n plt.show()\\n return ax\",\n \"def plot_time_slices(self):\\n U = self.r.u[:, 15:-15, :]\\n T = range(U.shape[2])\\n kwarglist = [dict(t=t,\\n index=self.index,\\n U=U,\\n levels=self.levels,\\n fname=self.time_slice_path(t))\\n for t in T]\\n util.parallel_process(plot_time_slice, kwarglist=kwarglist)\",\n \"def PlotWakeModel(x_table, y_table, z_table, wake_speeds, params):\\n axes = pyplot.figure().add_subplot(1, 1, 1, projection='3d')\\n\\n # To display the wing in the hovering orientation, the axes are\\n # rotated such that the x and z axes are flipped and the y axis is\\n # inverted.\\n\\n # Plot slices of the wake speeds at each point in x_table.\\n ys, zs = np.meshgrid(y_table, z_table, indexing='ij')\\n for i in range(len(x_table)):\\n axes.contourf(zs, -ys, np.squeeze(wake_speeds[i, :, :]), 20,\\n zdir='z', offset=x_table[i], alpha=0.2, cmap=pyplot.cm.jet)\\n\\n # Plot rotor disks.\\n for rotor in params['rotors']:\\n rotor_disk = matplotlib.patches.Circle(\\n (rotor['pos'][2], -rotor['pos'][1]), rotor['radius'], alpha=0.3,\\n color='k')\\n axes.add_patch(rotor_disk)\\n mplot3d.art3d.pathpatch_2d_to_3d(rotor_disk, z=rotor['pos'][0], zdir='z')\\n\\n # Plot panels.\\n for panel in params['panels']:\\n vertices_s = np.array([\\n [panel['chord'] * 0.25, panel['span'] / 2.0, 0.0],\\n [panel['chord'] * 0.25, -panel['span'] / 2.0, 0.0],\\n [-panel['chord'] * 0.75, -panel['span'] / 2.0, 0.0],\\n [-panel['chord'] * 0.75, panel['span'] / 2.0, 0.0]\\n ])\\n vertices_b = np.dot(panel['dcm_b2s'].T, vertices_s.T).T + panel['pos_b']\\n vertices = np.dot([[0.0, 0.0, 1.0], [0.0, 1.0, 0.0], [1.0, 0.0, 0.0]],\\n vertices_b.T).T\\n rect = mplot3d.art3d.Poly3DCollection([vertices])\\n rect.set_color('k')\\n rect.set_alpha(0.3)\\n axes.add_collection3d(rect)\\n\\n # Set axes properties.\\n axes.set_xlabel('z')\\n axes.set_ylabel('y')\\n axes.set_zlabel('x')\\n axes.set_xlim((-5.0, 5.0))\\n axes.set_ylim((-15.0, 15.0))\\n axes.set_zlim((-10.0, 2.0))\\n axes.invert_yaxis()\",\n \"def figure_2():\\n from matplotlib.animation import FuncAnimation\\n from collections import OrderedDict\\n\\n plt.rc(\\\"font\\\", **{\\n \\\"family\\\": \\\"sans-serif\\\",\\n \\\"sans-serif\\\": [\\\"Helvetica\\\"],\\n })\\n plt.rc(\\\"text\\\", usetex=True)\\n plt.rc(\\\"lines\\\", linewidth=1)\\n plt.rc(\\\"axes\\\", grid=True)\\n plt.rc(\\\"grid\\\", linestyle=\\\"--\\\", alpha=0.8)\\n\\n exp_list = os.listdir(BASE_DATA_DIR)\\n exp_list.remove(\\\"tmp\\\")\\n exp_list.remove(\\\"mrac-nullagent\\\")\\n\\n data = {exp: get_data(exp) for exp in exp_list}\\n\\n fig, ax = plt.subplots(figsize=[16, 9])\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n linekw = dict(linewidth=1, alpha=0.3)\\n\\n def make_line(label, *args):\\n ln, = plt.plot([], [], label=label, *args, **linekw)\\n return ln\\n\\n time_list = [data[exp][\\\"time\\\"] for exp in exp_list]\\n time = time_list[np.argmin(list(map(len, time_list)))]\\n lines = [\\n (\\n make_line(\\\"Command\\\", \\\"k--\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"cmd\\\"]\\n ),\\n (\\n make_line(r\\\"$x_{r,1}$\\\", \\\"k\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"reference_system\\\"][:, 0]\\n ),\\n (\\n make_line(r\\\"$x_{r,2}$\\\", \\\"k\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"reference_system\\\"][:, 1]\\n ),\\n (\\n make_line(r\\\"FE-CMRAC $x_{1}$\\\", \\\"r-.\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(r\\\"FE-CMRAC $x_{2}$\\\", \\\"r-.\\\"),\\n data[\\\"fecmrac-nullagent\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n (\\n make_line(r\\\"RL-CMRAC $x_{1}$\\\", \\\"b-.\\\"),\\n data[\\\"rlcmrac-sac\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(r\\\"RL-CMRAC $x_{2}$\\\", \\\"b-.\\\"),\\n data[\\\"rlcmrac-sac\\\"][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n ]\\n\\n dist_lines = {\\n \\\"rlcmrac-sac\\\": plt.vlines(\\n [], [], [],\\n colors=FORMATTING[\\\"rlcmrac-sac\\\"][\\\"color\\\"],\\n alpha=1,\\n label=\\\"RL-CMRAC\\\",\\n ),\\n \\\"fecmrac-nullagent\\\": plt.vlines(\\n [], [], [],\\n colors=FORMATTING[\\\"fecmrac-nullagent\\\"][\\\"color\\\"],\\n alpha=1,\\n label=\\\"FE-CMRAC\\\",\\n ),\\n }\\n memory_time_diff = np.diff(data[\\\"fecmrac-nullagent\\\"][\\\"memory\\\"][\\\"time\\\"])\\n\\n plt.legend(handles=dist_lines.values())\\n\\n def to_segments(xs, ys):\\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\\n\\n def init():\\n states = np.hstack([\\n data[exp][\\\"state\\\"][\\\"main_system\\\"].ravel() for exp in exp_list\\n ])\\n ylim_max = states.max()\\n ylim_min = states.min()\\n ylim_btw = 1.2 * (ylim_max - ylim_min)\\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\\n\\n ax.set_xlim(0, time[-1])\\n ax.set_ylim(ylim_min, ylim_max)\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n def update(frame):\\n for line, line_data in lines:\\n line.set_data(time[:frame], line_data[:frame])\\n\\n # Update FE-CMRAC\\n if frame > 0 and memory_time_diff[frame-1] != 0:\\n ta_idx = np.argmax(\\n time > data[\\\"fecmrac-nullagent\\\"][\\\"memory\\\"][\\\"time\\\"][frame]\\n )\\n dist_time = time[:ta_idx]\\n dist_k = data[\\\"fecmrac-nullagent\\\"][\\\"k\\\"][:ta_idx]\\n dist = [\\n -np.exp(-np.trapz(dist_k[i:], dist_time[i:]))\\n for i in range(len(dist_time))\\n ]\\n segments = to_segments(dist_time, dist)\\n dist_lines[\\\"fecmrac-nullagent\\\"].set_segments(segments)\\n\\n # Update RL-CMRAC\\n dist_time = data[\\\"rlcmrac-sac\\\"][\\\"memory\\\"][\\\"t\\\"][frame]\\n dist = 100 * data[\\\"rlcmrac-sac\\\"][\\\"dist\\\"][frame]\\n segments = to_segments(dist_time, dist)\\n dist_lines[\\\"rlcmrac-sac\\\"].set_segments(segments)\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n anim = FuncAnimation(\\n fig, update, init_func=init,\\n frames=range(0, len(time), 10), interval=10\\n )\\n # plt.show()\\n anim.save(os.path.join(args.save_dir, \\\"dist-movie.mp4\\\"))\",\n \"def makePlot(timeStamp):\\n\\n #-------------------------------------------------------------------------\\n # Create figure and axes\\n #-------------------------------------------------------------------------\\n\\n width = 12 # inches\\n height = 8 # inches\\n fig = plt.figure(figsize=(width, height))\\n\\n # We'll use gridspec to create axes in rectangular 6-by-5 lattice\\n import matplotlib.gridspec as gridspec\\n nrows = 6\\n ncols = 5\\n Grid = gridspec.GridSpec(nrows, ncols)\\n\\n # axis for elevation time series\\n axElev = fig.add_subplot(Grid[:2, :2]) # first 2 rows, first 2 columns\\n # axis for slab\\n axSlab = fig.add_subplot(Grid[:2, 2:]) # first 2 rows, columns > 2\\n # and the transects\\n axTran1 = fig.add_subplot(Grid[2:4, :]) # rows 2,3,4, all columns\\n # rows 5,6,7, all columns, share x/y axis with previous (sets same ticks\\n # etc)\\n axTran2 = fig.add_subplot(Grid[4:6, :], sharex=axTran1, sharey=axTran1)\\n\\n # gridspec allows to tune the spacing between plots (unit is fraction of\\n # font size)\\n boundary_pad = 3.5\\n horizontal_pad = 0.2\\n vertical_pad = 1.0\\n # figure area left,bottom,right,top in normalized coordinates [0,1]\\n bounds = [0, 0, 1, 1]\\n Grid.tight_layout(\\n fig,\\n pad=boundary_pad,\\n w_pad=horizontal_pad,\\n h_pad=vertical_pad,\\n rect=bounds)\\n\\n #-------------------------------------------------------------------------\\n # Create plots\\n #-------------------------------------------------------------------------\\n\\n # for all avaiable colormaps see ( '_r' reverses the colormap )\\n # http://matplotlib.org/examples/color/colormaps_reference.html\\n colormap = plt.get_cmap('Spectral_r')\\n colormap_kine = plt.get_cmap('gist_heat')\\n\\n # slab\\n salt_clim = [0, 32]\\n ncontours = 16\\n # bouding box for slab [xmin,xmax,ymin,ymax] in model x,y coordinates\\n estuarybbox = [330000, 360000, 284500, 297500]\\n dia = slabSnapshotDC(\\n clabel='Salinity',\\n unit='psu',\\n clim=salt_clim,\\n cmap=colormap)\\n dia.setAxes(axSlab)\\n dia.addSample(slabDC, timeStamp=timeStamp, plotType='contourf',\\n bbox=estuarybbox, N=ncontours)\\n # overrides default format for colorbar floats\\n dia.showColorBar(format='%.2g')\\n #dia.addTitle('in case you want a custom title')\\n # get transect (x,y) coordinates from the transectDC\\n transectXYCoords = generateTransectFromDataContainer(transectDC_salt, 0)[4]\\n # plot transect on the map (thin black on thick white)\\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\\n color='w', linewidth=2.0)\\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\\n color='k', linewidth=1.0)\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(\\n staX,\\n staY,\\n label=station,\\n printLabel=True,\\n marker='*')\\n # add text to plot. x,y are in normalized axis coordinates [0,1]\\n dia.ax.text(0.05, 0.98, 'custom text', fontsize=fontsize,\\n verticalalignment='top', horizontalalignment='left',\\n transform=dia.ax.transAxes)\\n\\n # elevation time series\\n # define the time range to plot\\n elevStartTime = datetime.datetime(2012, 5, 4, 0, 0)\\n elevEndTime = datetime.datetime(2012, 5, 5, 0, 15)\\n elevMeanTime = elevStartTime + (elevEndTime - elevStartTime) / 2\\n elevLim = [-1.5, 2.5]\\n dia = timeSeriesPlotDC2(\\n xlabel=elevMeanTime.strftime('%Y %b %d'),\\n ylim=elevLim)\\n dia.setAxes(axElev)\\n #dia.addShadedRange( timeStamp, timeStamp+datetime.timedelta(seconds=30), facecolor='IndianRed')\\n dia.addShadedRange(\\n timeStamp,\\n timeStamp,\\n edgecolor='IndianRed',\\n facecolor='none',\\n linewidth=2)\\n tag = elevDC.getMetaData('tag')\\n dia.addSample(\\n elevDC.timeWindow(\\n elevStartTime,\\n elevEndTime),\\n label=tag,\\n color='k')\\n dia.addTitle('Elevation ({0:s}) [m]'.format(\\n elevDC.getMetaData('location').upper()))\\n # adjust the number of ticks in x/y axis\\n dia.updateXAxis(maxticks=5)\\n dia.updateYAxis(maxticks=3, prune='lower')\\n\\n # transects\\n dia = transectSnapshotDC(\\n clabel='Salinity',\\n unit='psu',\\n cmap=colormap,\\n clim=salt_clim)\\n dia.setAxes(axTran1)\\n #transectDC_salt.data *= 1e-3\\n dia.addSample(transectDC_salt, timeStamp, N=ncontours)\\n dia.addTitle('')\\n dia.showColorBar()\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(staX, staY, label=station, color='k',\\n linewidth=1.5, linestyle='dashed')\\n # do not show x axis ticks and label for this plot\\n dia.hideXTicks()\\n\\n dia = transectSnapshotDC(clabel='TKE', unit='m2s-1', logScale=True,\\n clim=[-7, -2], climIsLog=True, cmap=colormap_kine)\\n dia.setAxes(axTran2)\\n dia.addSample(transectDC_kine, timeStamp, N=ncontours)\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(staX, staY, label=station, color='k',\\n linewidth=1.5, linestyle='dashed')\\n dia.addTitle('')\\n dia.showColorBar()\\n dia.updateXAxis(maxticks=15)\\n dia.updateYAxis(maxticks=6)\\n\\n #-------------------------------------------------------------------------\\n # Save to disk\\n #-------------------------------------------------------------------------\\n dateStr = timeStamp.strftime('%Y-%m-%d_%H-%M')\\n filename = '_'.join([imgPrefix, dateStr])\\n saveFigure(\\n imgDir,\\n filename,\\n imgFiletype,\\n verbose=True,\\n dpi=200,\\n bbox_tight=True)\\n plt.close()\",\n \"def figure3():\\n\\n plot_settings = {'y_limits': [-75, -50],\\n 'x_limits': None,\\n 'y_ticks': [-75, -70, -65, -60, -55, -50],\\n 'locator_size': 2.5,\\n 'y_label': 'Voltage (mV)',\\n 'x_ticks': [],\\n 'scale_size': 2,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 3,\\n 'figure_name': 'figure_3',\\n 'legend': ['0.1 $\\\\mu$S', '0.125 $\\\\mu$S', '0.15 $\\\\mu$S'],\\n 'legend_size': 8,\\n 'legend_location': 4,\\n 'y_on': True}\\n line_styles = ['-', 'dotted', '-.']\\n\\n plt.figure(figsize=(5, 3))\\n plt.subplot(1, 2, 1) # Generate subplot 1 (left)\\n for ix, g_t_bar in enumerate([0.1, 0.125, 0.15]):\\n t, y = solver(6, g_t_bar=g_t_bar, t_start=0.5)\\n plt.plot(t, y[:, 0], c='k', linestyle=line_styles[ix])\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(1, 2, 2) # Generate subplot 2 (right)\\n for ix, i_bias_on in enumerate([0, -0.1, -0.2]):\\n \\\"\\\"\\\"\\n First step (hyperpolarizing)\\n \\\"\\\"\\\"\\n t1 = 1000\\n duration = t1\\n\\n t, y_hold = solver(t1, duration=duration, i_bias_on=i_bias_on)\\n y_0 = y_hold[-1, :] # Create new initial conditions\\n\\n \\\"\\\"\\\"\\n Second step (current pulse)\\n \\\"\\\"\\\"\\n t1 = 20\\n t, y = solver(t1, t_start=0, y_hold=y_0)\\n v = y[:, 0]\\n\\n \\\"\\\"\\\"\\n Append the end of the first step onto the second step (for plotting purposes)\\n \\\"\\\"\\\"\\n len_pre = 100\\n t = np.concatenate((np.linspace(-len_pre * np.diff(t)[0], -np.diff(t)[0], len_pre), t))\\n v_bar = np.concatenate((y_hold[-len_pre:, 0], v))\\n v_bar = v_bar - v_bar[0] + -7.16300325e+01 # Align solution to initial condition of the \\\"standard simulation\\\"\\n\\n plt.plot(t, v_bar, c='k', linestyle=line_styles[ix])\\n\\n plot_settings['y_ticks'] = []\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['x_limits'] = [-1, 20]\\n plot_settings['legend'] = ['-72 mV', '-75 mV', '-78 mV']\\n plot_settings['scale_size'] = 5\\n plot_settings['legend_location'] = 1\\n alter_figure(plot_settings, close=True)\",\n \"def figure_3():\\n from matplotlib.animation import FuncAnimation\\n from collections import OrderedDict\\n\\n plt.rc(\\\"font\\\", **{\\n \\\"family\\\": \\\"sans-serif\\\",\\n \\\"sans-serif\\\": [\\\"Helvetica\\\"],\\n })\\n plt.rc(\\\"text\\\", usetex=True)\\n plt.rc(\\\"lines\\\", linewidth=1)\\n plt.rc(\\\"axes\\\", grid=True)\\n plt.rc(\\\"grid\\\", linestyle=\\\"--\\\", alpha=0.8)\\n\\n exp1 = \\\"rlcmrac-sac\\\"\\n exp2 = \\\"clcmrac-nullagent\\\"\\n exp_list = [exp1, exp2]\\n\\n data = {exp: get_data(exp) for exp in exp_list}\\n\\n fig, ax = plt.subplots(figsize=[16, 9])\\n plt.xlabel(\\\"Time, sec\\\")\\n\\n linekw = dict(linewidth=1, alpha=0.3)\\n\\n def make_line(label, *args):\\n ln, = plt.plot([], [], label=label, *args, **linekw)\\n return ln\\n\\n time_list = [data[exp][\\\"time\\\"] for exp in exp_list]\\n time = time_list[np.argmin(list(map(len, time_list)))]\\n\\n sample_data = list(data.values())[0]\\n lines = [\\n (\\n make_line(\\\"Command\\\", \\\"k--\\\"),\\n sample_data[\\\"cmd\\\"]\\n ),\\n (\\n make_line(r\\\"$x_{r,1}$\\\", \\\"k\\\"),\\n sample_data[\\\"state\\\"][\\\"reference_system\\\"][:, 0]\\n ),\\n (\\n make_line(r\\\"$x_{r,2}$\\\", \\\"k\\\"),\\n sample_data[\\\"state\\\"][\\\"reference_system\\\"][:, 1]\\n ),\\n (\\n make_line(FORMATTING[exp2][\\\"label\\\"] + r\\\" $x_{1}\\\", \\\"r-.\\\"),\\n data[exp2][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(FORMATTING[exp2][\\\"label\\\"] + r\\\" $x_{2}\\\", \\\"r-.\\\"),\\n data[exp2][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n (\\n make_line(FORMATTING[exp1][\\\"label\\\"] + r\\\" $x_{1}\\\", \\\"b-.\\\"),\\n data[exp1][\\\"state\\\"][\\\"main_system\\\"][:, 0],\\n ),\\n (\\n make_line(FORMATTING[exp1][\\\"label\\\"] + r\\\" $x_{2}\\\", \\\"b-.\\\"),\\n data[exp1][\\\"state\\\"][\\\"main_system\\\"][:, 1],\\n ),\\n ]\\n\\n dist_lines = {\\n k: plt.vlines(\\n [], [], [],\\n colors=FORMATTING[k][\\\"color\\\"],\\n alpha=1,\\n label=FORMATTING[k][\\\"label\\\"],\\n )\\n for k in exp_list\\n }\\n\\n plt.legend(handles=dist_lines.values())\\n\\n def to_segments(xs, ys):\\n return [[[x, 0], [x, y]] for x, y in zip(xs, ys)]\\n\\n def init():\\n states = np.hstack([\\n data[exp][\\\"state\\\"][\\\"main_system\\\"].ravel() for exp in exp_list\\n ])\\n ylim_max = states.max()\\n ylim_min = states.min()\\n ylim_btw = 1.2 * (ylim_max - ylim_min)\\n ylim_max, ylim_min = ylim_min + ylim_btw, ylim_max - ylim_btw\\n\\n ax.set_xlim(0, time[-1])\\n ax.set_ylim(ylim_min, ylim_max)\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n def update(frame):\\n for line, line_data in lines:\\n line.set_data(time[:frame], line_data[:frame])\\n\\n # Update\\n for i, exp in enumerate(exp_list):\\n dist_time = data[exp][\\\"memory\\\"][\\\"t\\\"][frame]\\n if i == 0:\\n dist = 100 * data[exp][\\\"dist\\\"][frame]\\n else:\\n dist = [-1] * len(dist_time)\\n\\n segments = to_segments(dist_time, dist)\\n dist_lines[exp].set_segments(segments)\\n\\n return [line for line, _ in lines] + list(dist_lines.values())\\n\\n anim = FuncAnimation(\\n fig, update, init_func=init,\\n frames=range(0, len(time), 10), interval=10\\n )\\n # plt.show()\\n anim.save(os.path.join(args.save_dir, \\\"dist-movie.mp4\\\"))\",\n \"def plot_data(heart_filt, pace_filt):\\n\\n plt.figure(1)\\n plt.plot(heart_filt, pace_filt)\\n plt.show()\",\n \"def figure8():\\n\\n plot_settings = {'y_limits': [15, 60],\\n 'x_limits': None,\\n 'y_ticks': [20, 30, 40, 50, 60],\\n 'locator_size': 5,\\n 'y_label': 'ISI (ms)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_8',\\n 'legend': ['First ISI', 'Second ISI'],\\n 'legend_size': 8,\\n 'y_on': True,\\n 'legend_location': 4}\\n\\n g_t_bars = np.linspace(0.02, 0.2, 10)\\n isi = np.zeros((len(g_t_bars), 2))\\n\\n for ix, g_t_bar in enumerate(g_t_bars):\\n t, y = solver(200, t_start=15, duration=260, g_t_bar=g_t_bar)\\n t_spike, f = spike_times(t, y[:, 0])\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_t_bars[3], 35, 0, 11, head_width=0, head_length=0, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[3], 46, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[3], 35, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Acceleration\\\", (0.1, 35), fontsize=8)\\n plt.gca().annotate(\\\"Adaptation\\\", (0.01, 46), fontsize=8)\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n g_n_bars = np.linspace(0.02, 0.2, 10)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_n_bar in enumerate(g_n_bars):\\n t, y = solver(200, g_n_bar=g_n_bar, duration=260, t_start=15, g_t_bar=0.02)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_n_bars[3], 30, 0, 10, head_width=0, head_length=0, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[3], 40, -0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[3], 30, 0.01, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Acceleration\\\", (0.1, 30), fontsize=8)\\n plt.gca().annotate(\\\"Adaptation\\\", (0.015, 40), fontsize=8)\\n plot_settings['y_ticks'] = []\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['y_on'] = False\\n plot_settings['legend_location'] = 4\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n g_t_bars = np.linspace(0.02, 0.16, 8)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_t_bar in enumerate(g_t_bars):\\n t, y = solver(200, g_t_bar=g_t_bar, duration=260, t_start=15, ca_type=1)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_t_bars[2], 25, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_t_bars[4], 25, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Adaptation\\\", (0.06, 25), fontsize=8)\\n\\n plot_settings['y_limits'] = [0, 45]\\n plot_settings['y_ticks'] = [0, 10, 20, 30, 40]\\n plot_settings['locator_size'] = 5\\n plot_settings['y_label'] = 'ISI (ms)'\\n plot_settings['y_on'] = True\\n plot_settings['legend_location'] = 3\\n alter_figure(plot_settings)\\n\\n plt.subplot(2, 2, 4)\\n g_n_bars = np.linspace(0.02, 0.16, 8)\\n isi = np.zeros((len(g_t_bars), 2))\\n for ix, g_n_bar in enumerate(g_n_bars):\\n t, y = solver(200, duration=260, t_start=15, g_n_bar=g_n_bar, g_t_bar=0.02, ca_type=2)\\n t_spike, f = spike_times(t, y[:, 0])\\n\\n isi[ix, 0] = t_spike[1] - t_spike[0]\\n isi[ix, 1] = t_spike[2] - t_spike[1]\\n plt.plot(g_t_bars, isi[:, 0], c='k', marker='o', fillstyle='none', linestyle='-')\\n plt.plot(g_t_bars, isi[:, 1], c='k', marker='s', fillstyle='none', linestyle='dotted')\\n\\n \\\"\\\"\\\"\\n Annotate plot\\n \\\"\\\"\\\"\\n plt.gca().arrow(g_n_bars[2], 20, -0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().arrow(g_n_bars[4], 20, 0.02, 0, head_width=2, head_length=0.01, fc='k', ec='k')\\n plt.gca().annotate(\\\"Adaptation\\\", (0.06, 20), fontsize=8)\\n\\n plot_settings['y_ticks'] = []\\n plot_settings['y_label'] = ''\\n plot_settings['y_on'] = False\\n plot_settings['legend_location'] = 2\\n alter_figure(plot_settings, close=True)\",\n \"def PlotTimes(metadata, data):\\n\\n gp = Gnuplot.Gnuplot(persist=1)\\n gp('set data style impulses')\\n gp('set xtics 1')\\n gp.clear()\\n gp.xlabel('seconds')\\n gp.ylabel('duration in second')\\n gp.title(metadata.AsTitle())\\n styles = {}\\n line_style = 1\\n\\n for dataset in data:\\n x = numpy.array(dataset.time, dtype='float_')\\n if not dataset.name in styles:\\n styles[dataset.name] = line_style\\n line_style += 1\\n d = Gnuplot.Data(x, dataset.data,\\n title=dataset.name,\\n with_='impulses ls %d' % styles[dataset.name])\\n else: # no need to repeat a title that exists already.\\n d = Gnuplot.Data(x, dataset.data,\\n with_='impulses ls %d' % styles[dataset.name])\\n\\n gp.replot(d)\\n gp.hardcopy('/tmp/%s-%s-%f.png' %\\n (metadata.name, metadata.kernel, metadata.duration),\\n terminal='png')\",\n \"def plot_time_frames(self):\\n\\n fig = plt.figure()\\n plt.grid(True)\\n\\n plt.ylim([-1.5,1.5])\\n plt.xlim([0,1])\\n\\n for key in self.timeframes.keys():\\n if key == 0:\\n plt.plot(self.x, self.timeframes[key], label=\\\"time: \\\" + str(round(key*self.dt, 3)), linewidth=5)\\n else:\\n plt.plot(self.x, self.timeframes[key], label=\\\"time: \\\" + str(round(key*self.dt, 3)))\\n\\n plt.title(\\\"Wave at different times\\\")\\n plt.legend(loc=\\\"upper right\\\")\\n plt.show()\\n\\n # fig.savefig('results/pics_wave/vibrating_string_'+ self.type + '.png', dpi=150)\",\n \"def plot_fig44a_wlc_inhomo_test7():\\n\\n fig, ax = plt.subplots(figsize=(default_width, default_height))\\n #paramters from calculation, all in nm\\n a = 5 #looping radius\\n DEL = 15.3 #spacing between nucleosomes\\n MINUS1NUC = -83.3 #distance between -1 nuc and TSS\\n PLUS1NUC = 0\\n NNUC = 50 #number of nucleosomes on each side of TSS\\n LPB = 0.34 #nm per basepair (as used in calculation)\\n\\n Llinks = np.concatenate(([245], np.tile(45, 49)))\\n Rlinks = np.tile(45, 49)\\n #plot as negative distance from TSS in bp\\n unwrap=0\\n ldna_Llinks = -1*convert.genomic_length_from_links_unwraps(Llinks, unwraps=unwrap)\\n ldna_Rlinks = convert.genomic_length_from_links_unwraps(Rlinks, unwraps=unwrap)\\n x = np.concatenate((ldna_Llinks[::-1], [0], ldna_Rlinks))\\n y = np.loadtxt('csvs/Sarah/pnucsite_test7.txt')\\n ax.plot(x, y, '-o', markersize=3, color=teal_flucts)\\n plt.xlabel(r'Distance from TSS (bp)')\\n plt.ylabel(r'$P_\\\\mathrm{loop}(a=5\\\\mathrm{nm}; L)\\\\;\\\\;\\\\;(\\\\mathrm{nm}^{-3})$')\\n plt.subplots_adjust(left=0.16, bottom=0.19, top=0.98, right=0.96)\\n plt.yscale('log')\\n #plt.ylim([10**-3, 10**-0.4])\\n plt.xlim([-10000, 10000])\\n plt.savefig(f'plots/thesis/fig44a_wlc-inhomo-looping.pdf', bbox_inches='tight')\",\n \"def plot_tariff(self):\\n\\t\\tplt.figure(1)\\n\\t\\tplt.cla() # clear the plotting window to allow for re-plotting\\n\\n\\t\\tif self.chargetypetoplot.get() == 'energy':\\n\\t\\t\\ttoplot = []\\n\\t\\t\\tenergy_filter = ('energy' == self.data[\\\"Charge\\\"]) | ('Energy' == self.data[\\\"Charge\\\"])\\n\\t\\t\\tfor mo in range(1, 13):\\n\\t\\t\\t\\tmonth_filter = (mo >= self.data[\\\"Start Month\\\"]) & (mo <= self.data[\\\"End Month\\\"])\\n\\t\\t\\t\\ttemp = self.data.loc[(energy_filter & month_filter), :]\\n\\t\\t\\t\\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \\\"Value\\\"])\\n\\t\\t\\t\\t\\t\\t\\t for hr in range(1, 25)])\\n\\t\\t\\tim = plt.imshow(toplot, interpolation='nearest')\\n\\t\\t\\tplt.xticks(ticks=[i-.5 for i in range(25)],\\n\\t\\t\\t\\t\\t labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)], rotation=45)\\n\\t\\t\\tplt.yticks(ticks=[i-0.5 for i in range(13)],\\n\\t\\t\\t\\t\\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul',\\n\\t\\t\\t\\t\\t\\t\\t 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''], va='top')\\n\\n\\t\\t\\t# get the colors of the values, according to the\\n\\t\\t\\t# colormap used by imshow\\n\\t\\t\\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\\n\\t\\t\\tcolors = [im.cmap(im.norm(value)) for value in values]\\n\\t\\t\\t# create a patch (proxy artist) for every color\\n\\t\\t\\tpatches = [mpatches.Patch(color=colors[i], label=\\\"${:1.5}/kWh\\\".format(values[i]))\\n\\t\\t\\t\\t\\t for i in range(len(values))]\\n\\t\\t\\t# put those patched as legend-handles into the legend\\n\\t\\t\\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\\\"upper right\\\", borderaxespad=0.)\\n\\t\\t\\tplt.title('Energy Price Heatmap')\\n\\t\\telse:\\n\\t\\t\\ttoplot = []\\n\\t\\t\\tdemand_filter = ('demand' == self.data[\\\"Charge\\\"]) | ('Demand' == self.data[\\\"Charge\\\"])\\n\\t\\t\\tfor mo in range(1, 13):\\n\\t\\t\\t\\tmonth_filter = (mo >= self.data[\\\"Start Month\\\"]) & (mo <= self.data[\\\"End Month\\\"])\\n\\t\\t\\t\\ttemp = self.data.loc[(demand_filter & month_filter), :]\\n\\t\\t\\t\\ttoplot.append([sum(temp.loc[(hr >= temp['Start Time']) & (hr <= temp['End Time']), \\\"Value\\\"]) for hr in\\n\\t\\t\\t\\t\\t\\t\\t range(1, 25)])\\n\\t\\t\\tim = plt.imshow(toplot, interpolation='nearest')\\n\\t\\t\\tplt.xticks(ticks=[i - .5 for i in range(25)], labels=['{}:00'.format(str(j).zfill(2)) for j in range(25)],\\n\\t\\t\\t\\t\\t rotation=45)\\n\\t\\t\\tplt.yticks(ticks=[i - 0.5 for i in range(13)],\\n\\t\\t\\t\\t\\t labels=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', ''],\\n\\t\\t\\t\\t\\t va='top')\\n\\n\\t\\t\\t# get the colors of the values, according to the\\n\\t\\t\\t# colormap used by imshow\\n\\t\\t\\tvalues = np.unique([toplot[i][j] for i in range(12) for j in range(24)])\\n\\t\\t\\tcolors = [im.cmap(im.norm(value)) for value in values]\\n\\t\\t\\t# create a patch (proxy artist) for every color\\n\\t\\t\\tpatches = [mpatches.Patch(color=colors[i], label=\\\"${:1.5}/kW\\\".format(values[i])) for i in\\n\\t\\t\\t\\t\\t range(len(values))]\\n\\t\\t\\t# put those patched as legend-handles into the legend\\n\\t\\t\\tplt.legend(handles=patches, bbox_to_anchor=(1.05, 1), loc=\\\"upper right\\\", borderaxespad=0.)\\n\\t\\t\\tplt.title('Demand Price Heatmap')\\n\\n\\t\\tself.chart_type.draw()\\n\\n\\t\\treturn 0\",\n \"def showPlot1():\\n\\n interested_in = list(range(5,30,5))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(1, 1.0, item, item, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on room size')\\n xlabel('area of the room (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def tracer_movie(datadir = 'data/', tracerFile = 'tracers.dat',\\n fixedFile = 'fixed_points.dat', zlim = [],\\n head_size = 3, hm = 1,\\n imageDir = './', movieFile = 'fixed_points.mpg',\\n fps = 5.0, bitrate = 1800):\\n \\n import pylab as plt\\n\\n # read the mapping and the fixed point positions\\n tracers, mapping, t = pc.read_tracers(datadir = datadir, fileName = tracerFile, zlim = zlim, head_size = head_size)\\n fixed = pc.read_fixed_points(datadir = datadir, fileName = fixedFile, hm = hm)\\n\\n # read the parameters for the domain boundaries\\n params = pc.read_param(quiet = True)\\n domain = [params.xyz0[0], params.xyz1[0], params.xyz0[1], params.xyz1[1]]\\n\\n # determine the how much faster the fixed pints have been written out than the color mapping\\n advance = np.ceil(float(len(fixed.t))/len(mapping[0,0,:,0]))\\n\\n # determine the colors for the fixed points\\n colors = np.zeros(np.shape(fixed.q) + (3,))\\n colors[:,:,:] = 0.\\n print(np.shape(colors))\\n for j in range(len(colors[:,0,0])):\\n for k in range(len(colors[0,:,0])):\\n if fixed.q[j,k] >= 0:\\n colors[j,k,1] = colors[j,k,2] = (1-fixed.q[j,k]/np.max(np.abs(fixed.q[:,k])))\\n colors[j,k,0] = fixed.q[j,k]/np.max(np.abs(fixed.q[:,k]))\\n else:\\n colors[j,k,0] = colors[j,k,1] = (1+fixed.q[j,k]/np.max(np.abs(fixed.q[:,k])))\\n colors[j,k,2] = -fixed.q[j,k]/np.max(np.abs(fixed.q[:,k]))\\n\\n # prepare the plot\\n width = 6\\n height = 6\\n plt.rc(\\\"figure.subplot\\\", left=(60/72.27)/width)\\n plt.rc(\\\"figure.subplot\\\", right=(width-20/72.27)/width)\\n plt.rc(\\\"figure.subplot\\\", bottom=(50/72.27)/height)\\n plt.rc(\\\"figure.subplot\\\", top=(height-20/72.27)/height)\\n figure = plt.figure(figsize=(width, height))\\n\\n for k in range(len(fixed.x[0,:])):\\n dots = plt.plot(fixed.x[0,k], fixed.y[0,k], 'o', c = colors[0,k,:])\\n image = plt.imshow(zip(*mapping[:,::-1,0,:]), interpolation = 'nearest', extent = domain)\\n j = 0\\n frameName = imageDir + 'images%06d.png'%j\\n imageFiles = []\\n imageFiles.append(frameName)\\n figure.savefig(frameName)\\n\\n for j in range(1,len(fixed.t)):\\n #time.sleep(0.5)\\n figure.clear()\\n for k in range(len(fixed.x[j,:])):\\n dots = plt.plot(fixed.x[j,k], fixed.y[j,k], 'o', c = colors[j,k,:])\\n image = plt.imshow(zip(*mapping[:,::-1,np.floor(j/advance),:]), interpolation = 'nearest', extent = domain)\\n frameName = imageDir + 'images%06d.png'%j\\n imageFiles.append(frameName)\\n figure.savefig(frameName)\\n\\n # convert the images into a mpg file\\n mencodeCommand = \\\"mencoder 'mf://\\\"+imageDir+\\\"images*.png' -mf type=png:fps=\\\"+np.str(fps)+\\\" -ovc lavc -lavcopts vcodec=mpeg4:vhq:vbitrate=\\\"+np.str(bitrate)+\\\" -ffourcc MP4S -oac copy -o \\\"+movieFile\\n os.system(mencodeCommand)\\n\\n # remove the image files\\n for fname in imageFiles:\\n os.remove(fname)\",\n \"def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\\r\\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\\r\\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \\r\\n if listOfNames==None:\\r\\n listOfNames = listOfFilesToPlot\\r\\n if listOfColors==None:\\r\\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\\r\\n \\r\\n fig = pylab.figure(figsize=figsize)\\r\\n ax = fig.add_subplot(111, projection='3d')\\r\\n\\r\\n yTotal = len(listOfFilesToPlot)\\r\\n top = 0.0\\r\\n\\r\\n if not (subtractRef is None):\\r\\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\\r\\n #zsRef = list(numpy.array(zsRef)-fixedOffset\\r\\n zNorm = max(zsRef[len(zsRef)/2:])\\r\\n zsRef = numpy.array(zsRef)/zNorm\\r\\n \\r\\n for i,f in enumerate(listOfFilesToPlot):\\r\\n [xs, zs, name] = qMS.readMSSpectraFile(f)\\r\\n if fixedOffset:\\r\\n off = zs[len(zs)/2]\\r\\n print off\\r\\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\\r\\n zs = list(numpy.array(zs)-off)\\r\\n ys = [yTotal-i]*len(xs)\\r\\n ys = numpy.array(ys)*yScale\\r\\n if normalizeToN15:\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n if not (subtractRef is None):\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\\r\\n zs = zs*zNorm\\r\\n #xs = xs[:len(xs)/2]\\r\\n #ys = ys[:len(ys)/2]\\r\\n #zs = zs[:len(zs)/2]\\r\\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\\r\\n if (scaleP is True) and (i==scaleI):\\r\\n zs = numpy.array(zs)*scaleVal\\r\\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\\r\\n top = max([top, float(max(zs))])\\r\\n\\r\\n\\r\\n ax.w_xaxis.pane.set_visible(False)\\r\\n ax.w_yaxis.pane.set_visible(False)\\r\\n ax.w_zaxis.pane.set_visible(False)\\r\\n\\r\\n if gridLines: \\r\\n ax.w_xaxis.gridlines.set_linewidth(1)\\r\\n ax.w_yaxis.gridlines.set_linewidth(1)\\r\\n ax.w_zaxis.gridlines.set_linewidth(1)\\r\\n \\r\\n else:\\r\\n ax.w_xaxis.gridlines.set_visible(False)\\r\\n ax.w_yaxis.gridlines.set_visible(False)\\r\\n ax.w_zaxis.gridlines.set_visible(False)\\r\\n\\r\\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\\r\\n\\r\\n ax.w_xaxis.line.set_linewidth(1)\\r\\n ax.w_yaxis.line.set_linewidth(1)\\r\\n ax.w_zaxis.line.set_linewidth(1)\\r\\n \\r\\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\\r\\n ax.set_zlim3d([0, top])\\r\\n ax.set_ylim3d(yMin, yMax)\\r\\n ax.set_yticks(range(1,yTotal+1))\\r\\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\\r\\n ax.set_xlim3d([xMin, xMax])\\r\\n \\r\\n if noTicks:\\r\\n ax.set_zticks([])\\r\\n ax.set_xticks([])\\r\\n ax.set_yticks([])\\r\\n\\r\\n ax.set_xlabel(xlabel)\\r\\n ax.set_zlabel(zlabel)\\r\\n\\r\\n ax.view_init(15, -60)\\r\\n if legend:\\r\\n pylab.legend(loc=legendLoc)\\r\\n \\r\\n pylab.tight_layout()\\r\\n return ax\",\n \"def plot_visco_profiles(pointsh5, skip=slice(None,None,1), xscale=1e3, yscale=1e-2, tscale=3.1536e7, adjustRadial=False, benchmark=[], title=None):\\n\\tplt.figure()\\n\\n\\tcoords,data,number,times = pu.load_h5_visco(pointsh5)\\n\\n\\t#x = 1e3*np.loadtxt(points,usecols=[0]) # output_points2.txt\\n\\t#y = np.zeros_like(x)\\n\\tx = coords[:,0]\\n\\ty = np.zeros_like(x)\\n\\n\\t# NOTE: plot elastic solution by passing dictionary as showelastic\\n\\t# Plot analytic elastic solution (t=0)\\n\\t#print(benchmark)\\n\\tif len(benchmark)>=1:\\n\\t\\tur = zeros_like(x)\\n\\t\\tuz = np.zeros_like(x)\\n\\t\\tfor b in benchmark:\\n\\t\\t\\turi,uzi = m.calc_mogi_dp(x,y,**params)\\n\\t\\t\\tur += uri\\n\\t\\t\\tuz += uzi\\n\\t\\tplt.plot(x*xscale,uz*yscale,'ko',label='benchmark')\\n\\n\\t# Convert units\\n\\t#ur = np.hypot(data[:,:,0], data[:,:,1]) #assume progiles are along EW profile\\n\\tur = data[:,:,0]\\n\\tuz = data[:,:,2]\\n\\tx = x / xscale\\n\\tur = ur / yscale #cm\\n\\tuz = uz / yscale #cm\\n\\ttimes = times / tscale\\n\\t#times = times / 8.64e4 #days\\n\\t#times = times / 31536000 #years\\n\\n\\t#plots = np.arange(0,times.size,skip)\\n\\t#print(plots.size)\\n\\t#way to cycle through markers if plotting many lines\\n\\t#marker = itertools.cycle(['o','^','s','D']) #plot(marker=marker.next() iterates list)\\n\\t#way to use gradually changing colors from a colormap\\n\\t#color = plt.cm.jet(1.0*i/plots.size)\\n\\tindplots = np.arange(times.size-1)\\n\\tprint(indplots)\\n\\tindplots = indplots[skip]\\n\\tprint(indplots)\\n\\tfor i in indplots:\\n\\t\\tline, = plt.plot(x, uz[i], color=plt.cm.jet(1.0*i/indplots[-1]), label='{:.1f}'.format(times[i]))\\n\\t\\tplt.plot(x, ur[i], ls='dashed', color=line.get_color())\\n\\t#print uz[i]\\n\\t#print uz[i-1]\\n\\n\\tif title:\\n\\t\\tplt.title(title)\\n\\telse:\\n\\t\\tplt.title(pointsh5)\\n\\n\\tplt.axhline(color='k',linestyle='dashed')\\n\\tplt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\tplt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.show()\\n\\tplt.legend(title='{}'.format(get_unit(tscale)))\\n\\tplt.grid()\",\n \"def trajectories(self):\\n # OPTIMIZE: take too much time due to too much solver call\\n alpha_min = self.search_alpha_min()\\n alpha_finder = self.FOV_img/2\\n\\n if self.display_trajectories is True:\\n plt.figure('Trajectories plan')\\n plt.clf() #clear the graph to avoir superposing data from the same set (can be deactivated if need to superpose)\\n ax = plt.subplot(111, projection='polar') #warning if use python in ligne (!= graphical) graphs got superposed\\n ax.set_title(\\\"light trajectories close to a black hole\\\\n\\\", va='bottom')\\n ax.set_xlabel('R(UA)')\\n plt.ylabel('phi(°)\\\\n\\\\n\\\\n\\\\n', rotation=0)\\n ax.set_rlim((0, 4*self.D))\\n ax.set_rlabel_position(-90)\\n\\n seen_angle = np.array([])\\n deviated_angle = np.array([])\\n\\n booli = False # avoid points from the first loop to exceed points from the second loop\\n points = 40 # careful with this if using kind=linear\\n\\n for i in range(6):\\n # print(alpha_finder)\\n\\n for alpha in np.linspace(alpha_finder, alpha_min,\\n num=points, endpoint=booli):\\n r, phi = self.solver(alpha)\\n\\n if r[-1] > 1.1*self.Rs: # if not capture by black hole\\n seen_angle = np.append(seen_angle, 180-alpha)\\n dev_angle = phi[-1] + math.asin(self.D/r[-1]*math.sin(phi[-1]))\\n dev_angle = math.degrees(dev_angle)\\n deviated_angle = np.append(deviated_angle, dev_angle)\\n Ci = 'C'+str(i)\\n\\n if self.display_trajectories is True:\\n ax.plot(phi, r, Ci) # plot one trajectory\\n\\n if self.kind == 'linear':\\n alpha_finder = alpha_min + (alpha_finder - alpha_min)/(points/3 + 1) # start a more precise cycle from last point\\n\\n else:\\n alpha_finder = alpha_min + (alpha_finder - alpha_min)/(points + 1) # start a more precise cycle from last point\\n\\n points = 10 # careful with this if using kind=linear\\n\\n if i == 4:\\n booli = True # allow to display the last point\\n\\n if self.display_trajectories is True:\\n # plt.savefig('trajectories.png', format='png', dpi=1000, bbox_inches='tight')\\n plt.draw()\\n\\n return seen_angle, deviated_angle\",\n \"def experimental_report(environment, species, time_series,path=None,events=None):\\n\\n\\n M = len(environment)+1\\n L = int(np.ceil(1 + len(time_series)/2))\\n fig = plt.figure(figsize=(5*M,5*L))\\n \\n colormaps = [\\\"Greens\\\",\\\"bwr\\\",\\\"Blues\\\",\\\"Oranges\\\",\\\"RdPu\\\",\\\"Reds\\\"]\\n for i,(k,v) in enumerate(environment):\\n plt.subplot(L,M,i+1)\\n plt.imshow(v,\\n interpolation='None',\\n cmap=colormaps[i%len(colormaps)],\\n vmin=0,vmax=1,\\n aspect=\\\"equal\\\")\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(k)\\n plt.colorbar(orientation=\\\"horizontal\\\", fraction=0.045)\\n plt.subplot(L,M,M)\\n niches(species,path=path)\\n\\n colors = [\\\"blue\\\",\\\"green\\\",\\\"brown\\\",\\\"purple\\\",\\\"red\\\"]\\n host = [host_subplot(L*100+10+2+j, axes_class=AA.Axes) for j in range(L-1)]\\n\\n\\n for i,(k,v) in enumerate(time_series):\\n #if False and i%2 != 0:\\n # ax = host[int(i/2)].twinx()\\n #else:\\n ax = host[int(i/2)]\\n ax.set_ylabel(k)\\n if len(v) == 2:\\n T = len(v[0])\\n ax.plot(v[0],\\n label=k,\\n color=colors[i%len(colors)],\\n linewidth=2)\\n ax.fill_between(range(len(v[0])),\\n v[0]-v[1], v[0]+v[1],\\n alpha=0.3,\\n color=colors[i%len(colors)])\\n else:\\n T = len(v)\\n ax.plot(range(len(v)),v, color=colors[i%len(colors)], label=k)\\n \\n \\n for h in host:\\n h.set_xlim((0,T-1))\\n h.legend()\\n h.set_xlabel(\\\"Time\\\")\\n \\n h.set_ymargin(0.05)\\n h.autoscale(enable=True, axis=u'both', tight=False)\\n\\n if events is not None:\\n h.vlines(events,*h.get_ylim(),alpha=0.1)\",\n \"def plot(\\n ecg, \\n sample_rate = 500, \\n title = 'ECG 12', \\n lead_index = lead_index, \\n lead_order = None,\\n style = None,\\n columns = 2,\\n row_height = 6,\\n show_lead_name = True,\\n show_grid = True,\\n show_separate_line = True,\\n ):\\n\\n if not lead_order:\\n lead_order = list(range(0,len(ecg)))\\n secs = len(ecg[0])/sample_rate\\n leads = len(lead_order)\\n rows = ceil(leads/columns)\\n # display_factor = 2.5\\n display_factor = 1\\n line_width = 0.5\\n fig, ax = plt.subplots(figsize=(secs*columns * display_factor, rows * row_height / 5 * display_factor))\\n display_factor = display_factor ** 0.5\\n fig.subplots_adjust(\\n hspace = 0, \\n wspace = 0,\\n left = 0, # the left side of the subplots of the figure\\n right = 1, # the right side of the subplots of the figure\\n bottom = 0, # the bottom of the subplots of the figure\\n top = 1\\n )\\n\\n fig.suptitle(title)\\n\\n x_min = 0\\n x_max = columns*secs\\n y_min = row_height/4 - (rows/2)*row_height\\n y_max = row_height/4\\n\\n if (style == 'bw'):\\n color_major = (0.4,0.4,0.4)\\n color_minor = (0.75, 0.75, 0.75)\\n color_line = (0,0,0)\\n else:\\n color_major = (1,0,0)\\n color_minor = (1, 0.7, 0.7)\\n color_line = (0,0,0.7)\\n\\n if(show_grid):\\n ax.set_xticks(np.arange(x_min,x_max,0.2)) \\n ax.set_yticks(np.arange(y_min,y_max,0.5))\\n\\n ax.minorticks_on()\\n \\n ax.xaxis.set_minor_locator(AutoMinorLocator(5))\\n\\n ax.grid(which='major', linestyle='-', linewidth=0.5 * display_factor, color=color_major)\\n ax.grid(which='minor', linestyle='-', linewidth=0.5 * display_factor, color=color_minor)\\n\\n ax.set_ylim(y_min,y_max)\\n ax.set_xlim(x_min,x_max)\\n\\n\\n for c in range(0, columns):\\n for i in range(0, rows):\\n if (c * rows + i < leads):\\n y_offset = -(row_height/2) * ceil(i%rows)\\n # if (y_offset < -5):\\n # y_offset = y_offset + 0.25\\n\\n x_offset = 0\\n if(c > 0):\\n x_offset = secs * c\\n if(show_separate_line):\\n ax.plot([x_offset, x_offset], [ecg[t_lead][0] + y_offset - 0.3, ecg[t_lead][0] + y_offset + 0.3], linewidth=line_width * display_factor, color=color_line)\\n\\n \\n t_lead = lead_order[c * rows + i]\\n \\n step = 1.0/sample_rate\\n if(show_lead_name):\\n ax.text(x_offset + 0.07, y_offset - 0.5, lead_index[t_lead], fontsize=9 * display_factor)\\n ax.plot(\\n np.arange(0, len(ecg[t_lead])*step, step) + x_offset, \\n ecg[t_lead] + y_offset,\\n linewidth=line_width * display_factor, \\n color=color_line\\n )\",\n \"def plot_trajectories_XYZ(t_start,t_stop):\\n \\n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\\n \\n index_start = np.where(time == t_start)[0][0]\\n index_end = np.where(time == t_stop)[0][0]\\n \\n time = time[index_start:index_end+1]\\n ankle_l_trajectory = ankle_l_trajectory[index_start:index_end+1,:]\\n ankle_r_trajectory = ankle_r_trajectory[index_start:index_end+1,:]\\n \\n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\\n \\n plt.figure('Trajectories')\\n plt.subplot(311)\\n plt.plot(time,ankle_l_trajectory[:,0])\\n plt.plot(time,ankle_r_trajectory[:,0])\\n #plt.title('Trajectory of the X component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('X Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(312)\\n plt.plot(time,ankle_l_trajectory[:,1])\\n plt.plot(time,ankle_r_trajectory[:,1])\\n #plt.title('Trajectory of the Y component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Y Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n plt.subplot(313)\\n plt.plot(time,ankle_l_trajectory[:,2])\\n plt.plot(time,ankle_r_trajectory[:,2])\\n #plt.title('Trajectory of the Z component')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Z Position [cm]')\\n plt.legend(['Left ankle','Right ankle'],loc='upper right')\\n \\n# plt.suptitle('Decomposition of the trajectories of the hind feet')\\n return\",\n \"def plot_frames(beads, sim, ti, tf, savebase, save_eps):\\n \\n ### normalize variables for plotting purposes\\n \\n lx = sim.lx/sim.bl\\n ly = sim.ly/sim.bl\\n \\n ### set general plot properties\\n\\n savebase += 'eps_' + str(sim.eps) + '_fp_' + str(sim.fp) + '_areak_' + str(sim.areak) + '/'\\n os.system(\\\"mkdir -p \\\" + savebase)\\n quant_steps = 2056\\n norm = mpl.colors.Normalize(vmin=0, vmax=sim.ncells) \\n downlim = -2\\n uplim = lx+2\\n num_ticks = 5\\n ax_len = 1.0 # Length of one subplot square box\\n ax_b = 0.0 # Beginning/offset of the subplot in the box\\n ax_sep = 0.0 # Separation length between two subplots\\n total_subplots_in_x = 1 # Total number of subplots \\n fig = plt.figure()\\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \\n ax0 = subp.addSubplot()\\n \\n ### plot the frames\\n \\n for step in range(ti, tf):\\n \\n ### normalize variables for plotting purposes\\n \\n beads.xi[step, 0, :] /= sim.bl\\n beads.xi[step, 1, :] /= sim.bl\\n \\n time = step*sim.dt\\n print 'Step / Total : ', step, tf\\n \\n ### plot \\n\\n subp = misc_tools.Subplots(fig, ax_len, ax_sep, ax_b, total_subplots_in_x) \\n ax0 = subp.addSubplot()\\n \\n line0 = ax0.scatter(beads.xi[step, 0, :], beads.xi[step, 1, :], s=1, c=beads.cid, \\\\\\n cmap=plt.cm.get_cmap('jet',quant_steps), \\\\\\n edgecolors='None', alpha=0.7, vmin=0, vmax=sim.ncells, \\\\\\n norm=norm, rasterized=True)\\n \\n ax0.axis('scaled')\\n \\n ### title\\n \\n ax0.set_title(\\\"$t/\\\\\\\\tau_{D}$ = \\\" + \\\"{0:.2f}\\\".format(time/sim.tau_D) + \\\\\\n \\\", $t/\\\\\\\\tau_{A}$ = \\\" + \\\"{0:.2f}\\\".format(time/sim.tau_A), fontsize=30)\\n \\n ### labels\\n \\n ax0.set_xlabel(\\\"$x/r_{0}$\\\", fontsize=40)\\n ax0.set_ylabel(\\\"$y/r_{0}$\\\", fontsize=40)\\n\\n ### limits\\n\\n ax0.set_xlim((downlim, uplim))\\n ax0.set_ylim((downlim, uplim))\\n \\n ### ticks\\n \\n ax0.xaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\\n ax0.yaxis.set_ticks(np.linspace(0, uplim, num_ticks, endpoint=True))\\n ax0.tick_params(axis='both', which='major', labelsize=30)\\n \\n ### save\\n\\n savepath1 = savebase + \\\"frame-\\\" + \\\"{0:05d}\\\".format(int(step)) + \\\".png\\\"\\n if save_eps:\\n savepath2 = savebase + \\\"frame-\\\" + \\\"{0:05d}\\\".format(int(step)) + \\\".eps\\\"\\n \\n plt.savefig(savepath1, dpi=200, bbox_inches='tight', pad_inches=0.08)\\n if save_eps:\\n plt.savefig(savepath2, dpi=200, bbox_inches='tight', pad_inches=0.08) \\n fig.clf() \\n \\n return\",\n \"def trajectory1(self):\\r\\n\\r\\n trackt = [] # particle trajectory,\\r\\n trackx = [] # particle trajectory\\r\\n an = [] # analitical s**2 + x**2 = t**2\\r\\n s1 = [] # s = 10; s = 0, light\\r\\n s2 = [] # s = 20;\\r\\n s3 = [] # s = 40;\\r\\n for i in range(0, len(self.dt.obs.obt_g)):\\r\\n trackt.append(float(i))\\r\\n trackx.append(self.dt.x[i])\\r\\n an.append(math.sqrt(float(i) ** 2 + self.dt.x[i] ** 2))\\r\\n s1.append(math.sqrt(1.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s2.append(math.sqrt(2.0 ** 2 + self.dt.x[i] ** 2))\\r\\n s3.append(math.sqrt(4.0 ** 2 + self.dt.x[i] ** 2))\\r\\n\\r\\n # plots:\\r\\n\\r\\n (fig, ax) = plt.subplots() # figsize=(7,5)\\r\\n\\r\\n # trajectory\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n trackt,\\r\\n marker='+',\\r\\n linewidth=1,\\r\\n linestyle='-',\\r\\n color='green',\\r\\n label='treck',\\r\\n )\\r\\n\\r\\n # measurement t\\r\\n # ax.plot(self.dt.x, self.dt.t, marker=\\\"+\\\", linestyle=\\\" \\\", color=\\\"blue\\\", label=\\\"result of measurement\\\")\\r\\n\\r\\n ax.plot(\\r\\n self.dt.x,\\r\\n self.dt.t,\\r\\n marker='o',\\r\\n linestyle=' ',\\r\\n color='black',\\r\\n label='result of measurement',\\r\\n )\\r\\n\\r\\n # analitical t\\r\\n\\r\\n ax.plot(self.dt.x, an, linestyle='-', color='red',\\r\\n label='continuum')\\r\\n\\r\\n # light trajectory\\r\\n\\r\\n ax.plot(trackx, trackx, linestyle='-', color='yellow',\\r\\n label='s=0 (light)')\\r\\n\\r\\n # s(x) curves\\r\\n\\r\\n ax.plot(\\r\\n trackx,\\r\\n s1,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=1.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s2,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=2.0',\\r\\n )\\r\\n ax.plot(\\r\\n trackx,\\r\\n s3,\\r\\n linestyle=':',\\r\\n linewidth=1,\\r\\n color='k',\\r\\n label='s=4.0',\\r\\n )\\r\\n\\r\\n # error of measurement t\\r\\n\\r\\n ax.errorbar(self.dt.x, self.dt.t, fmt='k ', yerr=self.dt.t_err)\\r\\n\\r\\n # signature on the horizontal x-axis\\r\\n\\r\\n ax.set_xlabel('x in metres')\\r\\n xm = -1.0\\r\\n for i in range(len(self.dt.x)):\\r\\n if self.dt.x[i] > xm:\\r\\n xm = self.dt.x[i]\\r\\n stepx = round(xm / float(len(self.dt.x)), 1)\\r\\n xm = round(xm + stepx, 1)\\r\\n ax.set_xlim([0.0, xm])\\r\\n\\r\\n # signature on vertical y axis\\r\\n\\r\\n ax.set_ylabel('t in metres of light time ')\\r\\n ym = -1.0\\r\\n for i in range(len(self.dt.t)):\\r\\n if self.dt.t[i] > ym:\\r\\n ym = self.dt.t[i]\\r\\n stepy = round(ym / float(len(self.dt.t)), 1)\\r\\n ym = round(ym + stepy, 1)\\r\\n ax.set_ylim([0.0, ym])\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on x)\\r\\n\\r\\n locatorx = matplotlib.ticker.MultipleLocator(base=stepx)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.xaxis.set_major_locator(locatorx)\\r\\n\\r\\n # Create an instance of the class that will be responsible for the location of the labels (base is step on y)\\r\\n\\r\\n locatory = matplotlib.ticker.MultipleLocator(base=stepy)\\r\\n\\r\\n # Set the locator for the main labels\\r\\n\\r\\n ax.yaxis.set_major_locator(locatory)\\r\\n\\r\\n ax.grid()\\r\\n\\r\\n # show legend\\r\\n\\r\\n ax.legend(loc='upper left')\\r\\n\\r\\n # show drawing\\r\\n\\r\\n plt.show()\",\n \"def app(ngr=100,c2a=1.6235):\\n import matplotlib.pyplot as plt\\n\\n ## small donuts\\n # plt.gcf().clf()\\n grs = main(mu=0,ngrains=ngr,tilt_1=30.,sigma=15)\\n plt.gcf().savefig('small_doughnut.pdf',bbox_inches='tight')\\n plt.gcf().clf()\\n f = gen_file(lab='sm_doughnut',ngr=ngr)\\n write_gr(f,grs)\\n\\n ## Big donuts\\n grs = main(mu=0,ngrains=ngr,tilt_1=50.,sigma=15)\\n plt.gcf().savefig('big_doughnut.pdf',bbox_inches='tight')\\n plt.gcf().clf()\\n f = gen_file(lab='big_doughnut',ngr=ngr)\\n write_gr(f,grs)\\n\\n ## twin tilts (30).\\n gr1=main(mu=0,ngrains=ngr/2,tilts_about_ax1=30.,sigma=45)\\n plt.gcf().clf()\\n gr2=main(mu=0,ngrains=ngr/2,tilts_about_ax1=-30.,sigma=45)\\n plt.gcf().clf()\\n grs =[]\\n for i in range(len(gr1)):\\n grs.append(gr1[i])\\n grs.append(gr2[i])\\n grs=np.array(grs)\\n mypf=upf.polefigure(grains=grs,csym='hexag',cdim=[1,1,c2a])\\n mypf.pf_new(poles=[[0,0,0,1],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\\n plt.gcf().savefig('t30.pdf',bbox_inches='tight')\\n f = gen_file(lab='dbl_lets_30',ngr=ngr)\\n write_gr(f,grs)\\n\\n ## twin tilts (50).\\n gr1=main(mu=0,ngrains=ngr/2,tilts_about_ax1=50.,sigma=45)\\n plt.gcf().clf()\\n gr2=main(mu=0,ngrains=ngr/2,tilts_about_ax1=-50.,sigma=45)\\n plt.gcf().clf()\\n gr =[]\\n for i in range(len(gr1)):\\n gr.append(gr1[i])\\n gr.append(gr2[i])\\n gr=np.array(gr)\\n mypf=upf.polefigure(grains=gr,csym='hexag',cdim=[1,1,c2a])\\n mypf.pf_new(poles=[[0,0,0,1],[1,0,-1,0]],cmap='jet',ix='TD',iy='RD')\\n plt.gcf().savefig('t50.pdf',bbox_inches='tight')\\n plt.gcf().clf()\\n f = gen_file(lab='dbl_lets_50',ngr=ngr)\\n write_gr(f,gr)\",\n \"def plot_ave(pulse, trap, ToP):\\n time_array = np.linspace(0, pulse.t * trap.N, trap.N + 1)\\n # fig, ax = plt.subplots()\\n all_trial_n, all_trial_n_ave = trap.sideband_cool_sch(pulse, ave = True)\\n if ToP == 'a':\\n plt.plot(time_array * 1e3, all_trial_n_ave, label = pulse.t)\\n if ToP == 'b':\\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'magenta', linewidth = 3, label = 'Monte Carlo')\\n if ToP == 'c':\\n plt.plot(time_array * 1e3, all_trial_n_ave, color = 'b')\\n if ToP == 'd':\\n if trap.no_decay == True and trap.off_resonant_excite == False:\\n plt.plot(time_array * 1e3, all_trial_n_ave, label = 'Decay to carrier')\\n if trap.no_decay == False and trap.off_resonant_excite == False:\\n plt.plot(time_array * 1e3, all_trial_n_ave, \\n label = 'Decay to %s sideband'%(trap.sideband))\\n if trap.no_decay == False and trap.off_resonant_excite == True:\\n plt.plot(time_array * 1e3, all_trial_n_ave, \\n label = 'Decay to %s sideband, off-resonant excite'%(trap.sideband))\\n # plt.xlabel('time / ms')\\n # plt.ylabel('Phonon State')\\n # plt.legend()\",\n \"def showPlot3():\\n interested_in = [(20,20),(25,16),(40,10),(50,8),(80,5),(100,4)]\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(2, 1.0, item[0], item[1], 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot([1,1.56,4,6.25,16,25], proc_sim_data)\\n title('Dependence of cleaning time on room shape')\\n xlabel('ratio of width to height')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def plot_stress_time(F_tot, response_t, coords, t_range):\\n section = np.where((t>t_range[0]) & (t<t_range[1]))[0]\\n fig, ax1 = plt.subplots(figsize=[15,5])\\n ax2 = ax1.twinx()\\n# ax1.set_title('Load and response at '+str(coords),fontsize = 14)\\n ax1.set_xlim(t_range)\\n ax1.set_xlabel('t [s]')\\n resp = ax1.plot(t[section], response_t[section]/10**6, color=\\\"#00A6D6\\\",\\n label='Equivalent gate stress')\\n ax1.set_ylabel('Stress [MPa]', fontsize=12)\\n d_max = 1.2*max(response_t[section])/10**6\\n d_mean = np.mean(response_t[section])/10**6\\n ax1.set_ylim(d_mean-d_max,d_max)\\n ax1.legend()\\n\\n force = ax2.plot(t[section], F_tot[section]/1000, color=\\\"#c3312f\\\", label = 'Wave force')\\n ax2.set_ylabel('Integrated wave force [$kN/m$]', fontsize = 12)\\n F_lim = 1.2*max(F_tot[section])/1000\\n F_mean = np.mean(F_tot[section]/1000)\\n ax2.set_ylim(F_mean-F_lim,F_lim)\\n\\n lines = resp + force\\n labs = [l.get_label() for l in lines]\\n ax1.grid(lw=0.25)\\n ax1.legend(lines,labs, fontsize = 12)\\n return fig\",\n \"def plot(self):\\n\\t\\t\\t\\n\\t\\tfig,p1=_plt.subplots(4,sharex=True)\\n\\t\\tp1[0].plot(self.time*1e3,self.eRogA,label='Rogowski A')\\n\\t\\tp1[1].plot(self.time*1e3,self.eRogB,label='Rogowski B')\\n\\t\\tp1[2].plot(self.time*1e3,self.eRogC,label='Rogowski C')\\n\\t\\tp1[3].plot(self.time*1e3,self.eRogD,label='Rogowski D')\\n\\t\\t_plot.finalizeSubplot(p1,xlabel='Time (ms)',ylabel='Current (A)')\\n\\t\\t_plot.finalizeFigure(fig,title=self.title)\\n\\t\\t\\n\\t\\treturn p1\",\n \"def plottrace_paper(moviedict, figw, figh, figdpi, fontsz, border, xlabel, ylabel, yaxisticks, \\n xaxisticks, labels, lw, fs):\\n \\n for movie, val in moviedict.iteritems():\\n os.chdir(movie)\\n condition, xlim, color, inum = val\\n \\n fontv = matplotlib.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\\n fontv.set_size(fontsz)\\n \\n print(movie)\\n td = dil.load_params()\\n x, roi_cols = dil.load_results(RESULTS_FILE)\\n start = int(td['startshort'])\\n end = int(td['endshort'])\\n \\n \\n fig1 = plt.figure(figsize=(figw*xlim/0.6, figh), dpi=figdpi, facecolor='w', edgecolor='k')\\n \\n xlen = len(x[roi_cols['Mean1']][start:end])\\n #print(xlen)\\n xvals = np.arange(0, float(xlen)/fs, 1/float(fs))\\n #print(xvals)\\n \\n \\n ycib = x[roi_cols['Mean1']][start:end]\\n ycib = [v - np.mean(ycib) for v in ycib]\\n #print(ycib)\\n \\n ylab = x[roi_cols['Mean2']][start:end]\\n ylab = [v - np.mean(ylab) for v in ylab]\\n ylab = [v + 70 for v in ylab]\\n \\n # Plots the traces\\n \\n plt.plot(xvals, ylab, label='proboscis tip', linewidth=lw, color='k')\\n plt.plot(xvals, ycib, label='cibarium', linewidth=lw, color='b')\\n \\n \\n \\n \\n \\n \\n \\n if labels == 'yes':\\n plt.title(td['condition'], fontproperties=fontv, horizontalalignment='left')\\n \\n #Plots legend and removes the border around it.\\n legend=plt.legend()\\n #legend = plt.legend(bbox_to_anchor = (1.5, 1.6))\\n legend.draw_frame(False)\\n ltext = legend.get_texts() \\n plt.setp(ltext, fontproperties=fontv) \\n \\n ax = plt.gca()\\n \\n #Uncomment lines below to display without top and right borders.\\n \\n if border == 'no':\\n for loc, spine in ax.spines.iteritems():\\n if loc in ['left','bottom']:\\n pass\\n elif loc in ['right','top']:\\n spine.set_color('none') # don't draw spine\\n else:\\n raise ValueError('unknown spine location: %s'%loc)\\n \\n \\n #Uncomment lines below to display ticks only where there are borders.\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n \\n # Specifies the number of tickmarks/labels on the yaxis.\\n #ax.yaxis.set_major_locator(matplotlib.ticker.MaxNLocator(yaxisticks)) \\n ## Removes tick labels and ticks from xaxis.\\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\\n \\n if labels == 'yes':\\n plt.ylabel(ylabel, fontsize=fontsz, labelpad=12)\\n fig1.figsize = (6, 3)\\n \\n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower \\n #lefthand corner of the figure.\\n fig1.subplots_adjust(bottom=0.3)\\n fig1.subplots_adjust(left=0.05)\\n fig1.subplots_adjust(right=0.95)\\n fig1.subplots_adjust(top=0.95)\\n \\n #ax.xaxis.set_major_locator(matplotlib.ticker.MaxNLocator(XAXISTICKS)) \\n \\n #Specifies axis labels and axis tick label sizes.\\n plt.xlabel(xlabel, fontproperties=fontv)\\n plt.ylabel(ylabel, fontproperties=fontv)\\n plt.xticks([0, 0.2, 0.4, 0.6], fontproperties=fontv)\\n plt.xlim( (0, xlim+0.05) )\\n #plt.yticks(fontproperties=fontv)\\n \\n \\n \\n # Saves the figures in plots/plots.\\n if labels == 'no':\\n plotfolder = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath('.'))),\\n 'plots')\\n makenewdir(plotfolder)\\n figname = os.path.join(plotfolder, movie + '_trace_nolab')\\n plt.savefig(figname+'.svg', dpi=FIGDPI, format='svg')\\n plt.savefig(figname+'.png', dpi=FIGDPI, format='png')\\n os.chdir('../')\\n\\n if labels == 'yes':\\n plotfolder = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath('.'))),\\n 'plots')\\n makenewdir(plotfolder)\\n figname = os.path.join(plotfolder, movie + '_trace')\\n plt.savefig(figname+'.svg', dpi=FIGDPI, format='svg')\\n plt.savefig(figname+'.png', dpi=FIGDPI, format='png')\\n os.chdir('../')\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def lick_piezo():\\n lp_raw = read_npy_file('lickPiezo.raw.npy')\\n lp_timestamps = read_npy_file('lickPiezo.timestamps.npy')\\n lp_rate = get_rate(lp_timestamps)\\n lick_piezo_ts = TimeSeries(\\n name='lickPiezo',\\n starting_time=lp_timestamps[0, 1],\\n rate=lp_rate,\\n data=np.ravel(lp_raw),\\n unit='V',\\n description='Voltage values from a thin-film piezo connected to the '\\n 'lick spout, so that values are proportional to deflection '\\n 'of the spout and licks can be detected as peaks of the signal.'\\n )\\n nwb_file.add_acquisition(lick_piezo_ts)\",\n \"def plot_1():\\n p_files = []\\n filename = \\\"energy_data_2D_80\\\"\\n for file in sorted(os.listdir(folder)):\\n if file.startswith(filename):\\n p_files.append(os.path.join(folder,file))\\n T_list = []\\n fig, ax = plt.subplots()\\n for p_file in p_files[3::3]:\\n T = (os.path.splitext(os.path.basename(p_file))[0]).split('_',4)[4]\\n #print(T)\\n E = []\\n t = []\\n if (T not in T_list):\\n T_list.append(T)\\n with open(p_file) as csvfile:\\n lines = csv.reader(csvfile, delimiter=' ')\\n sweep = 0\\n for row in lines:\\n E.append(float(row[0]))\\n t.append(sweep)\\n sweep += 1\\n ax.plot(t[0:200], E[0:200],label=\\\"T = \\\"+format(T[0:3]))\\n ax.set_title(\\\"Energy per bond vs Time\\\")\\n ax.set_ylabel(\\\"e / J\\\")\\n ax.set_xlabel(\\\"t / sweeps\\\")\\n ax.legend()\\n\\n fig.savefig(folder2+\\\"energy_vs_time.png\\\")\\n fig.savefig(texfolder+\\\"energy_vs_time.pdf\\\")\",\n \"def plot_ocp_momentum(self, figsize: Tuple[int, int] = (5, 5),\\n ax: plt.axes = None):\\n\\n if not ax:\\n fig, ax = plt.subplots(1, figsize=figsize)\\n fig.suptitle(\\\"One Cycle Momentum with Tail\\\")\\n\\n ax.plot(self.steps_list, self.momentum_list, label=\\\"1cycle Momentum\\\")\\n\\n ax.set_xlabel(\\\"Steps\\\")\\n ax.set_ylabel(\\\"Momentum\\\")\\n\\n return ax\",\n \"def plot_muscle_activations_with_patches(side,t_start,t_stop):\\n \\n time, ankle_l_trajectory, ankle_r_trajectory,foot_l_contact,foot_r_contact,muscle_lh_activations, muscle_rh_activations,muscle_lh_forces,muscle_rh_forces,joint_lh_positions,joint_rh_positions = load_data()\\n\\n index_start = np.where(time == t_start)[0][0]\\n index_end = np.where(time == t_stop)[0][0]\\n \\n time = time[index_start:index_end+1]\\n muscle_rh_activations = muscle_rh_activations[index_start:index_end+1,:]\\n muscle_lh_activations = muscle_lh_activations[index_start:index_end+1,:]\\n \\n gait = foot_r_contact[index_start:index_end+1,:]\\n #time=np.linspace(1,len(ankle_l_trajectory[:,0]),len(ankle_l_trajectory[:,0]));\\n if side =='right':\\n muscle_activations = muscle_rh_activations\\n elif side == 'left':\\n muscle_activations = muscle_lh_activations \\n else:\\n return\\n \\n plt.figure('Muscle activations')\\n ax = plt.subplot(421)\\n plt.plot(time,muscle_activations[:,0],'r')\\n plt.title('Muscle PMA')\\n #plt.xlabel('Time [s]')\\n plt.ylabel('Muscle activation')\\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n\\n ax = plt.subplot(422)\\n plt.plot(time,muscle_activations[:,1],'r')\\n plt.title('Muscle CF')\\n #plt.xlabel('Time [s]')\\n #plt.ylabel('Muscle activation') \\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n\\n ax = plt.subplot(423) \\n plt.plot(time,muscle_activations[:,2],'r')\\n plt.title('Muscle SM')\\n #plt.xlabel('Time [s]')\\n plt.ylabel('Muscle activation')\\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n \\n ax = plt.subplot(424) \\n plt.plot(time,muscle_activations[:,3],'r')\\n plt.title('Muscle POP')\\n #plt.xlabel('Time [s]')\\n #plt.ylabel('Muscle activation') \\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n \\n ax = plt.subplot(425) \\n plt.plot(time,muscle_activations[:,4],'r')\\n plt.title('Muscle RF')\\n# plt.xlabel('Time [s]')\\n plt.ylabel('Muscle activation') \\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n\\n ax = plt.subplot(426) \\n plt.plot(time,muscle_activations[:,5],'r')\\n plt.title('Muscle TA')\\n# plt.xlabel('Time [s]')\\n #plt.ylabel('Muscle activation') \\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n \\n ax = plt.subplot(427) \\n plt.plot(time,muscle_activations[:,6],'r')\\n plt.title('Muscle SOL')\\n plt.xlabel('Time [s]')\\n plt.ylabel('Muscle activation') \\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n \\n ax = plt.subplot(428) \\n plt.plot(time,muscle_activations[:,7],'r')\\n plt.title('Muscle LG')\\n plt.xlabel('Time [s]')\\n for t, g in enumerate(gait):\\n for l, gait_l in enumerate(g):\\n if gait_l:\\n add_patch(ax, time[t], -300, width=0.01, height=150)\\n \\n plt.subplots_adjust(hspace=0.5)\\n #plt.ylabel('Muscle activation') \\n# plt.suptitle('Decomposition of the trajectories of the hind feet')\\n \\n# plt.suptitle('Muscle activations of the '+ side + ' limb')\\n plt.show()\\n return\",\n \"def index_shift_plot():\\n file = \\\"Data/matfiles/20131221.mat\\\"\\n object = MatReader(file)\\n thing = object.shifted == False\\n assert thing, \\\"shifter must be commented out\\\"\\n \\n start = 1920 #index of 16 minutes\\n stop = 3120 #index of 26 minutes\\n \\n NeA = object.NeA[start:stop]\\n NeB = object.NeB[start:stop]\\n NeC = object.NeC[start:stop]\\n NeA = object.meanie(NeA, 5)\\n NeB = object.meanie(NeB, 5)\\n NeC = object.meanie(NeC, 5)\\n \\n secondsA = object.secondsA[start:stop]\\n secondsB = object.secondsB[start:stop]\\n secondsC = object.secondsC[start:stop]\\n \\n plt.plot(secondsB, NeB, \\\"r\\\")\\n plt.plot(secondsB, NeA, \\\"g\\\")\\n plt.plot(secondsB, NeC, \\\"b\\\")\\n plt.xlabel(\\\"Seconds since midnight UTC of satellite B\\\")\\n plt.ylabel(\\\"Electron density [cm$^{-3}$]\\\")\\n plt.legend([\\\"Satellite B\\\", \\\"Satellite A\\\", \\\"Satellite C\\\"])\\n plt.title(\\\"Electron density data before index-shift\\\")\\n plt.savefig(\\\"Figures/preshift_example.pdf\\\")\\n plt.show()\\n \\n object.shifter()\\n NeA = object.NeA[start:stop]\\n NeB = object.NeB[start:stop]\\n NeC = object.NeC[start:stop]\\n NeA = object.meanie(NeA, 5)\\n NeB = object.meanie(NeB, 5)\\n NeC = object.meanie(NeC, 5)\\n \\n secondsA = object.secondsA[start:stop]\\n secondsB = object.secondsB[start:stop]\\n secondsC = object.secondsC[start:stop]\\n \\n plt.plot(secondsB, NeB, \\\"r\\\")\\n plt.plot(secondsB, NeA, \\\"g\\\")\\n plt.plot(secondsB, NeC, \\\"b\\\")\\n plt.xlabel(\\\"Seconds since midnight UTC of satellite B\\\")\\n plt.ylabel(\\\"Electron density [cm$^{-3}$]\\\")\\n plt.legend([\\\"Satellite B\\\", \\\"Satellite A\\\", \\\"Satellite C\\\"])\\n plt.title(\\\"Electron density data after index-shift\\\")\\n plt.savefig(\\\"Figures/postshift_example.pdf\\\")\\n plt.show()\",\n \"def oneplot(moviedict, toplotdict, figw, figh, figdpi, fontsz, border, ylabel, ylim, time, ymin, \\n lw):\\n print(toplotdict.keys())\\n \\n fontv = mpl.font_manager.FontProperties()\\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \\n # similar (just slightly narrower).\\n fontv = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\\n fontv.set_size(fontsz)\\n \\n fonti = mpl.font_manager.FontProperties()\\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \\n #similar (just slightly narrower).\\n fonti = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/ariali.ttf')\\n fonti.set_size(fontsz)\\n \\n fig1 = plt.figure(figsize=(figw, figh), dpi=figdpi, facecolor='w', edgecolor='k')\\n \\n #Plots data on one graph with parameters specified in the moviedict directory.\\n for k, v in moviedict.iteritems():\\n print(k)\\n cond1, offset, color, inum = v\\n xvals = toplotdict[k][0]\\n data = toplotdict[k][1] + offset\\n condition = cond1\\n \\n\\n plt.plot(xvals, data, color, linewidth=0.75, label=condition)\\n print(condition)\\n #if k == 'mov_20110113_180524':\\n #plt.text(0.5, offset+7, inum+condition, horizontalalignment='left', \\n #fontproperties=fontv)\\n #else:\\n #plt.text(0.5, offset+9, inum+condition, horizontalalignment='left', \\n #fontproperties=fontv)\\n \\n # Plots text labels\\n \\n if k == 'mov_20101130_200030':\\n plt.text(0.03, offset+6, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.11, offset+6.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n if k == 'mov_20101130_201605':\\n plt.text(0.03, offset+5, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.125, offset+5.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n if k == 'mov_20101213_193258':\\n plt.text(0.03, offset+3, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.137, offset+3.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n\\n ax = plt.gca()\\n\\n ## Plots legend.\\n #legend = plt.legend()\\n ### Manipulates order of the legend entries.\\n ##handles, labels = ax.get_legend_handles_labels()\\n ##handles2 = handles[0], handles[2], handles[1], handles[3]\\n ##labels2 = labels[0], labels[2], labels[1], labels[3]\\n ##legend = ax.legend(handles2, labels2, bbox_to_anchor=(0, 0, 1, 1), \\n ##transform=plt.gcf().transFigure)\\n ### Changes legend font to fontsz.\\n #ltext = legend.get_texts()\\n #plt.setp(ltext, fontsize=fontsz)\\n ### Removes border around the legend.\\n #legend.draw_frame(False)\\n \\n \\n #Uncomment lines below to display without top and right borders.\\n if border == 'no':\\n for loc, spine in ax.spines.iteritems():\\n if loc in ['left','bottom']:\\n pass\\n elif loc in ['right','top']:\\n spine.set_color('none') # don't draw spine\\n else:\\n raise ValueError('unknown spine location: %s'%loc)\\n \\n #Uncomment lines below to display ticks only where there are borders.\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n ## Removes tick labels and ticks from yaxis.\\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\\n \\n # Specifies axis labels and axis tick label sizes.\\n plt.xlabel(XLABEL, fontproperties=fontv, labelpad=4)\\n plt.ylabel(ylabel, fontproperties=fontv, labelpad=4)\\n plt.xticks(fontproperties=fontv)\\n plt.yticks(fontproperties=fontv)\\n \\n # Specifies axis limits.\\n plt.axis( [0, time, ymin, ylim])\\n \\n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower lefthand corner of the figure.\\n fig1.subplots_adjust(top=0.95)\\n fig1.subplots_adjust(left=0.15)\\n #fig1.subplots_adjust(right=0.95)\\n fig1.subplots_adjust(bottom=0.15)\",\n \"def test4():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\t#Voigt\\n\\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def drawAxes(t):\\r\\n t.speed(0)\\r\\n t.pd()\\r\\n t.forward(500)\\r\\n t.back(500)\",\n \"def plot_pretty():\\n\\n ts, ys, lin_model, K, us, dt_control, biass, end_time = simulate()\\n plt.style.use('seaborn-deep')\\n\\n black = '#2B2B2D'\\n red = '#E90039'\\n orange = '#FF1800'\\n white = '#FFFFFF'\\n yellow = '#FF9900'\\n\\n plt.figure(figsize=(12.8, 9.6))\\n plt.rcParams.update({'font.size': 16, 'text.color': white, 'axes.labelcolor': white,\\n 'axes.edgecolor': white, 'xtick.color': white, 'ytick.color': white})\\n\\n plt.gcf().set_facecolor(black)\\n\\n plt.subplot(2, 3, 1)\\n plt.plot(ts, ys[:, 2], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[1], color=white)\\n plt.title(r'$C_{FA}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 2)\\n plt.plot(ts, ys[:, 0], color=orange)\\n plt.axhline(lin_model.yd2n(K.ysp)[0], color=white)\\n plt.title(r'$C_{G}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 3)\\n plt.plot(ts, ys[:, 3], color=orange)\\n plt.title(r'$C_{E}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 4)\\n plt.plot(ts, us[:, lin_model.inputs[1]], color=red)\\n plt.title(r'$F_{m, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 5)\\n plt.plot(ts, us[:, lin_model.inputs[0]], color=red)\\n plt.title(r'$F_{G, in}$')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n plt.subplot(2, 3, 6)\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 1],\\n color=red\\n )\\n plt.plot(\\n numpy.arange(dt_control, end_time, dt_control),\\n biass[:, 0],\\n color=yellow\\n )\\n plt.legend([r'$C_{FA}$', r'$C_G$'], facecolor=black)\\n plt.title('bias')\\n plt.xlim([0, ts[-1]])\\n plt.gca().set_facecolor(black)\\n\\n # plt.suptitle('Closedloop bioreactor without noise')\\n plt.tight_layout(rect=[0, 0.03, 1, 0.95])\\n plt.savefig('no_noise_pretty.png', transparent=True)\\n plt.show()\",\n \"def plot_timeres(timeres):\\n tint = 24 / timeres\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n mxcont = np.max(cont)\\n\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\\n # cont[i,j]*(circlesize/scale), \\\"#FF0000\\\")\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\\n # minLon+((j+1.5)/normLon), 30, \\\"#FF0000\\\")\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n stime = time.localtime(np.int32(self.dataset[i][2]))\\n evtime = stime[3]\\n if (evtime / timeres) == t:\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\",\n \"def onTimer(self, evt): \\r\\n # restore the clean background, saved at the beginning \\r\\n self.canvas.restore_region(self.bg) \\r\\n # update the data \\r\\n self.r1 = self.r1[1:] + [t1.getRatio()] \\r\\n self.r2 = self.r2[1:] + [t2.getRatio()]\\r\\n self.v1 = self.v1[1:] + [t1.getSpeed()] \\r\\n self.v2 = self.v2[1:] + [t2.getSpeed()] \\r\\n \\r\\n # update the plot \\r\\n self.pr1.set_ydata(self.r1) \\r\\n self.pr2.set_ydata(self.r2)\\r\\n self.pv1.set_ydata(self.v1) \\r\\n self.pv2.set_ydata(self.v2) \\r\\n # just draw the \\\"animated\\\" objects \\r\\n self.ax.draw_artist(self.pr1) \\r\\n self.ax.draw_artist(self.pr2)\\r\\n self.ax.draw_artist(self.pv1) \\r\\n self.ax.draw_artist(self.pv2) \\r\\n self.canvas.blit(self.ax.bbox)\",\n \"def OneDynSpectraPlot(Data, Vmin, Vmax, Suptitle, CBarLabel, no_of_spectra, TimeScale,\\n frequency, FreqPointsNum, colormap, Xlabel, fig_file_name,\\n currentDate, currentTime, Software_version, customDPI):\\n\\n fig, axarr = plt.subplots(1, 1, figsize=(16.0, 7.0))\\n im0 = axarr.imshow(np.flipud(Data), aspect='auto', vmin=Vmin, vmax=Vmax,\\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\\n rc('font', size=8, weight='bold')\\n axarr.set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=0.96)\\n\\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=8, fontweight='bold')\\n cbar = fig.colorbar(im0, ax=axarr, pad=0.005)\\n cbar.ax.tick_params(labelsize=8)\\n cbar.set_label(CBarLabel, fontsize=9, fontweight='bold')\\n text = axarr.get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeScale[k]\\n\\n ticks_loc = axarr.get_xticks().tolist() # <---- Added to suppress warning\\n axarr.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr.set_xticklabels(text, fontsize=8, fontweight='bold')\\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=8, fontweight='bold')\\n axarr.set_xlabel(Xlabel, fontsize=10, fontweight='bold')\\n fig.text(0.72, 0.04, 'Processed ' + currentDate + ' at ' + currentTime,\\n fontsize=6, fontweight='bold', transform=plt.gcf().transFigure)\\n fig.text(0.09, 0.04, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\\n fontsize=6, fontweight='bold', transform=plt.gcf().transFigure)\\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\\n plt.close('all')\\n return\",\n \"def plot_events(ax, MD):\\n\\n coord_vars = ['CT_at_HB', 'CT_out_HB']\\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\\n all_vars = coord_vars + ingestion_vars\\n\\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\\n \\n names = ['M', 'M', 'F', 'F', 'W', 'W']\\n idx = [2, 0, 0, 1, 0, 1]\\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\\n\\n offsets = [-3, -5, -9, -11, -14, -16]\\n height = 1.\\n \\n print \\\"plotting events..\\\"\\n\\n\\n for c, name in enumerate(all_vars):\\n\\n # load\\n if not hasattr(MD, name):\\n MD.load(name)\\n\\n events = getattr(MD, name) / 3600. - 7 \\n\\n offset = offsets[c]\\n color = colors[c]\\n label = str(events.shape[0]) + ' ' + labels[c]\\n\\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\\n label += ' events'\\n\\n if name in coord_vars:\\n \\n ax.scatter(\\n events, offset * np.ones(events.shape[0]),\\n c=color,\\n marker='|',\\n linewidths=1,\\n edgecolors=None\\n )\\n \\n\\n elif name in ingestion_vars:\\n\\n for x in events: \\n event_patch = patches.Rectangle(\\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\\n linewidth=0.001,\\n fc=color, \\n ec=color\\n ) \\n ax.add_patch(event_patch) \\n\\n # event descritpion\\n ax.text(31, offset, label, color=color, \\n fontsize=7, ha='left', va='bottom'\\n )\",\n \"def showPlot2():\\n interested_in = list(range(1,10))\\n proc_sim_data = []\\n for item in interested_in:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, 0.75, 100, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n plot(interested_in, proc_sim_data)\\n title('Dependence of cleaning time on number of robots')\\n xlabel('number of robots (tiles)')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def figure2():\\n # sim_data_XPP = pd.read_csv(\\\"XPP.dat\\\", delimiter=\\\" \\\", header=None) # Load the XPP simulation\\n\\n plot_settings = {'y_limits': [-25, 0],\\n 'x_limits': None,\\n 'y_ticks': [-25, -20, -15, -10, -5, 0],\\n 'locator_size': 2.5,\\n 'y_label': 'Current (nA)',\\n 'x_ticks': [],\\n 'scale_size': 0,\\n 'x_label': \\\"\\\",\\n 'scale_loc': 4,\\n 'figure_name': 'figure_2',\\n 'legend': ['I-Na', 'I-NaP'],\\n 'legend_size': 8,\\n 'y_on': True}\\n\\n t, y = solver(100) # Integrate solution\\n t_short = np.where((t >= 8) & (t <= 18))[0] # shorter time bounds for plots A and C\\n v, m, h, m_nap, h_na_p, n, m_t, h_t, m_p, m_n, h_n, z_sk, m_a, h_a, m_h, ca = y[:, ].T # Extract all variables\\n\\n \\\"\\\"\\\"\\n Explicitly calculate all currents: Extra constants duplicated from function dydt to calculate currents\\n \\\"\\\"\\\"\\n g_na_bar = 0.7\\n g_nap_bar = 0.05\\n g_k_bar = 1.3\\n g_p_bar = 0.05\\n g_leak = 0.005\\n g_a_bar = 1.0\\n e_na = 60\\n e_k = -80\\n e_leak = -50\\n e_ca = 40\\n g_t_bar = 0.1\\n g_n_bar = 0.05\\n g_sk_bar = 0.3\\n\\n \\\"\\\"\\\"\\n Calculate currents used in the plot\\n \\\"\\\"\\\"\\n i_na = g_na_bar * (m ** 3) * h * (v - e_na)\\n i_na_p = g_nap_bar * m_nap * h_na_p * (v - e_na)\\n i_k = g_k_bar * (n ** 4) * (v - e_k)\\n i_leak = g_leak * (v - e_leak)\\n i_t = g_t_bar * m_t * h_t * (v - e_ca)\\n i_n = g_n_bar * m_n * h_n * (v - e_ca)\\n i_p = g_p_bar * m_p * (v - e_ca)\\n i_sk = g_sk_bar * (z_sk ** 2) * (v - e_k)\\n i_a = g_a_bar * m_a * h_a * (v - e_k)\\n\\n plt.figure(figsize=(5, 3), dpi=96) # Create figure\\n\\n plt.subplot(2, 2, 1) # Generate subplot 1 (top left)\\n plt.plot(t[t_short], i_na[t_short], 'k-')\\n plt.plot(t[t_short], i_na_p[t_short], c='k', linestyle='dotted')\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 2) # Generate subplot 2 (top right)\\n plt.plot(t, i_t + i_n + i_p, 'k-')\\n plt.plot(t, i_t, c='k', linestyle='dotted')\\n plt.plot(t, i_p, 'k--')\\n plt.plot(t, i_n, 'k-.')\\n\\n plot_settings['y_limits'] = [-2.5, 0]\\n plot_settings['y_ticks'] = [-2.5, -2, -1.5, -1, -0.5, 0]\\n plot_settings['locator_size'] = 0.25\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-Ca', 'I-T', 'I-P', 'I-N']\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 3) # Generate subplot 3 (bottom left)\\n plt.plot(t[t_short], i_k[t_short], 'k-')\\n plt.plot(t[t_short], i_a[t_short], c='k', linestyle='dotted')\\n plt.plot(t[t_short], i_leak[t_short], 'k-.')\\n\\n plot_settings['y_limits'] = [0, 25]\\n plot_settings['y_ticks'] = [0, 5, 10, 15, 20, 25]\\n plot_settings['locator_size'] = 2.5\\n plot_settings['y_label'] = \\\"Current (nA)\\\"\\n plot_settings['legend'] = ['I-K', 'I-A', 'I-leak']\\n plot_settings['scale_size'] = 2\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings) # Alter figure for publication\\n\\n plt.subplot(2, 2, 4) # Generate subplot 4 (bottom left)\\n\\n plt.plot(t, i_sk, 'k-')\\n # plt.plot(sim_data_XPP[0][900:]-200,sim_data_XPP[34][900:]) # Isk for XPP data\\n\\n plot_settings['y_limits'] = [0, 1]\\n plot_settings['y_ticks'] = [0, 0.2, 0.4, 0.6, 0.8, 1]\\n plot_settings['locator_size'] = 0.2\\n plot_settings['y_label'] = \\\"\\\"\\n plot_settings['legend'] = ['I-SK']\\n plot_settings['scale_size'] = 20\\n plot_settings['scale_loc'] = 2\\n alter_figure(plot_settings, close=True) # Alter figure for publication\",\n \"def TwoDynSpectraPlot(Data_Ch_A, Data_Ch_B, VminA, VmaxA, VminB, VmaxB, Suptitle,\\n CBarLabelA, CBarLabelB, no_of_spectra,\\n TimeFigureScale, TimeScale, frequency,\\n FreqPointsNum, colormap, TitleA, TitleB, fig_file_name,\\n currentDate, currentTime, Software_version, customDPI):\\n fig, axarr = plt.subplots(2, 1, figsize=(16.0, 9.0))\\n fig.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.08)\\n im0 = axarr[0].imshow(np.flipud(Data_Ch_A), aspect='auto', vmin=VminA, vmax=VmaxA,\\n extent=[0, no_of_spectra, frequency[0], frequency[FreqPointsNum-1]], cmap=colormap)\\n rc('font', size=8, weight='bold')\\n\\n ticks_loc = axarr[0].get_yticks().tolist() # <---- Added to suppress warning\\n axarr[0].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[0].set_ylabel('Frequency, MHz', fontweight='bold', fontsize=10)\\n axarr[0].set_yticklabels(axarr[0].get_yticks(), fontsize=8, fontweight='bold')\\n cbar = fig.colorbar(im0, ax=axarr[0], pad=0.005)\\n cbar.ax.tick_params(labelsize=8)\\n cbar.set_label(CBarLabelA, fontsize=9, fontweight='bold')\\n text = axarr[0].get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = ' '\\n\\n ticks_loc = axarr[0].get_xticks().tolist() # <---- Added to suppress warning\\n axarr[0].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[0].set_xticklabels(text)\\n axis_copy = axarr[0].twiny()\\n axis_copy.set_xlim(0, no_of_spectra)\\n text = axis_copy.get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeFigureScale[k]\\n\\n ticks_loc = axis_copy.get_xticks().tolist() # <---- Added to suppress warning\\n axis_copy.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axis_copy.set_xticklabels(text, fontsize=8, fontweight='bold')\\n axarr[0].set_title(TitleA, fontsize=10, fontweight='bold', style='italic', y=1.05)\\n im1 = axarr[1].imshow(np.flipud(Data_Ch_B), aspect='auto', vmin=VminB, vmax=VmaxB,\\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\\n # frequency[FreqPointsNum-1]\\n\\n ticks_loc = axarr[1].get_xticks().tolist() # <---- Added to suppress warning\\n axarr[1].xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n ticks_loc = axarr[1].get_yticks().tolist() # <---- Added to suppress warning\\n axarr[1].yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n\\n axarr[1].set_xlabel('UTC Time, HH:MM:SS.msec', fontsize=10, fontweight='bold')\\n axarr[1].set_ylabel('Frequency, MHz', fontsize=10, fontweight='bold')\\n cbar = fig.colorbar(im1, ax=axarr[1], pad=0.005)\\n cbar.set_label(CBarLabelB, fontsize=9, fontweight='bold')\\n cbar.ax.tick_params(labelsize=8)\\n text = axarr[1].get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeScale[k]\\n axarr[1].set_xticklabels(text, fontsize=8, fontweight='bold')\\n axarr[1].set_yticklabels(axarr[1].get_yticks(), fontsize=8, fontweight='bold')\\n axarr[1].set_title(TitleB, fontsize=10, fontweight='bold', style='italic', y=1.00)\\n fig.suptitle(Suptitle, fontsize=10, fontweight='bold', x=0.46, y=1.01)\\n fig.subplots_adjust(top=0.91)\\n fig.text(0.72, 0.065, 'Processed ' + currentDate + ' at ' + currentTime,\\n fontsize=6, transform=plt.gcf().transFigure)\\n fig.text(0.1, 0.065, 'Software version: ' + Software_version + ', yerin.serge@gmail.com, IRA NASU',\\n fontsize=6, transform=plt.gcf().transFigure)\\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\\n plt.close('all')\\n return 0\",\n \"def showPlot4():\\n overall_data = []\\n per_to_clean = [round(x * 0.1,1) for x in range(0,10)]\\n number_of_robots = list(range(1,6))\\n for per in per_to_clean:\\n proc_sim_data = []\\n for item in number_of_robots:\\n len_sim_data = []\\n raw_sim_data = runSimulation(item, 1.0, 25, 25, per, 10, Robot, False)\\n for mes in raw_sim_data:\\n len_sim_data.append(len(mes))\\n proc_sim_data.append(sum(len_sim_data)/len(len_sim_data))\\n overall_data.append(proc_sim_data)\\n plot(per_to_clean, overall_data)\\n title('cleaning time vs. percentage cleaned')\\n xlabel('percentage clean')\\n ylabel('mean time (clocks)')\\n show()\",\n \"def setplot(plotdata):\\n#-------------------------- \\n\\n\\n from pyclaw.plotters import colormaps, geoplot\\n\\n plotdata.clearfigures() # clear any old figures,axes,items data\\n\\n def set_drytol(current_data):\\n # The drytol parameter is used in masking land and water and\\n # affects what color map is used for cells with small water depth h.\\n # The cell will be plotted as dry if h < drytol.\\n # The best value to use often depends on the application and can\\n # be set here (measured in meters):\\n current_data.user.drytol = 1.e-4\\n\\n\\n plotdata.beforeframe = set_drytol\\n\\n # To plot gauge locations on pcolor or contour plot, use this as\\n # an afteraxis function:\\n\\n def addgauges(current_data):\\n from pyclaw.plotters import gaugetools\\n gaugetools.plot_gauge_locations(current_data.plotdata, \\\\\\n gaugenos='all', format_string='ko', add_labels=True)\\n \\n\\n #-----------------------------------------\\n # Figure for imshow plot\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='imshow', figno=0)\\n plotfigure.show = False\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('imshow')\\n plotaxes.title = 'Surface'\\n plotaxes.scaled = True\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.02\\n plotitem.imshow_cmax = 0.02\\n plotitem.add_colorbar = True\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = 'auto'\\n\\n \\n\\n #-----------------------------------------\\n # Figure for imshow plot\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Surface and Gauge 1', figno=20)\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('imshow')\\n plotaxes.axescmd = \\\"axes([.1,.5,.8,.4])\\\"\\n plotaxes.title = 'Surface'\\n plotaxes.scaled = True\\n plotaxes.afteraxes = addgauges\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.03\\n plotitem.imshow_cmax = 0.03\\n plotitem.add_colorbar = True\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0,0,0]\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = 'auto'\\n\\n\\n # Gauge trace:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.show = False\\n plotaxes.axescmd = \\\"axes([.1,.1,.8,.3])\\\"\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = [-0.02, 0.05]\\n plotaxes.title = 'Gauge 1'\\n\\n # Plot surface as blue curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_gauge_trace')\\n plotitem.plot_var = 3\\n plotitem.plotstyle = 'b-'\\n plotitem.gaugeno = 1\\n\\n\\n #-----------------------------------------\\n # Figure for zoom\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Zoom', figno=10)\\n #plotfigure.show = False\\n plotfigure.kwargs = {'figsize':[7,7]}\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes('monai')\\n #plotaxes.axescmd = 'axes([0.0,0.1,0.6,0.6])'\\n plotaxes.title = 'Monai Valley'\\n plotaxes.scaled = True\\n #plotaxes.xlimits = [4.0, 5.2]\\n #plotaxes.ylimits = [1.3, 2.5]\\n plotaxes.xlimits = [4.7, 5.2]\\n plotaxes.ylimits = [1.5, 2.2]\\n\\n # Water\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n #plotitem.plot_var = geoplot.surface\\n plotitem.plot_var = geoplot.surface_or_depth\\n plotitem.imshow_cmap = geoplot.tsunami_colormap\\n plotitem.imshow_cmin = -0.02\\n plotitem.imshow_cmax = 0.02\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0]\\n plotitem.amr_gridedges_show = [1]\\n\\n # Land\\n plotitem = plotaxes.new_plotitem(plot_type='2d_imshow')\\n plotitem.plot_var = geoplot.land\\n plotitem.imshow_cmap = geoplot.land_colors\\n plotitem.imshow_cmin = 0.0\\n plotitem.imshow_cmax = 0.05\\n plotitem.add_colorbar = False\\n plotitem.amr_gridlines_show = [0]\\n\\n # Add contour lines of bathymetry:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = geoplot.topo\\n from numpy import arange, linspace\\n plotitem.contour_levels = arange(-0.02, 0., .0025)\\n plotitem.amr_contour_colors = ['k'] # color on each level\\n plotitem.kwargs = {'linestyles':'solid'}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n \\n # Add contour lines of topography:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = geoplot.topo\\n from numpy import arange, linspace\\n plotitem.contour_levels = arange(0., .2, .01)\\n plotitem.amr_contour_colors = ['w'] # color on each level\\n plotitem.kwargs = {'linestyles':'solid'}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n\\n # Add dashed contour line for current shoreline\\n plotitem = plotaxes.new_plotitem(plot_type='2d_contour')\\n plotitem.plot_var = 0\\n plotitem.contour_levels = [0.002]\\n plotitem.amr_contour_colors = ['k'] # color on each level\\n plotitem.kwargs = {'linestyles':'dashed','linewidths':2}\\n plotitem.amr_contour_show = [1] # show contours only on finest level\\n plotitem.gridlines_show = 0\\n plotitem.gridedges_show = 0\\n plotitem.show = True\\n\\n\\n\\n\\n #-----------------------------------------\\n # Figures for gauges\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='Surface & topo', figno=300, \\\\\\n type='each_gauge')\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.xlimits = [0,25]\\n plotaxes.ylimits = [-0.02, 0.05]\\n plotaxes.title = 'Surface'\\n\\n # Plot surface as blue curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n plotitem.plot_var = 3\\n plotitem.plotstyle = 'b-'\\n\\n # Plot topo as green curve:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n\\n def gaugetopo(current_data):\\n q = current_data.q\\n h = q[:,0]\\n eta = q[:,3]\\n topo = eta - h\\n return topo\\n \\n plotitem.plot_var = gaugetopo\\n plotitem.clf_each_gauge = False\\n plotitem.plotstyle = 'g-'\\n def afteraxes(current_data):\\n from pylab import plot, legend, loadtxt\\n t = current_data.t\\n plot(t, 0*t, 'k')\\n gaugeno = current_data.gaugeno\\n \\n if gaugeno in [5,7,9]:\\n col = (gaugeno-3)/2\\n plot(labgage[:,0],0.01*labgage[:,col],'r')\\n legend(('GeoClaw','topography','sea level','lab data'),loc='upper left')\\n else:\\n legend(('GeoClaw','topography','sea level'),loc='upper right')\\n \\n \\n\\n plotaxes.afteraxes = afteraxes\\n\\n\\n #-----------------------------------------\\n # Figure for grids alone\\n #-----------------------------------------\\n plotfigure = plotdata.new_plotfigure(name='grids', figno=2)\\n plotfigure.show = False\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.xlimits = [0,1]\\n plotaxes.ylimits = [0,1]\\n plotaxes.title = 'grids'\\n plotaxes.scaled = True\\n\\n # Set up for item on these axes:\\n plotitem = plotaxes.new_plotitem(plot_type='2d_grid')\\n plotitem.amr_grid_bgcolor = ['#ffeeee', '#eeeeff', '#eeffee']\\n plotitem.amr_gridlines_show = [1,1,0] \\n plotitem.amr_gridedges_show = [1] \\n\\n #-----------------------------------------\\n \\n # Parameters used only when creating html and/or latex hardcopy\\n # e.g., via pyclaw.plotters.frametools.printframes:\\n\\n plotdata.printfigs = True # print figures\\n plotdata.print_format = 'png' # file format\\n #plotdata.print_framenos = [4,6,8,10,12]\\n plotdata.print_framenos = [5,7,9,11,13]\\n plotdata.print_gaugenos = [0,5,7,9] # list of gauges to print\\n plotdata.print_fignos = 'all' # list of figures to print\\n plotdata.html = True # create html files of plots?\\n plotdata.html_homelink = '../README.html' # pointer for top of index\\n plotdata.latex = True # create latex file of plots?\\n plotdata.latex_figsperline = 2 # layout of plots\\n plotdata.latex_framesperline = 1 # layout of plots\\n plotdata.latex_makepdf = False # also run pdflatex?\\n\\n return plotdata\",\n \"def plotspec(ant,freq=True,test=False):\\n snap.write_int('rst',1)\\n snap.write_int('antenna',ant);\\n snap.write_int('rst',0)\\n\\n ## Test\\n if (test):\\n if ant in [2,3,6,7,10,11]:\\n test = (np.linspace(256,511,num=256,dtype='uint64')**2)*(ACC_LEN/256)\\n else:\\n test = (np.linspace(0,255,num=256,dtype='uint64')**2)*(ACC_LEN/256)\\n plt.plot(test,'.',label='test')\\n \\n ## Wait for vector to get accumulated\\n time.sleep(ACC_LEN/(512*200e6)*1e3)\\n arr = struct.unpack('>256Q',snap.read('spectrum',8*256))\\n if (freq):\\n plt.plot(FREQ,arr,'.-',lw=1,label='%s'%ANT_LABELS[ant])\\n plt.xlim(FREQ.max(), FREQ.min())\\n else:\\n plt.plot(arr,lw=2,label='%s'%ANT_LABELS[ant])\",\n \"def plot_figure5():\\n column_titles = [\\\"50 - 150m\\\", \\\"0 - 10km\\\", \\\"Ratio\\\"]\\n\\n plot_item0 = {\\n 'data': p_integral_mean[0, :, :]*1e-6,\\n 'contour_line_levels': np.linspace(0, .31, 21)[::4],\\n 'contour_fill_levels': np.linspace(0, .31, 21),\\n 'colorbar_ticks': np.linspace(0, .31, 21)[::4],\\n 'colorbar_tick_fmt': '{:.2f}',\\n 'colorbar_label': '[$MWm/m^2$]',\\n }\\n plot_item1 = {\\n 'data': p_integral_mean[1, :, :]*1e-6,\\n 'contour_line_levels': np.linspace(0, 65, 21)[::4],\\n 'contour_fill_levels': np.linspace(0, 65, 21),\\n 'colorbar_ticks': np.linspace(0, 65, 21)[::4],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': '[$MWm/m^2$]',\\n }\\n plot_item2 = {\\n 'data': plot_item1['data']/plot_item0['data'],\\n 'log_scale': True,\\n 'contour_line_levels': [300., 600.],\\n 'contour_fill_levels': np.logspace(np.log10(100.0), np.log10(6700.0), num=16),\\n 'colorbar_ticks': [100., 300., 1000., 3000.],\\n 'colorbar_tick_fmt': '{:.0f}',\\n 'colorbar_label': 'Increase factor [-]',\\n }\\n\\n plot_items = [plot_item0, plot_item1, plot_item2]\\n\\n eval_contour_fill_levels(plot_items)\\n plot_panel_1x3_seperate_colorbar(plot_items, column_titles)\",\n \"def plotOfSlice(self,index=0):\\n\\t\\tj=index;\\n\\t\\t[n,m]=_np.shape(self._data)\\n\\t\\ty=_np.zeros(n);\\n\\t\\tfor i in range(0,n):\\n\\t\\t\\ty[i]=self._data[i][j]*1e4\\n\\t\\tp1=_plot.plot(title='t=%.3f ms. %s ' % (self.time[j]*1000, self.title),\\n\\t\\t\\t\\t\\t shotno=self.shotno)\\n\\t\\ttheta=_np.linspace(self._theta[0],self._theta[-1],100)\\n#\\t\\tm0Fit=self._x[0,j]\\n\\t\\tm1Fit=self._x[0,j]+self._x[1,j]*_np.sin(theta)+self._x[2,j]*_np.cos(theta)\\n\\t\\tm2Fit=self._x[0,j]+self._x[3,j]*_np.sin(2*theta)+self._x[4,j]*_np.cos(2*theta)\\n\\t\\tm3Fit=self._x[0,j]+self._x[5,j]*_np.sin(3*theta)+self._x[6,j]*_np.cos(3*theta)\\n\\t\\tm4Fit=self._x[0,j]+self._x[7,j]*_np.sin(4*theta)+self._x[8,j]*_np.cos(4*theta)\\n\\t\\tm5Fit=self._x[0,j]+self._x[9,j]*_np.sin(5*theta)+self._x[10,j]*_np.cos(5*theta)\\n\\t\\tfitTotal=(-4.)*self._x[0,j]+m1Fit+m2Fit+m3Fit+m4Fit+m5Fit # the -4 corrects for the 4 extra offsets added from the preview 5 fits\\n\\t\\t\\n\\t\\tp1.addTrace(yData=y,xData=self._theta,\\n\\t\\t\\t\\t\\tlinestyle='',marker='.',yLegendLabel='raw')\\n\\t\\tp1.addTrace(yData=m1Fit,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=1')\\n\\t\\tp1.addTrace(yData=m2Fit,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=2')\\n\\t\\tp1.addTrace(yData=m3Fit,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=3')\\n\\t\\tp1.addTrace(yData=m4Fit,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=4')\\n\\t\\tp1.addTrace(yData=m5Fit,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=5')\\n\\t\\tp1.addTrace(yData=fitTotal,xData=theta,\\n\\t\\t\\t\\t\\tyLegendLabel='m=1-5')\\n\\t\\treturn p1\",\n \"def plot_time_slice(index, t, U, fname, levels):\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n title = 'Time slice {r} {t:0>4d}'.format(r=index, t=t)\\n ax.set_title(title)\\n U = U[:, :, t]\\n contourf = ax.contourf(U, levels)\\n fig.colorbar(contourf)\\n util.makedirs_p(os.path.dirname(fname))\\n fig.savefig(fname)\",\n \"def cplot(self, figure, i, n):\\n xx, yy = np.meshgrid(range(self.L), range(self.L))\\n ax = figure.add_subplot(2,2,n)\\n plt.setp(ax.get_yticklabels(), visible=False)\\n plt.setp(ax.get_xticklabels(), visible=False) \\n plt.pcolormesh(xx, yy, self.config, cmap=plt.cm.RdBu);\\n plt.title('Time=%d'%i, fontsize=20)\\n plt.xlabel('X', fontsize=12)\\n plt.ylabel('Y',fontsize=12) \\n plt.axis('tight') \\n self.ax = ax\",\n \"def plot(self, noTLS, path_plots, interactive):\\n fig = plt.figure(figsize=(10,12))\\n ax1 = fig.add_subplot(4, 1, 1)\\n ax2 = fig.add_subplot(4, 1, 2)\\n ax3 = fig.add_subplot(4, 2, 5)\\n ax4 = fig.add_subplot(4, 2, 6)\\n ax5 = fig.add_subplot(4, 2, 7)\\n ax6 = fig.add_subplot(4, 2, 8)\\n\\n # First panel: data from each sector\\n colors = self._get_colors(self.nlc)\\n for i, lci in enumerate(self.alllc):\\n p = lci.normalize().remove_outliers(sigma_lower=5.0, sigma_upper=5.0)\\n p.bin(5).scatter(ax=ax1, label='Sector %d' % self.sectors[i], color=colors[i])\\n self.trend.plot(ax=ax1, color='orange', lw=2, label='Trend')\\n ax1.legend(fontsize='small', ncol=4)\\n\\n # Second panel: Detrended light curve\\n self.lc.remove_outliers(sigma_lower=5.0, sigma_upper=5.0).bin(5).scatter(ax=ax2,\\n color='black',\\n label='Detrended')\\n\\n # Third panel: BLS\\n self.BLS.bls.plot(ax=ax3, label='_no_legend_', color='black')\\n mean_SR = np.mean(self.BLS.power)\\n std_SR = np.std(self.BLS.power)\\n best_power = self.BLS.power[np.where(self.BLS.period.value == self.BLS.period_max)[0]]\\n SDE = (best_power - mean_SR)/std_SR\\n ax3.axvline(self.BLS.period_max, alpha=0.4, lw=4)\\n for n in range(2, 10):\\n if n*self.BLS.period_max <= max(self.BLS.period.value):\\n ax3.axvline(n*self.BLS.period_max, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax3.axvline(self.BLS.period_max / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n sx, ex = ax3.get_xlim()\\n sy, ey = ax3.get_ylim()\\n ax3.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.2f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nSDE = %.3f' %\\n (self.BLS.period_max, self.BLS.t0_max,\\n self.BLS.depth_max, self.BLS.duration_max, SDE))\\n\\n\\n # Fourth panel: lightcurve folded to the best period from the BLS\\n self.folded.bin(1*self.nlc).scatter(ax=ax4, label='_no_legend_', color='black',\\n marker='.', alpha=0.5)\\n l = max(min(4*self.BLS.duration_max/self.BLS.period_max, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.folded.phase, self.folded.flux, x0=-0.5, nbins=nbins)\\n ax4.plot(r1[::,0], r1[::,1], marker='o', ls='None',\\n color='orange', markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n\\n lc_model = self.BLS.bls.get_transit_model(period=self.BLS.period_max,\\n duration=self.BLS.duration_max,\\n transit_time=self.BLS.t0_max)\\n lc_model_folded = lc_model.fold(self.BLS.period_max, t0=self.BLS.t0_max)\\n ax4.plot(lc_model_folded.phase, lc_model_folded.flux, color='green', lw=2)\\n ax4.set_xlim(-l, l)\\n h = max(lc_model.flux)\\n l = min(lc_model.flux)\\n ax4.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n del lc_model, lc_model_folded, r1, dt1\\n\\n\\n if not noTLS:\\n # Fifth panel: TLS periodogram\\n ax5.axvline(self.tls.period, alpha=0.4, lw=3)\\n ax5.set_xlim(np.min(self.tls.periods), np.max(self.tls.periods))\\n for n in range(2, 10):\\n ax5.axvline(n*self.tls.period, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.axvline(self.tls.period / n, alpha=0.4, lw=1, linestyle=\\\"dashed\\\")\\n ax5.set_ylabel(r'SDE')\\n ax5.set_xlabel('Period (days)')\\n ax5.plot(self.tls.periods, self.tls.power, color='black', lw=0.5)\\n ax5.set_xlim(0, max(self.tls.periods))\\n\\n period_tls = self.tls.period\\n T0_tls = self.tls.T0\\n depth_tls = self.tls.depth\\n duration_tls = self.tls.duration\\n FAP_tls = self.tls.FAP\\n\\n sx, ex = ax5.get_xlim()\\n sy, ey = ax5.get_ylim()\\n ax5.text(ex-(ex-sx)/3, ey-(ey-sy)/3,\\n 'P$_{MAX}$ = %.3f d\\\\nT0 = %.1f\\\\nDepth = %.4f\\\\nDuration = %.2f d\\\\nFAP = %.4f' %\\n (period_tls, T0_tls, 1.-depth_tls, duration_tls, FAP_tls))\\n\\n # Sixth panel: folded light curve to the best period from the TLS\\n ax6.plot(self.tls.folded_phase, self.tls.folded_y, color='black', marker='.',\\n alpha=0.5, ls='None', markersize=0.7)\\n l = max(min(4*duration_tls/period_tls, 0.5), 0.02)\\n nbins = int(50*0.5/l)\\n r1, dt1 = binningx0dt(self.tls.folded_phase, self.tls.folded_y,\\n x0=0.0, nbins=nbins, useBinCenter=True)\\n ax6.plot(r1[::,0], r1[::,1], marker='o', ls='None', color='orange',\\n markersize=5, markeredgecolor='orangered', label='_no_legend_')\\n ax6.plot(self.tls.model_folded_phase, self.tls.model_folded_model, color='green', lw=2)\\n ax6.set_xlim(0.5-l, 0.5+l)\\n h = max(self.tls.model_folded_model)\\n l = min(self.tls.model_folded_model)\\n ax6.set_ylim(l-4.*(h-l), h+5.*(h-l))\\n ax6.set_xlabel('Phase')\\n ax6.set_ylabel('Relative flux')\\n del r1, dt1\\n\\n fig.subplots_adjust(top=0.98, bottom=0.05, wspace=0.25, left=0.1, right=0.97)\\n fig.savefig(os.path.join(path_plots, 'TIC%d.pdf' % self.TIC))\\n if interactive:\\n plt.show()\\n plt.close('all')\\n del fig\",\n \"def plot(model, results, filename):\\n\\n # c = model.compartments.get_one(id='c')\\n #\\n # rna_1 = model.species_types.get_one(id='rna_1').species.get_one(compartment=c)\\n # rna_2 = model.species_types.get_one(id='rna_2').species.get_one(compartment=c)\\n # rna_3 = model.species_types.get_one(id='rna_3').species.get_one(compartment=c)\\n #\\n pops = results.get('populations')\\n time = pops.index\\n pop_rna_1 = pops['rna_1[c]']\\n pop_rna_2 = pops['rna_2[c]']\\n pop_rna_3 = pops['rna_3[c]']\\n\\n pop_atp = pops['atp[c]']\\n pop_gtp = pops['gtp[c]']\\n pop_utp = pops['ctp[c]']\\n pop_ctp = pops['utp[c]']\\n\\n pop_amp = pops['amp[c]']\\n pop_gmp = pops['gmp[c]']\\n pop_ump = pops['cmp[c]']\\n pop_cmp = pops['ump[c]']\\n\\n print(pop_rna_1, pop_atp, pop_gtp, pop_utp, pop_ctp)\\n\\n fig1, axes1 = pyplot.subplots(nrows=3, ncols=1)\\n\\n axes1[0].plot(time / 3600, pop_rna_1)\\n axes1[0].plot(time / 3600, pop_rna_2)\\n axes1[0].plot(time / 3600, pop_rna_3)\\n axes1[0].set_xlim((time[0] / 3600, time[-1] / 3600))\\n axes1[0].set_ylim((0., 10.0))\\n axes1[0].legend(loc='upper right')\\n\\n axes1[1].plot(time / 3600, pop_atp)\\n axes1[1].plot(time / 3600, pop_gtp)\\n axes1[1].plot(time / 3600, pop_utp)\\n axes1[1].plot(time / 3600, pop_ctp)\\n axes1[1].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[1].set_ylim((0., 10.0))\\n axes1[1].legend(loc='upper right')\\n\\n axes1[2].plot(time / 3600, pop_amp)\\n axes1[2].plot(time / 3600, pop_gmp)\\n axes1[2].plot(time / 3600, pop_ump)\\n axes1[2].plot(time / 3600, pop_cmp)\\n axes1[2].set_xlim((time[0] / 3600, time[-1] / 3600))\\n # axes1[2].set_ylim((0., 10.0))\\n axes1[2].legend(loc='upper right')\\n\\n fig1.savefig(filename.format('species'))\\n pyplot.close(fig1)\",\n \"def plotTrajectory(xydata, colordata = 'time', cmap = cm.jet, size = 20, ax = None, line = True):\\n \\n if isinstance(colordata, basestring) and colordata in ['time']:\\n c = np.linspace(0, len(xydata[:,0]), len(xydata[:,0]));\\n else:\\n c = colordata;\\n \\n if ax is None:\\n ax = plt.gca();\\n s = ax.scatter(xydata[:,0], xydata[:,1], c = c, cmap = cmap, s = size, marker = 'o', lw = 0);\\n if isinstance(line, basestring):\\n ax.plot(xydata[:,0], xydata[:,1], color = line); \\n \\n ax.get_figure().colorbar(s, ax = ax);\\n return ax\",\n \"def plotCombinedIncludingOceanFloors(self):\\n self.CombinedPlotHelper(minc=70,maxc=170,num=50)\",\n \"def plot_traj(ax,traj,style,color,label,mode, timestep = None):\\n x = []\\n y = []\\n i = 0.0\\n # traj = traj +zs [traj[0]]\\n for co in traj:\\n rotX, rotY, rotZ = quaternion_to_euler(co[4], co[5], co[6], co[7])\\n if mode == 'xy':\\n x.append(co[0+1])\\n y.append(co[1+1])\\n if mode == 'xz':\\n x.append(co[0+1])\\n y.append(co[2+1])\\n if mode == 'yz':\\n x.append(co[1+1])\\n y.append(co[2+1])\\n\\n if mode == 'rotx':\\n x.append(i)\\n y.append(rotX)\\n if mode == 'roty':\\n x.append(i)\\n y.append(rotY)\\n if mode == 'rotz':\\n x.append(i)\\n y.append(rotZ)\\n\\n if mode == 'ax':\\n x.append(i)\\n y.append(co[1])\\n if mode == 'ay':\\n x.append(i)\\n y.append(co[2])\\n if mode == 'az':\\n x.append(i)\\n y.append(co[3])\\n i += timestep\\n\\n ax.plot(x,y,style,color=color,label=label)\",\n \"def OneDynSpectraPlotPhD(Data, Vmin, Vmax, Suptitle, CBarLabel, no_of_spectra, TimeScale,\\n frequency, FreqPointsNum, colormap, Xlabel, fig_file_name,\\n currentDate, currentTime, Software_version, customDPI):\\n\\n fig, axarr = plt.subplots(1, 1, figsize=(16.0, 7.0))\\n im0 = axarr.imshow(np.flipud(Data), aspect='auto', vmin=Vmin, vmax=Vmax,\\n extent=[0, no_of_spectra, frequency[0], frequency[-1]], cmap=colormap)\\n rc('font', size=14, weight='bold')\\n # plt.rcParams[\\\"font.family\\\"] = \\\"Times New Roman\\\" # !!! NEW !!!\\n axarr.set_ylabel('Частота, МГц', fontweight='bold', fontsize=14)\\n #fig.suptitle(Suptitle, fontsize = 10, fontweight = 'bold', x = 0.46, y = 0.96)\\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=14, fontweight='bold')\\n cbar = fig.colorbar(im0, ax=axarr, pad=0.005)\\n cbar.ax.tick_params(labelsize=14)\\n cbar.set_label(CBarLabel, fontsize=14, fontweight='bold')\\n text = axarr.get_xticks().tolist()\\n for i in range(len(text)-1):\\n k = int(text[i])\\n text[i] = TimeScale[k]\\n # text[i] = TimeScale[k][0:20]\\n\\n ticks_loc = axarr.get_xticks().tolist() # <---- Added to suppress warning\\n axarr.xaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n ticks_loc = axarr.get_yticks().tolist() # <---- Added to suppress warning\\n axarr.yaxis.set_major_locator(mticker.FixedLocator(ticks_loc)) # <---- Added to suppress warning\\n axarr.set_xticklabels(text, fontsize=12, fontweight='bold')\\n axarr.set_yticklabels(axarr.get_yticks(), fontsize=12, fontweight='bold')\\n axarr.set_xlabel(Xlabel, fontsize=14, fontweight='bold')\\n pylab.savefig(fig_file_name, bbox_inches='tight', dpi=customDPI)\\n plt.close('all')\\n return\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def pf_plot(pf, t):\\n xx = pf.XS[t, :, 0]\\n yy = pf.XS[t, :, 1]\\n ww = pf.WS[t, :]\\n plt.scatter(xx, yy, s=ww * 5000)\",\n \"def update_plot(axes):\\n axes.clear()\\n\\n i = C.i\\n C.i += di # globale Zählvariable erhöhen\\n if C.i >= len(tt):\\n time.sleep(2)\\n C.i = 0\\n\\n t = tt[i]\\n q1 = qq1[i]\\n q2 = qq2[i]\\n q3 = qq3[i]\\n CCframe(q1, q2, q3)\\n\\n # Ausgabe der aktuellen Zeit\\n pl.text(0.06, 0.05, \\\"t = %3.2fs\\\" % t, transform = axes.transAxes)\\n pl.axis([-3, 3, -3, 3])\\n axes.figure.canvas.draw()\",\n \"def plot_array(self):\\n locations = np.array([getattr(pulsar, 'location') for pulsar in self.pulsars])\\n fig = plt.figure()\\n ax = plt.subplot(111, projection=\\\"hammer\\\")\\n for location in locations:\\n plt.plot(location.ra, location.dec, '.', color='b')\\n return fig\",\n \"def generateTrajectoryPlots(dir_path, traj_list, plot_name='scecliptic', plot_vg=True, plot_sol=True, \\\\\\n plot_density=True, plot_showers=False):\\n\\n\\n\\n ### Plot Sun-centered geocentric ecliptic plots ###\\n\\n lambda_list = []\\n beta_list = []\\n vg_list = []\\n sol_list = []\\n\\n shower_no_list = []\\n shower_obj_dict = {}\\n\\n hypo_count = 0\\n jd_min = np.inf\\n jd_max = 0\\n for traj in traj_list:\\n\\n # Reject all hyperbolic orbits\\n if traj.orbit.e > 1:\\n hypo_count += 1\\n continue\\n\\n # Compute Sun-centered longitude\\n lambda_list.append(traj.orbit.L_g - traj.orbit.la_sun)\\n\\n beta_list.append(traj.orbit.B_g)\\n vg_list.append(traj.orbit.v_g/1000)\\n sol_list.append(np.degrees(traj.orbit.la_sun))\\n\\n # Track first and last observation\\n jd_min = min(jd_min, traj.jdt_ref)\\n jd_max = max(jd_max, traj.jdt_ref)\\n\\n\\n\\n if plot_showers:\\n\\n # Perform shower association and track the list of all showers\\n shower_obj = associateShowerTraj(traj)\\n\\n # If the trajectory was associated, sort it to the appropriate shower\\n if shower_obj is not None:\\n if shower_obj.IAU_no not in shower_no_list:\\n shower_no_list.append(shower_obj.IAU_no)\\n shower_obj_dict[shower_obj.IAU_no] = [shower_obj]\\n else:\\n shower_obj_dict[shower_obj.IAU_no].append(shower_obj)\\n\\n\\n\\n # Compute mean shower radiant for all associated showers\\n shower_obj_list = []\\n if plot_showers and shower_obj_dict:\\n for shower_no in shower_obj_dict:\\n\\n # Check if there are enough shower members for plotting\\n if len(shower_obj_dict[shower_no]) < MIN_SHOWER_MEMBERS:\\n continue\\n\\n la_sun_mean = meanAngle([sh.la_sun for sh in shower_obj_dict[shower_no]])\\n L_g_mean = meanAngle([sh.L_g for sh in shower_obj_dict[shower_no]])\\n B_g_mean = np.mean([sh.B_g for sh in shower_obj_dict[shower_no]])\\n v_g_mean = np.mean([sh.v_g for sh in shower_obj_dict[shower_no]])\\n\\n # Init a new shower object\\n shower_obj_mean = MeteorShower(la_sun_mean, L_g_mean, B_g_mean, v_g_mean, shower_no)\\n\\n shower_obj_list.append(shower_obj_mean)\\n\\n\\n\\n print(\\\"Hyperbolic percentage: {:.2f}%\\\".format(100*hypo_count/len(traj_list)))\\n\\n # Compute the range of solar longitudes\\n sol_min = np.degrees(jd2SolLonSteyaert(jd_min))\\n sol_max = np.degrees(jd2SolLonSteyaert(jd_max))\\n\\n\\n\\n # Plot SCE vs Vg\\n if plot_vg:\\n plotSCE(lambda_list, beta_list, vg_list, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"$V_g$ (km/s)\\\", dir_path, plot_name + \\\"_vg.png\\\", \\\\\\n shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n\\n\\n # Plot SCE vs Sol\\n if plot_sol:\\n plotSCE(lambda_list, beta_list, sol_list, (sol_min, sol_max), \\\\\\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Solar longitude (deg)\\\", dir_path, \\\\\\n plot_name + \\\"_sol.png\\\", shower_obj_list=shower_obj_list, plot_showers=plot_showers)\\n \\n\\n \\n # Plot SCE orbit density\\n if plot_density:\\n plotSCE(lambda_list, beta_list, None, (sol_min, sol_max), \\n \\\"Sun-centered geocentric ecliptic coordinates\\\", \\\"Count\\\", dir_path, plot_name + \\\"_density.png\\\", \\\\\\n density_plot=True, shower_obj_list=shower_obj_list, plot_showers=plot_showers)\",\n \"def plotOfOneChannel(self, i=0):\\n p1=_plot.plot(xLabel='time [ms]',yLabel=r'a.u.',title=self.title,\\n\\t\\t\\t\\t\\t shotno=[self.shotno],subtitle='%d' %i);\\n\\t\\t\\n\\t\\t# smoothed data\\n p1.addTrace(yData=self.data[i],xData=self.time*1000,\\n\\t\\t\\t\\t\\tyLegendLabel=str(i)) \\n\\t\\t\\t\\n return p1\",\n \"def plot_fig43b_spreading_yeast():\\n fig, ax = plt.subplots(figsize=(default_width, default_height))\\n y = np.loadtxt('csvs/ratio_lp50a10ad5hp0.0067379_yeast.txt')\\n links35 = np.tile(35, 44)\\n Rlinks = np.array([47, 21, 18, 15, 20, 17])\\n Llinks = np.array([245, 30, 26, 15, 23, 35])\\n #links to right of methylation site (50 in total)\\n Rlinks = np.concatenate((Rlinks, links35))\\n #links to left of methylation site (50 in total)\\n Llinks = np.concatenate((Llinks, links35))\\n #cumulative chain length including burried basepairs\\n unwrap = 0\\n #plot as positive distance from TSS in bp\\n ldna_Rlinks = convert.genomic_length_from_links_unwraps(Rlinks, unwraps=unwrap) #max WLC chain length in bp\\n #plot as negative distance from TSS in bp\\n ldna_Llinks = -1*convert.genomic_length_from_links_unwraps(Llinks, unwraps=unwrap) #max WLC chain length in bp\\n x = np.concatenate((ldna_Llinks[::-1], ldna_Rlinks))\\n ax.plot(x, y, color='k')\\n ax.set_xlabel(r'Distance from TSS (bp)')\\n ax.set_ylabel('Relative enrichment')\\n #plot inset using Crabtree data\\n axins = inset_axes(ax, width=\\\"40%\\\", height=\\\"40%\\\", \\n bbox_to_anchor=(.1, .1, .8, .8),\\n bbox_transform=ax.transAxes, loc=2)\\n xcrabtree = np.array([-10256, -3077, -2241, -1485, -739, -309, -169, 489, 1746, 3087, 4400, 5300])\\n REday0 = np.array([0.27, 0.13, 0.46, 0.12, 0.17, 0.33, 0.33, 0.31, 0.32, 0.27, 0.21, 0.33])\\n REday5 = np.array([0.19, 0.40, 0.89, 1.55, 0.97, 1.25, 2.25, 3.57, 3.03, 2.09, 1.12, 0.14])\\n ycrabtree = REday5/np.mean(REday0)\\n axins.plot(xcrabtree, ycrabtree)\\n axins.set_xlim([-10000, 10000])\\n ax.set_xlim([-10000, 10000])\\n #axins.set_ylabel('Relative enrichment', fontsize=8)\\n #axins.set_xlabel('Distance from TSS (bp)', fontsize=8)\\n plt.subplots_adjust(left=0.16, bottom=0.19, top=0.98, right=0.96)\\n plt.savefig(f'plots/thesis/fig43b_spreading-TSS-yeast.pdf', bbox_inches='tight')\",\n \"def plot_limit(bolo_name, list_mass, analysis_type, exposure, detector_mass = 0.6):\\n\\n d_graph = {}\\n list_color = [kOrange-8, kGreen+2, kBlue-7, kRed, kBlack, kMagenta, kAzure+10, kGreen-3, kOrange-9]\\n\\n for index, heat_fraction in enumerate([\\\"0.3\\\",\\\"0.4\\\",\\\"0.5\\\",\\\"0.8\\\",\\\"1\\\"]):\\n d_graph[heat_fraction] = get_simulated_event_limit(bolo_name, list_mass, analysis_type, \\\"_\\\" + heat_fraction, exposure, detector_mass = 0.6)\\n d_graph[heat_fraction].SetName(heat_fraction)\\n PyRPl.process_TGraph(d_graph[heat_fraction], color = list_color[index])\\n\\n gr_edw_poisson = get_limit_graph(\\\"./Text_files/edw3_ana_1.5_0_5_poisson.txt\\\", 2, kBlack)\\n gr_edw_low = get_limit_graph(\\\"./Text_files/Published_limits/edw_lowmass_2012.txt\\\", 2, kRed)\\n gr_edw_low.SetLineStyle(7)\\n gr_cdms = get_limit_graph(\\\"./Text_files/Published_limits/cdms_limit.txt\\\", 2, kBlue)\\n\\n h = TH1F(\\\"h\\\", \\\"\\\", 100, 3,25)\\n PyRPl.process_TH1(h, X_title = \\\"Mass (GeV)\\\", Y_title = \\\"#sigma (pb)\\\", X_title_size = .06, Y_title_size = .06, X_title_offset = .98, Y_title_offset = .95)\\n\\n\\n gr_edw_low.SetName(\\\"gr_edw_low\\\")\\n gr_edw_poisson.SetName(\\\"gr_edw_poisson\\\")\\n gr_cdms.SetName(\\\"gr_cdms\\\")\\n\\n cc = TCanvas(\\\"cc\\\", \\\"cc\\\")\\n gPad.SetLogy()\\n gPad.SetLogx()\\n h.SetMaximum(1E-1)\\n h.SetMinimum(4E-8)\\n h.Draw()\\n\\n gr_cdms.Draw(\\\"sameC\\\")\\n gr_edw_poisson.Draw(\\\"sameC\\\")\\n gr_edw_low.Draw(\\\"sameC\\\")\\n\\n for index, heat_fraction in enumerate([\\\"0.3\\\",\\\"0.4\\\",\\\"0.5\\\",\\\"0.8\\\",\\\"1\\\"]):\\n d_graph[heat_fraction].Draw(\\\"sameC\\\")\\n\\n leg =TLegend(0.564,0.584,0.83,0.857)\\n leg.AddEntry(\\\"gr_cdms\\\", \\\"SCDMS\\\" , \\\"l\\\")\\n leg.AddEntry(\\\"gr_edw_low\\\", \\\"EDW II\\\" , \\\"l\\\")\\n leg.AddEntry(\\\"gr_edw_poisson\\\", \\\"EDW III Poisson\\\" , \\\"l\\\")\\n for index, heat_fraction in enumerate([\\\"0.3\\\",\\\"0.4\\\",\\\"0.5\\\",\\\"0.8\\\",\\\"1\\\"]):\\n leg.AddEntry( d_graph[heat_fraction].GetName(), heat_fraction , \\\"l\\\")\\n\\n leg.SetFillColor(kWhite)\\n leg.SetLineColor(kWhite)\\n leg.Draw()\\n raw_input()\",\n \"def setplot(plotdata):\\n#-------------------------- \\n\\n\\n plotdata.clearfigures() # clear any old figures,axes,items data\\n\\n # Figure for q[0]\\n plotfigure = plotdata.new_plotfigure(name='Pressure', figno=1)\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.axescmd = 'subplot(211)'\\n \\n #plotaxes.xlimits = [0.,150.]\\n plotaxes.ylimits = [-1.,1.0]\\n plotaxes.title = 'Pressure'\\n\\n # Set up for item on these axes:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n plotitem.plot_var = 0\\n plotitem.plotstyle = '-o'\\n plotitem.color = 'b'\\n plotitem.show = True # show on plot?\\n plotitem.kwargs = {'linewidth':2,'markersize':5}\\n \\n\\n\\n # Set up for axes in this figure:\\n plotaxes = plotfigure.new_plotaxes()\\n plotaxes.axescmd = 'subplot(212)'\\n plotaxes.xlimits = 'auto'\\n plotaxes.ylimits = [-1.,1.]\\n plotaxes.title = 'Velocity'\\n\\n # Set up for item on these axes:\\n plotitem = plotaxes.new_plotitem(plot_type='1d_plot')\\n plotitem.plot_var = 1\\n plotitem.plotstyle = '-'\\n plotitem.color = 'b'\\n plotitem.show = True # show on plot?\\n plotitem.kwargs = {'linewidth':3,'markersize':5}\\n \\n\\n # Parameters used only when creating html and/or latex hardcopy\\n # e.g., via visclaw.frametools.printframes:\\n\\n plotdata.printfigs = True # print figures\\n plotdata.print_format = 'png' # file format\\n plotdata.print_framenos = 'all' # list of frames to print\\n plotdata.print_fignos = 'all' # list of figures to print\\n plotdata.html = True # create html files of plots?\\n plotdata.html_homelink = '../README.html'\\n plotdata.latex = True # create latex file of plots?\\n plotdata.latex_figsperline = 2 # layout of plots\\n plotdata.latex_framesperline = 1 # layout of plots\\n plotdata.latex_makepdf = False # also run pdflatex?\\n\\n return plotdata\",\n \"def gaze_ethoplot(anglearrays,title,show = True,save = False):\\n colors = ['red','blue']\\n labels = ['fish1 gaze', 'fish2 gaze']\\n fig,ax = plt.subplots(2,1,sharex = True)\\n for i in range(2):\\n anglearray = anglearrays[i]\\n inds = np.arange(len(anglearray))\\n color = colors[i]\\n ax[0].plot(anglearray,color = color,linewidth = 1,alpha = 0.5,label = labels[i])\\n boolean = anglearray.apply(lambda x: 1 if x > 140 else 0) \\n [ax[1].axvline(x = j,alpha = 0.2,color = color) for j in inds if boolean[j] == 1]\\n\\n ax[0].set_ylabel('relative angle (degrees)')\\n ax[1].set_ylabel('threshold crossing')\\n ax[1].set_xlabel('time (frame)')\\n ax[0].set_title(title)\\n\\n ax[0].legend(loc = 1)## in the upper right; faster than best. \\n\\n if save == True:\\n plt.savefig(title + '.png')\\n \\n if show == True:\\n plt.show()\",\n \"def animate(input_filename):\\n # With matplotlib, it's much, much faster to just update the properties\\n # of a display object than it is to create a new one, so we'll just update\\n # the data and position of the same objects throughout this animation...\\n\\n infile = paw_file(input_filename)\\n\\n # Since we're making an animation with matplotlib, we need \\n # ion() instead of show()...\\n plt.ion()\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n fig.suptitle(input_filename)\\n\\n # Make an image based on the first frame that we'll update later\\n # (The first frame is never actually displayed)\\n im = ax.imshow(infile.next()[1])\\n\\n # Make 4 rectangles that we can later move to the position of each paw\\n rects = [Rectangle((0,0), 1,1, fc='none', ec='red') for i in range(4)]\\n [ax.add_patch(rect) for rect in rects]\\n\\n title = ax.set_title('Time 0.0 ms')\\n\\n # Process and display each frame\\n for time, frame in infile:\\n paw_slices = find_paws(frame)\\n\\n # Hide any rectangles that might be visible\\n [rect.set_visible(False) for rect in rects]\\n\\n # Set the position and size of a rectangle for each paw and display it\\n for slice, rect in zip(paw_slices, rects):\\n dy, dx = slice\\n rect.set_xy((dx.start, dy.start))\\n rect.set_width(dx.stop - dx.start + 1)\\n rect.set_height(dy.stop - dy.start + 1)\\n rect.set_visible(True)\\n\\n # Update the image data and title of the plot\\n title.set_text('Time %0.2f ms' % time)\\n im.set_data(frame)\\n im.set_clim([frame.min(), frame.max()])\\n fig.canvas.draw()\",\n \"def plot_timeres(timeres):\\n tint = 24 / len(timeres.intervals)\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n\\n # if distrib:\\n # cont = cont / np.max(cont)\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=cont[i] * circlesize,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n # else:\\n # for i in range(cont.shape[0]):\\n # if cont[i] > 0.01:\\n # cx = cluster.cluster_centers_[i][0]\\n # cy = cluster.cluster_centers_[i][1]\\n # mymap.circle_marker(location=[cx, cy],\\n # radius=30,\\n # line_color='#FF0000',\\n # fill_color='#110000')\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + \\\\\\n (str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros(cluster.num_clusters())\\n for i in range(self.dataset.shape[0]):\\n posy = self.dataset[i][0]\\n posx = self.dataset[i][1]\\n ejem = np.array([[posy, posx]]).reshape(1,-1)\\n ncl = cluster.predict(ejem)\\n ncl = ncl[0]\\n\\n _, evtime = timeres.discretize(self.dataset[i][2])\\n\\n if evtime == t:\\n if distrib:\\n cont[ncl] += 1\\n else:\\n cont[ncl] = 1\\n if distrib:\\n cont = cont / np.max(cont)\\n for i in range(cont.shape[0]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=cont[i] * circlesize,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i] > 0.01:\\n cx = cluster.cluster_centers_[i][0]\\n cy = cluster.cluster_centers_[i][1]\\n mymap.circle_marker(location=[cx, cy],\\n radius=30,\\n line_color=pltcolors[t],\\n fill_color=pltcolors[t], #'#110000',\\n popup=str(t) + '-' + str(cont[i]), fill_opacity=0.2)\",\n \"def _plot_particle_level_spectra_with_matplotlib(ep_analyses: AnalysesBase,\\n output_name: str,\\n output_info: analysis_objects.PlottingOutputWrapper,\\n general_labels: Dict[str, str],\\n plot_labels: plot_base.PlotLabels) -> None:\\n # Setup\\n fig, ax = plt.subplots(figsize = (8, 6))\\n # Diamond, square, up triangle, circle\\n markers = [\\\"D\\\", \\\"s\\\", \\\"^\\\", \\\"o\\\"]\\n colors = [\\\"black\\\", \\\"blue\\\", \\\"green\\\", \\\"red\\\"]\\n # Label axes\\n plot_labels.apply_labels(ax)\\n\\n # Plot the actual hists. The inclusive orientation will be plotted first.\\n particle_level_max_pt = 0\\n for analysis, color, marker in zip(ep_analyses.values(), colors, markers):\\n # Store this value for convenience. It is the same for all orientations.\\n particle_level_max_pt = analysis.task_config[\\\"particle_level_spectra\\\"][\\\"particle_level_max_pt\\\"]\\n\\n # For inclusive, use open markers that are plotted on top of all points.\\n additional_args = {}\\n if analysis.reaction_plane_orientation == params.ReactionPlaneOrientation.inclusive:\\n additional_args.update({\\n \\\"fillstyle\\\": \\\"none\\\",\\n \\\"zorder\\\": 10,\\n })\\n\\n # Convert and plot hist\\n h = histogram.Histogram1D.from_existing_hist(analysis.particle_level_spectra)\\n ax.errorbar(\\n h.x, h.y,\\n xerr = (h.bin_edges[1:] - h.bin_edges[:-1]) / 2,\\n yerr = h.errors,\\n label = analysis.reaction_plane_orientation.display_str(),\\n color = color,\\n marker = marker,\\n linestyle = \\\"\\\",\\n **additional_args\\n )\\n\\n # Final presentation settings\\n # Axis ticks\\n ax.xaxis.set_major_locator(matplotlib.ticker.MultipleLocator(base = 10))\\n ax.xaxis.set_minor_locator(matplotlib.ticker.MultipleLocator(base = 2))\\n tick_shared_args = {\\n \\\"axis\\\": \\\"both\\\",\\n \\\"bottom\\\": True,\\n \\\"left\\\": True,\\n }\\n ax.tick_params(\\n which = \\\"major\\\",\\n # Size of the axis mark labels\\n labelsize = 15,\\n length = 8,\\n **tick_shared_args,\\n )\\n ax.tick_params(\\n which = \\\"minor\\\",\\n length = 4,\\n **tick_shared_args,\\n )\\n # Limits\\n ax.set_xlim(0, particle_level_max_pt)\\n # Unfortunately, MPL doesn't calculate restricted log limits very nicely, so we\\n # we have to set the values by hand.\\n # We grab the value from the last analysis object - the value will be the same for all of them.\\n y_limits = analysis.task_config[\\\"particle_level_spectra\\\"][\\\"y_limits\\\"]\\n ax.set_ylim(y_limits[0], y_limits[1])\\n ax.set_yscale(\\\"log\\\")\\n # Legend\\n ax.legend(\\n loc = \\\"lower left\\\",\\n frameon = False,\\n fontsize = 18,\\n )\\n # Combine the general labels and then plot them.\\n label = \\\"\\\\n\\\".join(general_labels.values())\\n # The label is anchored in the upper right corner.\\n ax.text(0.95, 0.95, s = label,\\n horizontalalignment = \\\"right\\\",\\n verticalalignment = \\\"top\\\",\\n multialignment = \\\"right\\\",\\n fontsize = 18,\\n transform = ax.transAxes)\\n fig.tight_layout()\\n\\n # Finally, save and cleanup\\n output_name += \\\"_mpl\\\"\\n plot_base.save_plot(output_info, fig, output_name)\\n plt.close(fig)\",\n \"def make_plot(d0,t0,d1,t1,d2,t2,d3,t3,suptitle,path_out):\\n fig0 = plt.figure(1,(10.,7.))\\n grid = ImageGrid(fig0, 111, # similar to subplot(111)\\n nrows_ncols = (2, 2), # creates 2x2 grid of axes\\n axes_pad=0.4, # pad between axes in inch.\\n share_all=True, # share axes\\n cbar_mode='each')\\n \\n im = grid[0].pcolor(d0)\\n grid[0].set_title(t0)\\n grid.cbar_axes[0].colorbar(im)\\n grid[0].axis([0,d0.shape[1],0,d0.shape[0]])\\n \\n im = grid[1].pcolor(d1)\\n grid[1].set_title(t1)\\n grid.cbar_axes[1].colorbar(im)\\n grid[0].axis([0,d1.shape[1],0,d1.shape[0]])\\n \\n im = grid[2].pcolor(d2)\\n grid[2].set_title(t2)\\n grid.cbar_axes[2].colorbar(im)\\n grid[0].axis([0,d2.shape[1],0,d2.shape[0]])\\n \\n im = grid[3].pcolor(d3)\\n grid[3].set_title(t3) \\n grid.cbar_axes[3].colorbar(im)\\n grid[0].axis([0,d3.shape[1],0,d3.shape[0]])\\n\\n \\n fig0.suptitle(suptitle,fontsize=18)\\n \\n fig0.savefig(path_out, dpi=300)\\n fig0.clf()\\n return\",\n \"def plot_results_traj_3d(p_x, p_y, p_z, xmin, xmax, ymin, ymax, zmin, zmax):\\n fig, ax = plt.subplots(2 , 2, figsize = (10, 10))\\n \\n for p in np.arange(0, p_x.shape[0], step = 1): \\n for t in np.arange(0, p_x.shape[1], step = 1): \\n ax[0,0].plot(t, p_x[p, t], 'rx') \\n ax[0,1].plot(t, p_y[p, t], 'gx') \\n ax[1,0].plot(t, p_z[p, t], 'bx') \\n ax[1,1].plot(t, p_x[p, t], 'rx') \\n ax[1,1].plot(t, p_y[p, t], 'gx') \\n ax[1,1].plot(t, p_z[p, t], 'bx') \\n for a in ax.flat: \\n a.set(xlabel = 'Time steps', ylabel = 'Position')\\n ax[0,0].set_title('X (pix)') \\n ax[0,0].set_ylim([xmin, xmax]) \\n ax[0,1].set_title('Y (pix)') \\n ax[0,1].set_ylim([ymin, ymax]) \\n ax[1,0].set_title('Z (pix)') \\n ax[1,0].set_ylim([zmin, zmax])\\n ax[1,1].set_title('Positions combined') \\n ax[1,1].set_ylim([np.array([xmin, ymin, zmin]).min(), np.array([xmax, ymax, zmax]).max()])\",\n \"def making_plot(sample_points_x_y_nonZero, gauge_volume, y_upper_imit, y_lower_limit,\\n sample_height=10, sample_width=5., min_color=None, max_color = None):\\n if sample_points_x_y_nonZero.size==0:\\n print \\\"the array does not have a non zero gauge volume\\\"\\n\\n\\n else:\\n\\n xS, yS=sample_points_x_y_nonZero\\n X,Y= np.meshgrid(xS,yS)\\n\\n gauge_volume=np.array(gauge_volume)\\n\\n Z = griddata((xS,yS), gauge_volume, (X,Y), method='nearest')\\n\\n plt.figure()\\n # r=plt.contour( X, Y,Z)\\n # plt.clabel(r, inline=1, fontsize=10)\\n plt.pcolormesh(X, Y, Z, cmap = plt.get_cmap('rainbow'),vmin=min_color, vmax=max_color )\\n plt.xlabel('points along sample width (mm)')\\n plt.ylabel('points along sample height (mm)')\\n plt.ylim(y_lower_limit,y_upper_imit)\\n plt.colorbar()\\n plt.axhline(y=-sample_height/2., color='r', linestyle='-')\\n plt.axhline(y=sample_height/2., color='r', linestyle='-')\\n plt.axvline(x=- sample_width/2., color='r', linestyle='-')\\n plt.axvline(x= sample_width/2., color='r', linestyle='-')\\n # plt.scatter(xS,yS ,marker = 'o', c = 'b', s = 5, zorder = 10)\\n plt.savefig(os.path.join(thisdir, '../figures/{sample}.png'.format(sample='gauge_volume')))\\n plt.show()\",\n \"def plot_vanHove_dt(comp,conn,start,step_size,steps):\\n \\n (fin,) = conn.execute(\\\"select fout from comps where comp_key = ?\\\",comp).fetchone()\\n (max_step,) = conn.execute(\\\"select max_step from vanHove_prams where comp_key = ?\\\",comp).fetchone()\\n Fin = h5py.File(fin,'r')\\n g = Fin[fd('vanHove',comp[0])]\\n\\n temp = g.attrs['temperature']\\n dtime = g.attrs['dtime']\\n\\n\\n # istatus = plots.non_i_plot_start()\\n \\n fig = mplt.figure()\\n fig.suptitle(r'van Hove dist temp: %.2f dtime: %d'% (temp,dtime))\\n dims = figure_out_grid(steps)\\n \\n plt_count = 1\\n outs = []\\n tmps = []\\n for j in range(start,start+step_size*steps, step_size):\\n (edges,count,x_lim) = _extract_vanHove(g,j+1,1,5)\\n if len(count) < 50:\\n plt_count += 1\\n continue\\n #count = count/np.sum(count)\\n \\n sp_arg = dims +(plt_count,)\\n ax = fig.add_subplot(*sp_arg)\\n ax.grid(True)\\n\\n \\n alpha = _alpha2(edges,count)\\n \\n ax.set_ylabel(r'$\\\\log{P(N)}$')\\n ax.step(edges,np.log((count/np.sum(count))),lw=2)\\n ax.set_title(r'$\\\\alpha_2 = %.2f$'%alpha + ' j:%d '%j )\\n ax.set_xlim(x_lim)\\n plt_count += 1\\n\\n mplt.draw()\\n\\n # plots.non_i_plot_start(istatus)\\n\\n del g\\n Fin.close()\\n del Fin\",\n \"def plot_iou_over_time(path, iou, bboxes, bboxes_noisy):\\r\\n capture = cv2.VideoCapture(path)\\r\\n success = True\\r\\n rescaling_factor = 0.25\\r\\n margin = 0\\r\\n while success:\\r\\n success, frame = capture.read()\\r\\n current_frame = int(capture.get(cv2.CAP_PROP_POS_FRAMES))\\r\\n print('frame: ', current_frame)\\r\\n\\r\\n plt.subplot(2, 1, 1)\\r\\n plt.imshow(cv2.resize(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), (0,0), fx=rescaling_factor, fy=rescaling_factor))\\r\\n if str(current_frame) in bboxes.keys():\\r\\n for bbox in bboxes[str(current_frame)]:\\r\\n rect = pat.Rectangle((bbox[1]*rescaling_factor, bbox[2]*rescaling_factor),\\r\\n bbox[3]*rescaling_factor, bbox[4]*rescaling_factor,\\r\\n linewidth=1, edgecolor='r', facecolor='none')\\r\\n plt.gca().add_patch(rect)\\r\\n if str(current_frame) in bboxes_noisy.keys():\\r\\n for bbox_noisy in bboxes_noisy[str(current_frame)]:\\r\\n rect = pat.Rectangle((bbox_noisy[1]*rescaling_factor, bbox_noisy[2]*rescaling_factor),\\r\\n bbox_noisy[3]*rescaling_factor, bbox_noisy[4]*rescaling_factor,\\r\\n linewidth=1, edgecolor='b', facecolor='none')\\r\\n plt.gca().add_patch(rect)\\r\\n plt.subplot(2, 1, 2)\\r\\n if current_frame > 150: margin = current_frame - 150\\r\\n plt.plot(iou[margin:current_frame])\\r\\n plt.show(block=False)\\r\\n\\r\\n plt.pause(0.0001)\\r\\n plt.clf()\\r\\n\\r\\n capture.release()\",\n \"def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\\n action_legend_location=None):\\n\\n #get location of files\\n running_reward_file, _, actions_file = \\\\\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\\n\\n #font size\\n matplotlib.rcParams.update({'font.size': 14, \\\"text.usetex\\\": True,\\n 'text.latex.preamble' : r'\\\\usepackage{amsmath}\\\\usepackage{physics}'})\\n\\n #create the axis (subplots)\\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\\n reward_ax = fig.add_subplot(gs[0, :])\\n prot_0_ax = fig.add_subplot(gs[1, 0])\\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\\n prot_final_ax = fig.add_subplot(gs[2, :])\\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \\n\\n #set the reward axis\\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\\n custom_color = \\\"black\\\", lines_to_mark = [nearest_int(act_0/actions_per_log),\\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\\n custom_mark_color=\\\"black\\\",ylim=reward_ylim,ylabel=reward_ylabel,\\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\\n legend_labels=reward_legend_labels)\\n\\n #set the three actions axis\\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\\n two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_1,ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_2, ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\\n\\n #set the final protocol axis\\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\\n actions_ylim=large_action_ylim,plot_to_file_line=None,\\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\\n linewidth = prot_linewidth, xlabel=\\\"$t[dt]$\\\",extra_cycles=extra_cycles,\\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\\n legend_text=action_legend_text, legend_location=action_legend_location)\\n\\n #add the (a) (b) (c) labels\\n reward_ax.text(-0.11,-0.38, r'\\\\textbf{(a)}', transform=reward_ax.transAxes )\\n prot_0_ax.text(-0.4,-0.55, r'\\\\textbf{(b)}', transform=prot_0_ax.transAxes )\\n prot_final_ax.text(-0.11,-0.38, r'\\\\textbf{(c)}', transform=prot_final_ax.transAxes )\\n\\n #save if necessary\\n if plot_file_name is not None:\\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\\n plot_file_name = os.path.join(plot_folder, plot_file_name)\\n plt.savefig(plot_file_name)\\n\\n #show\\n plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6307774","0.6264446","0.6067582","0.5951146","0.594318","0.59195983","0.59024936","0.5900452","0.5894213","0.5889887","0.58874977","0.5886258","0.58600056","0.58458775","0.58402437","0.5836458","0.5819858","0.57920396","0.5785791","0.5773497","0.577211","0.5762697","0.57317036","0.57077646","0.5702603","0.5696181","0.56796354","0.56711924","0.5668726","0.5646131","0.5645368","0.5642955","0.5642607","0.5638602","0.56158984","0.5605723","0.5594444","0.55931664","0.5592298","0.5584942","0.5579647","0.5578534","0.5563942","0.55617017","0.5559112","0.55560374","0.5555399","0.55535835","0.55529785","0.5547019","0.5542472","0.55375236","0.55348635","0.5528795","0.55181944","0.55179733","0.55144835","0.5502174","0.5499886","0.5497838","0.5491796","0.54909736","0.5487393","0.5483045","0.54772043","0.54740274","0.5464355","0.5462682","0.54593265","0.5452867","0.5451174","0.5449479","0.5432201","0.54307026","0.54295343","0.5429109","0.5427797","0.54198635","0.54193604","0.5418964","0.5418058","0.5416104","0.54143554","0.5410854","0.5409203","0.5391215","0.5389367","0.538148","0.5379388","0.53779256","0.5376618","0.5376551","0.53704655","0.53688544","0.536318","0.53614247","0.53551435","0.53540194","0.535347","0.53529334"],"string":"[\n \"0.6307774\",\n \"0.6264446\",\n \"0.6067582\",\n \"0.5951146\",\n \"0.594318\",\n \"0.59195983\",\n \"0.59024936\",\n \"0.5900452\",\n \"0.5894213\",\n \"0.5889887\",\n \"0.58874977\",\n \"0.5886258\",\n \"0.58600056\",\n \"0.58458775\",\n \"0.58402437\",\n \"0.5836458\",\n \"0.5819858\",\n \"0.57920396\",\n \"0.5785791\",\n \"0.5773497\",\n \"0.577211\",\n \"0.5762697\",\n \"0.57317036\",\n \"0.57077646\",\n \"0.5702603\",\n \"0.5696181\",\n \"0.56796354\",\n \"0.56711924\",\n \"0.5668726\",\n \"0.5646131\",\n \"0.5645368\",\n \"0.5642955\",\n \"0.5642607\",\n \"0.5638602\",\n \"0.56158984\",\n \"0.5605723\",\n \"0.5594444\",\n \"0.55931664\",\n \"0.5592298\",\n \"0.5584942\",\n \"0.5579647\",\n \"0.5578534\",\n \"0.5563942\",\n \"0.55617017\",\n \"0.5559112\",\n \"0.55560374\",\n \"0.5555399\",\n \"0.55535835\",\n \"0.55529785\",\n \"0.5547019\",\n \"0.5542472\",\n \"0.55375236\",\n \"0.55348635\",\n \"0.5528795\",\n \"0.55181944\",\n \"0.55179733\",\n \"0.55144835\",\n \"0.5502174\",\n \"0.5499886\",\n \"0.5497838\",\n \"0.5491796\",\n \"0.54909736\",\n \"0.5487393\",\n \"0.5483045\",\n \"0.54772043\",\n \"0.54740274\",\n \"0.5464355\",\n \"0.5462682\",\n \"0.54593265\",\n \"0.5452867\",\n \"0.5451174\",\n \"0.5449479\",\n \"0.5432201\",\n \"0.54307026\",\n \"0.54295343\",\n \"0.5429109\",\n \"0.5427797\",\n \"0.54198635\",\n \"0.54193604\",\n \"0.5418964\",\n \"0.5418058\",\n \"0.5416104\",\n \"0.54143554\",\n \"0.5410854\",\n \"0.5409203\",\n \"0.5391215\",\n \"0.5389367\",\n \"0.538148\",\n \"0.5379388\",\n \"0.53779256\",\n \"0.5376618\",\n \"0.5376551\",\n \"0.53704655\",\n \"0.53688544\",\n \"0.536318\",\n \"0.53614247\",\n \"0.53551435\",\n \"0.53540194\",\n \"0.535347\",\n \"0.53529334\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72579896"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85181,"cells":{"query":{"kind":"string","value":"Return content without the comments. If filter_multiline_comment is set to False, only the one line comment will be filtered out. If keep_content_size is set to True, the size of the content is preserved."},"document":{"kind":"string","value":"def filter_comments(\n content, filter_multiline_comment=True, keep_content_size=False\n):\n def _replace_comment(element):\n \"\"\"Replace matched *element* in content.\"\"\"\n replacement = \"\"\n matched = element.group()\n\n # Ensure that only the comment part is being replaced\n if not matched.startswith(\"/\"):\n replacement += matched[0]\n matched = matched[1:]\n\n count = matched.count(\"\\n\")\n\n # Add empty spaces with the size of the content if the size\n # must be kept.\n if keep_content_size:\n _buffer = len(matched) - count\n replacement += \" \" * _buffer + \"\\n\" * count\n\n # Otherwise simply keep the number of lines\n else:\n replacement += \"\\n\" * count\n\n return replacement\n\n content = _ONE_LINE_COMMENT_PATTERN.sub(_replace_comment, content)\n\n if filter_multiline_comment:\n content = _MULTI_LINES_COMMENT_PATTERN.sub(_replace_comment, content)\n\n return content"},"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 _strip_comments(file_contents):\n lines_without_comments = []\n for line in file_contents:\n comment_position = line.find(COMMENT_INDICATOR)\n if comment_position != -1:\n lines_without_comments.append(line[:comment_position])\n else:\n lines_without_comments.append(line)\n return lines_without_comments","def collapse_all(content, filter_comment=False):\n _initial_content = content\n collapsed_content = {}\n\n if filter_comment:\n # Filter comment before collapsing elements to prevent comment analysis\n content = filter_comments(content, keep_content_size=True)\n\n def _replace_element(element):\n \"\"\"Replace matched *element* in content.\"\"\"\n # Guess line number\n count = element.group().count(\"\\n\")\n\n # Ensure that the replacement string keep the same length that\n # the original content to be able to use the match positions\n _buffer = len(element.group()) - count - 2\n\n if len(element.group()) > 2:\n line_number = content[:element.start()].count(\"\\n\")+1\n collapsed_content[line_number] = (\n _initial_content[element.start():element.end()]\n )\n\n return \"<>{buffer}{lines}\".format(\n buffer=\" \" * _buffer,\n lines=\"\\n\" * count\n )\n\n _content = None\n\n while _content != content:\n _content = content\n content = _NESTED_ELEMENT_PATTERN.sub(_replace_element, content)\n\n # Remove the space buffer before returning the content\n content = re.sub(r\"<> *\", lambda x: \"{}\", content)\n\n return content, collapsed_content","def get_shrinked_checkpoint_content(content, lines_to_keep)->str:\n i = 0\n original_lines = content.splitlines()\n newlines = []\n for line in reversed(original_lines):\n if i < lines_to_keep:\n newlines.append(line)\n i += 1\n else:\n break #reached max lines to keep\n\n if len(newlines) < len(original_lines):\n newlines.append(original_lines[0]) # Add header line\n\n new_content = \"\\n\".join(reversed(newlines))\n return new_content","def contents_without_whitespace(self):\n return self.contents.replace(' ', '').replace('\\n', '')","def strip_blocks(self):\n print_content = False\n if self.exclude_blocks and len(self.exclude_blocks) > 0:\n for package_name, package in self.packages.items():\n for c, fd in package.components.iteritems():\n for block in self.exclude_blocks:\n JS_BLOCKS = re.compile(r'/[/*]\\s*<' + block + '>.+?<\\/' + block + '>(?:\\s*\\*/)?(?s)', re.MULTILINE)\n fd.content = JS_BLOCKS.sub('/* compat block ' + block + ' removed */', fd.content)\n print_content = True\n if print_content:\n print fd.content","def deleteComments(self: Self, event: Event = None) -> None:\n #@+<< deleteComments docstring >>\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\n #@@pagewidth 50\n #@-<< deleteComments docstring >>\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\n #\n # \"Before\" snapshot.\n bunch = u.beforeChangeBody(p)\n #\n # Initial data.\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\n if not lines:\n g.warning('no text selected')\n return\n # The default language in effect at p.\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\n if c.hasAmbiguousLanguage(p):\n language = c.getLanguageAtCursor(p, language)\n d1, d2, d3 = g.set_delims_from_language(language)\n #\n # Calculate the result.\n changed, result = False, []\n if d1:\n # Remove the single-line comment delim in front of each line\n d1b = d1 + ' '\n n1, n1b = len(d1), len(d1b)\n for s in lines:\n i = g.skip_ws(s, 0)\n if g.match(s, i, d1b):\n result.append(s[:i] + s[i + n1b :])\n changed = True\n elif g.match(s, i, d1):\n result.append(s[:i] + s[i + n1 :])\n changed = True\n else:\n result.append(s)\n else:\n # Remove the block comment delimiters from each line.\n n2, n3 = len(d2), len(d3)\n for s in lines:\n i = g.skip_ws(s, 0)\n j = s.find(d3, i + n2)\n if g.match(s, i, d2) and j > -1:\n first = i + n2\n if g.match(s, first, ' '):\n first += 1\n last = j\n if g.match(s, last - 1, ' '):\n last -= 1\n result.append(s[:i] + s[first:last] + s[j + n3 :])\n changed = True\n else:\n result.append(s)\n if not changed:\n return\n #\n # Set p.b and w's text first.\n middle = ''.join(result)\n p.b = head + middle + tail # Sets dirty and changed bits.\n w.setAllText(head + middle + tail)\n #\n # Set the selection range and scroll position.\n i = len(head)\n j = ins = max(i, len(head) + len(middle) - 1)\n w.setSelectionRange(i, j, insert=ins)\n w.setYScrollPosition(oldYview)\n #\n # \"after\" snapshot.\n u.afterChangeBody(p, 'Indent Region', bunch)","def del_comm(self, blocks=False):\n logging.debug('Delete comments from text')\n if not(self.check()):\n raise GcodeError(\"Invalid g-codes\")\n temp = []\n comment = re.compile(';\\ .*')\n for line in self.blocks:\n n = comment.search(line)\n if n:\n line = line[:n.span()[0]]\n line = line.strip()\n if line != \"\":\n temp.append(line)\n if blocks:\n return temp\n return \"\\n\".join(temp)","def _RemoveStaleComments(content: str) -> str:\n for match in STALE_GROUP_COMMENT_REGEX.findall(content):\n content = content.replace(match, '')\n\n return content","def comment_content(c):\n content = str(c)[4:-3]\n return content.strip()","def DropComment(text):\n grp = re.compile(r'/\\*[^/]*\\*/').split(text)\n result = string.join(grp);\n grp = re.compile(r'//.*').split(result);\n result = string.join(grp);\n #result = string.join(result.split('\\n')) #remove the line break\n return(' '+result);","def extract_only_content(self, path=None, payload=None):\n\n f = file_path(path, payload)\n switches = [\"-t\", f]\n result = self._command_template(switches)\n return result, path, f","def process_comment(self, data):\r\n if not self.is_suppress:\r\n return [data]","def _removeComments(code):\r\n # remove all occurance streamed comments (/*COMMENT */) from string\r\n text = re.sub(re.compile('/\\*.*?\\*/', re.DOTALL), '', code)\r\n # remove all occurance singleline comments (//COMMENT\\n ) from string\r\n return re.sub(re.compile('//.*?\\n'), '', text)","def _filter(self, text, context, encoding):\n\n content = []\n soup = bs4.BeautifulSoup(text, self.parser)\n soup = self.get_sub_node(soup)\n blocks, attributes, comments = self.to_text(soup)\n if self.comments:\n for c, desc in comments:\n content.append(filters.SourceText(c, context + ': ' + desc, encoding, self.type + 'comment'))\n if self.attributes:\n for a, desc in attributes:\n content.append(filters.SourceText(a, context + ': ' + desc, encoding, self.type + 'attribute'))\n for b, desc in blocks:\n content.append(filters.SourceText(b, context + ': ' + desc, encoding, self.type + 'content'))\n return content","def removeHtmlComments(self, text):\n sb = []\n start = text.find(u'<!--')\n last = 0\n while start != -1:\n end = text.find(u'-->', start)\n if end == -1:\n break\n end += 3 \n \n spaceStart = max(0, start-1)\n spaceEnd = end\n while text[spaceStart] == u' ' and spaceStart > 0:\n spaceStart -= 1\n while text[spaceEnd] == u' ':\n spaceEnd += 1\n \n if text[spaceStart] == u'\\n' and text[spaceEnd] == u'\\n':\n sb.append(text[last:spaceStart])\n sb.append(u'\\n')\n last = spaceEnd+1\n else:\n sb.append(text[last:spaceStart+1])\n last = spaceEnd\n \n start = text.find(u'<!--', end)\n sb.append(text[last:])\n return u''.join(sb)","def strip_comments(blob, delim='#'):\n lines = blob.split('\\n')\n return '\\n'.join([line for line in lines if line.strip()[0] != delim])","def lines(filename, exclude_imports=True, exclude_comments=True, exclude_tests=True, exclude_globals=True, exclude_blank=True, verbose=False, is_c=False, s=None):\n if s is None:\n s = open(filename, 'rt').read()\n\n L = s.split('\\n')\n \n # Hack to strip out triple and single quote string lines in a heuristic (unreliable) way, which avoids parsing Cython\n if not is_c:\n for i in range(len(L)):\n if L[i].strip().startswith(\"'\") and L[i].strip().endswith(\"'\"):\n L[i] = ''\n i = 0\n while i < len(L):\n found = False\n for triple_quote in ['\"\"\"', \"'''\"]:\n if L[i].strip().startswith(triple_quote):\n L[i] = L[i].strip()[3:]\n for j in range(i, len(L)):\n if triple_quote in L[j]:\n found = True\n L[j] = ''\n if found:\n break\n i = j+1\n if not found:\n i += 1\n else:\n begin_comment = '/*'\n end_comment = '*/'\n i = 0\n while i < len(L):\n found = False\n if begin_comment in L[i]:\n rest = L[i][L[i].index(begin_comment)+len(begin_comment):]\n L[i] = L[i][:L[i].index(begin_comment)]\n if end_comment in rest:\n found = True\n i += 1\n else:\n for j in range(i+1, len(L)):\n if end_comment in L[j]:\n found = True\n L[j] = L[j][L[j].index(end_comment)+len(end_comment):]\n else:\n L[j] = ''\n if found:\n break\n i = j + 1\n if not found:\n i += 1\n\n# util.print_header('Lines before exclude_tests:' + filename, '\\n'.join(L))\n\n # Hack to strip out def test() and other methods in a heuristic (unreliable) way, which avoids parsing Cython\n if exclude_tests:\n # Also exclude makeColorMatrix so that our camera pipe is apples-to-apples comparable with reported lines in Halide paper\n if not is_c:\n methods = 'test run_test_all mandelbrot_gray mandelbrot_color composite_numpy composite_numexpr makeColorMatrix'.split()\n else:\n methods = ['int main', 'void main']\n i = 0\n while i < len(L):\n L_i_strip = L[i].strip()\n if ((not is_c and (any(L_i_strip.startswith('def ' + method) for method in methods) or\n any(L_i_strip.startswith('cdef ' + method) for method in methods))) or\n (is_c and (any(L_i_strip.startswith(method) for method in methods)))):\n L[i] = ''\n for j in range(i+1, len(L)):\n L_j_strip = L[j].strip()\n c_ok = True\n if is_c:\n c_ok = L_j_strip != '{' and L_j_strip != '}'\n if not L[j].startswith(' ') and not L[j].startswith('\\t') and not len(L[j].strip()) == 0 and c_ok:\n break\n else:\n L[j] = ''\n i = j\n elif (L[i].strip().startswith('test(') or L[i].strip().startswith('run_test_all(')) and not is_c:\n L[i] = ''\n i += 1\n else:\n i += 1\n\n# util.print_header('Lines before exclude_imports:' + filename, '\\n'.join(L))\n if exclude_imports:\n if not is_c:\n L = [x for x in L if not x.lstrip().startswith('import') and not x.lstrip().startswith('cimport') and not x.startswith('cdef extern')]\n else:\n L = [x for x in L if not x.lstrip().startswith('#include')]\n# util.print_header('Lines before exclude_comments:' + filename, '\\n'.join(L))\n if exclude_comments:\n if not is_c:\n L = [x for x in L if not x.lstrip().startswith('#') and not x.strip() == 'pass']\n else:\n L = [x for x in L if not x.lstrip().startswith('//')]\n# util.print_header('Lines before exclude_globals:' + filename, '\\n'.join(L))\n if exclude_globals and not is_c:\n L = [x for x in L if (x.startswith(' ') or x.startswith('\\t') or x.startswith('def') or x.startswith('cdef')) and (not x.lstrip().startswith('has_'))]\n# util.print_header('Lines before exclude_blank:' + filename, '\\n'.join(L))\n\n if is_c:\n # Also exclude makeColorMatrix so that C camera pipe is apples-to-apples comparable with reported lines in Halide paper\n L = [x for x in L if not x.lstrip().startswith('matrix_3200') and not x.lstrip().startswith('matrix_7000')]\n if exclude_blank:\n L = [x for x in L if not len(x.strip()) == 0]\n\n if verbose:\n util.print_header('Final lines for:' + filename, '\\n'.join(L))\n\n return len(L)","def return_filtered_comments(submission):\n submission.comment_sort = COMMENT_SORT_BY\n submission.comment_limit = COMMENT_LIMIT\n filtered_comments = []\n for top_level_comment in submission.comments:\n if isinstance(top_level_comment, praw.models.MoreComments):\n continue\n # Here you can fetch data off the comment.\n comment = top_level_comment.body\n\n # ensure that the comment does not contain any words in blacklist\n # and also it is less than COMMENT_MAX_WORDS\n fail_test = 0\n lcomment = comment.lower()\n for badword in blacklist:\n if badword not in lcomment and len(comment) < COMMENT_MAX_WORDS:\n pass\n else:\n fail_test += 1\n if not fail_test:\n filtered_comments.append(replace_words(comment).capitalize())\n\n return filtered_comments","def unMarkupCommentsAndStrings(self, content):\n\n def replaceMarkups(match):\n groupdict = match.groupdict()\n if groupdict[\"str\"] is not None:\n return self.strings[int(match.group(\"str\"))]\n elif groupdict[\"comment\"] is not None:\n return self.comments[int(match.group(\"comment\"))]\n else:\n assert False\n\n unMarkedup = markups.sub(replaceMarkups, content)\n\n return unMarkedup","def prune_qc(keep=False):\n ppg.util.global_pipegraph._qc_keep_function = keep\n for job in get_qc_jobs():\n if keep is not False and keep(job):\n job.unprune()\n else:\n job.prune()","def clean_comments(self):\n new_lines = list()\n for line in self.lines:\n if ((not line.startswith(\"//\")) & (not line.isspace()) &\n (not line.startswith(\"/*\") & (not line.startswith(\"*/\")))):\n line = Parser.strip_line(line)\n new_lines.append(line)\n self.lines = new_lines","def clean_html(message):\n all_lines = []\n started_html = False\n finished_with_html_tag = False\n html_part = []\n for idx, line in enumerate(message.split(\"\\n\")):\n if re.search(r\"<.*?html.*?>\", line):\n started_html = True\n html_part.append(line)\n else:\n if started_html:\n html_part.append(line)\n else:\n all_lines.append(line)\n if \"</html>\" in line:\n finished_with_html_tag = True\n if finished_with_html_tag:\n all_lines.append(clean_text_from_html_tags(\"\\n\".join(html_part)))\n html_part = []\n finished_with_html_tag = False\n started_html = False\n if len(html_part) > 0:\n all_lines.extend(html_part)\n return delete_empty_lines(\"\\n\".join(all_lines))","def keep_only_archive(self):\n\n keep = []\n read_datafile = open(self.filename, 'rt')\n for line in read_datafile:\n line = line.strip()\n if line.startswith('ARCHIVE'):\n keep.append(line)\n read_datafile.close()\n\n write_datafile = open(self.filename, 'wt')\n write_datafile.write('\\n'.join(keep))\n write_datafile.write('\\n')\n write_datafile.close()","def clean_content(self) -> str:","def keeponly(s, keep):\n return ''.join([x for x in s if x in keep])","def getContents(self):\n normal_body_regex = re.compile(r'[ \\n\\r\\t]+')\n return normal_body_regex.sub(' ', self.contents)","def cleaned_contents(self):\n snip_with_code = re.compile(\"(//.*snip(\\-file)*:?.*\\n)(\\+\\n)?(\\[.*\\]\\n)*----\\n(.*\\n)*?----\\n\", flags=re.IGNORECASE)\n cleaned = re.sub(snip_with_code, r'\\1', self.contents)\n return cleaned","def splitBodyLines(cls, text):\n\n def remove_comments(line):\n \"\"\"\n Returns the given line stripped of any comments.\n \"\"\"\n hashPos = line.find('#')\n return line[:hashPos] if hashPos >= 0 else line\n\n # Remove comments, strip whitespace, and return only non-blank lines\n lines = map(str.strip, map(remove_comments, text.splitlines()))\n return [l for l in lines if l]","def stripped_lines(lines, ignore_comments, ignore_docstrings, ignore_imports):\n if ignore_imports:\n tree = astroid.parse(\"\".join(lines))\n node_is_import_by_lineno = (\n (node.lineno, isinstance(node, (astroid.Import, astroid.ImportFrom)))\n for node in tree.body\n )\n line_begins_import = {\n lineno: all(is_import for _, is_import in node_is_import_group)\n for lineno, node_is_import_group in groupby(\n node_is_import_by_lineno, key=lambda x: x[0]\n )\n }\n current_line_is_import = False\n\n strippedlines = []\n docstring = None\n for lineno, line in enumerate(lines, start=1):\n line = line.strip()\n if ignore_docstrings:\n if not docstring and any(\n line.startswith(i) for i in ['\"\"\"', \"'''\", 'r\"\"\"', \"r'''\"]\n ):\n docstring = line[:3]\n line = line[3:]\n if docstring:\n if line.endswith(docstring):\n docstring = None\n line = \"\"\n if ignore_imports:\n current_line_is_import = line_begins_import.get(\n lineno, current_line_is_import\n )\n if current_line_is_import:\n line = \"\"\n if ignore_comments:\n line = line.split(\"#\", 1)[0].strip()\n strippedlines.append(line)\n return strippedlines","def filter_out_data(text):\n if len(text) < 30:\n return None\n return text","def _clean_message(comment):\n message = comment['message']\n # Remove comments with linked persons (they mostly contain only emojis)\n if 'message_tags' in comment:\n for tag in comment['message_tags']:\n if 'type' in tag and tag['type'] == 'user':\n message = message.replace(tag['name'], '')\n # Remove links\n message = re.sub(r'http\\S+', '', message)\n return message.strip()","def get_content(self):\n content = copy(self.content)\n self.content = ''\n return content","def _remove_whitespace(file_contents):\n whitespace_stripped = [line.strip() for line in file_contents]\n return [line for line in whitespace_stripped if line != \"\"]","def process_only_nodes(config, document, tags):\n # type: (nodes.Node, Tags) -> None\n ret_html_cell = config['jupyter_allow_html_only'] \n for node in document.traverse(addnodes.only):\n try:\n ret = tags.eval_condition(node['expr']) #check for jupyter only\n if ret_html_cell and node['expr'] == 'html': #allow html only cells if option is specified\n ret = True\n except Exception as err:\n logger.warning(__('exception while evaluating only directive expression: %s'), err,\n location=node)\n node.replace_self(node.children or nodes.comment())\n else:\n if ret:\n node.replace_self(node.children or nodes.comment())\n else:\n # A comment on the comment() nodes being inserted: replacing by [] would\n # result in a \"Losing ids\" exception if there is a target node before\n # the only node, so we make sure docutils can transfer the id to\n # something, even if it's just a comment and will lose the id anyway...\n node.replace_self(nodes.comment())","def _get_review_comments_body(\n self, pull_request_number: int) -> List[Tuple[str, str]]:\n review_comments = get_pull_request_review_comments(\n self._repo_name, pull_request_number, self._auth)\n if not review_comments:\n return []\n review_comments_msg = []\n for comment in review_comments:\n review_comments_msg.append((comment['path'], comment['body']))\n return review_comments_msg","def get_formatted_comments(self, threshold=400):\n comments = IDossier(self).comments\n if comments:\n if threshold:\n comments = truncate_ellipsis(comments, threshold)\n return api.portal.get_tool(name='portal_transforms').convertTo(\n 'text/html', comments, mimetype='text/x-web-intelligent').getData()","def stripText(self, rawText):\n strippedText = []\n for line in rawText:\n if line.rstrip():\n if line[0] != '#':\n strippedText.append(line.rstrip()) #also remove newline character\n return strippedText","def comment_remover(text):\n\n def replacer(match):\n s = match.group(0)\n if s.startswith(\"/\"):\n return \"\"\n else:\n return s\n\n pattern = re.compile(\n r'//.*?$|/\\*.*?\\*/|\\'(?:\\\\.|[^\\\\\\'])*\\'|\"(?:\\\\.|[^\\\\\"])*\"',\n re.DOTALL | re.MULTILINE,\n )\n return re.sub(pattern, replacer, text)","def split_by_lines(text, remove_empty=False):\n\tlines = text.splitlines()\n\t\n\treturn remove_empty and [line for line in lines if line.strip()] or lines","def contentextract(text):\n stopword=stopwords.words('english')\n punctuation=['.','?','!',',',';',\"''\",'\"\"',\"'\",\"--\",\"``\",\"|\",\"<\",\">\",\"...\",\"......\",\"'s\",':','[',']',\n '(',')','#','*','$','%','@','^','-','+','=','/','{','}','\\\\','\"','&']\n content=[w for w in text if w.lower() not in stopword]\n content=[w for w in content if w not in punctuation]\n return content","def parse_comments_html(advertise: Dict[str, Any]) -> Optional[List[str]]:\n if \"comments_html\" in advertise.keys():\n\n filtred_comments: str = advertise[\"comments_html\"][200::]\n\n tmp: List[str] = re.split(\"[ \\n\\t]{2,}\", filtred_comments)\n if '' in tmp:\n tmp.remove('')\n\n # Breaking comments\n master: List[List[str]] = []\n tmp_vec: List[str] = []\n for line in tmp:\n\n if re.search(\"de \\d{4,}\", line): # matches 'de 2018' that signals the end of comment\n master.append(tmp_vec)\n tmp_vec = []\n else:\n tmp_vec.append(line)\n\n # Cleaning comments\n for comment in master:\n if \"...\" in comment:\n comment.remove(\"...\")\n if \"O usuário contratou o serviço em\" in comment:\n comment.remove(\"O usuário contratou o serviço em\")\n\n return [\" \".join(m) for m in master]","def remove_comments(css):\n log.debug(\"Removing all Comments.\")\n iemac, preserve = False, False\n comment_start = css.find(\"/*\")\n while comment_start >= 0: # Preserve comments that look like `/*!...*/`.\n # Slicing is used to make sure we dont get an IndexError.\n preserve = css[comment_start + 2:comment_start + 3] == \"!\"\n comment_end = css.find(\"*/\", comment_start + 2)\n if comment_end < 0:\n if not preserve:\n css = css[:comment_start]\n break\n elif comment_end >= (comment_start + 2):\n if css[comment_end - 1] == \"\\\\\":\n # This is an IE Mac-specific comment; leave this one and the\n # following one alone.\n comment_start = comment_end + 2\n iemac = True\n elif iemac:\n comment_start = comment_end + 2\n iemac = False\n elif not preserve:\n css = css[:comment_start] + css[comment_end + 2:]\n else:\n comment_start = comment_end + 2\n comment_start = css.find(\"/*\", comment_start)\n return css","def _get_comments(self):\n if not hasattr(self, 'id'):\n raise BadReference('No matching issue on disk')\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))","def process_all(self):\n global multi_comment_line_mode\n multi_comment_line_mode = False\n for line in self.fileToProcess:\n line = line.strip() # creating a strip line, with no whitespace in the beginning and in the end\n # multi_comment_line_mode = False\n # first, we want to filter all the lines which are comments or part of comments\n while line != '':\n ignoring_status,newline = self.shouldTheLineBeIgnored(line)\n if ignoring_status:\n break # we are ignoring the line\n elif (not ignoring_status) and (newline != '') and newline != '$endOfMultiLine':\n line = newline\n continue\n elif not ignoring_status and newline == '$endOfMultiLine':\n break\n else:\n line = self.isThereApartToIgnore(line) #getting the good line\n line = line.strip()\n if line.endswith('$endOfMultiLine'):\n # line = line[:-1]\n line = line[:-15]\n # in this case we don't want to ignore the current line\n # if multi_comment_line_mode:\n # # this comes from the\n list_of_line_strings = re.split('(\\W)', line) # the default of this method is to remove all the white spaces\n list_of_line_strings = list(filter(None, list_of_line_strings))\n global i\n i = 0\n global first_index\n first_index = 0\n global second_index\n second_index = 0\n len_of_list = len(list_of_line_strings)\n while i < len_of_list:\n # first adding the string literals\n if (list_of_line_strings[i] == '\"' and i == 0) or (i>0 and list_of_line_strings[i] == '\"' and\n list_of_line_strings[i-1]!='*'):\n first_index = i\n i = i + 1\n if i == len(list_of_line_strings):\n break\n while list_of_line_strings[i] != '\"':\n i = i + 1\n if i>=len(list_of_line_strings):\n # in case it's the end\n i = first_index\n break\n else:\n continue\n second_index = i\n list_of_line_strings[first_index:second_index + 1] = [\n ''.join(list_of_line_strings[first_index:second_index + 1])]\n i = i + 2\n len_of_list = len(list_of_line_strings)\n else:\n i = i + 1\n j=0\n global skip_mode\n skip_mode = False\n global counter\n counter = 0\n for string in list_of_line_strings:\n if j != len(list_of_line_strings)-1:\n j+=1\n if counter == 1:\n counter = 0\n continue\n if skip_mode and not (string == '*' and list_of_line_strings[j] == '/'):\n continue\n if skip_mode and string == '*' and list_of_line_strings[j] == '/':\n skip_mode = False\n counter = 1\n continue\n if string == \"/\" and (list_of_line_strings[j] == \"/\" ):\n # this is a comment that appeared in the line\n break # in this case, there are no more chars to read because it's a note\n if string == \"/\" and list_of_line_strings[j] == \"*\":\n skip_mode = True\n counter = 1\n continue # entering a skip mode\n if string.strip() == '':\n continue\n self.currStringToProcess = string\n type = self.tokenType()\n self.createToken(type,self.currStringToProcess)\n break","def sanitize_comment(comment):\n\n if hasattr(settings, \"BLEACH_ALLOWED_TAGS\"):\n allowed_tags = settings.BLEACH_ALLOWED_TAGS\n else:\n allowed_tags = bleach.sanitizer.ALLOWED_TAGS\n\n return bleach.clean(comment, tags=allowed_tags, strip=True)","def main(in_path, keep_path, out_path):\n\t# First open the input csv\n\tcsv_hndl = lambda x: np.array([np.array(r) for r in x])\n\tdata, headers = read_csv(in_path, csv_hndl, use_headers=True, delimiter=',')\n\n\t# Read headers to keep\n\tkeeps = []\n\n\t# Regex for ignoring comments\n\tcmnt_re = re.compile(\"^#\")\n\n\t# Open and read the file\n\twith open(keep_path) as f_obj:\n\t\tfor line in f_obj:\n\t\t\tline = line.strip()\n\t\t\t# If line is commented out, ignore\n\t\t\tif cmnt_re.match(line):\n\t\t\t\tcontinue\n\t\t\t# Otherwise add to list of keeps\n\t\t\tkeeps.append(line)\n\n\t# Prune the csv\n\tnew_data, new_headers = prune_csv(data,headers,keeps)\n\n\t# Write to output csv file\n\twrite_csv(\n\t\tout_path, \n\t\tnew_data, \n\t\tnew_headers, \n\t\tdelimiter=',', \n\t\tquotechar='\"',\n\t\tquoting=csv.QUOTE_MINIMAL\n\t)","def contents(filepath):\n f = open(filepath, 'r')\n rval = [x.rstrip(\"\\r\\n\") for x in f.readlines()]\n f.close()\n return rval","def remove_patches(self):\n content = []\n stretch = []\n for line in self.spec_content.section(\"%package\"):\n stretch.append(line)\n # Empty lines save the current stretch into content.\n if not line.strip():\n content += stretch\n stretch = []\n # Patch-lines throw away the current stretch.\n if line.lower().startswith(\"patch\"):\n stretch = []\n # If there is an empty line at the end of content\n # throw it away, to avoid duplicate lines.\n if not content[-1].strip():\n content.pop()\n self.spec_content.replace_section(\"%package\", content)\n self.save()","def remove_fewwords_paragraphs(self, article):\r\n all_nodes = self.parser.getElementsByTags(self.get_top_node(), ['*'])\r\n all_nodes.reverse()\r\n for el in all_nodes:\r\n tag = self.parser.getTag(el)\r\n text = self.parser.getText(el)\r\n stop_words = self.stopwords_class(language=self.get_language(article)).get_stopword_count(text)\r\n if (tag != 'br' or text != '\\\\r') and stop_words.get_stopword_count() < 3 \\\r\n and len(self.parser.getElementsByTag(el, tag='object')) == 0 \\\r\n and len(self.parser.getElementsByTag(el, tag='embed')) == 0:\r\n self.parser.remove(el)\r\n # TODO\r\n # check if it is in the right place\r\n else:\r\n trimmed = self.parser.getText(el)\r\n if trimmed.startswith(\"(\") and trimmed.endswith(\")\"):\r\n self.parser.remove(el)","def remove_html_comment(html_data):\n html_data = re.compile('<!--(.*?)-->', re.MULTILINE|re.DOTALL).sub(\"\", html_data)\n return html_data","def parse_comment(self, node):\n\n data = []\n\n if node is not None:\n comment_id_pattern = re.compile('comment-(\\d+)')\n for comment_node in node.find_all('div', class_='comment'):\n item = {}\n item['is_deletable'] = False\n item['is_editable'] = False\n \n comment_id_result = comment_id_pattern.search(comment_node.get('id'))\n if comment_id_result:\n item['id'] = int(comment_id_result.group(1))\n \n comment_body_node = comment_node.find('div', class_='comment-body')\n if comment_body_node is not None:\n item['content'] = ''\n for p in comment_body_node.find_all(recursive=False):\n if 'class' in p.attrs and 'author' in p['class']:\n item['author'] = p.get_text()\n item['profile_url'] = self.get_link(p.get('href'))\n author_id = self._parse_user_id_from_url(item['profile_url'])\n if self.userId == author_id:\n item['is_deletable'] = True\n item['is_editable'] = True\n elif 'class' in p.attrs and 'age' in p['class']:\n item['date'] = p.abbr['title']\n item['date_ago'] = timeago.format(self._parse_datetime(item['date']), datetime.now(TIMEZONE))\n elif 'class' in p.attrs and 'edit' in p['class']:\n continue\n elif p.name == 'form':\n continue\n else:\n item['content'] += str(p)\n\n data.append(item)\n\n return data","def config(self, filter_includes=False):\n def the_filter(k):\n if filter_includes and k is not None and k.lower() == \"include\":\n return False\n else:\n return True\n \n return \"\\n\".join([x.line for x in self.lines_ if the_filter(x.key)])","def file_read(self):\r\n with open(self.source_text_path, 'r') as myfile:\r\n data = myfile.read() \r\n comments = re.compile(r'''\r\n (//[^\\n]*(?:\\n|$)) # Everything between // and the end of the line/file\r\n | # or \r\n (/\\*.*?\\*/) # Everything between /* and */\r\n |\r\n \\/\\*[\\s\\S]*?\\*\\/|([^:]|^)\\/\\/.*$ # Every comment between /** and */ \r\n ''', re.VERBOSE)\r\n self.modified_source_text = comments.sub('\\n', data) \r\n return self.modified_source_text","def read_content(path):\n input_file = open(path, \"r\")\n file_handler = input_file.readlines()\n input_file.close()\n list = []\n\n for line in file_handler:\n line = line.split('\\n')\n without_empty_strings = []\n for string in line:\n if (string != \"\"):\n without_empty_strings.append(string)\n line = without_empty_strings\n line = \"\".join(line)\n list.append(line)\n return list","def remove_c_style_comments(fd):\n ret = []\n comment_state = False\n for line in fd:\n while True:\n # seems we have nothing left\n if len(line) < 2:\n break\n # we're still inside a comment\n if comment_state:\n idx = line.find(\"*/\")\n if idx > -1:\n line = line[idx + 2:]\n comment_state = False\n continue\n # comment doesn't seem to end on this line\n break\n # we're not inside any comment\n else:\n idx = line.find(\"/*\")\n if idx > -1:\n line = line[idx + 2:]\n comment_state = True\n continue\n if \"//\" in line:\n line = line.split(\"//\", 1)[0]\n # only now we can actually do our job\n line = line.strip()\n if len(line) > 0:\n ret.append(line)\n break\n return ret","def readFiltered(f):\n line = f.readline()\n while line:\n line = line.strip()\n if len(line) != 0:\n if line == \"### NEW EXPERIMENT ###\":\n # print (\"readFiltered: ''\")\n yield \"\"\n elif line[0] != \"#\":\n # print (\"readFiltered: '\",line,\"'\")\n yield line\n line = f.readline()\n # print (\"readFiltered: '\",line,\"'\")\n return line","def get_file_contents(self):\n with open(self.sql_file, 'r') as sql:\n text = sql.read()\n # text = text.replace('\\n', '\\n\\n')\n # text=sql.read()\n # TODO: fix some text replacement issues here\n # https://github.com/andialbrecht/sqlparse/issues/313\n return self.filter_text(text)","def _read_content(self,\n length,\n encoding=None,\n indent=None,\n line_endings=None,\n preserve_trailing_newline=False,\n keep_bytes=False):\n fp = self._fp\n content = fp.read(length)\n\n # First, determine the line endings that we're going to be working\n # with.\n if line_endings:\n # An explicit line ending type was specified. Validate it and\n # get the newline characters, encoding it for the byte string.\n try:\n newline = get_newline_for_type(line_endings,\n encoding=encoding)\n except ValueError as e:\n raise DiffXParseError(six.text_type(e),\n linenum=self._linenum)\n else:\n # An explicit line ending type was not specified. Try to determine\n # the appropriate line ending based on the first line of content.\n line_endings, newline = guess_line_endings(content,\n encoding=encoding)\n\n lines = split_lines(data=content,\n newline=newline,\n keep_ends=True)\n\n if indent:\n # It's important that we don't assume each line is actually\n # indented correctly. There could be nothing but a newline,\n # or due to some error the indentation on some line may be\n # wrong. Be careful to strip only the spaces, up to the specified\n # indentation level.\n indent_re = re.compile(br'^ {1,%d}' % indent)\n content = b''.join(\n indent_re.sub(b'', _line)\n for _line in lines\n )\n\n if encoding and not keep_bytes:\n # We know what this content was encoded with. We can now decode\n # it.\n content = content.decode(encoding)\n newline = newline.decode(encoding)\n\n # Validate that the content ends in a newline. This is to ensure that\n # the file was written according to spec.\n if not content.endswith(newline):\n raise DiffXParseError(\n 'Expected a newline after content',\n linenum=self._linenum)\n\n self._linenum += len(lines)\n\n return content","def test_remove_single_line_comments_noannotation():\n\n\tinput_ = \"\"\"line1\n\t\t\t\tline2 \n\t\t\t\t//comment\n\t\t\t\tline3 \"\"\"\n\n\texpect = \"\"\"line1\n\t\t\t\tline2 \n\t\t\t\t\n\t\t\t\tline3 \"\"\"\n\n\tassert aunit.remove_single_line_comments(input_) == expect","def filter_wiki(raw, promote_remaining=True, simplify_links=True):\n # parsing of the wiki markup is not perfect, but sufficient for our purposes\n # contributions to improving this code are welcome :)\n text = to_unicode(raw, 'utf8', errors='ignore')\n text =decode_htmlentities(text) # '&nbsp;' --> '\\xa0'\n return remove_markup(text, promote_remaining, simplify_links)","def strip_text(text):\n\n return [line.strip() for line in text.splitlines()]","def minify(input,\n remove_comments=False,\n remove_empty_space=False,\n remove_all_empty_space=False,\n reduce_empty_attributes=True,\n reduce_boolean_attributes=False,\n remove_optional_attribute_quotes=True,\n convert_charrefs=True,\n keep_pre=False,\n pre_tags=parser.PRE_TAGS,\n pre_attr='pre',\n cls=parser.HTMLMinParser):\n minifier = cls(\n remove_comments=remove_comments,\n remove_empty_space=remove_empty_space,\n remove_all_empty_space=remove_all_empty_space,\n reduce_empty_attributes=reduce_empty_attributes,\n reduce_boolean_attributes=reduce_boolean_attributes,\n remove_optional_attribute_quotes=remove_optional_attribute_quotes,\n convert_charrefs=convert_charrefs,\n keep_pre=keep_pre,\n pre_tags=pre_tags,\n pre_attr=pre_attr)\n minifier.feed(input)\n minifier.close()\n return minifier.result","def remove_comments(html):\n return re.sub(r\"<!--.*?-->\", \" \", html)","def extract_comments(comments_file, output_filename=direc+\"/comments.txt\"):\r\n if not os.path.exists(output_filename.split(\"/\")[0]):\r\n os.makedirs(output_filename.split(\"/\")[0])\r\n\r\n print(\"Extracting comments from \" + comments_file + \"...\")\r\n comments_dict = {}\r\n with open(output_filename, \"w\", encoding=encoding) as f:\r\n current = 0\r\n for event, child in iterparse(comments_file, events=('start', 'end')):\r\n if current > SAMPLE_SIZE:\r\n break\r\n elif len(child.attrib) > 0 and event == \"start\":\r\n if child.attrib['PostId'] not in comments_dict:\r\n comments_dict[child.attrib['PostId']] = []\r\n comments_dict[child.attrib['PostId']].append(child.attrib['Id'])\r\n clean_comment = clean_markdown(child.attrib['Text'])\r\n line = child.attrib['Id'] + \"\\t\" + child.attrib['PostId'] + \"\\t\" + clean_comment + \"\\t\" + child.attrib['Score'] + \"\\n\"\r\n f.write(line)\r\n\r\n current += 1\r\n print_progress(current, SAMPLE_SIZE)\r\n print(\"\\nFinished extracting comments from \" + comments_file + \".\\n\")\r\n return comments_dict","def _strip_excerpt(self, raw_html):\n clean_regex = re.compile(\"<.*?>\")\n clean_text = re.sub(clean_regex, \"\", raw_html)\n return html.unescape(clean_text).replace(\"\\n\", \"\")","def remove_comments(line):\n hashPos = line.find('#')\n return line[:hashPos] if hashPos >= 0 else line","def filter_none(data, split_by_client=False):\n\n if split_by_client:\n # filter out missing files and empty clients\n existing_data = [[d for d in client_data if d is not None]\n for client_data in data]\n existing_data = [\n client_data for client_data in existing_data if client_data]\n else:\n # filter out missing files\n existing_data = [d for d in data if d is not None]\n return existing_data","def get_file_content(self):\n after = self.file.revisions.filter(\n revision_number__gt=self.revision_number)\n content = self.file.content\n\n for revision in after:\n patch = dmp.patch_fromText(revision.diff)\n content = dmp.patch_apply(patch, content)[0]\n\n return content","def strip_blanklines(blob):\n lines = blob.split('\\n')\n return '\\n'.join([line for line in lines if line.strip() != ''])","def clean_content(sender, instance, **kwargs):\r\n if kwargs.get('raw'):\r\n # We're in loaddata (or something similar).\r\n return\r\n\r\n page = instance\r\n fields = dict(stemplates.get_fields_bare(page.template))\r\n current_contents = list(page.pagecontent_set.all())\r\n\r\n for content in current_contents:\r\n if content.title not in fields or fields[content.title] != content.typ:\r\n content.delete()\r\n\r\n existing_contents = dict([(pc.title, pc.typ)\r\n for pc in page.pagecontent_set.all()])\r\n\r\n for title, typ in fields.items():\r\n if title not in existing_contents or existing_contents[title] != typ:\r\n PageContent(page=page, title=title, typ=typ, content='').save()","def line_comments(self, tail_comment = None):\n tail_comment = tail_comment or self.tail_comment()\n return [comment for comment in self.comments if comment != tail_comment]","def filter_line(self, line):\n if line.startswith(\"<\"):\n # Simply filter out all lines beginning with '<', which are metadata\n return None\n\n # Some metadata-like text is also included at the start of lines, followed by \". - \"\n if u\". - \" in line:\n __, __, line = line.partition(u\". - \")\n\n # Remove -s and spaces from the start of lines\n # Not sure why they're often there, but it's just how the transcripts were formatted\n line = line.lstrip(u\"- \")\n\n # Skip lines that are fully surrounded by brackets: they're typically descriptions of what happened\n # E.g. (Applause)\n if line.startswith(u\"(\") and line.endswith(u\")\"):\n return None\n\n # It's common for a speaker's first utterance to start with a marker indicating the original language\n line = language_indicator_re.sub(u\"\", line)\n return line","def remove_markup(text, promote_remaining=True, simplify_links=True):\n text = re.sub(RE_P2, '', text) # remove the last list (=languages)\n # the wiki markup is recursive (markup inside markup etc)\n # instead of writing a recursive grammar, here we deal with that by removing\n # markup in a loop, starting with inner-most expressions and working outwards,\n # for as long as something changes.\n text = remove_template(text)\n text = remove_file(text)\n iters = 0\n while True:\n old, iters = text, iters + 1\n text = re.sub(RE_P0, '', text) # remove comments\n text = re.sub(RE_P1, '', text) # remove footnotes\n text = re.sub(RE_P9, '', text) # remove outside links\n text = re.sub(RE_P10, '', text) # remove math content\n text = re.sub(RE_P11, '', text) # remove all remaining tags\n text = re.sub(RE_P14, '', text) # remove categories\n text = re.sub(RE_P5, '\\\\3', text) # remove urls, keep description\n\n if simplify_links:\n text = re.sub(RE_P6, '\\\\2', text) # simplify links, keep description only\n # remove table markup\n text = text.replace(\"!!\", \"\\n|\") # each table head cell on a separate line\n text = text.replace(\"|-||\", \"\\n|\") # for cases where a cell is filled with '-'\n text = re.sub(RE_P12, '\\n', text) # remove formatting lines\n text = text.replace('|||', '|\\n|') # each table cell on a separate line(where |{{a|b}}||cell-content)\n text = text.replace('||', '\\n|') # each table cell on a separate line\n text = re.sub(RE_P13, '\\n', text) # leave only cell content\n text = re.sub(RE_P17, '\\n', text) # remove formatting lines\n\n # remove empty mark-up\n text = text.replace('[]', '')\n # stop if nothing changed between two iterations or after a fixed number of iterations\n if old == text or iters > 2:\n break\n\n if promote_remaining:\n text = text.replace('[', '').replace(']', '') # promote all remaining markup to plain text\n\n return text","def remove_empty_lines(self):\n self.result_code = open(\"result.c\", \"r\") # Opening the intermediate file in 'read' mode.\n self.line_array = self.result_code.readlines() # Obtaining an array of strings, where each string is a line from the intermediate file.\n self.result_code.close() # Closing the intermediate file.\n self.result_code = open(\"result.c\",\"w\") #Opening the intermediate file in 'write' mode.\n # Looping over all the lines in the input file.\n for line in self.line_array:\n # Checking if the line is empty.\n if line != \"\\n\":\n self.result_code.write(line) # Writing the non-empty line onto the intermediate file.\n self.result_code.close() # Closing the intermediate file.","def _split_into_body_and_options(\n section_content: str,\n) -> Tuple[str, Optional[str], Dict[int, bool]]:\n lines = section_content.strip().splitlines()\n\n skipif_expr = None\n flag_settings = {}\n i = 0\n for line in lines:\n stripped = line.strip()\n if _OPTION_SKIPIF_RE.match(stripped):\n skipif_match = _OPTION_SKIPIF_RE.match(stripped)\n assert skipif_match is not None\n skipif_expr = skipif_match.group(1)\n i += 1\n elif _OPTION_DIRECTIVE_RE.match(stripped):\n directive_match = _OPTION_DIRECTIVE_RE.match(stripped)\n assert directive_match is not None\n option_strings = directive_match.group(1).replace(\",\", \" \").split()\n for option in option_strings:\n if (\n option[0] not in \"+-\"\n or option[1:] not in doctest.OPTIONFLAGS_BY_NAME\n ):\n raise ValueError(f\"doctest has an invalid option {option}\")\n flag = doctest.OPTIONFLAGS_BY_NAME[option[1:]]\n flag_settings[flag] = option[0] == \"+\"\n i += 1\n elif stripped == \":hide:\":\n i += 1\n else:\n break\n\n if i == len(lines):\n raise ValueError(\"no code/output\")\n\n body = \"\\n\".join(lines[i:]).lstrip()\n if not body:\n raise ValueError(\"no code/output\")\n\n if i and lines[i].strip():\n # no newline between option block and body\n raise ValueError(f\"invalid option block: {section_content!r}\")\n\n return body, skipif_expr, flag_settings","def listFromLines(lines):\n reComment = re.compile('#.*')\n temp = [reComment.sub('',x).strip() for x in lines.split('\\n')]\n temp = [x for x in temp if x]\n return temp","def strip_logfile_html(text):\n out_text = \"\"\n buff = \"\"\n start_tag = \"\"\n end_tag = \"\"\n context = \"none\"\n for i in range(len(text)):\n c = text[i]\n # print \"c = \"+str(c)+\" context = \"+str(context)\n if c == \"<\":\n if context == \"none\":\n # Possible start of a tag, depending on\n # next character\n context = \"putative_tag\"\n buff = c\n else:\n # Everything up to this needs to\n # be dumped directly to output\n out_text = out_text + escape_xml_characters(buff)\n elif context == \"putative_tag\":\n buff = buff + c\n if c.isalpha():\n context = \"start_tag\"\n elif c == \"/\":\n context = \"end_tag\"\n elif c == \"!\":\n context = \"comment_tag\"\n else:\n # Not a tag so dump it\n context = \"none\"\n out_text = out_text + escape_xml_characters(buff)\n elif context == \"start_tag\" or context == \"end_tag\" or context == \"comment_tag\":\n buff = buff + c\n if c == \">\":\n if context == \"start_tag\":\n # End of a start tag\n # Process it and see if we can\n # salvage something\n salvage_text = salvage_tag_data(buff)\n if salvage_text != \"\":\n out_text = out_text + escape_xml_characters(salvage_text)\n # Reset the buffer\n context = \"none\"\n buff = \"\"\n elif context == \"end_tag\":\n # End of an end tag\n # Throw this away (for now)\n context = \"none\"\n buff = \"\"\n elif context == \"comment_tag\":\n # End of a comment\n # Throw this away (for now)\n context = \"none\"\n buff = \"\"\n else:\n # Nothing special about this\n # Add to the output\n out_text = out_text + escape_xml_characters(c)\n # Finished - append the remaining buffer\n out_text = out_text + escape_xml_characters(buff)\n return remove_blank_lines(out_text)","def recipe12_6():\n from xml import dom\n def remove_whitespace_nodes(node):\n \"\"\" Removes all of the whitespace-only text descendants of a DOM node. \"\"\"\n # prepare the list of text nodes to remove (and recurse when needed)\n remove_list=[]\n for child in node.childNodes:\n if child.nodeType==dom.Node.TEXT_NODE and not child.data.strip():\n # add this text node to the to-be-removed list\n remove_list.append(chid)\n elif child.hasChildNodes():\n # recurse, it's the simplest way to deal with the subtree\n remove_whitespace_nodes(child)\n # perform the removals\n for node in remove_list:\n node.parentNode.removeChild(node)\n node.unlink()","def __clean_line_comments(self):\n self.lines = [l for l in self.lines if not l.startswith(\"//\") and len(l) != 0]","def __clean_line_comments(self):\n self.lines = [l for l in self.lines if not l.startswith(\"//\") and len(l) != 0]","def _getContent(self, excludeRead=False, continuation=None, loadLimit=20, since=None, until=None):\r\n return None","def remove_comments(ls):\r\n for i in range(len(ls)):\r\n ls[i] = re.sub(r'//.*', '', ls[i])\r\n\r\n return ls","def remove_empty_lines(file_name):\n removed_lines = 0\n with open(file_name, mode=\"r\", encoding=\"utf-8\") as fd:\n with open(get_output_file(file_name), mode=\"w\", encoding=\"utf-8\") as ofd:\n for line in fd.readlines():\n if re.search(\"^$\", line):\n removed_lines += 1\n else:\n ofd.write(line)\n print(\"Removed lines: {}\".format(removed_lines))","def html_minify(html, comments=False):\n log.info(\"Compressing HTML...\")\n html = remove_html_comments(html) if not comments else html\n html = condense_style(html)\n html = condense_script(html)\n html = clean_unneeded_html_tags(html)\n html = condense_html_whitespace(html)\n html = unquote_html_attributes(html)\n log.info(\"Finished compressing HTML !.\")\n return html.strip()","def _get_file_content(realpath, ignore_undocumented=False):\n\n result = \"\"\"<h2>Module: %s</h2>\n <div class=\"alert alert-info\">\n <div style = \"details\">path: %s</div>\n <div style = \"details\">created: %s, last modified: %s</div></div>\"\"\" %(\n os.path.basename(realpath),\n urlparse.unquote(_convert_path_to_url(realpath)),\n time.ctime(os.path.getmtime(realpath)),\n time.ctime(os.path.getctime(realpath))\n )\n with open(realpath) as sourcefile:\n code = sourcefile.readlines()\n abstract_syntax_tree = ast.parse(''.join(code))\n description = ast.get_docstring(abstract_syntax_tree)\n if description:\n result += \"<h3>Summary:</h3> <div style = 'summary'>%s</div>\" % _convert_str_to_html(description)\n visitor = DocVisitor()\n visitor.visit(abstract_syntax_tree)\n parsed_code = visitor.get_doc()\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\n for entry in entries:\n if ignore_undocumented is False or entry.get(\"description\"):\n begin, end = entry.get(\"lines\")\n result += '<hr /><div><pre>' + \"\".join(code[begin:end]).rstrip().rstrip(\":\") +\"</pre>\"\n result += _convert_str_to_html(entry.get(\"description\"))+\"</div>\"\n\n return result","def remove_discarded(self):\n while self.shrink_target.has_discards:\n discarded = []\n\n for ex in self.shrink_target.examples:\n if ex.discarded and (not discarded or ex.start >= discarded[-1][-1]):\n discarded.append((ex.start, ex.end))\n\n assert discarded\n\n attempt = bytearray(self.shrink_target.buffer)\n for u, v in reversed(discarded):\n del attempt[u:v]\n\n if not self.incorporate_new_buffer(attempt):\n break","def __remove_c_comments(self, line):\n new_chars = []\n i = 0\n while i < len(line):\n blocks = self.__ingest_c_block_comments(line, i)\n if blocks > 0:\n i += blocks\n continue\n\n whitespace = self.__ingest_whitespace(line, i)\n if whitespace > 0:\n new_chars.append(' ')\n i += whitespace\n continue\n\n comm_start = self.__ingest_c_comment_start(line, i)\n if comm_start == -1:\n new_chars.append(' ')\n break\n elif comm_start > 0:\n new_chars.append(' ')\n i += comm_start\n\n if blocks + whitespace + comm_start == 0:\n new_chars.append(line[i])\n i += 1\n\n new_line = ''.join(new_chars)\n return new_line","def strip_out_sensitive_data(configuration_object):\n return deployr_config_repository.strip_out_sensitive_data(configuration_object=configuration_object)","def filter_lines(view_lines):\n\n # this still doesn't work because we need to filter xml above the line level\n # do newlines from the server ever contain meaningful data or are they pointless?\n # is all the newline data given by a terminating xml-type tag?\n\n # filter lines that start with an exclude string - non-regex\n excludes = ['<prompt time=\"']\n for exclude in excludes:\n view_lines = [line for line in view_lines if line[0 : len(exclude)] != exclude]\n\n # first lets just rip out the xml... later we will want to process it back into the stream\n # mostly we can use the xml just to update the state, if that's the case then if we miss\n # one then it's no proble, we just catch the next one... provided they are regular enough.\n # if they are not, or set state once, then we definitely want to catch every one\n xml_free_lines = list()\n for line in view_lines:\n\n # assuming lines only have xml if they start with xml? interesting idea, not sure if real\n i = 0\n xml_free_line_segments = list()\n xml_line_segments = list()\n xml_free_line_part = b\"\"\n xml_line_part = b\"\"\n ordered_parsed_line = list() # give a tuple of string, type\n\n # ISSUE: i'm pretty sure this is dropping a letter off the first non-xml line segment (or more)\n # make a bunch of line segments\n # note that line is a bytes() type, indexing line[i] returns int\n # if we slice into it line[i:i+1] we get a bytes() type of length 1\n while i < len(line):\n\n if line[i : i + 1] != b\"<\":\n xml_free_line_part += line[i : i + 1]\n\n else:\n\n # increment until you get out of the xml tag or out of the line\n while i < len(line) and line[i : i + 1] != b\">\":\n xml_line_part += line[i : i + 1]\n i += 1\n\n # toss the last b'>' on the end!\n xml_line_part += line[i : i + 1]\n\n # store the xml part off\n xml_line_segments.append(xml_line_part)\n ordered_parsed_line.append((\"xml\", xml_line_part))\n xml_line_part = b\"\" # reset the xml part\n\n # store xml free part off\n if len(xml_free_line_part) > 1:\n xml_free_line_segments.append(xml_free_line_part)\n ordered_parsed_line.append((\"text\", xml_free_line_part))\n xml_free_line_part = b\"\" # reset the xml_free_line_part\n\n i += 1 # covers incrementing past the '>' and incrementing if not yet in a '<'\n\n \"\"\"\n # https://lxml.de/tutorial.html\n # if the xml cannot be parsed, we just want to catch it and decide what to do\n try:\n xml = [lxml.etree.XML(xml_line) for xml_line in xml_line_segments]\n xml_tags = [x.tag for x in xml]\n # just testing lxml tag parsing\n if b'streamWindow' in xml_tags:\n xml_free_lines.append(b'streamWindow skipped...')\n\n except lxml.etree.XMLSyntaxError:\n xml = list() # no tags\n # toss any failing XML onto the text stream for manual parsing?\n # we can follow this approach even if we replace or wrap lxml with a manual parser\n xml_free_lines.extend(xml_line_segments)\n \"\"\"\n # do stuff with the xml components of the line\n op_line = ordered_parsed_line\n\n # strip the line back down to text\n clean_line = [x[1].replace(b\">\", b\">\") for x in op_line if x[0] == \"text\"]\n xml_free_lines.append(b\"\".join(clean_line))\n\n # send a hunk of xml so we can see what happened\n xml_line = [x[1].replace(b\">\", b\">\") for x in op_line if x[0] == \"xml\"]\n xml_free_lines.append(b\"\".join(xml_line))\n\n # just point it here for now so we don't have to change the return\n view_lines = xml_free_lines\n\n \"\"\"\n EXCLUDES = [\n r'<prompt.*>',\n r'</prompt.*>',\n ]\n\n SUBS = [\n (r'<.*>', ''),\n ]\n\n # drop empty lines before the regex to save processing\n # what about lines with whitespace only...\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\n\n for exclude in EXCLUDES:\n view_lines = [str(line) for line in view_lines if not re.search(exclude, str(line))]\n\n for expr, sub in SUBS:\n view_lines = [re.sub(expr, sub, str(line)) for line in view_lines]\n\n # drop empty lines after the regex so they aren't shown\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\n \"\"\"\n\n return view_lines","def prune(record: cfg.OpenAPI, outformat: cfg.Format = None) -> NoReturn:\n content = record.oas\n # Cleanup\n content, _, _ = clean.remove_unused_components(content)\n content = clean.remove_empty_objects(content)\n # Output\n out(content, outformat or record.oastype)","def nonempty_lines(text):\n return [line for line in text.split('\\n') if line]","def cleanup_comments(comments):\n clean_comments = []\n\n if comments:\n for comment in comments:\n cleaned_up = sub(r'\\n\\n {8}\\n {8}\\n {12}\\n {16}\\n {16}\\n {12}\\nEdit', '', comment)\n clean_comments.append(cleaned_up)\n\n return clean_comments","def strip_html(text: str, **serializer_kwargs: bool):\n cleaner = get_cleaner(**serializer_kwargs)\n text = cleaner.clean(text)\n return text","def sanitize_content(content):\r\n\r\n # stripping all HTML TAGS\r\n content = BeautifulSoup(content).find(\"div\", {\"id\": \"content\", \"role\": \"main\"}).get_text()\r\n\r\n if CASE_FOLDING:\r\n # case folding\r\n content = content.lower()\r\n if PUNCTUATION_REMOVAL:\r\n\r\n # Removing punctuation.\r\n content = re.sub(PUNCTUATIONS_REGEX_COMMA_1, \"\", content, 0)\r\n content = re.sub(PUNCTUATIONS_REGEX_COMMA, \"\", content, 0)\r\n content = re.sub(PUNCTUATIONS_REGEX, \"\", content, 0).replace(\"'\", \"\");\r\n\r\n return re.sub(r\"([\\n\\t])+\", \" \", content, 0)","def getHTMLComments(self, text):\n return self.doSpecial(text, '<!--', '-->', self.fParseHTMLComments)","def remove_comments(s):\n return \"\\n\".join(l for l in s.strip().split(\"\\n\") if not l.strip().startswith(\"#\"))","def purify_comments(csv_file, keep_stops=False, POS=False, lemmatize=False, popular=0):\r\n\r\n df = pd.read_csv(csv_file)\r\n df = df.loc[df[\"author\"] != \"[deleted]\"] # trim out comments whose authors have deleted their accounts\r\n df = df.loc[df[\"score\"] != \"score\"] # this is an error in the code when building new csv_files from dask\r\n\r\n # extracts only the popular comments\r\n if popular > 0:\r\n df = df.loc[pd.to_numeric(df[\"score\"]) > popular]\r\n\r\n comments = df[\"body\"]\r\n del df # no need for this anymore, and it'll merely eat up memory\r\n\r\n nlp = en_core_web_sm.load()\r\n\r\n revised_comments = []\r\n for comment in comments.astype('unicode').values:\r\n comment = comment[1:] # remove the initial 'b' bytes-representation character\r\n comment = comment.encode(\"utf-8-sig\").decode(\"utf-8-sig\") # get rid of BOM character\r\n comment = comment.lower().replace(r\"\\n\", r\"\").replace(r'\"', r'')\r\n\r\n tokens = nlp(comment)\r\n\r\n # actual specification section\r\n for sent in tokens.sents:\r\n\r\n if POS: # conversion of comments to tokens/lemmas-POS tags\r\n if lemmatize:\r\n if keep_stops:\r\n revised_tokens = [\"{}-{}\".format(token.lemma_, token.tag_) for token in sent\r\n if not token.is_punct]\r\n else:\r\n revised_tokens = [\"{}-{}\".format(token.lemma_, token.tag_) for token in sent\r\n if not token.is_stop and not token.is_punct\r\n and not token.orth_ == \"n't\" and not token.orth_ == \"'s\"]\r\n else:\r\n if keep_stops:\r\n revised_tokens = [\"{}-{}\".format(token.orth_, token.tag_) for token in sent\r\n if not token.is_punct]\r\n else:\r\n revised_tokens = [\"{}-{}\".format(token.orth_, token.tag_) for token in sent\r\n if not token.is_stop and not token.is_punct\r\n and not token.orth_ == \"n't\" and not token.orth_ == \"'s\"]\r\n\r\n elif lemmatize: # just lemmatization\r\n if keep_stops:\r\n revised_tokens = [token.lemma_ for token in sent\r\n if not token.is_punct]\r\n else:\r\n revised_tokens = [token.lemma_ for token in sent\r\n if not token.is_stop and not token.is_punct\r\n and not token.orth_ == \"n't\" and not token.orth_ == \"'s\"]\r\n\r\n else: # nothing but removal of stop words (or not)\r\n if keep_stops:\r\n revised_tokens = [token.orth_ for token in sent\r\n if not token.is_punct]\r\n else:\r\n revised_tokens = [token.orth_ for token in sent\r\n if not token.is_stop and not token.is_punct\r\n and not token.orth_ == \"n't\" and not token.orth_ == \"'s\"]\r\n\r\n revised_comments.append(\" \".join(revised_tokens))\r\n\r\n return pd.Series(revised_comments)","def remove_lines():\n work_folder = os.path.join(CURRENT_FOLDER, \"..\\\\Data\\\\weather_data\")\n with open(os.path.join(work_folder, \"filtered_merged_history_KMDW.csv\"), \"w\") as outfile:\n with open(os.path.join(work_folder, \"merged_history_KMDW.csv\")) as infile:\n outfile.write(infile.next())\n for line in infile:\n if line[0].isdigit():\n outfile.write(line)","def clean_data(self, path, exclude_msgtypes=None):","def suppress_analyze(more_exclusions=None):\n return api.override_step_data(\n 'read filter exclusion spec',\n api.json.output({\n 'base': {\n 'exclusions': ['f.*'] + (more_exclusions or []),\n },\n 'chromium': {\n 'exclusions': [],\n },\n })\n )"],"string":"[\n \"def _strip_comments(file_contents):\\n lines_without_comments = []\\n for line in file_contents:\\n comment_position = line.find(COMMENT_INDICATOR)\\n if comment_position != -1:\\n lines_without_comments.append(line[:comment_position])\\n else:\\n lines_without_comments.append(line)\\n return lines_without_comments\",\n \"def collapse_all(content, filter_comment=False):\\n _initial_content = content\\n collapsed_content = {}\\n\\n if filter_comment:\\n # Filter comment before collapsing elements to prevent comment analysis\\n content = filter_comments(content, keep_content_size=True)\\n\\n def _replace_element(element):\\n \\\"\\\"\\\"Replace matched *element* in content.\\\"\\\"\\\"\\n # Guess line number\\n count = element.group().count(\\\"\\\\n\\\")\\n\\n # Ensure that the replacement string keep the same length that\\n # the original content to be able to use the match positions\\n _buffer = len(element.group()) - count - 2\\n\\n if len(element.group()) > 2:\\n line_number = content[:element.start()].count(\\\"\\\\n\\\")+1\\n collapsed_content[line_number] = (\\n _initial_content[element.start():element.end()]\\n )\\n\\n return \\\"<>{buffer}{lines}\\\".format(\\n buffer=\\\" \\\" * _buffer,\\n lines=\\\"\\\\n\\\" * count\\n )\\n\\n _content = None\\n\\n while _content != content:\\n _content = content\\n content = _NESTED_ELEMENT_PATTERN.sub(_replace_element, content)\\n\\n # Remove the space buffer before returning the content\\n content = re.sub(r\\\"<> *\\\", lambda x: \\\"{}\\\", content)\\n\\n return content, collapsed_content\",\n \"def get_shrinked_checkpoint_content(content, lines_to_keep)->str:\\n i = 0\\n original_lines = content.splitlines()\\n newlines = []\\n for line in reversed(original_lines):\\n if i < lines_to_keep:\\n newlines.append(line)\\n i += 1\\n else:\\n break #reached max lines to keep\\n\\n if len(newlines) < len(original_lines):\\n newlines.append(original_lines[0]) # Add header line\\n\\n new_content = \\\"\\\\n\\\".join(reversed(newlines))\\n return new_content\",\n \"def contents_without_whitespace(self):\\n return self.contents.replace(' ', '').replace('\\\\n', '')\",\n \"def strip_blocks(self):\\n print_content = False\\n if self.exclude_blocks and len(self.exclude_blocks) > 0:\\n for package_name, package in self.packages.items():\\n for c, fd in package.components.iteritems():\\n for block in self.exclude_blocks:\\n JS_BLOCKS = re.compile(r'/[/*]\\\\s*<' + block + '>.+?<\\\\/' + block + '>(?:\\\\s*\\\\*/)?(?s)', re.MULTILINE)\\n fd.content = JS_BLOCKS.sub('/* compat block ' + block + ' removed */', fd.content)\\n print_content = True\\n if print_content:\\n print fd.content\",\n \"def deleteComments(self: Self, event: Event = None) -> None:\\n #@+<< deleteComments docstring >>\\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\\n #@@pagewidth 50\\n #@-<< deleteComments docstring >>\\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\\n #\\n # \\\"Before\\\" snapshot.\\n bunch = u.beforeChangeBody(p)\\n #\\n # Initial data.\\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\\n if not lines:\\n g.warning('no text selected')\\n return\\n # The default language in effect at p.\\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\\n if c.hasAmbiguousLanguage(p):\\n language = c.getLanguageAtCursor(p, language)\\n d1, d2, d3 = g.set_delims_from_language(language)\\n #\\n # Calculate the result.\\n changed, result = False, []\\n if d1:\\n # Remove the single-line comment delim in front of each line\\n d1b = d1 + ' '\\n n1, n1b = len(d1), len(d1b)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n if g.match(s, i, d1b):\\n result.append(s[:i] + s[i + n1b :])\\n changed = True\\n elif g.match(s, i, d1):\\n result.append(s[:i] + s[i + n1 :])\\n changed = True\\n else:\\n result.append(s)\\n else:\\n # Remove the block comment delimiters from each line.\\n n2, n3 = len(d2), len(d3)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n j = s.find(d3, i + n2)\\n if g.match(s, i, d2) and j > -1:\\n first = i + n2\\n if g.match(s, first, ' '):\\n first += 1\\n last = j\\n if g.match(s, last - 1, ' '):\\n last -= 1\\n result.append(s[:i] + s[first:last] + s[j + n3 :])\\n changed = True\\n else:\\n result.append(s)\\n if not changed:\\n return\\n #\\n # Set p.b and w's text first.\\n middle = ''.join(result)\\n p.b = head + middle + tail # Sets dirty and changed bits.\\n w.setAllText(head + middle + tail)\\n #\\n # Set the selection range and scroll position.\\n i = len(head)\\n j = ins = max(i, len(head) + len(middle) - 1)\\n w.setSelectionRange(i, j, insert=ins)\\n w.setYScrollPosition(oldYview)\\n #\\n # \\\"after\\\" snapshot.\\n u.afterChangeBody(p, 'Indent Region', bunch)\",\n \"def del_comm(self, blocks=False):\\n logging.debug('Delete comments from text')\\n if not(self.check()):\\n raise GcodeError(\\\"Invalid g-codes\\\")\\n temp = []\\n comment = re.compile(';\\\\ .*')\\n for line in self.blocks:\\n n = comment.search(line)\\n if n:\\n line = line[:n.span()[0]]\\n line = line.strip()\\n if line != \\\"\\\":\\n temp.append(line)\\n if blocks:\\n return temp\\n return \\\"\\\\n\\\".join(temp)\",\n \"def _RemoveStaleComments(content: str) -> str:\\n for match in STALE_GROUP_COMMENT_REGEX.findall(content):\\n content = content.replace(match, '')\\n\\n return content\",\n \"def comment_content(c):\\n content = str(c)[4:-3]\\n return content.strip()\",\n \"def DropComment(text):\\n grp = re.compile(r'/\\\\*[^/]*\\\\*/').split(text)\\n result = string.join(grp);\\n grp = re.compile(r'//.*').split(result);\\n result = string.join(grp);\\n #result = string.join(result.split('\\\\n')) #remove the line break\\n return(' '+result);\",\n \"def extract_only_content(self, path=None, payload=None):\\n\\n f = file_path(path, payload)\\n switches = [\\\"-t\\\", f]\\n result = self._command_template(switches)\\n return result, path, f\",\n \"def process_comment(self, data):\\r\\n if not self.is_suppress:\\r\\n return [data]\",\n \"def _removeComments(code):\\r\\n # remove all occurance streamed comments (/*COMMENT */) from string\\r\\n text = re.sub(re.compile('/\\\\*.*?\\\\*/', re.DOTALL), '', code)\\r\\n # remove all occurance singleline comments (//COMMENT\\\\n ) from string\\r\\n return re.sub(re.compile('//.*?\\\\n'), '', text)\",\n \"def _filter(self, text, context, encoding):\\n\\n content = []\\n soup = bs4.BeautifulSoup(text, self.parser)\\n soup = self.get_sub_node(soup)\\n blocks, attributes, comments = self.to_text(soup)\\n if self.comments:\\n for c, desc in comments:\\n content.append(filters.SourceText(c, context + ': ' + desc, encoding, self.type + 'comment'))\\n if self.attributes:\\n for a, desc in attributes:\\n content.append(filters.SourceText(a, context + ': ' + desc, encoding, self.type + 'attribute'))\\n for b, desc in blocks:\\n content.append(filters.SourceText(b, context + ': ' + desc, encoding, self.type + 'content'))\\n return content\",\n \"def removeHtmlComments(self, text):\\n sb = []\\n start = text.find(u'<!--')\\n last = 0\\n while start != -1:\\n end = text.find(u'-->', start)\\n if end == -1:\\n break\\n end += 3 \\n \\n spaceStart = max(0, start-1)\\n spaceEnd = end\\n while text[spaceStart] == u' ' and spaceStart > 0:\\n spaceStart -= 1\\n while text[spaceEnd] == u' ':\\n spaceEnd += 1\\n \\n if text[spaceStart] == u'\\\\n' and text[spaceEnd] == u'\\\\n':\\n sb.append(text[last:spaceStart])\\n sb.append(u'\\\\n')\\n last = spaceEnd+1\\n else:\\n sb.append(text[last:spaceStart+1])\\n last = spaceEnd\\n \\n start = text.find(u'<!--', end)\\n sb.append(text[last:])\\n return u''.join(sb)\",\n \"def strip_comments(blob, delim='#'):\\n lines = blob.split('\\\\n')\\n return '\\\\n'.join([line for line in lines if line.strip()[0] != delim])\",\n \"def lines(filename, exclude_imports=True, exclude_comments=True, exclude_tests=True, exclude_globals=True, exclude_blank=True, verbose=False, is_c=False, s=None):\\n if s is None:\\n s = open(filename, 'rt').read()\\n\\n L = s.split('\\\\n')\\n \\n # Hack to strip out triple and single quote string lines in a heuristic (unreliable) way, which avoids parsing Cython\\n if not is_c:\\n for i in range(len(L)):\\n if L[i].strip().startswith(\\\"'\\\") and L[i].strip().endswith(\\\"'\\\"):\\n L[i] = ''\\n i = 0\\n while i < len(L):\\n found = False\\n for triple_quote in ['\\\"\\\"\\\"', \\\"'''\\\"]:\\n if L[i].strip().startswith(triple_quote):\\n L[i] = L[i].strip()[3:]\\n for j in range(i, len(L)):\\n if triple_quote in L[j]:\\n found = True\\n L[j] = ''\\n if found:\\n break\\n i = j+1\\n if not found:\\n i += 1\\n else:\\n begin_comment = '/*'\\n end_comment = '*/'\\n i = 0\\n while i < len(L):\\n found = False\\n if begin_comment in L[i]:\\n rest = L[i][L[i].index(begin_comment)+len(begin_comment):]\\n L[i] = L[i][:L[i].index(begin_comment)]\\n if end_comment in rest:\\n found = True\\n i += 1\\n else:\\n for j in range(i+1, len(L)):\\n if end_comment in L[j]:\\n found = True\\n L[j] = L[j][L[j].index(end_comment)+len(end_comment):]\\n else:\\n L[j] = ''\\n if found:\\n break\\n i = j + 1\\n if not found:\\n i += 1\\n\\n# util.print_header('Lines before exclude_tests:' + filename, '\\\\n'.join(L))\\n\\n # Hack to strip out def test() and other methods in a heuristic (unreliable) way, which avoids parsing Cython\\n if exclude_tests:\\n # Also exclude makeColorMatrix so that our camera pipe is apples-to-apples comparable with reported lines in Halide paper\\n if not is_c:\\n methods = 'test run_test_all mandelbrot_gray mandelbrot_color composite_numpy composite_numexpr makeColorMatrix'.split()\\n else:\\n methods = ['int main', 'void main']\\n i = 0\\n while i < len(L):\\n L_i_strip = L[i].strip()\\n if ((not is_c and (any(L_i_strip.startswith('def ' + method) for method in methods) or\\n any(L_i_strip.startswith('cdef ' + method) for method in methods))) or\\n (is_c and (any(L_i_strip.startswith(method) for method in methods)))):\\n L[i] = ''\\n for j in range(i+1, len(L)):\\n L_j_strip = L[j].strip()\\n c_ok = True\\n if is_c:\\n c_ok = L_j_strip != '{' and L_j_strip != '}'\\n if not L[j].startswith(' ') and not L[j].startswith('\\\\t') and not len(L[j].strip()) == 0 and c_ok:\\n break\\n else:\\n L[j] = ''\\n i = j\\n elif (L[i].strip().startswith('test(') or L[i].strip().startswith('run_test_all(')) and not is_c:\\n L[i] = ''\\n i += 1\\n else:\\n i += 1\\n\\n# util.print_header('Lines before exclude_imports:' + filename, '\\\\n'.join(L))\\n if exclude_imports:\\n if not is_c:\\n L = [x for x in L if not x.lstrip().startswith('import') and not x.lstrip().startswith('cimport') and not x.startswith('cdef extern')]\\n else:\\n L = [x for x in L if not x.lstrip().startswith('#include')]\\n# util.print_header('Lines before exclude_comments:' + filename, '\\\\n'.join(L))\\n if exclude_comments:\\n if not is_c:\\n L = [x for x in L if not x.lstrip().startswith('#') and not x.strip() == 'pass']\\n else:\\n L = [x for x in L if not x.lstrip().startswith('//')]\\n# util.print_header('Lines before exclude_globals:' + filename, '\\\\n'.join(L))\\n if exclude_globals and not is_c:\\n L = [x for x in L if (x.startswith(' ') or x.startswith('\\\\t') or x.startswith('def') or x.startswith('cdef')) and (not x.lstrip().startswith('has_'))]\\n# util.print_header('Lines before exclude_blank:' + filename, '\\\\n'.join(L))\\n\\n if is_c:\\n # Also exclude makeColorMatrix so that C camera pipe is apples-to-apples comparable with reported lines in Halide paper\\n L = [x for x in L if not x.lstrip().startswith('matrix_3200') and not x.lstrip().startswith('matrix_7000')]\\n if exclude_blank:\\n L = [x for x in L if not len(x.strip()) == 0]\\n\\n if verbose:\\n util.print_header('Final lines for:' + filename, '\\\\n'.join(L))\\n\\n return len(L)\",\n \"def return_filtered_comments(submission):\\n submission.comment_sort = COMMENT_SORT_BY\\n submission.comment_limit = COMMENT_LIMIT\\n filtered_comments = []\\n for top_level_comment in submission.comments:\\n if isinstance(top_level_comment, praw.models.MoreComments):\\n continue\\n # Here you can fetch data off the comment.\\n comment = top_level_comment.body\\n\\n # ensure that the comment does not contain any words in blacklist\\n # and also it is less than COMMENT_MAX_WORDS\\n fail_test = 0\\n lcomment = comment.lower()\\n for badword in blacklist:\\n if badword not in lcomment and len(comment) < COMMENT_MAX_WORDS:\\n pass\\n else:\\n fail_test += 1\\n if not fail_test:\\n filtered_comments.append(replace_words(comment).capitalize())\\n\\n return filtered_comments\",\n \"def unMarkupCommentsAndStrings(self, content):\\n\\n def replaceMarkups(match):\\n groupdict = match.groupdict()\\n if groupdict[\\\"str\\\"] is not None:\\n return self.strings[int(match.group(\\\"str\\\"))]\\n elif groupdict[\\\"comment\\\"] is not None:\\n return self.comments[int(match.group(\\\"comment\\\"))]\\n else:\\n assert False\\n\\n unMarkedup = markups.sub(replaceMarkups, content)\\n\\n return unMarkedup\",\n \"def prune_qc(keep=False):\\n ppg.util.global_pipegraph._qc_keep_function = keep\\n for job in get_qc_jobs():\\n if keep is not False and keep(job):\\n job.unprune()\\n else:\\n job.prune()\",\n \"def clean_comments(self):\\n new_lines = list()\\n for line in self.lines:\\n if ((not line.startswith(\\\"//\\\")) & (not line.isspace()) &\\n (not line.startswith(\\\"/*\\\") & (not line.startswith(\\\"*/\\\")))):\\n line = Parser.strip_line(line)\\n new_lines.append(line)\\n self.lines = new_lines\",\n \"def clean_html(message):\\n all_lines = []\\n started_html = False\\n finished_with_html_tag = False\\n html_part = []\\n for idx, line in enumerate(message.split(\\\"\\\\n\\\")):\\n if re.search(r\\\"<.*?html.*?>\\\", line):\\n started_html = True\\n html_part.append(line)\\n else:\\n if started_html:\\n html_part.append(line)\\n else:\\n all_lines.append(line)\\n if \\\"</html>\\\" in line:\\n finished_with_html_tag = True\\n if finished_with_html_tag:\\n all_lines.append(clean_text_from_html_tags(\\\"\\\\n\\\".join(html_part)))\\n html_part = []\\n finished_with_html_tag = False\\n started_html = False\\n if len(html_part) > 0:\\n all_lines.extend(html_part)\\n return delete_empty_lines(\\\"\\\\n\\\".join(all_lines))\",\n \"def keep_only_archive(self):\\n\\n keep = []\\n read_datafile = open(self.filename, 'rt')\\n for line in read_datafile:\\n line = line.strip()\\n if line.startswith('ARCHIVE'):\\n keep.append(line)\\n read_datafile.close()\\n\\n write_datafile = open(self.filename, 'wt')\\n write_datafile.write('\\\\n'.join(keep))\\n write_datafile.write('\\\\n')\\n write_datafile.close()\",\n \"def clean_content(self) -> str:\",\n \"def keeponly(s, keep):\\n return ''.join([x for x in s if x in keep])\",\n \"def getContents(self):\\n normal_body_regex = re.compile(r'[ \\\\n\\\\r\\\\t]+')\\n return normal_body_regex.sub(' ', self.contents)\",\n \"def cleaned_contents(self):\\n snip_with_code = re.compile(\\\"(//.*snip(\\\\-file)*:?.*\\\\n)(\\\\+\\\\n)?(\\\\[.*\\\\]\\\\n)*----\\\\n(.*\\\\n)*?----\\\\n\\\", flags=re.IGNORECASE)\\n cleaned = re.sub(snip_with_code, r'\\\\1', self.contents)\\n return cleaned\",\n \"def splitBodyLines(cls, text):\\n\\n def remove_comments(line):\\n \\\"\\\"\\\"\\n Returns the given line stripped of any comments.\\n \\\"\\\"\\\"\\n hashPos = line.find('#')\\n return line[:hashPos] if hashPos >= 0 else line\\n\\n # Remove comments, strip whitespace, and return only non-blank lines\\n lines = map(str.strip, map(remove_comments, text.splitlines()))\\n return [l for l in lines if l]\",\n \"def stripped_lines(lines, ignore_comments, ignore_docstrings, ignore_imports):\\n if ignore_imports:\\n tree = astroid.parse(\\\"\\\".join(lines))\\n node_is_import_by_lineno = (\\n (node.lineno, isinstance(node, (astroid.Import, astroid.ImportFrom)))\\n for node in tree.body\\n )\\n line_begins_import = {\\n lineno: all(is_import for _, is_import in node_is_import_group)\\n for lineno, node_is_import_group in groupby(\\n node_is_import_by_lineno, key=lambda x: x[0]\\n )\\n }\\n current_line_is_import = False\\n\\n strippedlines = []\\n docstring = None\\n for lineno, line in enumerate(lines, start=1):\\n line = line.strip()\\n if ignore_docstrings:\\n if not docstring and any(\\n line.startswith(i) for i in ['\\\"\\\"\\\"', \\\"'''\\\", 'r\\\"\\\"\\\"', \\\"r'''\\\"]\\n ):\\n docstring = line[:3]\\n line = line[3:]\\n if docstring:\\n if line.endswith(docstring):\\n docstring = None\\n line = \\\"\\\"\\n if ignore_imports:\\n current_line_is_import = line_begins_import.get(\\n lineno, current_line_is_import\\n )\\n if current_line_is_import:\\n line = \\\"\\\"\\n if ignore_comments:\\n line = line.split(\\\"#\\\", 1)[0].strip()\\n strippedlines.append(line)\\n return strippedlines\",\n \"def filter_out_data(text):\\n if len(text) < 30:\\n return None\\n return text\",\n \"def _clean_message(comment):\\n message = comment['message']\\n # Remove comments with linked persons (they mostly contain only emojis)\\n if 'message_tags' in comment:\\n for tag in comment['message_tags']:\\n if 'type' in tag and tag['type'] == 'user':\\n message = message.replace(tag['name'], '')\\n # Remove links\\n message = re.sub(r'http\\\\S+', '', message)\\n return message.strip()\",\n \"def get_content(self):\\n content = copy(self.content)\\n self.content = ''\\n return content\",\n \"def _remove_whitespace(file_contents):\\n whitespace_stripped = [line.strip() for line in file_contents]\\n return [line for line in whitespace_stripped if line != \\\"\\\"]\",\n \"def process_only_nodes(config, document, tags):\\n # type: (nodes.Node, Tags) -> None\\n ret_html_cell = config['jupyter_allow_html_only'] \\n for node in document.traverse(addnodes.only):\\n try:\\n ret = tags.eval_condition(node['expr']) #check for jupyter only\\n if ret_html_cell and node['expr'] == 'html': #allow html only cells if option is specified\\n ret = True\\n except Exception as err:\\n logger.warning(__('exception while evaluating only directive expression: %s'), err,\\n location=node)\\n node.replace_self(node.children or nodes.comment())\\n else:\\n if ret:\\n node.replace_self(node.children or nodes.comment())\\n else:\\n # A comment on the comment() nodes being inserted: replacing by [] would\\n # result in a \\\"Losing ids\\\" exception if there is a target node before\\n # the only node, so we make sure docutils can transfer the id to\\n # something, even if it's just a comment and will lose the id anyway...\\n node.replace_self(nodes.comment())\",\n \"def _get_review_comments_body(\\n self, pull_request_number: int) -> List[Tuple[str, str]]:\\n review_comments = get_pull_request_review_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not review_comments:\\n return []\\n review_comments_msg = []\\n for comment in review_comments:\\n review_comments_msg.append((comment['path'], comment['body']))\\n return review_comments_msg\",\n \"def get_formatted_comments(self, threshold=400):\\n comments = IDossier(self).comments\\n if comments:\\n if threshold:\\n comments = truncate_ellipsis(comments, threshold)\\n return api.portal.get_tool(name='portal_transforms').convertTo(\\n 'text/html', comments, mimetype='text/x-web-intelligent').getData()\",\n \"def stripText(self, rawText):\\n strippedText = []\\n for line in rawText:\\n if line.rstrip():\\n if line[0] != '#':\\n strippedText.append(line.rstrip()) #also remove newline character\\n return strippedText\",\n \"def comment_remover(text):\\n\\n def replacer(match):\\n s = match.group(0)\\n if s.startswith(\\\"/\\\"):\\n return \\\"\\\"\\n else:\\n return s\\n\\n pattern = re.compile(\\n r'//.*?$|/\\\\*.*?\\\\*/|\\\\'(?:\\\\\\\\.|[^\\\\\\\\\\\\'])*\\\\'|\\\"(?:\\\\\\\\.|[^\\\\\\\\\\\"])*\\\"',\\n re.DOTALL | re.MULTILINE,\\n )\\n return re.sub(pattern, replacer, text)\",\n \"def split_by_lines(text, remove_empty=False):\\n\\tlines = text.splitlines()\\n\\t\\n\\treturn remove_empty and [line for line in lines if line.strip()] or lines\",\n \"def contentextract(text):\\n stopword=stopwords.words('english')\\n punctuation=['.','?','!',',',';',\\\"''\\\",'\\\"\\\"',\\\"'\\\",\\\"--\\\",\\\"``\\\",\\\"|\\\",\\\"<\\\",\\\">\\\",\\\"...\\\",\\\"......\\\",\\\"'s\\\",':','[',']',\\n '(',')','#','*','$','%','@','^','-','+','=','/','{','}','\\\\\\\\','\\\"','&']\\n content=[w for w in text if w.lower() not in stopword]\\n content=[w for w in content if w not in punctuation]\\n return content\",\n \"def parse_comments_html(advertise: Dict[str, Any]) -> Optional[List[str]]:\\n if \\\"comments_html\\\" in advertise.keys():\\n\\n filtred_comments: str = advertise[\\\"comments_html\\\"][200::]\\n\\n tmp: List[str] = re.split(\\\"[ \\\\n\\\\t]{2,}\\\", filtred_comments)\\n if '' in tmp:\\n tmp.remove('')\\n\\n # Breaking comments\\n master: List[List[str]] = []\\n tmp_vec: List[str] = []\\n for line in tmp:\\n\\n if re.search(\\\"de \\\\d{4,}\\\", line): # matches 'de 2018' that signals the end of comment\\n master.append(tmp_vec)\\n tmp_vec = []\\n else:\\n tmp_vec.append(line)\\n\\n # Cleaning comments\\n for comment in master:\\n if \\\"...\\\" in comment:\\n comment.remove(\\\"...\\\")\\n if \\\"O usuário contratou o serviço em\\\" in comment:\\n comment.remove(\\\"O usuário contratou o serviço em\\\")\\n\\n return [\\\" \\\".join(m) for m in master]\",\n \"def remove_comments(css):\\n log.debug(\\\"Removing all Comments.\\\")\\n iemac, preserve = False, False\\n comment_start = css.find(\\\"/*\\\")\\n while comment_start >= 0: # Preserve comments that look like `/*!...*/`.\\n # Slicing is used to make sure we dont get an IndexError.\\n preserve = css[comment_start + 2:comment_start + 3] == \\\"!\\\"\\n comment_end = css.find(\\\"*/\\\", comment_start + 2)\\n if comment_end < 0:\\n if not preserve:\\n css = css[:comment_start]\\n break\\n elif comment_end >= (comment_start + 2):\\n if css[comment_end - 1] == \\\"\\\\\\\\\\\":\\n # This is an IE Mac-specific comment; leave this one and the\\n # following one alone.\\n comment_start = comment_end + 2\\n iemac = True\\n elif iemac:\\n comment_start = comment_end + 2\\n iemac = False\\n elif not preserve:\\n css = css[:comment_start] + css[comment_end + 2:]\\n else:\\n comment_start = comment_end + 2\\n comment_start = css.find(\\\"/*\\\", comment_start)\\n return css\",\n \"def _get_comments(self):\\n if not hasattr(self, 'id'):\\n raise BadReference('No matching issue on disk')\\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))\",\n \"def process_all(self):\\n global multi_comment_line_mode\\n multi_comment_line_mode = False\\n for line in self.fileToProcess:\\n line = line.strip() # creating a strip line, with no whitespace in the beginning and in the end\\n # multi_comment_line_mode = False\\n # first, we want to filter all the lines which are comments or part of comments\\n while line != '':\\n ignoring_status,newline = self.shouldTheLineBeIgnored(line)\\n if ignoring_status:\\n break # we are ignoring the line\\n elif (not ignoring_status) and (newline != '') and newline != '$endOfMultiLine':\\n line = newline\\n continue\\n elif not ignoring_status and newline == '$endOfMultiLine':\\n break\\n else:\\n line = self.isThereApartToIgnore(line) #getting the good line\\n line = line.strip()\\n if line.endswith('$endOfMultiLine'):\\n # line = line[:-1]\\n line = line[:-15]\\n # in this case we don't want to ignore the current line\\n # if multi_comment_line_mode:\\n # # this comes from the\\n list_of_line_strings = re.split('(\\\\W)', line) # the default of this method is to remove all the white spaces\\n list_of_line_strings = list(filter(None, list_of_line_strings))\\n global i\\n i = 0\\n global first_index\\n first_index = 0\\n global second_index\\n second_index = 0\\n len_of_list = len(list_of_line_strings)\\n while i < len_of_list:\\n # first adding the string literals\\n if (list_of_line_strings[i] == '\\\"' and i == 0) or (i>0 and list_of_line_strings[i] == '\\\"' and\\n list_of_line_strings[i-1]!='*'):\\n first_index = i\\n i = i + 1\\n if i == len(list_of_line_strings):\\n break\\n while list_of_line_strings[i] != '\\\"':\\n i = i + 1\\n if i>=len(list_of_line_strings):\\n # in case it's the end\\n i = first_index\\n break\\n else:\\n continue\\n second_index = i\\n list_of_line_strings[first_index:second_index + 1] = [\\n ''.join(list_of_line_strings[first_index:second_index + 1])]\\n i = i + 2\\n len_of_list = len(list_of_line_strings)\\n else:\\n i = i + 1\\n j=0\\n global skip_mode\\n skip_mode = False\\n global counter\\n counter = 0\\n for string in list_of_line_strings:\\n if j != len(list_of_line_strings)-1:\\n j+=1\\n if counter == 1:\\n counter = 0\\n continue\\n if skip_mode and not (string == '*' and list_of_line_strings[j] == '/'):\\n continue\\n if skip_mode and string == '*' and list_of_line_strings[j] == '/':\\n skip_mode = False\\n counter = 1\\n continue\\n if string == \\\"/\\\" and (list_of_line_strings[j] == \\\"/\\\" ):\\n # this is a comment that appeared in the line\\n break # in this case, there are no more chars to read because it's a note\\n if string == \\\"/\\\" and list_of_line_strings[j] == \\\"*\\\":\\n skip_mode = True\\n counter = 1\\n continue # entering a skip mode\\n if string.strip() == '':\\n continue\\n self.currStringToProcess = string\\n type = self.tokenType()\\n self.createToken(type,self.currStringToProcess)\\n break\",\n \"def sanitize_comment(comment):\\n\\n if hasattr(settings, \\\"BLEACH_ALLOWED_TAGS\\\"):\\n allowed_tags = settings.BLEACH_ALLOWED_TAGS\\n else:\\n allowed_tags = bleach.sanitizer.ALLOWED_TAGS\\n\\n return bleach.clean(comment, tags=allowed_tags, strip=True)\",\n \"def main(in_path, keep_path, out_path):\\n\\t# First open the input csv\\n\\tcsv_hndl = lambda x: np.array([np.array(r) for r in x])\\n\\tdata, headers = read_csv(in_path, csv_hndl, use_headers=True, delimiter=',')\\n\\n\\t# Read headers to keep\\n\\tkeeps = []\\n\\n\\t# Regex for ignoring comments\\n\\tcmnt_re = re.compile(\\\"^#\\\")\\n\\n\\t# Open and read the file\\n\\twith open(keep_path) as f_obj:\\n\\t\\tfor line in f_obj:\\n\\t\\t\\tline = line.strip()\\n\\t\\t\\t# If line is commented out, ignore\\n\\t\\t\\tif cmnt_re.match(line):\\n\\t\\t\\t\\tcontinue\\n\\t\\t\\t# Otherwise add to list of keeps\\n\\t\\t\\tkeeps.append(line)\\n\\n\\t# Prune the csv\\n\\tnew_data, new_headers = prune_csv(data,headers,keeps)\\n\\n\\t# Write to output csv file\\n\\twrite_csv(\\n\\t\\tout_path, \\n\\t\\tnew_data, \\n\\t\\tnew_headers, \\n\\t\\tdelimiter=',', \\n\\t\\tquotechar='\\\"',\\n\\t\\tquoting=csv.QUOTE_MINIMAL\\n\\t)\",\n \"def contents(filepath):\\n f = open(filepath, 'r')\\n rval = [x.rstrip(\\\"\\\\r\\\\n\\\") for x in f.readlines()]\\n f.close()\\n return rval\",\n \"def remove_patches(self):\\n content = []\\n stretch = []\\n for line in self.spec_content.section(\\\"%package\\\"):\\n stretch.append(line)\\n # Empty lines save the current stretch into content.\\n if not line.strip():\\n content += stretch\\n stretch = []\\n # Patch-lines throw away the current stretch.\\n if line.lower().startswith(\\\"patch\\\"):\\n stretch = []\\n # If there is an empty line at the end of content\\n # throw it away, to avoid duplicate lines.\\n if not content[-1].strip():\\n content.pop()\\n self.spec_content.replace_section(\\\"%package\\\", content)\\n self.save()\",\n \"def remove_fewwords_paragraphs(self, article):\\r\\n all_nodes = self.parser.getElementsByTags(self.get_top_node(), ['*'])\\r\\n all_nodes.reverse()\\r\\n for el in all_nodes:\\r\\n tag = self.parser.getTag(el)\\r\\n text = self.parser.getText(el)\\r\\n stop_words = self.stopwords_class(language=self.get_language(article)).get_stopword_count(text)\\r\\n if (tag != 'br' or text != '\\\\\\\\r') and stop_words.get_stopword_count() < 3 \\\\\\r\\n and len(self.parser.getElementsByTag(el, tag='object')) == 0 \\\\\\r\\n and len(self.parser.getElementsByTag(el, tag='embed')) == 0:\\r\\n self.parser.remove(el)\\r\\n # TODO\\r\\n # check if it is in the right place\\r\\n else:\\r\\n trimmed = self.parser.getText(el)\\r\\n if trimmed.startswith(\\\"(\\\") and trimmed.endswith(\\\")\\\"):\\r\\n self.parser.remove(el)\",\n \"def remove_html_comment(html_data):\\n html_data = re.compile('<!--(.*?)-->', re.MULTILINE|re.DOTALL).sub(\\\"\\\", html_data)\\n return html_data\",\n \"def parse_comment(self, node):\\n\\n data = []\\n\\n if node is not None:\\n comment_id_pattern = re.compile('comment-(\\\\d+)')\\n for comment_node in node.find_all('div', class_='comment'):\\n item = {}\\n item['is_deletable'] = False\\n item['is_editable'] = False\\n \\n comment_id_result = comment_id_pattern.search(comment_node.get('id'))\\n if comment_id_result:\\n item['id'] = int(comment_id_result.group(1))\\n \\n comment_body_node = comment_node.find('div', class_='comment-body')\\n if comment_body_node is not None:\\n item['content'] = ''\\n for p in comment_body_node.find_all(recursive=False):\\n if 'class' in p.attrs and 'author' in p['class']:\\n item['author'] = p.get_text()\\n item['profile_url'] = self.get_link(p.get('href'))\\n author_id = self._parse_user_id_from_url(item['profile_url'])\\n if self.userId == author_id:\\n item['is_deletable'] = True\\n item['is_editable'] = True\\n elif 'class' in p.attrs and 'age' in p['class']:\\n item['date'] = p.abbr['title']\\n item['date_ago'] = timeago.format(self._parse_datetime(item['date']), datetime.now(TIMEZONE))\\n elif 'class' in p.attrs and 'edit' in p['class']:\\n continue\\n elif p.name == 'form':\\n continue\\n else:\\n item['content'] += str(p)\\n\\n data.append(item)\\n\\n return data\",\n \"def config(self, filter_includes=False):\\n def the_filter(k):\\n if filter_includes and k is not None and k.lower() == \\\"include\\\":\\n return False\\n else:\\n return True\\n \\n return \\\"\\\\n\\\".join([x.line for x in self.lines_ if the_filter(x.key)])\",\n \"def file_read(self):\\r\\n with open(self.source_text_path, 'r') as myfile:\\r\\n data = myfile.read() \\r\\n comments = re.compile(r'''\\r\\n (//[^\\\\n]*(?:\\\\n|$)) # Everything between // and the end of the line/file\\r\\n | # or \\r\\n (/\\\\*.*?\\\\*/) # Everything between /* and */\\r\\n |\\r\\n \\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\/|([^:]|^)\\\\/\\\\/.*$ # Every comment between /** and */ \\r\\n ''', re.VERBOSE)\\r\\n self.modified_source_text = comments.sub('\\\\n', data) \\r\\n return self.modified_source_text\",\n \"def read_content(path):\\n input_file = open(path, \\\"r\\\")\\n file_handler = input_file.readlines()\\n input_file.close()\\n list = []\\n\\n for line in file_handler:\\n line = line.split('\\\\n')\\n without_empty_strings = []\\n for string in line:\\n if (string != \\\"\\\"):\\n without_empty_strings.append(string)\\n line = without_empty_strings\\n line = \\\"\\\".join(line)\\n list.append(line)\\n return list\",\n \"def remove_c_style_comments(fd):\\n ret = []\\n comment_state = False\\n for line in fd:\\n while True:\\n # seems we have nothing left\\n if len(line) < 2:\\n break\\n # we're still inside a comment\\n if comment_state:\\n idx = line.find(\\\"*/\\\")\\n if idx > -1:\\n line = line[idx + 2:]\\n comment_state = False\\n continue\\n # comment doesn't seem to end on this line\\n break\\n # we're not inside any comment\\n else:\\n idx = line.find(\\\"/*\\\")\\n if idx > -1:\\n line = line[idx + 2:]\\n comment_state = True\\n continue\\n if \\\"//\\\" in line:\\n line = line.split(\\\"//\\\", 1)[0]\\n # only now we can actually do our job\\n line = line.strip()\\n if len(line) > 0:\\n ret.append(line)\\n break\\n return ret\",\n \"def readFiltered(f):\\n line = f.readline()\\n while line:\\n line = line.strip()\\n if len(line) != 0:\\n if line == \\\"### NEW EXPERIMENT ###\\\":\\n # print (\\\"readFiltered: ''\\\")\\n yield \\\"\\\"\\n elif line[0] != \\\"#\\\":\\n # print (\\\"readFiltered: '\\\",line,\\\"'\\\")\\n yield line\\n line = f.readline()\\n # print (\\\"readFiltered: '\\\",line,\\\"'\\\")\\n return line\",\n \"def get_file_contents(self):\\n with open(self.sql_file, 'r') as sql:\\n text = sql.read()\\n # text = text.replace('\\\\n', '\\\\n\\\\n')\\n # text=sql.read()\\n # TODO: fix some text replacement issues here\\n # https://github.com/andialbrecht/sqlparse/issues/313\\n return self.filter_text(text)\",\n \"def _read_content(self,\\n length,\\n encoding=None,\\n indent=None,\\n line_endings=None,\\n preserve_trailing_newline=False,\\n keep_bytes=False):\\n fp = self._fp\\n content = fp.read(length)\\n\\n # First, determine the line endings that we're going to be working\\n # with.\\n if line_endings:\\n # An explicit line ending type was specified. Validate it and\\n # get the newline characters, encoding it for the byte string.\\n try:\\n newline = get_newline_for_type(line_endings,\\n encoding=encoding)\\n except ValueError as e:\\n raise DiffXParseError(six.text_type(e),\\n linenum=self._linenum)\\n else:\\n # An explicit line ending type was not specified. Try to determine\\n # the appropriate line ending based on the first line of content.\\n line_endings, newline = guess_line_endings(content,\\n encoding=encoding)\\n\\n lines = split_lines(data=content,\\n newline=newline,\\n keep_ends=True)\\n\\n if indent:\\n # It's important that we don't assume each line is actually\\n # indented correctly. There could be nothing but a newline,\\n # or due to some error the indentation on some line may be\\n # wrong. Be careful to strip only the spaces, up to the specified\\n # indentation level.\\n indent_re = re.compile(br'^ {1,%d}' % indent)\\n content = b''.join(\\n indent_re.sub(b'', _line)\\n for _line in lines\\n )\\n\\n if encoding and not keep_bytes:\\n # We know what this content was encoded with. We can now decode\\n # it.\\n content = content.decode(encoding)\\n newline = newline.decode(encoding)\\n\\n # Validate that the content ends in a newline. This is to ensure that\\n # the file was written according to spec.\\n if not content.endswith(newline):\\n raise DiffXParseError(\\n 'Expected a newline after content',\\n linenum=self._linenum)\\n\\n self._linenum += len(lines)\\n\\n return content\",\n \"def test_remove_single_line_comments_noannotation():\\n\\n\\tinput_ = \\\"\\\"\\\"line1\\n\\t\\t\\t\\tline2 \\n\\t\\t\\t\\t//comment\\n\\t\\t\\t\\tline3 \\\"\\\"\\\"\\n\\n\\texpect = \\\"\\\"\\\"line1\\n\\t\\t\\t\\tline2 \\n\\t\\t\\t\\t\\n\\t\\t\\t\\tline3 \\\"\\\"\\\"\\n\\n\\tassert aunit.remove_single_line_comments(input_) == expect\",\n \"def filter_wiki(raw, promote_remaining=True, simplify_links=True):\\n # parsing of the wiki markup is not perfect, but sufficient for our purposes\\n # contributions to improving this code are welcome :)\\n text = to_unicode(raw, 'utf8', errors='ignore')\\n text =decode_htmlentities(text) # '&nbsp;' --> '\\\\xa0'\\n return remove_markup(text, promote_remaining, simplify_links)\",\n \"def strip_text(text):\\n\\n return [line.strip() for line in text.splitlines()]\",\n \"def minify(input,\\n remove_comments=False,\\n remove_empty_space=False,\\n remove_all_empty_space=False,\\n reduce_empty_attributes=True,\\n reduce_boolean_attributes=False,\\n remove_optional_attribute_quotes=True,\\n convert_charrefs=True,\\n keep_pre=False,\\n pre_tags=parser.PRE_TAGS,\\n pre_attr='pre',\\n cls=parser.HTMLMinParser):\\n minifier = cls(\\n remove_comments=remove_comments,\\n remove_empty_space=remove_empty_space,\\n remove_all_empty_space=remove_all_empty_space,\\n reduce_empty_attributes=reduce_empty_attributes,\\n reduce_boolean_attributes=reduce_boolean_attributes,\\n remove_optional_attribute_quotes=remove_optional_attribute_quotes,\\n convert_charrefs=convert_charrefs,\\n keep_pre=keep_pre,\\n pre_tags=pre_tags,\\n pre_attr=pre_attr)\\n minifier.feed(input)\\n minifier.close()\\n return minifier.result\",\n \"def remove_comments(html):\\n return re.sub(r\\\"<!--.*?-->\\\", \\\" \\\", html)\",\n \"def extract_comments(comments_file, output_filename=direc+\\\"/comments.txt\\\"):\\r\\n if not os.path.exists(output_filename.split(\\\"/\\\")[0]):\\r\\n os.makedirs(output_filename.split(\\\"/\\\")[0])\\r\\n\\r\\n print(\\\"Extracting comments from \\\" + comments_file + \\\"...\\\")\\r\\n comments_dict = {}\\r\\n with open(output_filename, \\\"w\\\", encoding=encoding) as f:\\r\\n current = 0\\r\\n for event, child in iterparse(comments_file, events=('start', 'end')):\\r\\n if current > SAMPLE_SIZE:\\r\\n break\\r\\n elif len(child.attrib) > 0 and event == \\\"start\\\":\\r\\n if child.attrib['PostId'] not in comments_dict:\\r\\n comments_dict[child.attrib['PostId']] = []\\r\\n comments_dict[child.attrib['PostId']].append(child.attrib['Id'])\\r\\n clean_comment = clean_markdown(child.attrib['Text'])\\r\\n line = child.attrib['Id'] + \\\"\\\\t\\\" + child.attrib['PostId'] + \\\"\\\\t\\\" + clean_comment + \\\"\\\\t\\\" + child.attrib['Score'] + \\\"\\\\n\\\"\\r\\n f.write(line)\\r\\n\\r\\n current += 1\\r\\n print_progress(current, SAMPLE_SIZE)\\r\\n print(\\\"\\\\nFinished extracting comments from \\\" + comments_file + \\\".\\\\n\\\")\\r\\n return comments_dict\",\n \"def _strip_excerpt(self, raw_html):\\n clean_regex = re.compile(\\\"<.*?>\\\")\\n clean_text = re.sub(clean_regex, \\\"\\\", raw_html)\\n return html.unescape(clean_text).replace(\\\"\\\\n\\\", \\\"\\\")\",\n \"def remove_comments(line):\\n hashPos = line.find('#')\\n return line[:hashPos] if hashPos >= 0 else line\",\n \"def filter_none(data, split_by_client=False):\\n\\n if split_by_client:\\n # filter out missing files and empty clients\\n existing_data = [[d for d in client_data if d is not None]\\n for client_data in data]\\n existing_data = [\\n client_data for client_data in existing_data if client_data]\\n else:\\n # filter out missing files\\n existing_data = [d for d in data if d is not None]\\n return existing_data\",\n \"def get_file_content(self):\\n after = self.file.revisions.filter(\\n revision_number__gt=self.revision_number)\\n content = self.file.content\\n\\n for revision in after:\\n patch = dmp.patch_fromText(revision.diff)\\n content = dmp.patch_apply(patch, content)[0]\\n\\n return content\",\n \"def strip_blanklines(blob):\\n lines = blob.split('\\\\n')\\n return '\\\\n'.join([line for line in lines if line.strip() != ''])\",\n \"def clean_content(sender, instance, **kwargs):\\r\\n if kwargs.get('raw'):\\r\\n # We're in loaddata (or something similar).\\r\\n return\\r\\n\\r\\n page = instance\\r\\n fields = dict(stemplates.get_fields_bare(page.template))\\r\\n current_contents = list(page.pagecontent_set.all())\\r\\n\\r\\n for content in current_contents:\\r\\n if content.title not in fields or fields[content.title] != content.typ:\\r\\n content.delete()\\r\\n\\r\\n existing_contents = dict([(pc.title, pc.typ)\\r\\n for pc in page.pagecontent_set.all()])\\r\\n\\r\\n for title, typ in fields.items():\\r\\n if title not in existing_contents or existing_contents[title] != typ:\\r\\n PageContent(page=page, title=title, typ=typ, content='').save()\",\n \"def line_comments(self, tail_comment = None):\\n tail_comment = tail_comment or self.tail_comment()\\n return [comment for comment in self.comments if comment != tail_comment]\",\n \"def filter_line(self, line):\\n if line.startswith(\\\"<\\\"):\\n # Simply filter out all lines beginning with '<', which are metadata\\n return None\\n\\n # Some metadata-like text is also included at the start of lines, followed by \\\". - \\\"\\n if u\\\". - \\\" in line:\\n __, __, line = line.partition(u\\\". - \\\")\\n\\n # Remove -s and spaces from the start of lines\\n # Not sure why they're often there, but it's just how the transcripts were formatted\\n line = line.lstrip(u\\\"- \\\")\\n\\n # Skip lines that are fully surrounded by brackets: they're typically descriptions of what happened\\n # E.g. (Applause)\\n if line.startswith(u\\\"(\\\") and line.endswith(u\\\")\\\"):\\n return None\\n\\n # It's common for a speaker's first utterance to start with a marker indicating the original language\\n line = language_indicator_re.sub(u\\\"\\\", line)\\n return line\",\n \"def remove_markup(text, promote_remaining=True, simplify_links=True):\\n text = re.sub(RE_P2, '', text) # remove the last list (=languages)\\n # the wiki markup is recursive (markup inside markup etc)\\n # instead of writing a recursive grammar, here we deal with that by removing\\n # markup in a loop, starting with inner-most expressions and working outwards,\\n # for as long as something changes.\\n text = remove_template(text)\\n text = remove_file(text)\\n iters = 0\\n while True:\\n old, iters = text, iters + 1\\n text = re.sub(RE_P0, '', text) # remove comments\\n text = re.sub(RE_P1, '', text) # remove footnotes\\n text = re.sub(RE_P9, '', text) # remove outside links\\n text = re.sub(RE_P10, '', text) # remove math content\\n text = re.sub(RE_P11, '', text) # remove all remaining tags\\n text = re.sub(RE_P14, '', text) # remove categories\\n text = re.sub(RE_P5, '\\\\\\\\3', text) # remove urls, keep description\\n\\n if simplify_links:\\n text = re.sub(RE_P6, '\\\\\\\\2', text) # simplify links, keep description only\\n # remove table markup\\n text = text.replace(\\\"!!\\\", \\\"\\\\n|\\\") # each table head cell on a separate line\\n text = text.replace(\\\"|-||\\\", \\\"\\\\n|\\\") # for cases where a cell is filled with '-'\\n text = re.sub(RE_P12, '\\\\n', text) # remove formatting lines\\n text = text.replace('|||', '|\\\\n|') # each table cell on a separate line(where |{{a|b}}||cell-content)\\n text = text.replace('||', '\\\\n|') # each table cell on a separate line\\n text = re.sub(RE_P13, '\\\\n', text) # leave only cell content\\n text = re.sub(RE_P17, '\\\\n', text) # remove formatting lines\\n\\n # remove empty mark-up\\n text = text.replace('[]', '')\\n # stop if nothing changed between two iterations or after a fixed number of iterations\\n if old == text or iters > 2:\\n break\\n\\n if promote_remaining:\\n text = text.replace('[', '').replace(']', '') # promote all remaining markup to plain text\\n\\n return text\",\n \"def remove_empty_lines(self):\\n self.result_code = open(\\\"result.c\\\", \\\"r\\\") # Opening the intermediate file in 'read' mode.\\n self.line_array = self.result_code.readlines() # Obtaining an array of strings, where each string is a line from the intermediate file.\\n self.result_code.close() # Closing the intermediate file.\\n self.result_code = open(\\\"result.c\\\",\\\"w\\\") #Opening the intermediate file in 'write' mode.\\n # Looping over all the lines in the input file.\\n for line in self.line_array:\\n # Checking if the line is empty.\\n if line != \\\"\\\\n\\\":\\n self.result_code.write(line) # Writing the non-empty line onto the intermediate file.\\n self.result_code.close() # Closing the intermediate file.\",\n \"def _split_into_body_and_options(\\n section_content: str,\\n) -> Tuple[str, Optional[str], Dict[int, bool]]:\\n lines = section_content.strip().splitlines()\\n\\n skipif_expr = None\\n flag_settings = {}\\n i = 0\\n for line in lines:\\n stripped = line.strip()\\n if _OPTION_SKIPIF_RE.match(stripped):\\n skipif_match = _OPTION_SKIPIF_RE.match(stripped)\\n assert skipif_match is not None\\n skipif_expr = skipif_match.group(1)\\n i += 1\\n elif _OPTION_DIRECTIVE_RE.match(stripped):\\n directive_match = _OPTION_DIRECTIVE_RE.match(stripped)\\n assert directive_match is not None\\n option_strings = directive_match.group(1).replace(\\\",\\\", \\\" \\\").split()\\n for option in option_strings:\\n if (\\n option[0] not in \\\"+-\\\"\\n or option[1:] not in doctest.OPTIONFLAGS_BY_NAME\\n ):\\n raise ValueError(f\\\"doctest has an invalid option {option}\\\")\\n flag = doctest.OPTIONFLAGS_BY_NAME[option[1:]]\\n flag_settings[flag] = option[0] == \\\"+\\\"\\n i += 1\\n elif stripped == \\\":hide:\\\":\\n i += 1\\n else:\\n break\\n\\n if i == len(lines):\\n raise ValueError(\\\"no code/output\\\")\\n\\n body = \\\"\\\\n\\\".join(lines[i:]).lstrip()\\n if not body:\\n raise ValueError(\\\"no code/output\\\")\\n\\n if i and lines[i].strip():\\n # no newline between option block and body\\n raise ValueError(f\\\"invalid option block: {section_content!r}\\\")\\n\\n return body, skipif_expr, flag_settings\",\n \"def listFromLines(lines):\\n reComment = re.compile('#.*')\\n temp = [reComment.sub('',x).strip() for x in lines.split('\\\\n')]\\n temp = [x for x in temp if x]\\n return temp\",\n \"def strip_logfile_html(text):\\n out_text = \\\"\\\"\\n buff = \\\"\\\"\\n start_tag = \\\"\\\"\\n end_tag = \\\"\\\"\\n context = \\\"none\\\"\\n for i in range(len(text)):\\n c = text[i]\\n # print \\\"c = \\\"+str(c)+\\\" context = \\\"+str(context)\\n if c == \\\"<\\\":\\n if context == \\\"none\\\":\\n # Possible start of a tag, depending on\\n # next character\\n context = \\\"putative_tag\\\"\\n buff = c\\n else:\\n # Everything up to this needs to\\n # be dumped directly to output\\n out_text = out_text + escape_xml_characters(buff)\\n elif context == \\\"putative_tag\\\":\\n buff = buff + c\\n if c.isalpha():\\n context = \\\"start_tag\\\"\\n elif c == \\\"/\\\":\\n context = \\\"end_tag\\\"\\n elif c == \\\"!\\\":\\n context = \\\"comment_tag\\\"\\n else:\\n # Not a tag so dump it\\n context = \\\"none\\\"\\n out_text = out_text + escape_xml_characters(buff)\\n elif context == \\\"start_tag\\\" or context == \\\"end_tag\\\" or context == \\\"comment_tag\\\":\\n buff = buff + c\\n if c == \\\">\\\":\\n if context == \\\"start_tag\\\":\\n # End of a start tag\\n # Process it and see if we can\\n # salvage something\\n salvage_text = salvage_tag_data(buff)\\n if salvage_text != \\\"\\\":\\n out_text = out_text + escape_xml_characters(salvage_text)\\n # Reset the buffer\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n elif context == \\\"end_tag\\\":\\n # End of an end tag\\n # Throw this away (for now)\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n elif context == \\\"comment_tag\\\":\\n # End of a comment\\n # Throw this away (for now)\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n else:\\n # Nothing special about this\\n # Add to the output\\n out_text = out_text + escape_xml_characters(c)\\n # Finished - append the remaining buffer\\n out_text = out_text + escape_xml_characters(buff)\\n return remove_blank_lines(out_text)\",\n \"def recipe12_6():\\n from xml import dom\\n def remove_whitespace_nodes(node):\\n \\\"\\\"\\\" Removes all of the whitespace-only text descendants of a DOM node. \\\"\\\"\\\"\\n # prepare the list of text nodes to remove (and recurse when needed)\\n remove_list=[]\\n for child in node.childNodes:\\n if child.nodeType==dom.Node.TEXT_NODE and not child.data.strip():\\n # add this text node to the to-be-removed list\\n remove_list.append(chid)\\n elif child.hasChildNodes():\\n # recurse, it's the simplest way to deal with the subtree\\n remove_whitespace_nodes(child)\\n # perform the removals\\n for node in remove_list:\\n node.parentNode.removeChild(node)\\n node.unlink()\",\n \"def __clean_line_comments(self):\\n self.lines = [l for l in self.lines if not l.startswith(\\\"//\\\") and len(l) != 0]\",\n \"def __clean_line_comments(self):\\n self.lines = [l for l in self.lines if not l.startswith(\\\"//\\\") and len(l) != 0]\",\n \"def _getContent(self, excludeRead=False, continuation=None, loadLimit=20, since=None, until=None):\\r\\n return None\",\n \"def remove_comments(ls):\\r\\n for i in range(len(ls)):\\r\\n ls[i] = re.sub(r'//.*', '', ls[i])\\r\\n\\r\\n return ls\",\n \"def remove_empty_lines(file_name):\\n removed_lines = 0\\n with open(file_name, mode=\\\"r\\\", encoding=\\\"utf-8\\\") as fd:\\n with open(get_output_file(file_name), mode=\\\"w\\\", encoding=\\\"utf-8\\\") as ofd:\\n for line in fd.readlines():\\n if re.search(\\\"^$\\\", line):\\n removed_lines += 1\\n else:\\n ofd.write(line)\\n print(\\\"Removed lines: {}\\\".format(removed_lines))\",\n \"def html_minify(html, comments=False):\\n log.info(\\\"Compressing HTML...\\\")\\n html = remove_html_comments(html) if not comments else html\\n html = condense_style(html)\\n html = condense_script(html)\\n html = clean_unneeded_html_tags(html)\\n html = condense_html_whitespace(html)\\n html = unquote_html_attributes(html)\\n log.info(\\\"Finished compressing HTML !.\\\")\\n return html.strip()\",\n \"def _get_file_content(realpath, ignore_undocumented=False):\\n\\n result = \\\"\\\"\\\"<h2>Module: %s</h2>\\n <div class=\\\"alert alert-info\\\">\\n <div style = \\\"details\\\">path: %s</div>\\n <div style = \\\"details\\\">created: %s, last modified: %s</div></div>\\\"\\\"\\\" %(\\n os.path.basename(realpath),\\n urlparse.unquote(_convert_path_to_url(realpath)),\\n time.ctime(os.path.getmtime(realpath)),\\n time.ctime(os.path.getctime(realpath))\\n )\\n with open(realpath) as sourcefile:\\n code = sourcefile.readlines()\\n abstract_syntax_tree = ast.parse(''.join(code))\\n description = ast.get_docstring(abstract_syntax_tree)\\n if description:\\n result += \\\"<h3>Summary:</h3> <div style = 'summary'>%s</div>\\\" % _convert_str_to_html(description)\\n visitor = DocVisitor()\\n visitor.visit(abstract_syntax_tree)\\n parsed_code = visitor.get_doc()\\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\\n for entry in entries:\\n if ignore_undocumented is False or entry.get(\\\"description\\\"):\\n begin, end = entry.get(\\\"lines\\\")\\n result += '<hr /><div><pre>' + \\\"\\\".join(code[begin:end]).rstrip().rstrip(\\\":\\\") +\\\"</pre>\\\"\\n result += _convert_str_to_html(entry.get(\\\"description\\\"))+\\\"</div>\\\"\\n\\n return result\",\n \"def remove_discarded(self):\\n while self.shrink_target.has_discards:\\n discarded = []\\n\\n for ex in self.shrink_target.examples:\\n if ex.discarded and (not discarded or ex.start >= discarded[-1][-1]):\\n discarded.append((ex.start, ex.end))\\n\\n assert discarded\\n\\n attempt = bytearray(self.shrink_target.buffer)\\n for u, v in reversed(discarded):\\n del attempt[u:v]\\n\\n if not self.incorporate_new_buffer(attempt):\\n break\",\n \"def __remove_c_comments(self, line):\\n new_chars = []\\n i = 0\\n while i < len(line):\\n blocks = self.__ingest_c_block_comments(line, i)\\n if blocks > 0:\\n i += blocks\\n continue\\n\\n whitespace = self.__ingest_whitespace(line, i)\\n if whitespace > 0:\\n new_chars.append(' ')\\n i += whitespace\\n continue\\n\\n comm_start = self.__ingest_c_comment_start(line, i)\\n if comm_start == -1:\\n new_chars.append(' ')\\n break\\n elif comm_start > 0:\\n new_chars.append(' ')\\n i += comm_start\\n\\n if blocks + whitespace + comm_start == 0:\\n new_chars.append(line[i])\\n i += 1\\n\\n new_line = ''.join(new_chars)\\n return new_line\",\n \"def strip_out_sensitive_data(configuration_object):\\n return deployr_config_repository.strip_out_sensitive_data(configuration_object=configuration_object)\",\n \"def filter_lines(view_lines):\\n\\n # this still doesn't work because we need to filter xml above the line level\\n # do newlines from the server ever contain meaningful data or are they pointless?\\n # is all the newline data given by a terminating xml-type tag?\\n\\n # filter lines that start with an exclude string - non-regex\\n excludes = ['<prompt time=\\\"']\\n for exclude in excludes:\\n view_lines = [line for line in view_lines if line[0 : len(exclude)] != exclude]\\n\\n # first lets just rip out the xml... later we will want to process it back into the stream\\n # mostly we can use the xml just to update the state, if that's the case then if we miss\\n # one then it's no proble, we just catch the next one... provided they are regular enough.\\n # if they are not, or set state once, then we definitely want to catch every one\\n xml_free_lines = list()\\n for line in view_lines:\\n\\n # assuming lines only have xml if they start with xml? interesting idea, not sure if real\\n i = 0\\n xml_free_line_segments = list()\\n xml_line_segments = list()\\n xml_free_line_part = b\\\"\\\"\\n xml_line_part = b\\\"\\\"\\n ordered_parsed_line = list() # give a tuple of string, type\\n\\n # ISSUE: i'm pretty sure this is dropping a letter off the first non-xml line segment (or more)\\n # make a bunch of line segments\\n # note that line is a bytes() type, indexing line[i] returns int\\n # if we slice into it line[i:i+1] we get a bytes() type of length 1\\n while i < len(line):\\n\\n if line[i : i + 1] != b\\\"<\\\":\\n xml_free_line_part += line[i : i + 1]\\n\\n else:\\n\\n # increment until you get out of the xml tag or out of the line\\n while i < len(line) and line[i : i + 1] != b\\\">\\\":\\n xml_line_part += line[i : i + 1]\\n i += 1\\n\\n # toss the last b'>' on the end!\\n xml_line_part += line[i : i + 1]\\n\\n # store the xml part off\\n xml_line_segments.append(xml_line_part)\\n ordered_parsed_line.append((\\\"xml\\\", xml_line_part))\\n xml_line_part = b\\\"\\\" # reset the xml part\\n\\n # store xml free part off\\n if len(xml_free_line_part) > 1:\\n xml_free_line_segments.append(xml_free_line_part)\\n ordered_parsed_line.append((\\\"text\\\", xml_free_line_part))\\n xml_free_line_part = b\\\"\\\" # reset the xml_free_line_part\\n\\n i += 1 # covers incrementing past the '>' and incrementing if not yet in a '<'\\n\\n \\\"\\\"\\\"\\n # https://lxml.de/tutorial.html\\n # if the xml cannot be parsed, we just want to catch it and decide what to do\\n try:\\n xml = [lxml.etree.XML(xml_line) for xml_line in xml_line_segments]\\n xml_tags = [x.tag for x in xml]\\n # just testing lxml tag parsing\\n if b'streamWindow' in xml_tags:\\n xml_free_lines.append(b'streamWindow skipped...')\\n\\n except lxml.etree.XMLSyntaxError:\\n xml = list() # no tags\\n # toss any failing XML onto the text stream for manual parsing?\\n # we can follow this approach even if we replace or wrap lxml with a manual parser\\n xml_free_lines.extend(xml_line_segments)\\n \\\"\\\"\\\"\\n # do stuff with the xml components of the line\\n op_line = ordered_parsed_line\\n\\n # strip the line back down to text\\n clean_line = [x[1].replace(b\\\">\\\", b\\\">\\\") for x in op_line if x[0] == \\\"text\\\"]\\n xml_free_lines.append(b\\\"\\\".join(clean_line))\\n\\n # send a hunk of xml so we can see what happened\\n xml_line = [x[1].replace(b\\\">\\\", b\\\">\\\") for x in op_line if x[0] == \\\"xml\\\"]\\n xml_free_lines.append(b\\\"\\\".join(xml_line))\\n\\n # just point it here for now so we don't have to change the return\\n view_lines = xml_free_lines\\n\\n \\\"\\\"\\\"\\n EXCLUDES = [\\n r'<prompt.*>',\\n r'</prompt.*>',\\n ]\\n\\n SUBS = [\\n (r'<.*>', ''),\\n ]\\n\\n # drop empty lines before the regex to save processing\\n # what about lines with whitespace only...\\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\\n\\n for exclude in EXCLUDES:\\n view_lines = [str(line) for line in view_lines if not re.search(exclude, str(line))]\\n\\n for expr, sub in SUBS:\\n view_lines = [re.sub(expr, sub, str(line)) for line in view_lines]\\n\\n # drop empty lines after the regex so they aren't shown\\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\\n \\\"\\\"\\\"\\n\\n return view_lines\",\n \"def prune(record: cfg.OpenAPI, outformat: cfg.Format = None) -> NoReturn:\\n content = record.oas\\n # Cleanup\\n content, _, _ = clean.remove_unused_components(content)\\n content = clean.remove_empty_objects(content)\\n # Output\\n out(content, outformat or record.oastype)\",\n \"def nonempty_lines(text):\\n return [line for line in text.split('\\\\n') if line]\",\n \"def cleanup_comments(comments):\\n clean_comments = []\\n\\n if comments:\\n for comment in comments:\\n cleaned_up = sub(r'\\\\n\\\\n {8}\\\\n {8}\\\\n {12}\\\\n {16}\\\\n {16}\\\\n {12}\\\\nEdit', '', comment)\\n clean_comments.append(cleaned_up)\\n\\n return clean_comments\",\n \"def strip_html(text: str, **serializer_kwargs: bool):\\n cleaner = get_cleaner(**serializer_kwargs)\\n text = cleaner.clean(text)\\n return text\",\n \"def sanitize_content(content):\\r\\n\\r\\n # stripping all HTML TAGS\\r\\n content = BeautifulSoup(content).find(\\\"div\\\", {\\\"id\\\": \\\"content\\\", \\\"role\\\": \\\"main\\\"}).get_text()\\r\\n\\r\\n if CASE_FOLDING:\\r\\n # case folding\\r\\n content = content.lower()\\r\\n if PUNCTUATION_REMOVAL:\\r\\n\\r\\n # Removing punctuation.\\r\\n content = re.sub(PUNCTUATIONS_REGEX_COMMA_1, \\\"\\\", content, 0)\\r\\n content = re.sub(PUNCTUATIONS_REGEX_COMMA, \\\"\\\", content, 0)\\r\\n content = re.sub(PUNCTUATIONS_REGEX, \\\"\\\", content, 0).replace(\\\"'\\\", \\\"\\\");\\r\\n\\r\\n return re.sub(r\\\"([\\\\n\\\\t])+\\\", \\\" \\\", content, 0)\",\n \"def getHTMLComments(self, text):\\n return self.doSpecial(text, '<!--', '-->', self.fParseHTMLComments)\",\n \"def remove_comments(s):\\n return \\\"\\\\n\\\".join(l for l in s.strip().split(\\\"\\\\n\\\") if not l.strip().startswith(\\\"#\\\"))\",\n \"def purify_comments(csv_file, keep_stops=False, POS=False, lemmatize=False, popular=0):\\r\\n\\r\\n df = pd.read_csv(csv_file)\\r\\n df = df.loc[df[\\\"author\\\"] != \\\"[deleted]\\\"] # trim out comments whose authors have deleted their accounts\\r\\n df = df.loc[df[\\\"score\\\"] != \\\"score\\\"] # this is an error in the code when building new csv_files from dask\\r\\n\\r\\n # extracts only the popular comments\\r\\n if popular > 0:\\r\\n df = df.loc[pd.to_numeric(df[\\\"score\\\"]) > popular]\\r\\n\\r\\n comments = df[\\\"body\\\"]\\r\\n del df # no need for this anymore, and it'll merely eat up memory\\r\\n\\r\\n nlp = en_core_web_sm.load()\\r\\n\\r\\n revised_comments = []\\r\\n for comment in comments.astype('unicode').values:\\r\\n comment = comment[1:] # remove the initial 'b' bytes-representation character\\r\\n comment = comment.encode(\\\"utf-8-sig\\\").decode(\\\"utf-8-sig\\\") # get rid of BOM character\\r\\n comment = comment.lower().replace(r\\\"\\\\n\\\", r\\\"\\\").replace(r'\\\"', r'')\\r\\n\\r\\n tokens = nlp(comment)\\r\\n\\r\\n # actual specification section\\r\\n for sent in tokens.sents:\\r\\n\\r\\n if POS: # conversion of comments to tokens/lemmas-POS tags\\r\\n if lemmatize:\\r\\n if keep_stops:\\r\\n revised_tokens = [\\\"{}-{}\\\".format(token.lemma_, token.tag_) for token in sent\\r\\n if not token.is_punct]\\r\\n else:\\r\\n revised_tokens = [\\\"{}-{}\\\".format(token.lemma_, token.tag_) for token in sent\\r\\n if not token.is_stop and not token.is_punct\\r\\n and not token.orth_ == \\\"n't\\\" and not token.orth_ == \\\"'s\\\"]\\r\\n else:\\r\\n if keep_stops:\\r\\n revised_tokens = [\\\"{}-{}\\\".format(token.orth_, token.tag_) for token in sent\\r\\n if not token.is_punct]\\r\\n else:\\r\\n revised_tokens = [\\\"{}-{}\\\".format(token.orth_, token.tag_) for token in sent\\r\\n if not token.is_stop and not token.is_punct\\r\\n and not token.orth_ == \\\"n't\\\" and not token.orth_ == \\\"'s\\\"]\\r\\n\\r\\n elif lemmatize: # just lemmatization\\r\\n if keep_stops:\\r\\n revised_tokens = [token.lemma_ for token in sent\\r\\n if not token.is_punct]\\r\\n else:\\r\\n revised_tokens = [token.lemma_ for token in sent\\r\\n if not token.is_stop and not token.is_punct\\r\\n and not token.orth_ == \\\"n't\\\" and not token.orth_ == \\\"'s\\\"]\\r\\n\\r\\n else: # nothing but removal of stop words (or not)\\r\\n if keep_stops:\\r\\n revised_tokens = [token.orth_ for token in sent\\r\\n if not token.is_punct]\\r\\n else:\\r\\n revised_tokens = [token.orth_ for token in sent\\r\\n if not token.is_stop and not token.is_punct\\r\\n and not token.orth_ == \\\"n't\\\" and not token.orth_ == \\\"'s\\\"]\\r\\n\\r\\n revised_comments.append(\\\" \\\".join(revised_tokens))\\r\\n\\r\\n return pd.Series(revised_comments)\",\n \"def remove_lines():\\n work_folder = os.path.join(CURRENT_FOLDER, \\\"..\\\\\\\\Data\\\\\\\\weather_data\\\")\\n with open(os.path.join(work_folder, \\\"filtered_merged_history_KMDW.csv\\\"), \\\"w\\\") as outfile:\\n with open(os.path.join(work_folder, \\\"merged_history_KMDW.csv\\\")) as infile:\\n outfile.write(infile.next())\\n for line in infile:\\n if line[0].isdigit():\\n outfile.write(line)\",\n \"def clean_data(self, path, exclude_msgtypes=None):\",\n \"def suppress_analyze(more_exclusions=None):\\n return api.override_step_data(\\n 'read filter exclusion spec',\\n api.json.output({\\n 'base': {\\n 'exclusions': ['f.*'] + (more_exclusions or []),\\n },\\n 'chromium': {\\n 'exclusions': [],\\n },\\n })\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5167605","0.51409805","0.4917135","0.4830618","0.46820927","0.46535304","0.46266067","0.46166417","0.4502041","0.44980857","0.44534415","0.4443194","0.44398215","0.44346082","0.43637702","0.43127203","0.4308069","0.42852294","0.42846525","0.42836487","0.42811847","0.4269507","0.42648393","0.42627352","0.42416808","0.42353815","0.42271122","0.42013773","0.42001912","0.4182343","0.41632065","0.41495782","0.41392398","0.41090736","0.40913013","0.40844798","0.40808997","0.4067535","0.40566978","0.40566862","0.40467834","0.40447003","0.40322152","0.40191886","0.40145603","0.3996512","0.39718646","0.39667428","0.39658624","0.39647064","0.39568236","0.39398712","0.3918529","0.39137146","0.39104894","0.38938972","0.38910085","0.38835788","0.38787723","0.3875929","0.387155","0.3858048","0.38523343","0.38496783","0.38443795","0.38420162","0.38378936","0.383006","0.38267526","0.3814911","0.38099808","0.38097075","0.38085377","0.3807819","0.3807422","0.38061425","0.3805455","0.37968987","0.37956882","0.37956882","0.3791171","0.37883115","0.37830958","0.37755752","0.37623408","0.37579444","0.37454662","0.37366036","0.3732432","0.3725703","0.3720941","0.3718097","0.371596","0.37155014","0.37143365","0.37135506","0.37101153","0.3708357","0.37076604","0.37065813"],"string":"[\n \"0.5167605\",\n \"0.51409805\",\n \"0.4917135\",\n \"0.4830618\",\n \"0.46820927\",\n \"0.46535304\",\n \"0.46266067\",\n \"0.46166417\",\n \"0.4502041\",\n \"0.44980857\",\n \"0.44534415\",\n \"0.4443194\",\n \"0.44398215\",\n \"0.44346082\",\n \"0.43637702\",\n \"0.43127203\",\n \"0.4308069\",\n \"0.42852294\",\n \"0.42846525\",\n \"0.42836487\",\n \"0.42811847\",\n \"0.4269507\",\n \"0.42648393\",\n \"0.42627352\",\n \"0.42416808\",\n \"0.42353815\",\n \"0.42271122\",\n \"0.42013773\",\n \"0.42001912\",\n \"0.4182343\",\n \"0.41632065\",\n \"0.41495782\",\n \"0.41392398\",\n \"0.41090736\",\n \"0.40913013\",\n \"0.40844798\",\n \"0.40808997\",\n \"0.4067535\",\n \"0.40566978\",\n \"0.40566862\",\n \"0.40467834\",\n \"0.40447003\",\n \"0.40322152\",\n \"0.40191886\",\n \"0.40145603\",\n \"0.3996512\",\n \"0.39718646\",\n \"0.39667428\",\n \"0.39658624\",\n \"0.39647064\",\n \"0.39568236\",\n \"0.39398712\",\n \"0.3918529\",\n \"0.39137146\",\n \"0.39104894\",\n \"0.38938972\",\n \"0.38910085\",\n \"0.38835788\",\n \"0.38787723\",\n \"0.3875929\",\n \"0.387155\",\n \"0.3858048\",\n \"0.38523343\",\n \"0.38496783\",\n \"0.38443795\",\n \"0.38420162\",\n \"0.38378936\",\n \"0.383006\",\n \"0.38267526\",\n \"0.3814911\",\n \"0.38099808\",\n \"0.38097075\",\n \"0.38085377\",\n \"0.3807819\",\n \"0.3807422\",\n \"0.38061425\",\n \"0.3805455\",\n \"0.37968987\",\n \"0.37956882\",\n \"0.37956882\",\n \"0.3791171\",\n \"0.37883115\",\n \"0.37830958\",\n \"0.37755752\",\n \"0.37623408\",\n \"0.37579444\",\n \"0.37454662\",\n \"0.37366036\",\n \"0.3732432\",\n \"0.3725703\",\n \"0.3720941\",\n \"0.3718097\",\n \"0.371596\",\n \"0.37155014\",\n \"0.37143365\",\n \"0.37135506\",\n \"0.37101153\",\n \"0.3708357\",\n \"0.37076604\",\n \"0.37065813\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7138743"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85182,"cells":{"query":{"kind":"string","value":"Replace matched element in content."},"document":{"kind":"string","value":"def _replace_comment(element):\n replacement = \"\"\n matched = element.group()\n\n # Ensure that only the comment part is being replaced\n if not matched.startswith(\"/\"):\n replacement += matched[0]\n matched = matched[1:]\n\n count = matched.count(\"\\n\")\n\n # Add empty spaces with the size of the content if the size\n # must be kept.\n if keep_content_size:\n _buffer = len(matched) - count\n replacement += \" \" * _buffer + \"\\n\" * count\n\n # Otherwise simply keep the number of lines\n else:\n replacement += \"\\n\" * count\n\n return replacement"},"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 _replace_element(element):\n # Guess line number\n count = element.group().count(\"\\n\")\n\n # Ensure that the replacement string keep the same length that\n # the original content to be able to use the match positions\n _buffer = len(element.group()) - count - 2\n\n if len(element.group()) > 2:\n line_number = content[:element.start()].count(\"\\n\")+1\n collapsed_content[line_number] = (\n _initial_content[element.start():element.end()]\n )\n\n return \"<>{buffer}{lines}\".format(\n buffer=\" \" * _buffer,\n lines=\"\\n\" * count\n )","def _update_content(self, content, siteurl):\n if not content:\n return content\n\n hrefs = self._get_intrasite_link_regex()\n return hrefs.sub(lambda m: self._link_replacer(siteurl, m), content)","def string_replace_xml_text(element, pattern, value):\n if element.text:\n element.text = element.text.replace(pattern, value.decode('utf8'))\n for c in element.getchildren():\n string_replace_xml_text(c, pattern, value)","def replaceElement(self, *args):\n return _libsbml.Submodel_replaceElement(self, *args)","def _replace(self, p, e):\n node = self._validate_position(p)\n old = node.element\n node.element = e\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old = node.element\n node.element = e\n return old","def _replace(self, p, data):\n node = self._validate(p)\n old = node._element\n node._element = data\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old = node._element\n node._element = e\n return old","def updateContent(content, **kwargs):","def _replace(self, p, e):\n node = self._validate(p)\n old = node._element\n node._element = e\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old_value = node._element\n node._element = e\n return old_value","def _update_content(self, content, siteurl):\r\n if not content:\r\n return content\r\n\r\n instrasite_link_regex = self.settings['INTRASITE_LINK_REGEX']\r\n regex = r\"\"\"\r\n (?P<markup><\\s*[^\\>]* # match tag with all url-value attributes\r\n (?:href|src|poster|data|cite|formaction|action)\\s*=)\r\n\r\n (?P<quote>[\"\\']) # require value to be quoted\r\n (?P<path>{0}(?P<value>.*?)) # the url value\r\n \\2\"\"\".format(instrasite_link_regex)\r\n hrefs = re.compile(regex, re.X)\r\n\r\n def replacer(m):\r\n what = m.group('what')\r\n value = urlparse(m.group('value'))\r\n path = value.path\r\n origin = m.group('path')\r\n\r\n # XXX Put this in a different location.\r\n if what == 'filename':\r\n if path.startswith('/'):\r\n path = path[1:]\r\n else:\r\n # relative to the source path of this content\r\n path = self.get_relative_source_path(\r\n os.path.join(self.relative_dir, path)\r\n )\r\n\r\n if path not in self._context['filenames']:\r\n unquoted_path = path.replace('%20', ' ')\r\n\r\n if unquoted_path in self._context['filenames']:\r\n path = unquoted_path\r\n\r\n if path in self._context['filenames']:\r\n origin = '/'.join((siteurl,\r\n self._context['filenames'][path].url))\r\n origin = origin.replace('\\\\', '/') # for Windows paths.\r\n else:\r\n logger.warning((\"Unable to find {fn}, skipping url\"\r\n \" replacement\".format(fn=value),\r\n \"Other resources were not found\"\r\n \" and their urls not replaced\"))\r\n elif what == 'category':\r\n origin = Category(path, self.settings).url\r\n elif what == 'tag':\r\n origin = Tag(path, self.settings).url\r\n\r\n # keep all other parts, such as query, fragment, etc.\r\n parts = list(value)\r\n parts[2] = origin\r\n origin = urlunparse(parts)\r\n\r\n return ''.join((m.group('markup'), m.group('quote'), origin,\r\n m.group('quote')))\r\n\r\n return hrefs.sub(replacer, content)","def replace_by_xml(self, xml_str, el_idx=0):\n root_el = self.parse_xml(xml_str)\n self.replace_by_etree(root_el, el_idx)","def replace(\n haystack : Exp, haystack_context : Context, haystack_pool : Pool,\n needle : Exp, needle_context : Context, needle_pool : Pool,\n replacement : Exp) -> Exp:\n return _Replacer(haystack_context, haystack_pool, needle, needle_context, needle_pool, replacement).visit(haystack)","def replace(self, element):\n for i, sibling in enumerate(self.parent._children):\n if sibling is self:\n self.parent._children[i] = element\n element.parent_docid = self.parent_docid","def addReplacedElement(self, *args):\n return _libsbml.CompSBasePlugin_addReplacedElement(self, *args)","def ReplaceElement(self, position, element):\n self.__context.builder.DocumentElementReplace(self._blip_data.wave_id,\n self._blip_data.wavelet_id,\n self._blip_data.blip_id,\n position, element)","def run(self, content):\n parts = []\n offset = 0\n for match in self.regexp.finditer(content):\n parts.append(content[offset:match.start(0)])\n parts.append(self.replace(match))\n offset = match.end(0)\n parts.append(content[offset:])\n return ''.join(parts)","def replace(self, text):\n if self.should_skip(text):\n return text\n return self.replacer.sub(self._callback, text)","def replace(self, p, e):\n original = self._validate(p)\n old_value = original._element # temporarily store old element\n original._element = e # replace with new element\n\n return old_value","def inject_on_div(div_id, original, content_to_inject):\n m = re.match(\".*(<div.*id=\\\"\"+ div_id +\"\\\".*>)(.*)(</div>).*\", original, re.DOTALL)\n return re.sub(m.group(1) + m.group(2) + m.group(3), m.group(1) + content_to_inject + m.group(3) , original)","def update_content(self):\n raise NotImplementedError","def replace(self, oldtext, newtext):\r\n return self","def replace(self, pattern, substitute, pattern_type=None):\n\t\tpattern = convert_pattern(pattern, pattern_type)\n\t\twith self.AutoSplitlines():\n\t\t\tself.lines = [(pattern.sub(substitute, line) if pattern.search(line) else line) for line in self.lines]","def replace_content(g):\n g[0] = 88\n g[1] = 22\n g[2] = 44\n print(\"g = \", g)","def _replace(self, match_layer_node, replacement_layer_node):\n if self._is_functional_model(self.model):\n self._replace_functional(match_layer_node, replacement_layer_node)\n else:\n self._replace_sequential(match_layer_node, replacement_layer_node)","def replace_all(self, content):\n if (not self.exists()):\n raise IOError(\"File at '{}' does not exist.\".format(self.location))\n with open(self.location, 'w') as f:\n f.write(content)","def sed(self, search, replace):\n\n for section in self.sections:\n for i, block in enumerate(section.blocks):\n if block == search:\n section.blocks[i] = replace\n self.all_damaged = True\n self.dirty = True","def replace_by_etree(self, root_el, el_idx=0):\n el = self.get_element_by_name(root_el.tag, el_idx)\n el[:] = list(root_el)\n el.attrib = root_el.attrib","def test_replace(self):\n\n regex = \"th\"\n expected = \"Hello, htis is Fun Ilrys. I just wanted to know how htings goes around hte tests.\" # pylint: disable=line-too-long\n actual = Regex(self.data, regex, replace_with=\"ht\").replace()\n\n self.assertEqual(expected, actual)\n\n # Test of the case that there is not replace_with\n regex = \"th\"\n expected = self.data\n actual = Regex(self.data, regex).replace()\n\n self.assertEqual(expected, actual)","def replace_in_file(file_path, find, replace):\n\tcontent = read_file(file_path)\n\tcontent = content.replace(find, replace)\n\twrite_file(file_path, content)","def replacingBasicElementsFromEpubLibre(text):\n text = re.sub(r'<div class=\"vineta\"><img[^<]*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n \n \n # Replace some elements with atributes with other cleaner elements\n\n text = re.sub(r'<p class=\"ind\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<p class=\"cursiva\\d*\">(.*?)</p>', r'<p><seg rend=\"italic\">\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"calibre[0-9]+\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\\d*\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"salto[0-9]+\">', r'<milestone unit=\"section\"/>\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoc\">', r'<milestone unit=\"section\"/>\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"sinopsis\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"ilustra\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE) \n text = re.sub(r'<div class=\"info\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<br class=\"calibre9\" />', r' ', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<sup(|[^>]*)>(<a[^>]*?>)?\\[.*?\\](</a>)?</sup>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span(|[^>]*)>\\s*</span>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<a(|[^>]*)>\\s*</a>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(tlogo|tautor|ttitulo|trevision|tfirma)\">.*?</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<h1 class=\"ttitulo\">(.*?)</h1>\\s*(<p class=\"titulo\">.*?</p>)', r'<head>\\1: \\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<img[^>]*?>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(bloque|ala)?derecha[0-9]*\">(.*?)</p>', r'<ab>\\2</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asangre[0-9]?\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<p class=\"centrado1\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<p class=\"extenso\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"(normal|calibre)[0-9]*\">(.*?)</span>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p><span class=\"(cap[0-9]*|versalita|smallcaps)\">(..?)</span>', r'<p>\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"(versalita|smallcaps)[0-9]*\">(.*?)</span>', r'<seg rend=\"smallcaps\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<div class=\"(?:poema[0-9]*|poe|versos|estrofas|citar\\d*|verso\\d*|versosinpie\\d*|centro|centrado|poemaizqcursi\\d*|poemaizq|poemacursi\\d*)\">(.*?)</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"center\">\\s+<table class=\"text\">\\s+<tr class=\"calibre\\d*\">\\s+<td class=\"calibre\\d*\">(\\s+.*?)</td>\\s+</tr>\\s+</table>\\s+</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE) \n\n text = re.sub(r'<blockquote class=\"(?:versos?\\d*)\">(.*?)</blockquote>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n\n \n text = re.sub(r'(<lg>\\s*)<p class=\"izq\">', r'\\1<l>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"poemaizqcursi\">(.*?)</p>', r'<lg>\\n<l>\\1</l>\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"verso\">(.*?)</p>', r'<l>\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"normal1\">(.*?)</p>', r'<l>\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"cursiva\">(.*?)</p>', r'<p><seg rend=\"italic\">\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<em(|[^>]*)>(.*?)</em>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n\n text = re.sub(r'<p class=\"estrofa1\">', r'\\n\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<i(|[^>]*)>(.*?)</i>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<b(|[^>]*)>(.*?)</b>', r'<seg rend=\"bold\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<sup(|[^>]*)>(.*?)</sup>', r'<seg rend=\"sup\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"cursiva[0-9]*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<sub(|[^>]*)>(.*?)</sub>', r'<seg rend=\"subscript\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<small(|[^>]*)>(.*?)</small>', r'<seg rend=\"small\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"nosep\\d*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"nosep\\d*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<strong(|[^>]*)>(.*?)</strong>', r'<seg rend=\"bold\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"cita\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"micita\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"acotacion\\d*\">(.*?)</div>', r'<quote>\\n\\1\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<cite.*?>(.*?)</cite>', r'<seg type=\"cite\">\\1</seg>', text, flags=re.DOTALL|re.IGNORECASE)\n \n # Setting quotes in floatingText element\n text = re.sub(r'<div class=\"(?:mi)?cita\">(.*?)</div>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<blockquote class=\"bloque\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"salto25x\">([IVXCL\\d]+)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"salto25x\\d+\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n \n text = re.sub(r'<div class=\"bloquederecha1\">(.+?)</div>', r'<quote>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"cursiva[0-9]*\">', r'<div rend=\"italic\">', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"calibre\" id=\"calibre_link-[0-9]+\">', r'<div>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\">[… ]+?</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asteriscos\">[\\* ∗]+</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\">\\[…\\]</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asteriscos\\d*\">[\\. ]+</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<hr (class=\"calibre\\d*\" )?/>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<milestone unit=\"section\"/>\\s+)+', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<div class=\"(?:banner|text\\d+)\">(.*?)</div>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"banner\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"carta\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<blockquote class=\"cita\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div>\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"calibre\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<html.*?<body>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'</body></html>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>)\\s*(<head>.*?</head>)', r'\\1</div>\\n<div>\\n\\2', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"(?:subh?|inicio|numtitulo|subt)\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<h[1-6][^>]*>(.*?)</h[1-6]>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(tsub|sub)?tit(ulo)?[0-9]*\">(.*?)</p>', r'<head>\\3</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(subcapitulo|capitulonombre|h\\d+)\">(.*?)</p>', r'<head>\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"tit-cap\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'</head>\\s*<p class=\"(subtil|subcap)\">(.*?)</p>', r': \\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<span class=\"ncap\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"ncap\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"palabra\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"sigla\\d*\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<p>—?)<span class=\"inicial\">(.*?)</span>', r'\\1\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<p>—?¿?)<big class=\"calibre\\d*\">(.*?)</big>', r'\\1\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<head>\\s*</head>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p [^>]*?>\\s*\\* *\\* *\\*</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"sep\">\\* \\* \\*</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'</head>\\s*<head>', r': ', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'(</head>)(\\s*<head>)', r'\\1\\n<div>\\n\\2', text, flags=re.DOTALL|re.IGNORECASE)\n\n\n \"\"\"\n #Setting divs after ps. Used for 219\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n\n # Cleaning some <milestone />\n text = re.sub(r'(<div>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</div>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</head>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n\n # Setting some floatingTexts\n #text = re.sub(r'(<div(| [^>]*?)>((?!<div).)*</div>)(\\s*<p)', r'<floatingText>\\n<body>\\n\\1\\n</body>\\n</floatingText>\\n\\4', text, flags=re.DOTALL|re.IGNORECASE)\n\n #text = re.sub(r'(<div(|[^>]+?)>.*?</div>)(\\s*<p)', r'<floatingText>\\n<body>\\n<div>\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n \n # Floating Texts\n\n text = re.sub(r'<p(| [^>]+)>[\\s\\r\\n]*</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'\\n[ \\t]+', r'\\n', text, flags=re.IGNORECASE)\n text = re.sub(r'[\\r\\n]+', r'\\r\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div>[\\r?\\n]*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<div>((?!<div>).)*</div>\\r?\\n)\\Z', r'<!--\\1-->', text, flags=re.DOTALL|re.IGNORECASE)\n \n\n text = re.sub(r'<div class=\"cita?[0-9]*\">(.*?)</div>', r'<quote>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"cita[0-9]*\">(.*?</p>)', r'<quote>\\n<p>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n \n text = re.sub(r'<br class=\"calibre[0-9]*\" />', r'', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'(<p>—?. ?)<span class=\"palabra\">(.*?)</span>', r'\\1<seg rend=\"small\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\"><span class=\"inicial\">(.*)</span><span class=\"palabra\">(.*?)</span>', r'<p>\\1\\2', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\"><span class=\"inicial\">(.*)</span>', r'<p>\\1', text, flags=re.IGNORECASE)\n text = re.sub(r'<p>(.)<span>(.*)</span>', r'<p>\\1\\2', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"inicial\">(.*)</span>', r'\\1', text, flags=re.IGNORECASE)\n\n \n text = re.sub(r'(<head>.*?)<seg rend=\"(smallcaps|small)\">(.*?)</seg>(.*?</head>)', r'\\1\\3\\4', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<div[^>]*?>\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<div class=\"(?:tablacentro\\d*|center)\">\\s*<table class=\"text\\d*\">\\s*<tr class=\"calibre\\d*\">\\s*<td class=\"calibre\\d*\">(.*?)\\s*</td>\\s*</tr>\\s*</table>\\s*</div>', r'<lg>\\1\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"traduccion\">(.*?)</p>', r'<ab type=\"translation\">\\1</ab>', text, flags=re.IGNORECASE)\n\n #text = re.sub(r'<p class=\"centrado\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n \n #text = re.sub(r'<blockquote class=\"calibre18\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n\\1\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n \"\"\"\n #The next lines were used for 232, a theater-like novel\n \n text = re.sub(r'<p>(.*?</seg>)(\\.\\—.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n #The next lines were used for 109, a theater-like novel\n text = re.sub(r'<p>(.*?</seg>\\.)(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\"italic\">.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<seg rend=\"italic\">(\\(.*?)</seg>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n #The next lines were used for 224, a theater-like novel\n text = re.sub(r'<p>(.<seg rend=\"small\">.*?</seg>\\.)(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n #text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\"italic\">.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<seg rend=\"italic\">(\\(.*?)</seg>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n # Code used for paradox rey\n text = re.sub(r'<div class=\"clear\">\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"banner\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"francesa\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n \"\"\"\n text = re.sub(r'<p class=\"personaje\">(.*?)</p>\\s*<p>(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"descrip\">(.*?)</span>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(?:descrip\\d*|entrada|fin)\">(.*?)</p>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"cuadro\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"descrip1\">(.*?)</div>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"puntos\">.*?</div>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"tablacentro\">(.*?)</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n text = re.sub(r'<p class=\"decla\">(.*?\\. )(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"(?:descrip|decla1)\">(.*?)</p>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n\n\n text = re.sub(r'(<seg\\s+rend\\s*=\\s*\"small(?:caps)?\">)(.*?)(?=</seg>)', lambda m: m.group(1) + m.group(2).lower(), text)\n \n text = re.sub(r'(<seg\\s+rend\\s*=\\s*\"small(?:caps)?\">)(.*?)(</seg>)', r'\\2', text, flags=re.IGNORECASE)\n \n text = re.sub(r'<big[^>]*?>(.*?)</big>', r'\\1', text, flags=re.IGNORECASE) \n text = re.sub(r'<div class=\"serif\" id=\"calibre_link-\\d+\">', r'<div>', text, flags=re.IGNORECASE) \n text = re.sub(r'<div class=\"sinmargen\" id=\"calibre_link-\\d+\">', r'<div>', text, flags=re.IGNORECASE) \n\n text = re.sub(r'<p class=\"(?:carta|firma\\d+)\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.IGNORECASE) \n\n\n\n return text","def replace_with(*, replacement, f=DECORATED):\n return replacement","def replace_with(self, replacement_arg):\n replacement = BinaryNode.or_none(replacement_arg)\n\n # Do not proceed if replacement is invalid\n # Nothing to do if replacing node with itself\n if replacement == self:\n return self\n\n # Link parent\n parent = self.get_parent()\n if parent is not None:\n if self.is_left_child():\n parent.set_left(replacement)\n elif self.is_right_child():\n parent.set_right(replacement)\n elif self.tree is not None:\n # Replacing head\n self.tree.head = replacement\n\n # Remove node from tree\n self.set_parent(None)","def replace(node, key, value):\n if isinstance(node, (Document, Object)):\n data = dict(node)\n elif isinstance(node, Array):\n data = list(node)\n else:\n raise TypeError(\n \"Expected Core API container type. Got '%s'.\" % type(node)\n )\n\n data[key] = value\n if isinstance(node, Document):\n return type(node)(url=node.url, title=node.title, content=data)\n return type(node)(data)","def change_content(options):\n call_command('''grep -r -l -- '%(patrn)s' . | tr '\\\\n' '\\\\0' | xargs -0 sed -i \"s/%(patrn)s/%(repl)s/g\"''', options)","def replaceChild(self, *args):\n return _libsbml.ASTNode_replaceChild(self, *args)","def in_place_substitute(self):\r\n if self.substitute is not None:\r\n node = self.convert_type()\r\n self.leaf_replace(node) # for internals only\r\n self.root_replace(node)","def set_content(self, content):\n if check_data_exist(content) is True:\n self.content = content.text","def replaceChild(self, *args):\n return _libsbml.ASTBasePlugin_replaceChild(self, *args)","def _replace_keyword(self, keyword, replacement, count=0):\n\n def replace_with_inline(e, doc):\n if type(e) == Str and e.text == keyword:\n doc.num_matches += 1\n if not count or doc.num_matches <= count:\n return replacement\n\n def replace_with_block(e, doc):\n '''\n It's difficult to replace a keyword with an entire Block element.\n\n This is because the keyword is of type Str (an Inline) and the parent\n object of a Str can only contain Inlines and not Blocks\n (e.g. Para can contain Inlines, not Divs)\n\n Implications:\n\n 1) If the Str that contains the keyword is inside another\n Inline instead of a Block (e.g. Div -> Emph -> Str)\n then we have to do a trick:\n when .walk() touches an Emph that contains Str(keyword),\n it replaces the Emph with Str(keyword).\n\n 2) If the element that contains the Str(keyword) has multiple children,\n then we are in a bind as replacing it will destroy information.\n Thus, we can't do do it\n\n 3) If the element that contains the Str(keyword) does so in a DictContainer\n instead of a ListContainer, then we cannot retrieve the \"first and only\n element\" easily, so we also abort (happens with metadata elements).\n '''\n\n # Here we can check that e.content is ListContainer (i.e. not DictContainer)\n # or check that e is not a Metavalue (\"not isinstance(e, MetaValue)\")\n\n if hasattr(e, 'content') and isinstance(e.content, ListContainer) and len(e.content) == 1:\n ee = e.content[0]\n if type(ee) == Str and ee.text == keyword:\n if isinstance(e, Block):\n doc.num_matches += 1\n if not count or doc.num_matches <= count:\n return replacement\n elif isinstance(e, Inline):\n return Str(keyword)\n else:\n pass # not implemented\n\n doc = self.doc\n if doc is None:\n raise Exception('No root document')\n doc.num_matches = 0\n if isinstance(replacement, Inline):\n return self.walk(replace_with_inline, doc)\n elif isinstance(replacement, Block):\n return self.walk(replace_with_block, doc)\n else:\n raise NotImplementedError(type(replacement))","def replace_text(self,\n\t text,\n\t fname,\n\t pattern=None,\n\t expect=None,\n\t shutit_pexpect_child=None,\n\t note=None,\n\t before=False,\n\t force=False,\n\t line_oriented=True,\n\t loglevel=logging.DEBUG):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\treturn self.change_text(text,\n\t\t fname,\n\t\t pattern,\n\t\t expect,\n\t\t shutit_pexpect_child,\n\t\t before,\n\t\t force,\n\t\t note=note,\n\t\t line_oriented=line_oriented,\n\t\t replace=True,\n\t\t loglevel=loglevel)","def replace_with_text(self):\r\n self.parser.stripTags(self.get_top_node(), 'b', 'strong', 'i', 'br', 'sup')","def set_content(self, content):\n\n # pylint: disable=W0201\n self.clear()\n self.content = content","def replace_data(self, original, replacement, pattern=None, use_regex=False, queries=[]):\n import hxl.filters\n replacement = hxl.filters.ReplaceDataFilter.Replacement(original, replacement, pattern, use_regex)\n return hxl.filters.ReplaceDataFilter(self, [replacement], queries=queries)","def replace_all(self):\n i = 0\n while self.textedit.textCursor().hasSelection():\n self.textedit.textCursor().insertText(self.ui.textToReplace.text())\n self.find()\n i += 1\n self.show_message(unicode(self.tr(\"Replaced {0} occurrence(s)\")).format(i))","def set_content(self, content):\n self.content = content","def set_content(self, content):\n self.content = content","def replace_tag_value( msg, tag, value ) :\n _TAG_RE = re.compile('\\x01' + str(tag) + '=' + '[\\s\\w:-]*' + '\\x01')\n msg = _TAG_RE.sub('\\x01' + str(tag) + '=' + str(value) + '\\x01', msg,1)\n return msg","def Replace(expression, find, replace, start=1, count=-1):\n if find:\n return expression[:start - 1] + expression[start - 1:].replace(find, replace, count)\n else:\n return expression","def substituteNodes(node, replacements):\n p = node.parentNode\n for r in replacements:\n p.insertBefore(r, node)\n p.removeChild(node)","def rep(self,tag,nstr):\n tmp = []\n for line in self.content: \n if tag in line:\n tmp.append(line.replace(tag,nstr))\n else:\n tmp.append(line)\n self.content = tmp","def findAndReplace(self):\n\n # Prompts user for find regex and replace text\n findText, replaceText = Model.FindAndReplaceDialogBox.getResults(self)\n\n # Gets the current selection from the current tab\n selectionModel = self.getCurrentView().selectionModel()\n\n # Pass to panda\n self.getCurrentPanda().findAndReplace(findText, replaceText, selectionModel)","def DocumentElementReplace(self, wave_id, wavelet_id, blip_id, position,\n element):\n op = Operation(DOCUMENT_ELEMENT_REPLACE, wave_id, wavelet_id, blip_id,\n index=position,\n prop=element)\n self.__context.AddOperation(op)","def refresh(self, new_content):\n pass","def replace(self, replacer):\n for e in self.entries:\n e.update(replacer.replace(str(e)))","def replaceXMLObject(self, **kw):\n LOG(\"replaceXMLObject\", INFO, \"xml = %s\" %(kw.get('xml_string', '')))\n return self._createAddOrReplaceNode('Replace', **kw)","def fill_template(template, replacements):\n content = template\n for src, target in replacements.iteritems():\n content = content.replace(src, target)\n return content","def xreplace(self, rule):\n value, _ = self._xreplace(rule)\n return value","def replace_chunk(\n content: str, chunk: str, tags: str, inline: bool = False, **kwargs\n) -> str:\n \n r = re.compile(\n rf\"<!-- {tags} starts -->.*<!-- {tags} ends -->\",\n re.DOTALL,\n )\n if not inline:\n chunk = f\"\\n{chunk}\\n\"\n chunk = f\"<!-- {tags} starts -->{chunk}<!-- {tags} ends -->\"\n return r.sub(chunk, content)","def replaceNode(self, cur):\n if cur is None: cur__o = None\n else: cur__o = cur._o\n ret = libxml2mod.xmlReplaceNode(self._o, cur__o)\n if ret is None:raise treeError('xmlReplaceNode() failed')\n __tmp = xmlNode(_obj=ret)\n return __tmp","def _test_and_set(root, tag, default=None, params={}, quote=False):\n var = xml_utils.find_nodes_by_tag(root, tag)\n\n if var:\n # Only check the first one\n return el_utils.replace_el_with_var(var[0].text,\n params=params,\n quote=quote)\n else:\n return default","def replace(self):\n\n if self.replace_with is not None: # pylint: disable=no-member\n return substrings(\n self.regex,\n self.replace_with, # pylint: disable=no-member\n self.data,\n self.occurences, # pylint: disable=no-member\n )\n return self.data","def do_replace(self, tx, item):\n sql = \"\"\"REPLACE INTO des_raw_parsed_data (id, content, url, source, exception_detail, exception_code, site, template_id, domain, classify, subclass)\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\"\"\"\n content = json.dumps(dict(item[\"other_parameter\"]),ensure_ascii=False)\n # if content:\n # content = content.decode('unicode_escape')\n args = (\n item[\"uuid\"],\n content,\n item[\"url\"],\n item[\"source\"],\n json.dumps(item[\"exception\"],ensure_ascii=False),\n item[\"exception_code\"],\n item[\"site\"],\n item[\"template_id\"],\n item[\"domain\"],\n item[\"classify\"],\n item[\"subclass\"]\n )\n\n tx.execute(sql, args)","def getReplacedElement(self, *args):\n return _libsbml.CompSBasePlugin_getReplacedElement(self, *args)","def set_content(self, content):\n self.data['content'] = content","def replace_code(self, pattern, repl):\n regex = re.compile(pattern, re.DOTALL)\n for cell in self.content.cells:\n if cell.cell_type == \"code\" and regex.findall(cell.source):\n cell.source = regex.sub(repl, cell.source)\n print(f\"- code removed from {self.filename}\")","def replace(match_obj):\n return match_obj.group(0)[1:]","def replace_instance(s, to_replace, replacement):\n index=0\n matchedIndeces=0\n while index<len(s):\n if s[index]==to_replace[matchedIndeces]:\n matchedIndeces+=1\n if matchedIndeces>=len(to_replace):\n s=s[:index-(matchedIndeces-1)]+replacement+s[index+1:]\n index-=matchedIndeces-1\n matchedIndeces=0\n else:\n matchedIndeces=0\n index+=1\n return s","def replace(content, root_url):\n soup = BeautifulSoup(content, BEAUTIFULSOUP_BUILDER)\n soup.header.decompose()\n for tags, attribute in PROXY_ATTRIBUTES:\n for tag in soup.find_all(tags, **{attribute: True}):\n tag_old = tag\n value = tag[attribute]\n match = PROXY_PATH_RE.match(value)\n if match is not None:\n value = match.groups()[0]\n tag[attribute] = url_path_join(root_url, value)\n # log.debug(\"REPLACE: tag_attribute_old: %s tag_attribute_new: %s\", value, tag[attribute])\n return str(soup)","def find_replace_all(self):\n old_term = self.text_find.get()\n new_term = self.text_replace.get()\n while True:\n idx = '1.0'\n idx = self.text.search(old_term, idx, nocase=1,\n stopindex=tk.END)\n lastidx = '% s+% dc' % (idx, len(old_term))\n if not idx:\n break\n self.text.delete(idx, lastidx)\n self.text.insert(idx, new_term)","def _update_object_content(name, input):\n content = input._content\n\n hrefs = re.compile(r'<\\s*[^\\>]*href\\s*=\\s*([\"\\'])(.*?)\\1')\n srcs = re.compile(r'<\\s*[^\\>]*src\\s*=\\s*([\"\\'])(.*?)\\1')\n\n matches = hrefs.findall(content)\n matches.extend(srcs.findall(content))\n relative_paths = []\n for found in matches:\n found = found[1]\n if found not in relative_paths:\n relative_paths.append(found)\n\n for relative_path in relative_paths:\n if not \"://\" in relative_path: # we don't want to rewrite protocols\n dest_path = os.sep.join((get_relative_path(name), \"static\",\n relative_path))\n content = content.replace(relative_path, dest_path)\n\n return content","def patch(text):\n if match := re.search(r'\\d+__\\d+__\\d+', text):\n tag = match.group(0)\n if tag not in ocds_tags:\n if ocds_version or not use_development_version:\n text = text.replace(tag, ocds_tag)\n else:\n text = text.replace(ocds_schema_base_url + tag, development_base_url)\n return text","def Replace(self, *args):\n return _BRepAlgo.BRepAlgo_AsDes_Replace(self, *args)","def setContent(self, content):\n self.__content = content","def DocumentReplace(self, wave_id, wavelet_id, blip_id, content):\n op = Operation(DOCUMENT_REPLACE, wave_id, wavelet_id, blip_id,\n prop=content)\n self.__context.AddOperation(op)","def replace_with_arg(self, src_arg, tgt_arg):","def replace(self, param):\n self.discard(param)\n self.add(param)","def replace(content,line,word,string):\n\tline = int(line)\n\tstring = string.strip().replace(\" \",\" &^&%+\").split()\n\tif len(content)<int(line):\n\t\tprint \"Error: No such line.\"\n\t\treturn (content,False)\n\tif word is not None:\n\t\tword = int(word)\n\t\tif len(content[line-1])<int(word) or line>len(content):\n\t\t\tprint \"Error: No such word.\"\n\t\t\treturn (content,False)\n\t\tword = word-1\n\t\tcontent[line-1] = content[line-1][:word]+string+content[line-1][word+1:]\n\t\t\n\telse:\n\t\tline = line-1\n\t\tcontent[line] = string\n\treturn (content,True)","def update(self, data):\n self.content = data","def zap_tag_contents(self, tag):\n if hasattr(tag, 'contents'):\n content_length = len(tag.contents)\n\n for x in range(0, content_length):\n if isinstance(tag.contents[x], bs4.element.Comment):\n self.zap_tag_contents(tag.contents[x])\n elif isinstance(tag.contents[x], bs4.element.NavigableString):\n unicode_entry = self.zapper.kill_gremlins(tag.contents[x])\n unicode_entry = unidecode(unicode_entry)\n tag.contents[x].replace_with(unicode_entry)\n elif isinstance(tag.contents[x], bs4.element.Tag):\n self.zap_tag_contents(tag.contents[x])","def _count_or_replace(\n self, content, query, replacement, ignore_case, search_targets):\n occurrences = 0\n flags = re.U\n if ignore_case:\n flags = flags | re.I\n if not isinstance(query, unicode):\n query = unicode(query, 'utf-8')\n if replacement and not isinstance(replacement, unicode):\n replacement = unicode(replacement, 'utf-8')\n reg = re.compile(re.escape(query), flags)\n # find all text nodes and text attributes\n current = content.documentElement\n replaced = False\n while current:\n if 'text' in search_targets:\n if current.nodeType == 3:\n # text node\n toscan = current.nodeValue\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n toscan = reg.sub(replacement, toscan)\n current.nodeValue = toscan\n replaced = True\n elif current.nodeName in (\n 'image', 'link', 'index', 'abbr', 'acronym'):\n attrs = ('title',)\n for attr in attrs:\n toscan = current.getAttribute(attr)\n if toscan:\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n current.setAttribute(\n attr, reg.sub(replacement, toscan))\n replaced = True\n if 'paths' in search_targets or 'urls' in search_targets:\n for name, attr in (\n ('image', 'link'),\n ('image', 'path'),\n ('link', 'url')):\n if current.nodeName == name:\n toscan = current.getAttribute(attr)\n if (toscan and\n ('paths' in search_targets and not\n self._reg_urls.match(toscan)) or\n ('urls' in search_targets and\n self._reg_absurls.match(toscan))):\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n current.setAttribute(\n attr, reg.sub(replacement, toscan))\n replaced = True\n if current.childNodes.length:\n current = current.firstChild\n elif current.nextSibling:\n current = current.nextSibling\n else:\n while current.parentNode:\n current = current.parentNode\n if current.nextSibling:\n current = current.nextSibling\n break\n else:\n current = None\n if replaced:\n content._p_changed = True\n # XXX I assume this should always be done?\n if hasattr(aq_base(content), 'reindex_object'):\n content.reindex_object()\n return occurrences","def find_replace(text, list):\r\n\tfor pair in list:\r\n\t\tif pair[0] in text:\r\n\t\t\ttext = text.replace(pair[0], pair[1])\r\n\treturn text","def replace_with(self, replacement):\n\n # FIND NAMES IN replacement\n parts = list(regex_parameters.split(replacement, include_separators=True))\n\n def replacer(tokens):\n acc = []\n for s, n in zip(parts, parts[1:]):\n acc.append(s)\n acc.append(text(tokens[n]))\n acc.append(parts[-1])\n return \"\".join(acc)\n\n return self / replacer","def test_replace_group(self):\n pass","def test_replacement1(engine_contents, engine_locations):\n file_name = 'Triangle.java.xml'\n new_contents = copy.deepcopy(engine_contents)\n new_locations = copy.deepcopy(engine_locations)\n target1 = (file_name, 'expr_stmt', 3)\n assert not XmlEngine.do_replace(engine_contents, engine_locations, new_contents, new_locations, target1, target1)","def inject_content(self, content: str) -> None:\n self.content = content","def update_content(self, address, owner, content):\n page = self.get(address=address)\n page.check_address()\n revision = page.revision_set.create(page=page, content=content, owner=owner)\n page.update_html(content)\n return page","def edit(self, new_content: str) -> None:\n\n # YOUR CODE HERE\n self.content = new_content","def content(self, content):\n\n self._content = content","def content(self, content):\n\n self._content = content","def replace(self, *args, **kwargs): # real signature unknown\r\n pass","def substitute_elements(self, subs, **kwargs):\n return self","def replace(self, label, data):\n self._validate_can_write()\n self._validate_labels(label, must_exist=True)\n with self._h5file('r+') as h5file:\n attrs = get_decoded(h5file[label].attrs, 'Deflate', 'Description')\n del h5file[label]\n self.insert(label, data, attrs['Description'], attrs['Deflate'])","def regexpExec(self, content):\n ret = libxml2mod.xmlRegexpExec(self._o, content)\n return ret","def merge_content(self, other):\n self.__content += other.__content","def add_substitution(self, pattern, repl):\r\n\r\n self.substitutions.append( (re.compile(pattern), repl) )","def replace_constant(self, src, dst):\n replace_count = 0\n for ii in self.__sections:\n for jj in range(len(ii.content)):\n line = ii.content[jj]\n replaced = re.sub(r'(\\$%s|\\$%s)' % (src, hex(src)), r'$%s' % hex(dst), line)\n if line != replaced:\n ii.content[jj] = replaced\n replace_count += 1\n if 1 > replace_count:\n raise RuntimeError(\"could not find constant to be replaced\")\n elif 1 < replace_count:\n raise RuntimeError(\"found constant to be replaced more than once, source destroyed\")","def performReplacement(self):\n return _libsbml.Replacing_performReplacement(self)","def replace(self, **kwargs: Any) -> UiField:\n return dc.replace(self, **kwargs)","def update_well(self, row, col, content):\n self.plate.get_well(row, col).composition.update(content)"],"string":"[\n \"def _replace_element(element):\\n # Guess line number\\n count = element.group().count(\\\"\\\\n\\\")\\n\\n # Ensure that the replacement string keep the same length that\\n # the original content to be able to use the match positions\\n _buffer = len(element.group()) - count - 2\\n\\n if len(element.group()) > 2:\\n line_number = content[:element.start()].count(\\\"\\\\n\\\")+1\\n collapsed_content[line_number] = (\\n _initial_content[element.start():element.end()]\\n )\\n\\n return \\\"<>{buffer}{lines}\\\".format(\\n buffer=\\\" \\\" * _buffer,\\n lines=\\\"\\\\n\\\" * count\\n )\",\n \"def _update_content(self, content, siteurl):\\n if not content:\\n return content\\n\\n hrefs = self._get_intrasite_link_regex()\\n return hrefs.sub(lambda m: self._link_replacer(siteurl, m), content)\",\n \"def string_replace_xml_text(element, pattern, value):\\n if element.text:\\n element.text = element.text.replace(pattern, value.decode('utf8'))\\n for c in element.getchildren():\\n string_replace_xml_text(c, pattern, value)\",\n \"def replaceElement(self, *args):\\n return _libsbml.Submodel_replaceElement(self, *args)\",\n \"def _replace(self, p, e):\\n node = self._validate_position(p)\\n old = node.element\\n node.element = e\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node.element\\n node.element = e\\n return old\",\n \"def _replace(self, p, data):\\n node = self._validate(p)\\n old = node._element\\n node._element = data\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node._element\\n node._element = e\\n return old\",\n \"def updateContent(content, **kwargs):\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node._element\\n node._element = e\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old_value = node._element\\n node._element = e\\n return old_value\",\n \"def _update_content(self, content, siteurl):\\r\\n if not content:\\r\\n return content\\r\\n\\r\\n instrasite_link_regex = self.settings['INTRASITE_LINK_REGEX']\\r\\n regex = r\\\"\\\"\\\"\\r\\n (?P<markup><\\\\s*[^\\\\>]* # match tag with all url-value attributes\\r\\n (?:href|src|poster|data|cite|formaction|action)\\\\s*=)\\r\\n\\r\\n (?P<quote>[\\\"\\\\']) # require value to be quoted\\r\\n (?P<path>{0}(?P<value>.*?)) # the url value\\r\\n \\\\2\\\"\\\"\\\".format(instrasite_link_regex)\\r\\n hrefs = re.compile(regex, re.X)\\r\\n\\r\\n def replacer(m):\\r\\n what = m.group('what')\\r\\n value = urlparse(m.group('value'))\\r\\n path = value.path\\r\\n origin = m.group('path')\\r\\n\\r\\n # XXX Put this in a different location.\\r\\n if what == 'filename':\\r\\n if path.startswith('/'):\\r\\n path = path[1:]\\r\\n else:\\r\\n # relative to the source path of this content\\r\\n path = self.get_relative_source_path(\\r\\n os.path.join(self.relative_dir, path)\\r\\n )\\r\\n\\r\\n if path not in self._context['filenames']:\\r\\n unquoted_path = path.replace('%20', ' ')\\r\\n\\r\\n if unquoted_path in self._context['filenames']:\\r\\n path = unquoted_path\\r\\n\\r\\n if path in self._context['filenames']:\\r\\n origin = '/'.join((siteurl,\\r\\n self._context['filenames'][path].url))\\r\\n origin = origin.replace('\\\\\\\\', '/') # for Windows paths.\\r\\n else:\\r\\n logger.warning((\\\"Unable to find {fn}, skipping url\\\"\\r\\n \\\" replacement\\\".format(fn=value),\\r\\n \\\"Other resources were not found\\\"\\r\\n \\\" and their urls not replaced\\\"))\\r\\n elif what == 'category':\\r\\n origin = Category(path, self.settings).url\\r\\n elif what == 'tag':\\r\\n origin = Tag(path, self.settings).url\\r\\n\\r\\n # keep all other parts, such as query, fragment, etc.\\r\\n parts = list(value)\\r\\n parts[2] = origin\\r\\n origin = urlunparse(parts)\\r\\n\\r\\n return ''.join((m.group('markup'), m.group('quote'), origin,\\r\\n m.group('quote')))\\r\\n\\r\\n return hrefs.sub(replacer, content)\",\n \"def replace_by_xml(self, xml_str, el_idx=0):\\n root_el = self.parse_xml(xml_str)\\n self.replace_by_etree(root_el, el_idx)\",\n \"def replace(\\n haystack : Exp, haystack_context : Context, haystack_pool : Pool,\\n needle : Exp, needle_context : Context, needle_pool : Pool,\\n replacement : Exp) -> Exp:\\n return _Replacer(haystack_context, haystack_pool, needle, needle_context, needle_pool, replacement).visit(haystack)\",\n \"def replace(self, element):\\n for i, sibling in enumerate(self.parent._children):\\n if sibling is self:\\n self.parent._children[i] = element\\n element.parent_docid = self.parent_docid\",\n \"def addReplacedElement(self, *args):\\n return _libsbml.CompSBasePlugin_addReplacedElement(self, *args)\",\n \"def ReplaceElement(self, position, element):\\n self.__context.builder.DocumentElementReplace(self._blip_data.wave_id,\\n self._blip_data.wavelet_id,\\n self._blip_data.blip_id,\\n position, element)\",\n \"def run(self, content):\\n parts = []\\n offset = 0\\n for match in self.regexp.finditer(content):\\n parts.append(content[offset:match.start(0)])\\n parts.append(self.replace(match))\\n offset = match.end(0)\\n parts.append(content[offset:])\\n return ''.join(parts)\",\n \"def replace(self, text):\\n if self.should_skip(text):\\n return text\\n return self.replacer.sub(self._callback, text)\",\n \"def replace(self, p, e):\\n original = self._validate(p)\\n old_value = original._element # temporarily store old element\\n original._element = e # replace with new element\\n\\n return old_value\",\n \"def inject_on_div(div_id, original, content_to_inject):\\n m = re.match(\\\".*(<div.*id=\\\\\\\"\\\"+ div_id +\\\"\\\\\\\".*>)(.*)(</div>).*\\\", original, re.DOTALL)\\n return re.sub(m.group(1) + m.group(2) + m.group(3), m.group(1) + content_to_inject + m.group(3) , original)\",\n \"def update_content(self):\\n raise NotImplementedError\",\n \"def replace(self, oldtext, newtext):\\r\\n return self\",\n \"def replace(self, pattern, substitute, pattern_type=None):\\n\\t\\tpattern = convert_pattern(pattern, pattern_type)\\n\\t\\twith self.AutoSplitlines():\\n\\t\\t\\tself.lines = [(pattern.sub(substitute, line) if pattern.search(line) else line) for line in self.lines]\",\n \"def replace_content(g):\\n g[0] = 88\\n g[1] = 22\\n g[2] = 44\\n print(\\\"g = \\\", g)\",\n \"def _replace(self, match_layer_node, replacement_layer_node):\\n if self._is_functional_model(self.model):\\n self._replace_functional(match_layer_node, replacement_layer_node)\\n else:\\n self._replace_sequential(match_layer_node, replacement_layer_node)\",\n \"def replace_all(self, content):\\n if (not self.exists()):\\n raise IOError(\\\"File at '{}' does not exist.\\\".format(self.location))\\n with open(self.location, 'w') as f:\\n f.write(content)\",\n \"def sed(self, search, replace):\\n\\n for section in self.sections:\\n for i, block in enumerate(section.blocks):\\n if block == search:\\n section.blocks[i] = replace\\n self.all_damaged = True\\n self.dirty = True\",\n \"def replace_by_etree(self, root_el, el_idx=0):\\n el = self.get_element_by_name(root_el.tag, el_idx)\\n el[:] = list(root_el)\\n el.attrib = root_el.attrib\",\n \"def test_replace(self):\\n\\n regex = \\\"th\\\"\\n expected = \\\"Hello, htis is Fun Ilrys. I just wanted to know how htings goes around hte tests.\\\" # pylint: disable=line-too-long\\n actual = Regex(self.data, regex, replace_with=\\\"ht\\\").replace()\\n\\n self.assertEqual(expected, actual)\\n\\n # Test of the case that there is not replace_with\\n regex = \\\"th\\\"\\n expected = self.data\\n actual = Regex(self.data, regex).replace()\\n\\n self.assertEqual(expected, actual)\",\n \"def replace_in_file(file_path, find, replace):\\n\\tcontent = read_file(file_path)\\n\\tcontent = content.replace(find, replace)\\n\\twrite_file(file_path, content)\",\n \"def replacingBasicElementsFromEpubLibre(text):\\n text = re.sub(r'<div class=\\\"vineta\\\"><img[^<]*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n \\n # Replace some elements with atributes with other cleaner elements\\n\\n text = re.sub(r'<p class=\\\"ind\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<p class=\\\"cursiva\\\\d*\\\">(.*?)</p>', r'<p><seg rend=\\\"italic\\\">\\\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"calibre[0-9]+\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\\d*\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"salto[0-9]+\\\">', r'<milestone unit=\\\"section\\\"/>\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoc\\\">', r'<milestone unit=\\\"section\\\"/>\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"sinopsis\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"ilustra\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"info\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<br class=\\\"calibre9\\\" />', r' ', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<sup(|[^>]*)>(<a[^>]*?>)?\\\\[.*?\\\\](</a>)?</sup>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span(|[^>]*)>\\\\s*</span>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<a(|[^>]*)>\\\\s*</a>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(tlogo|tautor|ttitulo|trevision|tfirma)\\\">.*?</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<h1 class=\\\"ttitulo\\\">(.*?)</h1>\\\\s*(<p class=\\\"titulo\\\">.*?</p>)', r'<head>\\\\1: \\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<img[^>]*?>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(bloque|ala)?derecha[0-9]*\\\">(.*?)</p>', r'<ab>\\\\2</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asangre[0-9]?\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<p class=\\\"centrado1\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<p class=\\\"extenso\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"(normal|calibre)[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p><span class=\\\"(cap[0-9]*|versalita|smallcaps)\\\">(..?)</span>', r'<p>\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"(versalita|smallcaps)[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"smallcaps\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"(?:poema[0-9]*|poe|versos|estrofas|citar\\\\d*|verso\\\\d*|versosinpie\\\\d*|centro|centrado|poemaizqcursi\\\\d*|poemaizq|poemacursi\\\\d*)\\\">(.*?)</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"center\\\">\\\\s+<table class=\\\"text\\\">\\\\s+<tr class=\\\"calibre\\\\d*\\\">\\\\s+<td class=\\\"calibre\\\\d*\\\">(\\\\s+.*?)</td>\\\\s+</tr>\\\\s+</table>\\\\s+</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE) \\n\\n text = re.sub(r'<blockquote class=\\\"(?:versos?\\\\d*)\\\">(.*?)</blockquote>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\n text = re.sub(r'(<lg>\\\\s*)<p class=\\\"izq\\\">', r'\\\\1<l>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"poemaizqcursi\\\">(.*?)</p>', r'<lg>\\\\n<l>\\\\1</l>\\\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"verso\\\">(.*?)</p>', r'<l>\\\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"normal1\\\">(.*?)</p>', r'<l>\\\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cursiva\\\">(.*?)</p>', r'<p><seg rend=\\\"italic\\\">\\\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<em(|[^>]*)>(.*?)</em>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"estrofa1\\\">', r'\\\\n\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<i(|[^>]*)>(.*?)</i>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<b(|[^>]*)>(.*?)</b>', r'<seg rend=\\\"bold\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<sup(|[^>]*)>(.*?)</sup>', r'<seg rend=\\\"sup\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"cursiva[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<sub(|[^>]*)>(.*?)</sub>', r'<seg rend=\\\"subscript\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<small(|[^>]*)>(.*?)</small>', r'<seg rend=\\\"small\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"nosep\\\\d*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"nosep\\\\d*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<strong(|[^>]*)>(.*?)</strong>', r'<seg rend=\\\"bold\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cita\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"micita\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"acotacion\\\\d*\\\">(.*?)</div>', r'<quote>\\\\n\\\\1\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<cite.*?>(.*?)</cite>', r'<seg type=\\\"cite\\\">\\\\1</seg>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n # Setting quotes in floatingText element\\n text = re.sub(r'<div class=\\\"(?:mi)?cita\\\">(.*?)</div>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<blockquote class=\\\"bloque\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"salto25x\\\">([IVXCL\\\\d]+)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"salto25x\\\\d+\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n \\n text = re.sub(r'<div class=\\\"bloquederecha1\\\">(.+?)</div>', r'<quote>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"cursiva[0-9]*\\\">', r'<div rend=\\\"italic\\\">', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"calibre\\\" id=\\\"calibre_link-[0-9]+\\\">', r'<div>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\">[… ]+?</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asteriscos\\\">[\\\\* ∗]+</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\">\\\\[…\\\\]</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asteriscos\\\\d*\\\">[\\\\. ]+</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<hr (class=\\\"calibre\\\\d*\\\" )?/>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<milestone unit=\\\"section\\\"/>\\\\s+)+', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<div class=\\\"(?:banner|text\\\\d+)\\\">(.*?)</div>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"banner\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"carta\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<blockquote class=\\\"cita\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div>\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"calibre\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<html.*?<body>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'</body></html>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>)\\\\s*(<head>.*?</head>)', r'\\\\1</div>\\\\n<div>\\\\n\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"(?:subh?|inicio|numtitulo|subt)\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<h[1-6][^>]*>(.*?)</h[1-6]>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(tsub|sub)?tit(ulo)?[0-9]*\\\">(.*?)</p>', r'<head>\\\\3</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(subcapitulo|capitulonombre|h\\\\d+)\\\">(.*?)</p>', r'<head>\\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"tit-cap\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'</head>\\\\s*<p class=\\\"(subtil|subcap)\\\">(.*?)</p>', r': \\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<span class=\\\"ncap\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"ncap\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"palabra\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"sigla\\\\d*\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<p>—?)<span class=\\\"inicial\\\">(.*?)</span>', r'\\\\1\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<p>—?¿?)<big class=\\\"calibre\\\\d*\\\">(.*?)</big>', r'\\\\1\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<head>\\\\s*</head>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p [^>]*?>\\\\s*\\\\* *\\\\* *\\\\*</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"sep\\\">\\\\* \\\\* \\\\*</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'</head>\\\\s*<head>', r': ', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'(</head>)(\\\\s*<head>)', r'\\\\1\\\\n<div>\\\\n\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n\\n \\\"\\\"\\\"\\n #Setting divs after ps. Used for 219\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n\\n # Cleaning some <milestone />\\n text = re.sub(r'(<div>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</div>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</head>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n # Setting some floatingTexts\\n #text = re.sub(r'(<div(| [^>]*?)>((?!<div).)*</div>)(\\\\s*<p)', r'<floatingText>\\\\n<body>\\\\n\\\\1\\\\n</body>\\\\n</floatingText>\\\\n\\\\4', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n #text = re.sub(r'(<div(|[^>]+?)>.*?</div>)(\\\\s*<p)', r'<floatingText>\\\\n<body>\\\\n<div>\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n # Floating Texts\\n\\n text = re.sub(r'<p(| [^>]+)>[\\\\s\\\\r\\\\n]*</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'\\\\n[ \\\\t]+', r'\\\\n', text, flags=re.IGNORECASE)\\n text = re.sub(r'[\\\\r\\\\n]+', r'\\\\r\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div>[\\\\r?\\\\n]*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<div>((?!<div>).)*</div>\\\\r?\\\\n)\\\\Z', r'<!--\\\\1-->', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n\\n text = re.sub(r'<div class=\\\"cita?[0-9]*\\\">(.*?)</div>', r'<quote>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"cita[0-9]*\\\">(.*?</p>)', r'<quote>\\\\n<p>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\n text = re.sub(r'<br class=\\\"calibre[0-9]*\\\" />', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'(<p>—?. ?)<span class=\\\"palabra\\\">(.*?)</span>', r'\\\\1<seg rend=\\\"small\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\"><span class=\\\"inicial\\\">(.*)</span><span class=\\\"palabra\\\">(.*?)</span>', r'<p>\\\\1\\\\2', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\"><span class=\\\"inicial\\\">(.*)</span>', r'<p>\\\\1', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p>(.)<span>(.*)</span>', r'<p>\\\\1\\\\2', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"inicial\\\">(.*)</span>', r'\\\\1', text, flags=re.IGNORECASE)\\n\\n \\n text = re.sub(r'(<head>.*?)<seg rend=\\\"(smallcaps|small)\\\">(.*?)</seg>(.*?</head>)', r'\\\\1\\\\3\\\\4', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<div[^>]*?>\\\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<div class=\\\"(?:tablacentro\\\\d*|center)\\\">\\\\s*<table class=\\\"text\\\\d*\\\">\\\\s*<tr class=\\\"calibre\\\\d*\\\">\\\\s*<td class=\\\"calibre\\\\d*\\\">(.*?)\\\\s*</td>\\\\s*</tr>\\\\s*</table>\\\\s*</div>', r'<lg>\\\\1\\\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"traduccion\\\">(.*?)</p>', r'<ab type=\\\"translation\\\">\\\\1</ab>', text, flags=re.IGNORECASE)\\n\\n #text = re.sub(r'<p class=\\\"centrado\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n #text = re.sub(r'<blockquote class=\\\"calibre18\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n\\\\1\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\\"\\\"\\\"\\n #The next lines were used for 232, a theater-like novel\\n \\n text = re.sub(r'<p>(.*?</seg>)(\\\\.\\\\—.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n #The next lines were used for 109, a theater-like novel\\n text = re.sub(r'<p>(.*?</seg>\\\\.)(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\\\"italic\\\">.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<seg rend=\\\"italic\\\">(\\\\(.*?)</seg>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n #The next lines were used for 224, a theater-like novel\\n text = re.sub(r'<p>(.<seg rend=\\\"small\\\">.*?</seg>\\\\.)(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n #text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\\\"italic\\\">.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<seg rend=\\\"italic\\\">(\\\\(.*?)</seg>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # Code used for paradox rey\\n text = re.sub(r'<div class=\\\"clear\\\">\\\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"banner\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"francesa\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n text = re.sub(r'<p class=\\\"personaje\\\">(.*?)</p>\\\\s*<p>(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"descrip\\\">(.*?)</span>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(?:descrip\\\\d*|entrada|fin)\\\">(.*?)</p>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cuadro\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"descrip1\\\">(.*?)</div>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"puntos\\\">.*?</div>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"tablacentro\\\">(.*?)</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n text = re.sub(r'<p class=\\\"decla\\\">(.*?\\\\. )(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(?:descrip|decla1)\\\">(.*?)</p>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n\\n\\n text = re.sub(r'(<seg\\\\s+rend\\\\s*=\\\\s*\\\"small(?:caps)?\\\">)(.*?)(?=</seg>)', lambda m: m.group(1) + m.group(2).lower(), text)\\n \\n text = re.sub(r'(<seg\\\\s+rend\\\\s*=\\\\s*\\\"small(?:caps)?\\\">)(.*?)(</seg>)', r'\\\\2', text, flags=re.IGNORECASE)\\n \\n text = re.sub(r'<big[^>]*?>(.*?)</big>', r'\\\\1', text, flags=re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"serif\\\" id=\\\"calibre_link-\\\\d+\\\">', r'<div>', text, flags=re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"sinmargen\\\" id=\\\"calibre_link-\\\\d+\\\">', r'<div>', text, flags=re.IGNORECASE) \\n\\n text = re.sub(r'<p class=\\\"(?:carta|firma\\\\d+)\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.IGNORECASE) \\n\\n\\n\\n return text\",\n \"def replace_with(*, replacement, f=DECORATED):\\n return replacement\",\n \"def replace_with(self, replacement_arg):\\n replacement = BinaryNode.or_none(replacement_arg)\\n\\n # Do not proceed if replacement is invalid\\n # Nothing to do if replacing node with itself\\n if replacement == self:\\n return self\\n\\n # Link parent\\n parent = self.get_parent()\\n if parent is not None:\\n if self.is_left_child():\\n parent.set_left(replacement)\\n elif self.is_right_child():\\n parent.set_right(replacement)\\n elif self.tree is not None:\\n # Replacing head\\n self.tree.head = replacement\\n\\n # Remove node from tree\\n self.set_parent(None)\",\n \"def replace(node, key, value):\\n if isinstance(node, (Document, Object)):\\n data = dict(node)\\n elif isinstance(node, Array):\\n data = list(node)\\n else:\\n raise TypeError(\\n \\\"Expected Core API container type. Got '%s'.\\\" % type(node)\\n )\\n\\n data[key] = value\\n if isinstance(node, Document):\\n return type(node)(url=node.url, title=node.title, content=data)\\n return type(node)(data)\",\n \"def change_content(options):\\n call_command('''grep -r -l -- '%(patrn)s' . | tr '\\\\\\\\n' '\\\\\\\\0' | xargs -0 sed -i \\\"s/%(patrn)s/%(repl)s/g\\\"''', options)\",\n \"def replaceChild(self, *args):\\n return _libsbml.ASTNode_replaceChild(self, *args)\",\n \"def in_place_substitute(self):\\r\\n if self.substitute is not None:\\r\\n node = self.convert_type()\\r\\n self.leaf_replace(node) # for internals only\\r\\n self.root_replace(node)\",\n \"def set_content(self, content):\\n if check_data_exist(content) is True:\\n self.content = content.text\",\n \"def replaceChild(self, *args):\\n return _libsbml.ASTBasePlugin_replaceChild(self, *args)\",\n \"def _replace_keyword(self, keyword, replacement, count=0):\\n\\n def replace_with_inline(e, doc):\\n if type(e) == Str and e.text == keyword:\\n doc.num_matches += 1\\n if not count or doc.num_matches <= count:\\n return replacement\\n\\n def replace_with_block(e, doc):\\n '''\\n It's difficult to replace a keyword with an entire Block element.\\n\\n This is because the keyword is of type Str (an Inline) and the parent\\n object of a Str can only contain Inlines and not Blocks\\n (e.g. Para can contain Inlines, not Divs)\\n\\n Implications:\\n\\n 1) If the Str that contains the keyword is inside another\\n Inline instead of a Block (e.g. Div -> Emph -> Str)\\n then we have to do a trick:\\n when .walk() touches an Emph that contains Str(keyword),\\n it replaces the Emph with Str(keyword).\\n\\n 2) If the element that contains the Str(keyword) has multiple children,\\n then we are in a bind as replacing it will destroy information.\\n Thus, we can't do do it\\n\\n 3) If the element that contains the Str(keyword) does so in a DictContainer\\n instead of a ListContainer, then we cannot retrieve the \\\"first and only\\n element\\\" easily, so we also abort (happens with metadata elements).\\n '''\\n\\n # Here we can check that e.content is ListContainer (i.e. not DictContainer)\\n # or check that e is not a Metavalue (\\\"not isinstance(e, MetaValue)\\\")\\n\\n if hasattr(e, 'content') and isinstance(e.content, ListContainer) and len(e.content) == 1:\\n ee = e.content[0]\\n if type(ee) == Str and ee.text == keyword:\\n if isinstance(e, Block):\\n doc.num_matches += 1\\n if not count or doc.num_matches <= count:\\n return replacement\\n elif isinstance(e, Inline):\\n return Str(keyword)\\n else:\\n pass # not implemented\\n\\n doc = self.doc\\n if doc is None:\\n raise Exception('No root document')\\n doc.num_matches = 0\\n if isinstance(replacement, Inline):\\n return self.walk(replace_with_inline, doc)\\n elif isinstance(replacement, Block):\\n return self.walk(replace_with_block, doc)\\n else:\\n raise NotImplementedError(type(replacement))\",\n \"def replace_text(self,\\n\\t text,\\n\\t fname,\\n\\t pattern=None,\\n\\t expect=None,\\n\\t shutit_pexpect_child=None,\\n\\t note=None,\\n\\t before=False,\\n\\t force=False,\\n\\t line_oriented=True,\\n\\t loglevel=logging.DEBUG):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\treturn self.change_text(text,\\n\\t\\t fname,\\n\\t\\t pattern,\\n\\t\\t expect,\\n\\t\\t shutit_pexpect_child,\\n\\t\\t before,\\n\\t\\t force,\\n\\t\\t note=note,\\n\\t\\t line_oriented=line_oriented,\\n\\t\\t replace=True,\\n\\t\\t loglevel=loglevel)\",\n \"def replace_with_text(self):\\r\\n self.parser.stripTags(self.get_top_node(), 'b', 'strong', 'i', 'br', 'sup')\",\n \"def set_content(self, content):\\n\\n # pylint: disable=W0201\\n self.clear()\\n self.content = content\",\n \"def replace_data(self, original, replacement, pattern=None, use_regex=False, queries=[]):\\n import hxl.filters\\n replacement = hxl.filters.ReplaceDataFilter.Replacement(original, replacement, pattern, use_regex)\\n return hxl.filters.ReplaceDataFilter(self, [replacement], queries=queries)\",\n \"def replace_all(self):\\n i = 0\\n while self.textedit.textCursor().hasSelection():\\n self.textedit.textCursor().insertText(self.ui.textToReplace.text())\\n self.find()\\n i += 1\\n self.show_message(unicode(self.tr(\\\"Replaced {0} occurrence(s)\\\")).format(i))\",\n \"def set_content(self, content):\\n self.content = content\",\n \"def set_content(self, content):\\n self.content = content\",\n \"def replace_tag_value( msg, tag, value ) :\\n _TAG_RE = re.compile('\\\\x01' + str(tag) + '=' + '[\\\\s\\\\w:-]*' + '\\\\x01')\\n msg = _TAG_RE.sub('\\\\x01' + str(tag) + '=' + str(value) + '\\\\x01', msg,1)\\n return msg\",\n \"def Replace(expression, find, replace, start=1, count=-1):\\n if find:\\n return expression[:start - 1] + expression[start - 1:].replace(find, replace, count)\\n else:\\n return expression\",\n \"def substituteNodes(node, replacements):\\n p = node.parentNode\\n for r in replacements:\\n p.insertBefore(r, node)\\n p.removeChild(node)\",\n \"def rep(self,tag,nstr):\\n tmp = []\\n for line in self.content: \\n if tag in line:\\n tmp.append(line.replace(tag,nstr))\\n else:\\n tmp.append(line)\\n self.content = tmp\",\n \"def findAndReplace(self):\\n\\n # Prompts user for find regex and replace text\\n findText, replaceText = Model.FindAndReplaceDialogBox.getResults(self)\\n\\n # Gets the current selection from the current tab\\n selectionModel = self.getCurrentView().selectionModel()\\n\\n # Pass to panda\\n self.getCurrentPanda().findAndReplace(findText, replaceText, selectionModel)\",\n \"def DocumentElementReplace(self, wave_id, wavelet_id, blip_id, position,\\n element):\\n op = Operation(DOCUMENT_ELEMENT_REPLACE, wave_id, wavelet_id, blip_id,\\n index=position,\\n prop=element)\\n self.__context.AddOperation(op)\",\n \"def refresh(self, new_content):\\n pass\",\n \"def replace(self, replacer):\\n for e in self.entries:\\n e.update(replacer.replace(str(e)))\",\n \"def replaceXMLObject(self, **kw):\\n LOG(\\\"replaceXMLObject\\\", INFO, \\\"xml = %s\\\" %(kw.get('xml_string', '')))\\n return self._createAddOrReplaceNode('Replace', **kw)\",\n \"def fill_template(template, replacements):\\n content = template\\n for src, target in replacements.iteritems():\\n content = content.replace(src, target)\\n return content\",\n \"def xreplace(self, rule):\\n value, _ = self._xreplace(rule)\\n return value\",\n \"def replace_chunk(\\n content: str, chunk: str, tags: str, inline: bool = False, **kwargs\\n) -> str:\\n \\n r = re.compile(\\n rf\\\"<!-- {tags} starts -->.*<!-- {tags} ends -->\\\",\\n re.DOTALL,\\n )\\n if not inline:\\n chunk = f\\\"\\\\n{chunk}\\\\n\\\"\\n chunk = f\\\"<!-- {tags} starts -->{chunk}<!-- {tags} ends -->\\\"\\n return r.sub(chunk, content)\",\n \"def replaceNode(self, cur):\\n if cur is None: cur__o = None\\n else: cur__o = cur._o\\n ret = libxml2mod.xmlReplaceNode(self._o, cur__o)\\n if ret is None:raise treeError('xmlReplaceNode() failed')\\n __tmp = xmlNode(_obj=ret)\\n return __tmp\",\n \"def _test_and_set(root, tag, default=None, params={}, quote=False):\\n var = xml_utils.find_nodes_by_tag(root, tag)\\n\\n if var:\\n # Only check the first one\\n return el_utils.replace_el_with_var(var[0].text,\\n params=params,\\n quote=quote)\\n else:\\n return default\",\n \"def replace(self):\\n\\n if self.replace_with is not None: # pylint: disable=no-member\\n return substrings(\\n self.regex,\\n self.replace_with, # pylint: disable=no-member\\n self.data,\\n self.occurences, # pylint: disable=no-member\\n )\\n return self.data\",\n \"def do_replace(self, tx, item):\\n sql = \\\"\\\"\\\"REPLACE INTO des_raw_parsed_data (id, content, url, source, exception_detail, exception_code, site, template_id, domain, classify, subclass)\\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\\\"\\\"\\\"\\n content = json.dumps(dict(item[\\\"other_parameter\\\"]),ensure_ascii=False)\\n # if content:\\n # content = content.decode('unicode_escape')\\n args = (\\n item[\\\"uuid\\\"],\\n content,\\n item[\\\"url\\\"],\\n item[\\\"source\\\"],\\n json.dumps(item[\\\"exception\\\"],ensure_ascii=False),\\n item[\\\"exception_code\\\"],\\n item[\\\"site\\\"],\\n item[\\\"template_id\\\"],\\n item[\\\"domain\\\"],\\n item[\\\"classify\\\"],\\n item[\\\"subclass\\\"]\\n )\\n\\n tx.execute(sql, args)\",\n \"def getReplacedElement(self, *args):\\n return _libsbml.CompSBasePlugin_getReplacedElement(self, *args)\",\n \"def set_content(self, content):\\n self.data['content'] = content\",\n \"def replace_code(self, pattern, repl):\\n regex = re.compile(pattern, re.DOTALL)\\n for cell in self.content.cells:\\n if cell.cell_type == \\\"code\\\" and regex.findall(cell.source):\\n cell.source = regex.sub(repl, cell.source)\\n print(f\\\"- code removed from {self.filename}\\\")\",\n \"def replace(match_obj):\\n return match_obj.group(0)[1:]\",\n \"def replace_instance(s, to_replace, replacement):\\n index=0\\n matchedIndeces=0\\n while index<len(s):\\n if s[index]==to_replace[matchedIndeces]:\\n matchedIndeces+=1\\n if matchedIndeces>=len(to_replace):\\n s=s[:index-(matchedIndeces-1)]+replacement+s[index+1:]\\n index-=matchedIndeces-1\\n matchedIndeces=0\\n else:\\n matchedIndeces=0\\n index+=1\\n return s\",\n \"def replace(content, root_url):\\n soup = BeautifulSoup(content, BEAUTIFULSOUP_BUILDER)\\n soup.header.decompose()\\n for tags, attribute in PROXY_ATTRIBUTES:\\n for tag in soup.find_all(tags, **{attribute: True}):\\n tag_old = tag\\n value = tag[attribute]\\n match = PROXY_PATH_RE.match(value)\\n if match is not None:\\n value = match.groups()[0]\\n tag[attribute] = url_path_join(root_url, value)\\n # log.debug(\\\"REPLACE: tag_attribute_old: %s tag_attribute_new: %s\\\", value, tag[attribute])\\n return str(soup)\",\n \"def find_replace_all(self):\\n old_term = self.text_find.get()\\n new_term = self.text_replace.get()\\n while True:\\n idx = '1.0'\\n idx = self.text.search(old_term, idx, nocase=1,\\n stopindex=tk.END)\\n lastidx = '% s+% dc' % (idx, len(old_term))\\n if not idx:\\n break\\n self.text.delete(idx, lastidx)\\n self.text.insert(idx, new_term)\",\n \"def _update_object_content(name, input):\\n content = input._content\\n\\n hrefs = re.compile(r'<\\\\s*[^\\\\>]*href\\\\s*=\\\\s*([\\\"\\\\'])(.*?)\\\\1')\\n srcs = re.compile(r'<\\\\s*[^\\\\>]*src\\\\s*=\\\\s*([\\\"\\\\'])(.*?)\\\\1')\\n\\n matches = hrefs.findall(content)\\n matches.extend(srcs.findall(content))\\n relative_paths = []\\n for found in matches:\\n found = found[1]\\n if found not in relative_paths:\\n relative_paths.append(found)\\n\\n for relative_path in relative_paths:\\n if not \\\"://\\\" in relative_path: # we don't want to rewrite protocols\\n dest_path = os.sep.join((get_relative_path(name), \\\"static\\\",\\n relative_path))\\n content = content.replace(relative_path, dest_path)\\n\\n return content\",\n \"def patch(text):\\n if match := re.search(r'\\\\d+__\\\\d+__\\\\d+', text):\\n tag = match.group(0)\\n if tag not in ocds_tags:\\n if ocds_version or not use_development_version:\\n text = text.replace(tag, ocds_tag)\\n else:\\n text = text.replace(ocds_schema_base_url + tag, development_base_url)\\n return text\",\n \"def Replace(self, *args):\\n return _BRepAlgo.BRepAlgo_AsDes_Replace(self, *args)\",\n \"def setContent(self, content):\\n self.__content = content\",\n \"def DocumentReplace(self, wave_id, wavelet_id, blip_id, content):\\n op = Operation(DOCUMENT_REPLACE, wave_id, wavelet_id, blip_id,\\n prop=content)\\n self.__context.AddOperation(op)\",\n \"def replace_with_arg(self, src_arg, tgt_arg):\",\n \"def replace(self, param):\\n self.discard(param)\\n self.add(param)\",\n \"def replace(content,line,word,string):\\n\\tline = int(line)\\n\\tstring = string.strip().replace(\\\" \\\",\\\" &^&%+\\\").split()\\n\\tif len(content)<int(line):\\n\\t\\tprint \\\"Error: No such line.\\\"\\n\\t\\treturn (content,False)\\n\\tif word is not None:\\n\\t\\tword = int(word)\\n\\t\\tif len(content[line-1])<int(word) or line>len(content):\\n\\t\\t\\tprint \\\"Error: No such word.\\\"\\n\\t\\t\\treturn (content,False)\\n\\t\\tword = word-1\\n\\t\\tcontent[line-1] = content[line-1][:word]+string+content[line-1][word+1:]\\n\\t\\t\\n\\telse:\\n\\t\\tline = line-1\\n\\t\\tcontent[line] = string\\n\\treturn (content,True)\",\n \"def update(self, data):\\n self.content = data\",\n \"def zap_tag_contents(self, tag):\\n if hasattr(tag, 'contents'):\\n content_length = len(tag.contents)\\n\\n for x in range(0, content_length):\\n if isinstance(tag.contents[x], bs4.element.Comment):\\n self.zap_tag_contents(tag.contents[x])\\n elif isinstance(tag.contents[x], bs4.element.NavigableString):\\n unicode_entry = self.zapper.kill_gremlins(tag.contents[x])\\n unicode_entry = unidecode(unicode_entry)\\n tag.contents[x].replace_with(unicode_entry)\\n elif isinstance(tag.contents[x], bs4.element.Tag):\\n self.zap_tag_contents(tag.contents[x])\",\n \"def _count_or_replace(\\n self, content, query, replacement, ignore_case, search_targets):\\n occurrences = 0\\n flags = re.U\\n if ignore_case:\\n flags = flags | re.I\\n if not isinstance(query, unicode):\\n query = unicode(query, 'utf-8')\\n if replacement and not isinstance(replacement, unicode):\\n replacement = unicode(replacement, 'utf-8')\\n reg = re.compile(re.escape(query), flags)\\n # find all text nodes and text attributes\\n current = content.documentElement\\n replaced = False\\n while current:\\n if 'text' in search_targets:\\n if current.nodeType == 3:\\n # text node\\n toscan = current.nodeValue\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n toscan = reg.sub(replacement, toscan)\\n current.nodeValue = toscan\\n replaced = True\\n elif current.nodeName in (\\n 'image', 'link', 'index', 'abbr', 'acronym'):\\n attrs = ('title',)\\n for attr in attrs:\\n toscan = current.getAttribute(attr)\\n if toscan:\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n current.setAttribute(\\n attr, reg.sub(replacement, toscan))\\n replaced = True\\n if 'paths' in search_targets or 'urls' in search_targets:\\n for name, attr in (\\n ('image', 'link'),\\n ('image', 'path'),\\n ('link', 'url')):\\n if current.nodeName == name:\\n toscan = current.getAttribute(attr)\\n if (toscan and\\n ('paths' in search_targets and not\\n self._reg_urls.match(toscan)) or\\n ('urls' in search_targets and\\n self._reg_absurls.match(toscan))):\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n current.setAttribute(\\n attr, reg.sub(replacement, toscan))\\n replaced = True\\n if current.childNodes.length:\\n current = current.firstChild\\n elif current.nextSibling:\\n current = current.nextSibling\\n else:\\n while current.parentNode:\\n current = current.parentNode\\n if current.nextSibling:\\n current = current.nextSibling\\n break\\n else:\\n current = None\\n if replaced:\\n content._p_changed = True\\n # XXX I assume this should always be done?\\n if hasattr(aq_base(content), 'reindex_object'):\\n content.reindex_object()\\n return occurrences\",\n \"def find_replace(text, list):\\r\\n\\tfor pair in list:\\r\\n\\t\\tif pair[0] in text:\\r\\n\\t\\t\\ttext = text.replace(pair[0], pair[1])\\r\\n\\treturn text\",\n \"def replace_with(self, replacement):\\n\\n # FIND NAMES IN replacement\\n parts = list(regex_parameters.split(replacement, include_separators=True))\\n\\n def replacer(tokens):\\n acc = []\\n for s, n in zip(parts, parts[1:]):\\n acc.append(s)\\n acc.append(text(tokens[n]))\\n acc.append(parts[-1])\\n return \\\"\\\".join(acc)\\n\\n return self / replacer\",\n \"def test_replace_group(self):\\n pass\",\n \"def test_replacement1(engine_contents, engine_locations):\\n file_name = 'Triangle.java.xml'\\n new_contents = copy.deepcopy(engine_contents)\\n new_locations = copy.deepcopy(engine_locations)\\n target1 = (file_name, 'expr_stmt', 3)\\n assert not XmlEngine.do_replace(engine_contents, engine_locations, new_contents, new_locations, target1, target1)\",\n \"def inject_content(self, content: str) -> None:\\n self.content = content\",\n \"def update_content(self, address, owner, content):\\n page = self.get(address=address)\\n page.check_address()\\n revision = page.revision_set.create(page=page, content=content, owner=owner)\\n page.update_html(content)\\n return page\",\n \"def edit(self, new_content: str) -> None:\\n\\n # YOUR CODE HERE\\n self.content = new_content\",\n \"def content(self, content):\\n\\n self._content = content\",\n \"def content(self, content):\\n\\n self._content = content\",\n \"def replace(self, *args, **kwargs): # real signature unknown\\r\\n pass\",\n \"def substitute_elements(self, subs, **kwargs):\\n return self\",\n \"def replace(self, label, data):\\n self._validate_can_write()\\n self._validate_labels(label, must_exist=True)\\n with self._h5file('r+') as h5file:\\n attrs = get_decoded(h5file[label].attrs, 'Deflate', 'Description')\\n del h5file[label]\\n self.insert(label, data, attrs['Description'], attrs['Deflate'])\",\n \"def regexpExec(self, content):\\n ret = libxml2mod.xmlRegexpExec(self._o, content)\\n return ret\",\n \"def merge_content(self, other):\\n self.__content += other.__content\",\n \"def add_substitution(self, pattern, repl):\\r\\n\\r\\n self.substitutions.append( (re.compile(pattern), repl) )\",\n \"def replace_constant(self, src, dst):\\n replace_count = 0\\n for ii in self.__sections:\\n for jj in range(len(ii.content)):\\n line = ii.content[jj]\\n replaced = re.sub(r'(\\\\$%s|\\\\$%s)' % (src, hex(src)), r'$%s' % hex(dst), line)\\n if line != replaced:\\n ii.content[jj] = replaced\\n replace_count += 1\\n if 1 > replace_count:\\n raise RuntimeError(\\\"could not find constant to be replaced\\\")\\n elif 1 < replace_count:\\n raise RuntimeError(\\\"found constant to be replaced more than once, source destroyed\\\")\",\n \"def performReplacement(self):\\n return _libsbml.Replacing_performReplacement(self)\",\n \"def replace(self, **kwargs: Any) -> UiField:\\n return dc.replace(self, **kwargs)\",\n \"def update_well(self, row, col, content):\\n self.plate.get_well(row, col).composition.update(content)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6922728","0.6515308","0.6332452","0.62553614","0.61960304","0.6170884","0.6162246","0.6047259","0.60279584","0.60038835","0.5947182","0.58738005","0.5823154","0.5736322","0.5640052","0.5575298","0.55390126","0.5501876","0.5462999","0.5449665","0.54481953","0.5429287","0.54270405","0.5419557","0.54091096","0.53985655","0.5388554","0.5377131","0.535448","0.5330729","0.5322331","0.52958876","0.5286781","0.5258991","0.5251955","0.524588","0.5242719","0.5229057","0.52281964","0.5228149","0.5217918","0.52060527","0.51995677","0.5194059","0.5183777","0.516674","0.5155041","0.5155041","0.51485336","0.5144272","0.51405716","0.5139115","0.5129531","0.5122871","0.51148444","0.51107156","0.5108839","0.5096752","0.50746125","0.5063711","0.50491416","0.5045423","0.503969","0.50308126","0.502869","0.50156","0.5012278","0.50027496","0.49884775","0.49822745","0.4980944","0.49754515","0.49739784","0.49661472","0.4961652","0.4958183","0.49484614","0.4935497","0.49305344","0.492815","0.4919785","0.49173847","0.4916492","0.4913445","0.4900054","0.4895477","0.48849794","0.48847148","0.48818967","0.4875442","0.4875442","0.48696706","0.4865927","0.48620668","0.48475358","0.4839794","0.48277682","0.48096436","0.4796967","0.47962475","0.47912368"],"string":"[\n \"0.6922728\",\n \"0.6515308\",\n \"0.6332452\",\n \"0.62553614\",\n \"0.61960304\",\n \"0.6170884\",\n \"0.6162246\",\n \"0.6047259\",\n \"0.60279584\",\n \"0.60038835\",\n \"0.5947182\",\n \"0.58738005\",\n \"0.5823154\",\n \"0.5736322\",\n \"0.5640052\",\n \"0.5575298\",\n \"0.55390126\",\n \"0.5501876\",\n \"0.5462999\",\n \"0.5449665\",\n \"0.54481953\",\n \"0.5429287\",\n \"0.54270405\",\n \"0.5419557\",\n \"0.54091096\",\n \"0.53985655\",\n \"0.5388554\",\n \"0.5377131\",\n \"0.535448\",\n \"0.5330729\",\n \"0.5322331\",\n \"0.52958876\",\n \"0.5286781\",\n \"0.5258991\",\n \"0.5251955\",\n \"0.524588\",\n \"0.5242719\",\n \"0.5229057\",\n \"0.52281964\",\n \"0.5228149\",\n \"0.5217918\",\n \"0.52060527\",\n \"0.51995677\",\n \"0.5194059\",\n \"0.5183777\",\n \"0.516674\",\n \"0.5155041\",\n \"0.5155041\",\n \"0.51485336\",\n \"0.5144272\",\n \"0.51405716\",\n \"0.5139115\",\n \"0.5129531\",\n \"0.5122871\",\n \"0.51148444\",\n \"0.51107156\",\n \"0.5108839\",\n \"0.5096752\",\n \"0.50746125\",\n \"0.5063711\",\n \"0.50491416\",\n \"0.5045423\",\n \"0.503969\",\n \"0.50308126\",\n \"0.502869\",\n \"0.50156\",\n \"0.5012278\",\n \"0.50027496\",\n \"0.49884775\",\n \"0.49822745\",\n \"0.4980944\",\n \"0.49754515\",\n \"0.49739784\",\n \"0.49661472\",\n \"0.4961652\",\n \"0.4958183\",\n \"0.49484614\",\n \"0.4935497\",\n \"0.49305344\",\n \"0.492815\",\n \"0.4919785\",\n \"0.49173847\",\n \"0.4916492\",\n \"0.4913445\",\n \"0.4900054\",\n \"0.4895477\",\n \"0.48849794\",\n \"0.48847148\",\n \"0.48818967\",\n \"0.4875442\",\n \"0.4875442\",\n \"0.48696706\",\n \"0.4865927\",\n \"0.48620668\",\n \"0.48475358\",\n \"0.4839794\",\n \"0.48277682\",\n \"0.48096436\",\n \"0.4796967\",\n \"0.47962475\",\n \"0.47912368\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85183,"cells":{"query":{"kind":"string","value":"Return tuple of content with the top level elements only and dictionary containing the collapsed content associated with the line number. If filter_comment is set to True, all comment are removed from the content before collapsing the elements. The collapsed content dictionary preserve the comments."},"document":{"kind":"string","value":"def collapse_all(content, filter_comment=False):\n _initial_content = content\n collapsed_content = {}\n\n if filter_comment:\n # Filter comment before collapsing elements to prevent comment analysis\n content = filter_comments(content, keep_content_size=True)\n\n def _replace_element(element):\n \"\"\"Replace matched *element* in content.\"\"\"\n # Guess line number\n count = element.group().count(\"\\n\")\n\n # Ensure that the replacement string keep the same length that\n # the original content to be able to use the match positions\n _buffer = len(element.group()) - count - 2\n\n if len(element.group()) > 2:\n line_number = content[:element.start()].count(\"\\n\")+1\n collapsed_content[line_number] = (\n _initial_content[element.start():element.end()]\n )\n\n return \"<>{buffer}{lines}\".format(\n buffer=\" \" * _buffer,\n lines=\"\\n\" * count\n )\n\n _content = None\n\n while _content != content:\n _content = content\n content = _NESTED_ELEMENT_PATTERN.sub(_replace_element, content)\n\n # Remove the space buffer before returning the content\n content = re.sub(r\"<> *\", lambda x: \"{}\", content)\n\n return content, collapsed_content"},"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 filter_comments(\n content, filter_multiline_comment=True, keep_content_size=False\n):\n def _replace_comment(element):\n \"\"\"Replace matched *element* in content.\"\"\"\n replacement = \"\"\n matched = element.group()\n\n # Ensure that only the comment part is being replaced\n if not matched.startswith(\"/\"):\n replacement += matched[0]\n matched = matched[1:]\n\n count = matched.count(\"\\n\")\n\n # Add empty spaces with the size of the content if the size\n # must be kept.\n if keep_content_size:\n _buffer = len(matched) - count\n replacement += \" \" * _buffer + \"\\n\" * count\n\n # Otherwise simply keep the number of lines\n else:\n replacement += \"\\n\" * count\n\n return replacement\n\n content = _ONE_LINE_COMMENT_PATTERN.sub(_replace_comment, content)\n\n if filter_multiline_comment:\n content = _MULTI_LINES_COMMENT_PATTERN.sub(_replace_comment, content)\n\n return content","def _filter(self, text, context, encoding):\n\n content = []\n soup = bs4.BeautifulSoup(text, self.parser)\n soup = self.get_sub_node(soup)\n blocks, attributes, comments = self.to_text(soup)\n if self.comments:\n for c, desc in comments:\n content.append(filters.SourceText(c, context + ': ' + desc, encoding, self.type + 'comment'))\n if self.attributes:\n for a, desc in attributes:\n content.append(filters.SourceText(a, context + ': ' + desc, encoding, self.type + 'attribute'))\n for b, desc in blocks:\n content.append(filters.SourceText(b, context + ': ' + desc, encoding, self.type + 'content'))\n return content","def process_comment(self, data):\r\n if not self.is_suppress:\r\n return [data]","def uncollapse_special_comments(self, wrapped_by_id):\n\n if self.uncollapse_all:\n dont_collapse = set(wrapped_by_id.keys())\n elif self.comment:\n dont_collapse = set([self.comment._id])\n parent_id = self.comment.parent_id\n while parent_id:\n dont_collapse.add(parent_id)\n if parent_id in wrapped_by_id:\n parent_id = wrapped_by_id[parent_id].parent_id\n else:\n parent_id = None\n elif self.children:\n dont_collapse = set(self.children)\n else:\n dont_collapse = set()\n\n # we only care about preventing collapse of wrapped comments\n dont_collapse &= set(wrapped_by_id.keys())\n\n maybe_collapse = set(wrapped_by_id.keys()) - dont_collapse\n\n for comment_id in maybe_collapse:\n comment = wrapped_by_id[comment_id]\n if comment.distinguished and comment.distinguished != \"no\":\n dont_collapse.add(comment_id)\n\n maybe_collapse -= dont_collapse\n\n # ensure all ancestors of dont_collapse comments are not collapsed\n if maybe_collapse:\n for comment_id in sorted(dont_collapse):\n # sort comments so we start with the most root level comments\n comment = wrapped_by_id[comment_id]\n parent_id = comment.parent_id\n\n counter = 0\n while (parent_id and\n parent_id not in dont_collapse and\n parent_id in wrapped_by_id and\n counter < g.max_comment_parent_walk):\n dont_collapse.add(parent_id)\n counter += 1\n\n comment = wrapped_by_id[parent_id]\n parent_id = comment.parent_id\n\n for comment_id in dont_collapse:\n comment = wrapped_by_id[comment_id]\n if comment.collapsed:\n comment.collapsed = False\n comment.hidden = False","def header_children_filter(key, value, format, meta):\n if key == 'Code':\n # Aparently, Pandoc does not like code inside headers. We turn code \n # into plain strings.\n return Emph([Str(value[1])])\n elif key == 'RawInline' and value[0] == 'html':\n return html_inline_filter(value,pandoc_filter.current_file,False)\n else:\n return None","def _get_comment_map(self):\r\n def _visit(obj):\r\n res = []\r\n for child in obj.get('children', []):\r\n res.append((child['id'], child))\r\n if 'children' in child:\r\n res += _visit(child)\r\n return res\r\n return dict(_visit(self.thread))","def get_comment(view, pt):\n\n shell_vars = view.meta_info(\"shellVariables\", pt)\n if not shell_vars:\n return ([], [])\n\n # transform the list of dicts into a single dict\n all_vars = {}\n for v in shell_vars:\n if 'name' in v and 'value' in v:\n all_vars[v['name']] = v['value']\n\n line_comments = []\n block_comments = []\n\n # transform the dict into a single array of valid comments\n suffixes = [\"\"] + [\"_\" + str(i) for i in range(1, 10)]\n for suffix in suffixes:\n start = all_vars.setdefault(\"TM_COMMENT_START\" + suffix)\n end = all_vars.setdefault(\"TM_COMMENT_END\" + suffix)\n\n if start and end is None:\n line_comments.append((start,))\n elif start and end:\n block_comments.append((start, end))\n\n return (line_comments, block_comments)","def parse_comment(self, node):\n\n data = []\n\n if node is not None:\n comment_id_pattern = re.compile('comment-(\\d+)')\n for comment_node in node.find_all('div', class_='comment'):\n item = {}\n item['is_deletable'] = False\n item['is_editable'] = False\n \n comment_id_result = comment_id_pattern.search(comment_node.get('id'))\n if comment_id_result:\n item['id'] = int(comment_id_result.group(1))\n \n comment_body_node = comment_node.find('div', class_='comment-body')\n if comment_body_node is not None:\n item['content'] = ''\n for p in comment_body_node.find_all(recursive=False):\n if 'class' in p.attrs and 'author' in p['class']:\n item['author'] = p.get_text()\n item['profile_url'] = self.get_link(p.get('href'))\n author_id = self._parse_user_id_from_url(item['profile_url'])\n if self.userId == author_id:\n item['is_deletable'] = True\n item['is_editable'] = True\n elif 'class' in p.attrs and 'age' in p['class']:\n item['date'] = p.abbr['title']\n item['date_ago'] = timeago.format(self._parse_datetime(item['date']), datetime.now(TIMEZONE))\n elif 'class' in p.attrs and 'edit' in p['class']:\n continue\n elif p.name == 'form':\n continue\n else:\n item['content'] += str(p)\n\n data.append(item)\n\n return data","def extract_from_comment(self, comment):\n comment = re.sub(r'\\s+', ' ', comment.strip().strip(\"/*\").strip())\n if len(comment) == 0:\n return set(), set()\n domain_terms, code_elements = self.extract_from_sentence(comment)\n return domain_terms, code_elements","def config(self, filter_includes=False):\n def the_filter(k):\n if filter_includes and k is not None and k.lower() == \"include\":\n return False\n else:\n return True\n \n return \"\\n\".join([x.line for x in self.lines_ if the_filter(x.key)])","def get_semeval_content_with_relcomments(element):\n if element.tag == 'OrgQuestion':\n return get_orgquestion_content(element)\n\n if element.tag == 'Thread':\n return ' '.join(chain(\n [get_relquestion_content(element.find('./RelQuestion'))],\n [get_relcomment_content(comment)\n for comment in element.findall('./RelComment')]\n ))\n\n if element.tag == 'RelComment':\n return get_relcomment_content(element)\n\n return None","def parse_lit(self, lines):\n comment_char = \"#\" # TODO: move this into a directive option\n comment = re.compile(r\"^\\s*{}[ \\n]\".format(comment_char))\n section_test = lambda val: bool(comment.match(val))\n\n sections = []\n for is_doc, group in itertools.groupby(lines, section_test):\n if is_doc:\n text = [comment.sub(\"\", i).rstrip(\"\\r\\n\") for i in group]\n else:\n text = [i.rstrip(\"\\r\\n\") for i in group]\n\n sections.append((is_doc, text))\n\n return sections","def _get_review_comments_body(\n self, pull_request_number: int) -> List[Tuple[str, str]]:\n review_comments = get_pull_request_review_comments(\n self._repo_name, pull_request_number, self._auth)\n if not review_comments:\n return []\n review_comments_msg = []\n for comment in review_comments:\n review_comments_msg.append((comment['path'], comment['body']))\n return review_comments_msg","def get_initial_comment_list(self, comment_tree):\n return []","def make_parsed_comments(self):\n if not hasattr(self, 'separated_comments'):\n self.separated_comments = self.separate_comments()\n \n # build comments list of dictionaries, one dictionary for each article\n self.comments = []\n for self.separated_comment in self.separated_comments:\n try:\n comment_data = self.get_comment_data(self.separated_comment)\n self.comments.append(comment_data)\n except Exception as e:\n pass\n return self.comments","def _get_draft_details(request, comments):\n last_key = None\n output = []\n linecache = {} # Maps (c.patch_key, c.left) to mapping (lineno, line)\n modified_patches = []\n fetch_base_failed = False\n\n for c in comments:\n patch = c.patch_key.get()\n if (patch.key, c.left) != last_key:\n url = request.build_absolute_uri(\n reverse(diff, args=[request.issue.key.id(),\n patch.patchset_key.id(),\n patch.filename]))\n output.append('\\n%s\\nFile %s (%s):' % (url, patch.filename,\n c.left and \"left\" or \"right\"))\n last_key = (patch.key, c.left)\n if patch.no_base_file:\n linecache[last_key] = _patchlines2cache(\n patching.ParsePatchToLines(patch.lines), c.left)\n else:\n try:\n if c.left:\n old_lines = patch.get_content().text.splitlines(True)\n linecache[last_key] = dict(enumerate(old_lines, 1))\n else:\n new_lines = patch.get_patched_content().text.splitlines(True)\n linecache[last_key] = dict(enumerate(new_lines, 1))\n except FetchError:\n linecache[last_key] = _patchlines2cache(\n patching.ParsePatchToLines(patch.lines), c.left)\n fetch_base_failed = True\n context = linecache[last_key].get(c.lineno, '').strip()\n url = request.build_absolute_uri(\n '%s#%scode%d' % (reverse(diff, args=[request.issue.key.id(),\n patch.patchset_key.id(),\n patch.filename]),\n c.left and \"old\" or \"new\",\n c.lineno))\n output.append('\\n%s\\n%s:%d: %s\\n%s' % (url, patch.filename, c.lineno,\n context, c.text.rstrip()))\n if modified_patches:\n ndb.put_multi(modified_patches)\n return '\\n'.join(output)","def critic_view(self, m):\n\n if m.group('ins_open'):\n return self._ins(m.group('ins_text'))\n elif m.group('del_open'):\n return self._del(m.group('del_text'))\n elif m.group('sub_open'):\n return (\n self._del(m.group('sub_del_text')) +\n self._ins(m.group('sub_ins_text'))\n )\n elif m.group('mark_open'):\n return self._mark(m.group('mark_text'))\n elif m.group('com_open'):\n return self._comment(m.group('com_text'))","def get_formatted_comments(self, threshold=400):\n comments = IDossier(self).comments\n if comments:\n if threshold:\n comments = truncate_ellipsis(comments, threshold)\n return api.portal.get_tool(name='portal_transforms').convertTo(\n 'text/html', comments, mimetype='text/x-web-intelligent').getData()","def get_initial_comment_list(self, comment_tree):\n comment_tuples = []\n\n if self.link.sticky_comment_id:\n root_level_comments = comment_tree.tree.get(None, [])\n sticky_comment_id = self.link.sticky_comment_id\n if sticky_comment_id in root_level_comments:\n comment_tuples.append(CommentTuple(\n comment_id=sticky_comment_id,\n depth=0,\n parent_id=None,\n num_children=comment_tree.num_children[sticky_comment_id],\n child_ids=comment_tree.tree.get(sticky_comment_id, []),\n ))\n else:\n g.log.warning(\"Non-top-level sticky comment detected on \"\n \"link %r.\", self.link)\n return comment_tuples","def extract_comments(comments_file, output_filename=direc+\"/comments.txt\"):\r\n if not os.path.exists(output_filename.split(\"/\")[0]):\r\n os.makedirs(output_filename.split(\"/\")[0])\r\n\r\n print(\"Extracting comments from \" + comments_file + \"...\")\r\n comments_dict = {}\r\n with open(output_filename, \"w\", encoding=encoding) as f:\r\n current = 0\r\n for event, child in iterparse(comments_file, events=('start', 'end')):\r\n if current > SAMPLE_SIZE:\r\n break\r\n elif len(child.attrib) > 0 and event == \"start\":\r\n if child.attrib['PostId'] not in comments_dict:\r\n comments_dict[child.attrib['PostId']] = []\r\n comments_dict[child.attrib['PostId']].append(child.attrib['Id'])\r\n clean_comment = clean_markdown(child.attrib['Text'])\r\n line = child.attrib['Id'] + \"\\t\" + child.attrib['PostId'] + \"\\t\" + clean_comment + \"\\t\" + child.attrib['Score'] + \"\\n\"\r\n f.write(line)\r\n\r\n current += 1\r\n print_progress(current, SAMPLE_SIZE)\r\n print(\"\\nFinished extracting comments from \" + comments_file + \".\\n\")\r\n return comments_dict","def get_primaries(exclude_group):","def modify_comment_tree(self, comment_tree):\n return comment_tree","def parseComments(data):\n global comments\n reviewBegins = '<div style=\"margin-left:0.5em;\">'\n reviewEnds = '<div style=\"padding-top: 10px; clear: both; width: 100%;\">'\n stars_line = 'margin-right:5px;'\n stars = re.compile('\\d+.\\d+ out of 5 stars')\n header_line = '<span style=\"vertical-align:middle;\"'\n helpful_line ='people found the following review helpful'\n helpful = re.compile('\\d+ of \\d+ people found the following review helpful')\n reviewText = '<span class=\"h3color tiny\">' # Actual review\n\n boundaries = commentsStartStopLineNmbr(data)\n for i in range(boundaries[0], boundaries[1] + 1):\n if reviewBegins in data[i]:\n curcomment = Comment()\n while reviewEnds not in data[i]:\n # Parse stars\n if stars_line in data[i]:\n stars_found = re.search(stars, data[i])\n if stars_found != None:\n curcomment.stars = stars_found.group()\n # Parse header\n elif header_line in data[i]:\n line = data[i]\n begin = line.find('<b>') + 3\n end = line.find('</b>')\n curcomment.header = line[begin : end]\n # Parse helpfulness\n elif helpful_line in data[i]:\n helpful_found = data[i].replace(\",\", \"\")\n helpful_found = re.search(helpful, helpful_found)\n if helpful_found != None:\n curcomment.helpful = helpful_found.group()\n # Parse body text\n elif reviewText in data[i]:\n i += 3\n if '<span class=\"small\"' in data[i]: # Yep, dirty trick :(\n i += 3\n data[i] = stripHtmlTags(data[i])\n curcomment.comment = re.sub(\"\\s+\", \" \", data[i])\n i += 1\n comments.append(curcomment.getonelinecomment())\n #comments.append(curcomment.__repr__())","def cleaning_pipeline(self, tree: dict):\n tree = self.remove_redundant(tree)\n tree[\"selftext\"] = self.clean_text(tree[\"selftext\"])\n tree[\"title\"] = self.clean_text(tree[\"title\"])\n\n empty_comments = []\n for id, comment in tree[\"comments\"].items():\n if \"body\" in comment and \"parent_id\" in comment:\n comment[\"body\"] = self.clean_text(comment[\"body\"])\n comment[\"parent_id\"] = comment[\"parent_id\"][3:]\n else:\n empty_comments.append(id)\n print(\"Skipping empty comment : \", id, tree[\"comments\"][id])\n\n tree = self.resolve_empty_comments(tree, empty_comments)\n\n tree = self.correct_replies(tree)\n\n return tree","def _strip_comments(file_contents):\n lines_without_comments = []\n for line in file_contents:\n comment_position = line.find(COMMENT_INDICATOR)\n if comment_position != -1:\n lines_without_comments.append(line[:comment_position])\n else:\n lines_without_comments.append(line)\n return lines_without_comments","def get_summary(self):\n return self.internal_comments.filter(is_summary=True).order_by('-modified_date').first()","def getAllComments(self):\r\n return [(ind, comment) for ind, comment in enumerate(self.comments)]","def get_lines(self, criteria):\n rootiter = self.store.get_iter_first()\n lines = []\n\n def sub_get_lines(treeiter):\n \"\"\"\n Get the checked children\n \"\"\"\n while treeiter != None:\n tup = self.store[treeiter]\n if criteria(tup):\n lines.append({\n 'jid': tup[0],\n 'country': tup[3],\n 'ip': tup[4]})\n if self.store.iter_has_child(treeiter):\n childiter = self.store.iter_children(treeiter)\n sub_get_lines(childiter)\n treeiter = self.store.iter_next(treeiter)\n sub_get_lines(rootiter)\n return lines","def return_filtered_comments(submission):\n submission.comment_sort = COMMENT_SORT_BY\n submission.comment_limit = COMMENT_LIMIT\n filtered_comments = []\n for top_level_comment in submission.comments:\n if isinstance(top_level_comment, praw.models.MoreComments):\n continue\n # Here you can fetch data off the comment.\n comment = top_level_comment.body\n\n # ensure that the comment does not contain any words in blacklist\n # and also it is less than COMMENT_MAX_WORDS\n fail_test = 0\n lcomment = comment.lower()\n for badword in blacklist:\n if badword not in lcomment and len(comment) < COMMENT_MAX_WORDS:\n pass\n else:\n fail_test += 1\n if not fail_test:\n filtered_comments.append(replace_words(comment).capitalize())\n\n return filtered_comments","def list_content(lines):\n s0 = slices['MAT']\n s1 = slices['MF']\n s2 = slices['MT']\n content = set(((int(l[s0]), int(l[s1]), int(l[s2])) for l in lines))\n\n # remove section delimiters\n for c in content.copy():\n if 0 in c:\n content.discard(c)\n return content","def _get_comment_order(self):\n\n comment_tuples = CommentOrdererBase.get_comment_order(self)\n if not comment_tuples:\n return comment_tuples\n elif isinstance(comment_tuples[-1], MissingChildrenTuple):\n missing_children_tuple = comment_tuples.pop()\n else:\n missing_children_tuple = None\n\n special_responder_ids = self.link.responder_ids\n\n # unfortunately we need to look up all the Comments for QA\n comment_ids = {ct.comment_id for ct in comment_tuples}\n comments_by_id = Comment._byID(comment_ids, data=True)\n\n # figure out which comments will be kept (all others are discarded)\n kept_comment_ids = set()\n for comment_tuple in comment_tuples:\n if comment_tuple.depth == 0:\n kept_comment_ids.add(comment_tuple.comment_id)\n continue\n\n comment = comments_by_id[comment_tuple.comment_id]\n parent = comments_by_id[comment.parent_id] if comment.parent_id else None\n\n if comment.author_id in special_responder_ids:\n kept_comment_ids.add(comment_tuple.comment_id)\n continue\n\n if parent and parent.author_id in special_responder_ids:\n kept_comment_ids.add(comment_tuple.comment_id)\n continue\n\n if hasattr(comment, \"distinguished\") and comment.distinguished != \"no\":\n kept_comment_ids.add(comment_tuple.comment_id)\n continue\n\n # add all ancestors to kept_comment_ids\n for comment_id in sorted(kept_comment_ids):\n # sort the comments so we start with the most root level comments\n comment = comments_by_id[comment_id]\n parent_id = comment.parent_id\n\n counter = 0\n while (parent_id and\n parent_id not in kept_comment_ids and\n counter < g.max_comment_parent_walk):\n kept_comment_ids.add(parent_id)\n counter += 1\n\n comment = comments_by_id[parent_id]\n parent_id = comment.parent_id\n\n # remove all comment tuples that aren't in kept_comment_ids\n comment_tuples = [comment_tuple for comment_tuple in comment_tuples\n if comment_tuple.comment_id in kept_comment_ids\n ]\n\n if missing_children_tuple:\n comment_tuples.append(missing_children_tuple)\n\n return comment_tuples","def flatten_sections_filter_keys(report, key_filter=None):\n allitems = []\n\n if not key_filter:\n def walk_dict(d):\n if isinstance(d, dict):\n for kk in d:\n if isinstance(d[kk], dict):\n walk_dict(d[kk])\n else:\n allitems.append((kk, d[kk]))\n else:\n raise Exception('did not handle this case')\n return\n walk_dict(report.sections)\n\n return allitems\n else:\n def walk_dict(d):\n if isinstance(d, dict):\n for kk in d:\n if isinstance(d[kk], dict):\n walk_dict(d[kk])\n else:\n if key_filter(kk):\n allitems.append((kk, d[kk]))\n else:\n raise Exception('did not handle this case')\n return\n walk_dict(report.sections)\n\n return allitems","def get_all_transform_comments_str(s):\n\n program_lines = s.split(\"\\n\")\n result = []\n\n for i in range(len(program_lines)):\n line = program_lines[i]\n\n if line.lstrip(' ').startswith(\"#transform\"):\n transform_node = get_ast(line).body[0].value\n transform_node.lineno = i + 1\n result.append(transform_node)\n\n return result","def deleteComments(self: Self, event: Event = None) -> None:\n #@+<< deleteComments docstring >>\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\n #@@pagewidth 50\n #@-<< deleteComments docstring >>\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\n #\n # \"Before\" snapshot.\n bunch = u.beforeChangeBody(p)\n #\n # Initial data.\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\n if not lines:\n g.warning('no text selected')\n return\n # The default language in effect at p.\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\n if c.hasAmbiguousLanguage(p):\n language = c.getLanguageAtCursor(p, language)\n d1, d2, d3 = g.set_delims_from_language(language)\n #\n # Calculate the result.\n changed, result = False, []\n if d1:\n # Remove the single-line comment delim in front of each line\n d1b = d1 + ' '\n n1, n1b = len(d1), len(d1b)\n for s in lines:\n i = g.skip_ws(s, 0)\n if g.match(s, i, d1b):\n result.append(s[:i] + s[i + n1b :])\n changed = True\n elif g.match(s, i, d1):\n result.append(s[:i] + s[i + n1 :])\n changed = True\n else:\n result.append(s)\n else:\n # Remove the block comment delimiters from each line.\n n2, n3 = len(d2), len(d3)\n for s in lines:\n i = g.skip_ws(s, 0)\n j = s.find(d3, i + n2)\n if g.match(s, i, d2) and j > -1:\n first = i + n2\n if g.match(s, first, ' '):\n first += 1\n last = j\n if g.match(s, last - 1, ' '):\n last -= 1\n result.append(s[:i] + s[first:last] + s[j + n3 :])\n changed = True\n else:\n result.append(s)\n if not changed:\n return\n #\n # Set p.b and w's text first.\n middle = ''.join(result)\n p.b = head + middle + tail # Sets dirty and changed bits.\n w.setAllText(head + middle + tail)\n #\n # Set the selection range and scroll position.\n i = len(head)\n j = ins = max(i, len(head) + len(middle) - 1)\n w.setSelectionRange(i, j, insert=ins)\n w.setYScrollPosition(oldYview)\n #\n # \"after\" snapshot.\n u.afterChangeBody(p, 'Indent Region', bunch)","def get_annotated_content_infos(course_id, thread, user, user_info):\r\n infos = {}\r\n\r\n def annotate(content):\r\n infos[str(content['id'])] = get_annotated_content_info(course_id, content, user, user_info)\r\n for child in content.get('children', []):\r\n annotate(child)\r\n annotate(thread)\r\n return infos","def _get_issue_comments_body(self, pull_request_number: int) -> List[str]:\n issue_comments = get_pull_request_issue_comments(\n self._repo_name, pull_request_number, self._auth)\n if not issue_comments:\n return []\n issue_comments_msg = []\n for comment in issue_comments:\n issue_comments_msg.append(comment['body'])\n return issue_comments_msg","def get_comments_from_submission_id(submission_id):\n flat_comments = []\n tree_comments = []\n\n submission = (REDDIT.submission(id=submission_id))\n print(submission.num_comments)\n print(submission.shortlink)\n\n # sort comments by best and get the flattened list\n submission.comment_sort = 'confidence'\n\n # tree comments traversal\n submission.comments.replace_more(limit=1)\n for comm in submission.comments.list():\n tree_comments.append(comm)\n\n flat_comments = list(submission.comments)\n\n return flat_comments, tree_comments","def get_node_comments(self, node_id: str) -> Optional[str]:\n comments = []\n\n for pipeline in self.pipelines:\n comment_list = pipeline.comments\n for comment in comment_list:\n associated_node_id_list = comment.get(\"associated_id_refs\", [])\n for ref in associated_node_id_list:\n if ref[\"node_ref\"] == node_id:\n comments.append(comment.get(\"content\", \"\"))\n\n # remove empty (or whitespace-only) comment strings\n comments = [c for c in comments if c.strip()]\n comment_str = \"\\n\\n\".join(comments)\n if not comment_str:\n return None\n\n return comment_str","def _split_into_body_and_options(\n section_content: str,\n) -> Tuple[str, Optional[str], Dict[int, bool]]:\n lines = section_content.strip().splitlines()\n\n skipif_expr = None\n flag_settings = {}\n i = 0\n for line in lines:\n stripped = line.strip()\n if _OPTION_SKIPIF_RE.match(stripped):\n skipif_match = _OPTION_SKIPIF_RE.match(stripped)\n assert skipif_match is not None\n skipif_expr = skipif_match.group(1)\n i += 1\n elif _OPTION_DIRECTIVE_RE.match(stripped):\n directive_match = _OPTION_DIRECTIVE_RE.match(stripped)\n assert directive_match is not None\n option_strings = directive_match.group(1).replace(\",\", \" \").split()\n for option in option_strings:\n if (\n option[0] not in \"+-\"\n or option[1:] not in doctest.OPTIONFLAGS_BY_NAME\n ):\n raise ValueError(f\"doctest has an invalid option {option}\")\n flag = doctest.OPTIONFLAGS_BY_NAME[option[1:]]\n flag_settings[flag] = option[0] == \"+\"\n i += 1\n elif stripped == \":hide:\":\n i += 1\n else:\n break\n\n if i == len(lines):\n raise ValueError(\"no code/output\")\n\n body = \"\\n\".join(lines[i:]).lstrip()\n if not body:\n raise ValueError(\"no code/output\")\n\n if i and lines[i].strip():\n # no newline between option block and body\n raise ValueError(f\"invalid option block: {section_content!r}\")\n\n return body, skipif_expr, flag_settings","def getTopComments(self):\n return self.topComments","def parse_comments_html(advertise: Dict[str, Any]) -> Optional[List[str]]:\n if \"comments_html\" in advertise.keys():\n\n filtred_comments: str = advertise[\"comments_html\"][200::]\n\n tmp: List[str] = re.split(\"[ \\n\\t]{2,}\", filtred_comments)\n if '' in tmp:\n tmp.remove('')\n\n # Breaking comments\n master: List[List[str]] = []\n tmp_vec: List[str] = []\n for line in tmp:\n\n if re.search(\"de \\d{4,}\", line): # matches 'de 2018' that signals the end of comment\n master.append(tmp_vec)\n tmp_vec = []\n else:\n tmp_vec.append(line)\n\n # Cleaning comments\n for comment in master:\n if \"...\" in comment:\n comment.remove(\"...\")\n if \"O usuário contratou o serviço em\" in comment:\n comment.remove(\"O usuário contratou o serviço em\")\n\n return [\" \".join(m) for m in master]","def extractMarkup(text):\n\n groups = []\n indent = None\n buff = []\n comment = None\n i = len(\"'''harbor: \")\n for line in text:\n line = line + ' '\n\n if (line.lstrip())[:i] in [\"'''harbor: \",'\"\"\"harbor: '] and indent == None:\n indent = len(line) - len(line.lstrip())\n comment = (line.lstrip())[:3]\n buff = Markup(line[indent+i:].strip(),[])\n elif line.strip() == comment and indent != None:\n indent = None\n groups.append(buff)\n buff = []\n elif indent != None:\n buff = Markup(buff.dest,buff.contents + [line[indent:]])\n return groups","def read_patch_comments(self) -> dict:\n comment: List[str] = []\n patch_comments = {}\n for line in self.spec_content.section(\"%package\"):\n # An empty line clears the comment lines collected so far.\n if not line.strip():\n comment = []\n # Remember a comment line.\n if line.startswith(\"#\"):\n comment.append(line[1:].strip())\n # Associate comments with patches and clear the comments\n # collected.\n if line.lower().startswith(\"patch\"):\n patch_name = Path(line.split(\":\", 1)[1].strip()).name\n patch_comments[patch_name] = comment\n comment = []\n return patch_comments","def filter_top_section(text):\n head = re.search(r'==.*?==', text)\n idx = head.span(0)[0] if head else len(text)\n return text[:idx] #(text[:idx], text[idx:])","def get_comment_data(self, comment):\n # remove double spaces but not triple ones; we use triple spaces to split commenter and parent_commenter\n pattern = '(?<! ) {2}(?! )'\n comment = re.sub(pattern, ' ', comment).strip() # also strip leading and trailing spaces\n\n # get names\n ix = re.search('•', comment).span()[-1]\n names = [x.strip() for x in (comment[:ix]).strip().strip('•').split(' ')]\n try:\n commenter, parent_commenter = names\n except:\n commenter, parent_commenter = names[0], ''\n\n # handle deleted comments\n pattern = 'This comment was deleted.−+−+'\n commenter = commenter.replace(pattern, '').strip()\n \n # get post and upvotes\n comment_upvotes = comment[ix:].split('ago')[-1].strip(' ')\n ix = re.search('(see more)\\w+', comment_upvotes) # redefine ix as index that separates post message from post upvotes\n clean_comment, upvotes = comment_upvotes[:ix.span()[0]], comment_upvotes[ix.span()[0]:].replace('see more', '')\n\n # build dictionary\n d = dict(zip( ['commenter', 'parent_commenter', 'comment', 'upvotes']\n , [commenter, parent_commenter.strip(), clean_comment.strip(), upvotes.strip()]))\n\n return d","def _parse_data(self):\n current_block = []\n current_section = \"docstring\"\n\n # if we get a line that starts with #, this is a new comment or\n # part of a block comment. Otherwise, it means the current block\n # comment has ended.\n\n for this in self.data:\n # Beginning of a new section at top level\n if self.regex_section.findall(this):\n name = self.regex_section.findall(this)[0]\n current_section = name.strip(\":\")\n self.sections[current_section] = \"\".join(current_block)\n current_block = []\n current_section = None\n elif this.startswith(\"#\"): # a comment at top level\n current_block.append(this)\n elif this.strip() == \"\": # an empty line\n # this was the main comment, or an isolated comment\n current_block = []\n else: # a non-empty line to skip\n current_block = []\n\n for key in self._get_expected_sections():\n if key not in self.sections.keys():\n logger.warning(\"section %s not dealt by the parsing function\" % key)","def split(self, filter):\n split = dict()\n for label, traces in [\n (True, self.acceptedTraces),\n (False, self.rejectedTraces),\n ]:\n split[label] = {True: [], False: [],}\n for trace in traces:\n split[label][bool(filter(trace, label))].append(trace)\n ans = []\n for value in (True, False):\n traces = __class__(\n numVariables=self.numVariables,\n tracesToAccept=split[True][value],\n tracesToReject=split[False][value],\n operators=self.operators,\n depth=self.depthOfSolution,\n possibleSolution=self.possibleSolution,\n )\n ans.append(traces)\n return tuple(ans)","def get_comment_information_by_id(comment_id):\n comment = REDDIT.comment(comment_id)\n print(comment.body)\n print(vars(comment))","def comment_for_run (ins, exp, runnum) :\n return dict_of_recs_for_run(ins, exp, runnum)['comment']","def get_complex_content(data):\n lines = []\n for prop, headline in [('in-reply-to', 'In reply to'),\n ('like-of', 'Liked'),\n ('repost-of', 'Reposted'),\n ('bookmark-of', 'Bookmarked')]:\n for target in get_possible_array_value(data, prop):\n lines.append('<p>{} <a class=\"u-{}\" href=\"{}\">{}</a></p>'.format(\n headline, prop, target, prettify_url(target)))\n\n content = (data.get('content[html]') or data.get('content') or\n data.get('summary'))\n if content:\n lines.append(content)\n\n return '\\n'.join(lines)","def coalesceChunks(self):\n # using StringIO() for better performance\n coalesced1 = StringIO()\n for chunk in self.chunks:\n print(chunk.text, end=\"\", file=coalesced1)\n\n coalesced2 = self.unMarkupCommentsAndStrings(\n coalesced1.getvalue())\n\n return coalesced2","def critic_parse(self, m):\n accept = self.config[\"mode\"] == 'accept'\n if m.group('ins_open'):\n return m.group('ins_text') if accept else ''\n elif m.group('del_open'):\n return '' if accept else m.group('del_text')\n elif m.group('mark_open'):\n return m.group('mark_text')\n elif m.group('com_open'):\n return ''\n elif m.group('sub_open'):\n return m.group('sub_ins_text') if accept else m.group('sub_del_text')","def extract_traces(self):\n for blocks in self._iterate_blocks():\n blocks = [block[\"_source\"][\"number\"] for block in blocks]\n self._extract_traces_chunk(blocks)","def separate_comments(self):\n if not hasattr(self, 'cleaned_html'):\n self.cleaned_html = self.clean_html()\n \n self.separated_comments = self.cleaned_html.split(self.post_splitter)\n return self.separated_comments","def filter_comments(asm_utf):\n comments = []\n # removes nones\n a = filter(lambda x: x != None, asm_utf)\n # splits on comment token\n comments = [re.split(\";\", line) for line in a]\n # takes only those that have a comment token\n comments = list(filter(lambda x: len(x) > 1, comments))\n # strips the whitespace from those tokens\n comments = [line[1].strip() for line in comments]\n # removes the singleton chars\n comments = list(filter(lambda x: len(x) > 1, comments))\n # regex to remove section markers and extraneous tabs\n # left over by poor reading of files\n comments = [re.sub('([-=].*[-=]|\\t)', '', line) for line in comments]\n comments = list(filter(lambda x: x != '', comments))\n return comments","def isolate_relevant_information(self):\n\n def get_formula(oncat_formula):\n \"\"\"will need to go from something like\n \"${value/10e11}`\"\n to something more pythonic\n \"{value/10e11}\"\"\"\n regular_expression = r'\\$(?P<formula>.+)\\`'\n m = re.search(regular_expression, oncat_formula)\n if m:\n return m.group('formula')\n else:\n return \"\"\n\n template_information = {}\n for _index, _element in enumerate(self._oncat_default_template):\n _title = _element[\"name\"]\n _path = _element[\"path\"]\n if \"units\" in _element:\n _units = _element[\"units\"]\n else:\n _units = \"\"\n if \"transform\" in _element:\n _formula = get_formula(_element[\"transform\"])\n else:\n _formula = \"\"\n template_information[_index] = {'title': _title,\n 'path': _path,\n 'units': _units,\n 'formula': _formula}\n self.template_information = template_information","def out(self):\n return {'filenum': self.filenum, 'linenum': self.linenum, 'type': self.ast_type,\n 'source': self.source if self.save_element_source else None}","def _get_multi_line_comment(node):\n return _get_comment_from_node(node)","def getcomments(object):\r\n try:\r\n lines, lnum = findsource(object)\r\n except (IOError, TypeError):\r\n return None\r\n\r\n if ismodule(object):\r\n # Look for a comment block at the top of the file.\r\n start = 0\r\n if lines and lines[0][:2] == '#!': start = 1\r\n while start < len(lines) and string.strip(lines[start]) in ('', '#'):\r\n start = start + 1\r\n if start < len(lines) and lines[start][:1] == '#':\r\n comments = []\r\n end = start\r\n while end < len(lines) and lines[end][:1] == '#':\r\n comments.append(string.expandtabs(lines[end]))\r\n end = end + 1\r\n return string.join(comments, '')\r\n\r\n # Look for a preceding block of comments at the same indentation.\r\n elif lnum > 0:\r\n indent = indentsize(lines[lnum])\r\n end = lnum - 1\r\n if end >= 0 and string.lstrip(lines[end])[:1] == '#' and \\\r\n indentsize(lines[end]) == indent:\r\n comments = [string.lstrip(string.expandtabs(lines[end]))]\r\n if end > 0:\r\n end = end - 1\r\n comment = string.lstrip(string.expandtabs(lines[end]))\r\n while comment[:1] == '#' and indentsize(lines[end]) == indent:\r\n comments[:0] = [comment]\r\n end = end - 1\r\n if end < 0: break\r\n comment = string.lstrip(string.expandtabs(lines[end]))\r\n while comments and string.strip(comments[0]) == '#':\r\n comments[:1] = []\r\n while comments and string.strip(comments[-1]) == '#':\r\n comments[-1:] = []\r\n return string.join(comments, '')","def get_expanded_def_and_includes(self):\n self.expanded_def = {}\n self.includes = {}\n if 'merge' in self.sdef['df'].keys():\n self.process_merge(self.expanded_def, self.sdef['df']['merge'], self.includes)\n self.merge_def(self.expanded_def, self.sdef, self.includes)\n # merge any attributes to self.attributes for later processing\n if 'attributes' in self.expanded_def:\n self.attributes.update(self.expanded_def['attributes'])\n del self.expanded_def['attributes']","def order_lines_layouted(self):\n self.ensure_one()\n report_pages = [[]]\n #print(list(groupby(self.order_line, lambda l: l.layout_category_id)))\n for category, lines in groupby(self.order_line, lambda l: l.layout_category_id):\n\n if report_pages[-1] and report_pages[-1][-1]['pagebreak']:\n report_pages.append([])\n report_pages[-1].append({\n 'parent': category.parent.name,\n 'name': category and category.name or _('Uncategorized'),\n 'subtotal': category and category.subtotal,\n 'pagebreak': category and category.pagebreak,\n 'lines': list(lines)\n })\n\n return report_pages","def pandoc_filter(key, value, format, meta):\n if key == 'Link':\n value[1][0] = process_link_destination(value[1][0], pandoc_filter.current_file)\n if len(value[1][0]) == 0:\n print_warning(\n \"Found empty link ([%s]()) in file [%s]\" % \n (stringify(value[0]), pandoc_filter.current_file)\n )\n # Process link children in AST tree\n value[0] = walk(value[0],pandoc_filter,format,meta)\n return Link(value[0],value[1])\n elif key == 'Image':\n src_image_path = value[1][0]\n value[1][0] = make_image_path_absolute(value[1][0], pandoc_filter.current_file)\n if is_image_broken(value[1][0]):\n print_warning(\n (\n 'Ignoring local image not found [%s] in file [%s]' +\n '- Warning added to PDF'\n ) % (\n unicode(src_image_path).encode('utf-8'),\n unicode(pandoc_filter.current_file).encode('utf-8')\n )\n )\n return RawInline('tex', print_image_not_found(src_image_path.encode('utf-8')))\n else:\n return Image(value[0],value[1])\n elif key == 'Header':\n return header_filter(value,format,meta,pandoc_filter.current_file)\n elif key == 'RawInline' and value[0] == 'html':\n html_filter_result = html_inline_filter(value, pandoc_filter.current_file,True)\n if html_filter_result is not None:\n return html_filter_result\n else:\n file_marker = extract_file_marker(key,value)\n if file_marker is not None:\n pandoc_filter.current_file = file_marker\n return None","def collapsed(self) -> None:","def get_all_transform_comments(a):\n\n return [n for n in find_all(a, ast.Str)\n if n.s.startswith(STR_COMMENT_PREFIX + \"#transform\")]","def lines(filename, exclude_imports=True, exclude_comments=True, exclude_tests=True, exclude_globals=True, exclude_blank=True, verbose=False, is_c=False, s=None):\n if s is None:\n s = open(filename, 'rt').read()\n\n L = s.split('\\n')\n \n # Hack to strip out triple and single quote string lines in a heuristic (unreliable) way, which avoids parsing Cython\n if not is_c:\n for i in range(len(L)):\n if L[i].strip().startswith(\"'\") and L[i].strip().endswith(\"'\"):\n L[i] = ''\n i = 0\n while i < len(L):\n found = False\n for triple_quote in ['\"\"\"', \"'''\"]:\n if L[i].strip().startswith(triple_quote):\n L[i] = L[i].strip()[3:]\n for j in range(i, len(L)):\n if triple_quote in L[j]:\n found = True\n L[j] = ''\n if found:\n break\n i = j+1\n if not found:\n i += 1\n else:\n begin_comment = '/*'\n end_comment = '*/'\n i = 0\n while i < len(L):\n found = False\n if begin_comment in L[i]:\n rest = L[i][L[i].index(begin_comment)+len(begin_comment):]\n L[i] = L[i][:L[i].index(begin_comment)]\n if end_comment in rest:\n found = True\n i += 1\n else:\n for j in range(i+1, len(L)):\n if end_comment in L[j]:\n found = True\n L[j] = L[j][L[j].index(end_comment)+len(end_comment):]\n else:\n L[j] = ''\n if found:\n break\n i = j + 1\n if not found:\n i += 1\n\n# util.print_header('Lines before exclude_tests:' + filename, '\\n'.join(L))\n\n # Hack to strip out def test() and other methods in a heuristic (unreliable) way, which avoids parsing Cython\n if exclude_tests:\n # Also exclude makeColorMatrix so that our camera pipe is apples-to-apples comparable with reported lines in Halide paper\n if not is_c:\n methods = 'test run_test_all mandelbrot_gray mandelbrot_color composite_numpy composite_numexpr makeColorMatrix'.split()\n else:\n methods = ['int main', 'void main']\n i = 0\n while i < len(L):\n L_i_strip = L[i].strip()\n if ((not is_c and (any(L_i_strip.startswith('def ' + method) for method in methods) or\n any(L_i_strip.startswith('cdef ' + method) for method in methods))) or\n (is_c and (any(L_i_strip.startswith(method) for method in methods)))):\n L[i] = ''\n for j in range(i+1, len(L)):\n L_j_strip = L[j].strip()\n c_ok = True\n if is_c:\n c_ok = L_j_strip != '{' and L_j_strip != '}'\n if not L[j].startswith(' ') and not L[j].startswith('\\t') and not len(L[j].strip()) == 0 and c_ok:\n break\n else:\n L[j] = ''\n i = j\n elif (L[i].strip().startswith('test(') or L[i].strip().startswith('run_test_all(')) and not is_c:\n L[i] = ''\n i += 1\n else:\n i += 1\n\n# util.print_header('Lines before exclude_imports:' + filename, '\\n'.join(L))\n if exclude_imports:\n if not is_c:\n L = [x for x in L if not x.lstrip().startswith('import') and not x.lstrip().startswith('cimport') and not x.startswith('cdef extern')]\n else:\n L = [x for x in L if not x.lstrip().startswith('#include')]\n# util.print_header('Lines before exclude_comments:' + filename, '\\n'.join(L))\n if exclude_comments:\n if not is_c:\n L = [x for x in L if not x.lstrip().startswith('#') and not x.strip() == 'pass']\n else:\n L = [x for x in L if not x.lstrip().startswith('//')]\n# util.print_header('Lines before exclude_globals:' + filename, '\\n'.join(L))\n if exclude_globals and not is_c:\n L = [x for x in L if (x.startswith(' ') or x.startswith('\\t') or x.startswith('def') or x.startswith('cdef')) and (not x.lstrip().startswith('has_'))]\n# util.print_header('Lines before exclude_blank:' + filename, '\\n'.join(L))\n\n if is_c:\n # Also exclude makeColorMatrix so that C camera pipe is apples-to-apples comparable with reported lines in Halide paper\n L = [x for x in L if not x.lstrip().startswith('matrix_3200') and not x.lstrip().startswith('matrix_7000')]\n if exclude_blank:\n L = [x for x in L if not len(x.strip()) == 0]\n\n if verbose:\n util.print_header('Final lines for:' + filename, '\\n'.join(L))\n\n return len(L)","def test_get_comments():\n comments = list(get_comments(TEST_SUBREDDIT, TEST_START_DATE, TEST_END_DATE, TEST_MAX))\n\n # prints the dictionary of variables for each comment\n for x in comments:\n print(x.d_)","def content(self):\n K = self.domain\n elements, _ = self.to_flat_nz()\n return dup_content(elements, K)","def find_obs_request_comment(self, request_id=None, project_name=None):\n if self.do_comments:\n comments = self.commentapi.get_comments(request_id=request_id, project_name=project_name)\n for c in comments.values():\n m = comment_marker_re.match(c['comment'])\n if m:\n return {\n 'id': c['id'],\n 'state': m.group('state'),\n 'result': m.group('result'),\n 'comment': c['comment'],\n 'revision': m.group('revision')}\n return {}","def unMarkupCommentsAndStrings(self, content):\n\n def replaceMarkups(match):\n groupdict = match.groupdict()\n if groupdict[\"str\"] is not None:\n return self.strings[int(match.group(\"str\"))]\n elif groupdict[\"comment\"] is not None:\n return self.comments[int(match.group(\"comment\"))]\n else:\n assert False\n\n unMarkedup = markups.sub(replaceMarkups, content)\n\n return unMarkedup","def comments(self):\n return self.container['comments']","def filter_lines(lines, filter_regex, groups=None):\n pattern = re.compile(filter_regex)\n for line in lines:\n match = pattern.search(line)\n if match:\n if groups is None:\n yield line\n elif len(groups) == 1:\n yield match.group(groups[0])\n else:\n matched_groups = match.groupdict()\n yield tuple(matched_groups.get(group) for group in groups)","def process_all(self):\n global multi_comment_line_mode\n multi_comment_line_mode = False\n for line in self.fileToProcess:\n line = line.strip() # creating a strip line, with no whitespace in the beginning and in the end\n # multi_comment_line_mode = False\n # first, we want to filter all the lines which are comments or part of comments\n while line != '':\n ignoring_status,newline = self.shouldTheLineBeIgnored(line)\n if ignoring_status:\n break # we are ignoring the line\n elif (not ignoring_status) and (newline != '') and newline != '$endOfMultiLine':\n line = newline\n continue\n elif not ignoring_status and newline == '$endOfMultiLine':\n break\n else:\n line = self.isThereApartToIgnore(line) #getting the good line\n line = line.strip()\n if line.endswith('$endOfMultiLine'):\n # line = line[:-1]\n line = line[:-15]\n # in this case we don't want to ignore the current line\n # if multi_comment_line_mode:\n # # this comes from the\n list_of_line_strings = re.split('(\\W)', line) # the default of this method is to remove all the white spaces\n list_of_line_strings = list(filter(None, list_of_line_strings))\n global i\n i = 0\n global first_index\n first_index = 0\n global second_index\n second_index = 0\n len_of_list = len(list_of_line_strings)\n while i < len_of_list:\n # first adding the string literals\n if (list_of_line_strings[i] == '\"' and i == 0) or (i>0 and list_of_line_strings[i] == '\"' and\n list_of_line_strings[i-1]!='*'):\n first_index = i\n i = i + 1\n if i == len(list_of_line_strings):\n break\n while list_of_line_strings[i] != '\"':\n i = i + 1\n if i>=len(list_of_line_strings):\n # in case it's the end\n i = first_index\n break\n else:\n continue\n second_index = i\n list_of_line_strings[first_index:second_index + 1] = [\n ''.join(list_of_line_strings[first_index:second_index + 1])]\n i = i + 2\n len_of_list = len(list_of_line_strings)\n else:\n i = i + 1\n j=0\n global skip_mode\n skip_mode = False\n global counter\n counter = 0\n for string in list_of_line_strings:\n if j != len(list_of_line_strings)-1:\n j+=1\n if counter == 1:\n counter = 0\n continue\n if skip_mode and not (string == '*' and list_of_line_strings[j] == '/'):\n continue\n if skip_mode and string == '*' and list_of_line_strings[j] == '/':\n skip_mode = False\n counter = 1\n continue\n if string == \"/\" and (list_of_line_strings[j] == \"/\" ):\n # this is a comment that appeared in the line\n break # in this case, there are no more chars to read because it's a note\n if string == \"/\" and list_of_line_strings[j] == \"*\":\n skip_mode = True\n counter = 1\n continue # entering a skip mode\n if string.strip() == '':\n continue\n self.currStringToProcess = string\n type = self.tokenType()\n self.createToken(type,self.currStringToProcess)\n break","def get_content(self):\r\n content = []\r\n for regiongroup in self.region_groups:\r\n for region in regiongroup.get_content():\r\n # Add date, unique_name and project to the metadata\r\n region[0]['date'] = self.extracted_date\r\n region[0]['unique_name'] = self.unique_name\r\n try:\r\n project = os.path.split(\r\n os.path.split(self.unique_name)[0]\r\n )[1]\r\n except IndexError:\r\n project = ''\r\n region[0]['project'] = project\r\n content.append(region)\r\n return content","def get_comments(self,comments):\n all_comments = []\n for comment in comments:\n try :\n all_comments.append({\n 'comment':comment['data']['body'],\n 'score':comment['data']['score']\n })\n except: pass\n return all_comments","def _get_comment_from_node(node):\n\n def _remove_non_comment_ending(lines):\n for index, line in enumerate(lines):\n if not line.strip().startswith(\"#\"):\n return lines[:index]\n\n return lines # pragma: no cover\n\n def _replace_newlines(match):\n newlines = match.group(\"newlines\") or \"\"\n\n if len(newlines) < 2:\n return \" \"\n\n return newlines[:-1] # Remove one newline\n\n code = node.get_code()\n lines = _remove_beginning_newlines(code.split(\"\\n\"))\n lines = _remove_non_comment_ending(lines)\n matches = [_COMMENT_EXPRESSION.match(line).group(\"text\") for line in lines]\n\n if not matches:\n return \"\"\n\n clean_comment = \"\\n\".join(matches).strip(\"\\n\")\n unindented_comment = textwrap.dedent(clean_comment)\n collapsed_comment = _MULTIPLE_NEWLINE_MATCH.sub(\n _replace_newlines, unindented_comment\n )\n\n return collapsed_comment","def read_comment(comment):\n comment_dict = {}\n\n debug(\"parse tab in comment.\")\n comment_dict_from_tab, comment = parse_tab_in_comment(comment)\n debug(\"parsed dict: %s.\" % comment_dict_from_tab)\n comment_dict.update(comment_dict_from_tab)\n\n debug(\"parse space in comment.\")\n comment_dict_from_space, comment = parse_space_in_comment(comment)\n debug(\"parsed dict: %s.\" % comment_dict_from_space)\n comment_dict.update(comment_dict_from_space)\n\n debug(\"parse keyword in comment.\")\n comment_dict_from_keyword, comment = parse_keyword_in_comment(comment)\n debug(\"parsed dict: %s.\" % comment_dict_from_keyword)\n comment_dict.update(comment_dict_from_keyword)\n # keyword based separation.\n return comment_dict","def filter_lines(view_lines):\n\n # this still doesn't work because we need to filter xml above the line level\n # do newlines from the server ever contain meaningful data or are they pointless?\n # is all the newline data given by a terminating xml-type tag?\n\n # filter lines that start with an exclude string - non-regex\n excludes = ['<prompt time=\"']\n for exclude in excludes:\n view_lines = [line for line in view_lines if line[0 : len(exclude)] != exclude]\n\n # first lets just rip out the xml... later we will want to process it back into the stream\n # mostly we can use the xml just to update the state, if that's the case then if we miss\n # one then it's no proble, we just catch the next one... provided they are regular enough.\n # if they are not, or set state once, then we definitely want to catch every one\n xml_free_lines = list()\n for line in view_lines:\n\n # assuming lines only have xml if they start with xml? interesting idea, not sure if real\n i = 0\n xml_free_line_segments = list()\n xml_line_segments = list()\n xml_free_line_part = b\"\"\n xml_line_part = b\"\"\n ordered_parsed_line = list() # give a tuple of string, type\n\n # ISSUE: i'm pretty sure this is dropping a letter off the first non-xml line segment (or more)\n # make a bunch of line segments\n # note that line is a bytes() type, indexing line[i] returns int\n # if we slice into it line[i:i+1] we get a bytes() type of length 1\n while i < len(line):\n\n if line[i : i + 1] != b\"<\":\n xml_free_line_part += line[i : i + 1]\n\n else:\n\n # increment until you get out of the xml tag or out of the line\n while i < len(line) and line[i : i + 1] != b\">\":\n xml_line_part += line[i : i + 1]\n i += 1\n\n # toss the last b'>' on the end!\n xml_line_part += line[i : i + 1]\n\n # store the xml part off\n xml_line_segments.append(xml_line_part)\n ordered_parsed_line.append((\"xml\", xml_line_part))\n xml_line_part = b\"\" # reset the xml part\n\n # store xml free part off\n if len(xml_free_line_part) > 1:\n xml_free_line_segments.append(xml_free_line_part)\n ordered_parsed_line.append((\"text\", xml_free_line_part))\n xml_free_line_part = b\"\" # reset the xml_free_line_part\n\n i += 1 # covers incrementing past the '>' and incrementing if not yet in a '<'\n\n \"\"\"\n # https://lxml.de/tutorial.html\n # if the xml cannot be parsed, we just want to catch it and decide what to do\n try:\n xml = [lxml.etree.XML(xml_line) for xml_line in xml_line_segments]\n xml_tags = [x.tag for x in xml]\n # just testing lxml tag parsing\n if b'streamWindow' in xml_tags:\n xml_free_lines.append(b'streamWindow skipped...')\n\n except lxml.etree.XMLSyntaxError:\n xml = list() # no tags\n # toss any failing XML onto the text stream for manual parsing?\n # we can follow this approach even if we replace or wrap lxml with a manual parser\n xml_free_lines.extend(xml_line_segments)\n \"\"\"\n # do stuff with the xml components of the line\n op_line = ordered_parsed_line\n\n # strip the line back down to text\n clean_line = [x[1].replace(b\">\", b\">\") for x in op_line if x[0] == \"text\"]\n xml_free_lines.append(b\"\".join(clean_line))\n\n # send a hunk of xml so we can see what happened\n xml_line = [x[1].replace(b\">\", b\">\") for x in op_line if x[0] == \"xml\"]\n xml_free_lines.append(b\"\".join(xml_line))\n\n # just point it here for now so we don't have to change the return\n view_lines = xml_free_lines\n\n \"\"\"\n EXCLUDES = [\n r'<prompt.*>',\n r'</prompt.*>',\n ]\n\n SUBS = [\n (r'<.*>', ''),\n ]\n\n # drop empty lines before the regex to save processing\n # what about lines with whitespace only...\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\n\n for exclude in EXCLUDES:\n view_lines = [str(line) for line in view_lines if not re.search(exclude, str(line))]\n\n for expr, sub in SUBS:\n view_lines = [re.sub(expr, sub, str(line)) for line in view_lines]\n\n # drop empty lines after the regex so they aren't shown\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\n \"\"\"\n\n return view_lines","def _get_skipped_lines_response(rows, id_before, id_after, where, context):\n response_rows = []\n id_before_start = int(id_before)\n id_after_end = int(id_after)\n if context is not None:\n id_before_end = id_before_start+context\n id_after_start = id_after_end-context\n else:\n id_before_end = id_after_start = None\n\n for row in rows:\n m = re.match('^<tr( name=\"hook\")? id=\"pair-(?P<rowcount>\\d+)\">', row)\n if m:\n curr_id = int(m.groupdict().get(\"rowcount\"))\n # expand below marker line\n if (where == 'b'\n and curr_id > id_after_start and curr_id <= id_after_end):\n response_rows.append(row)\n # expand above marker line\n elif (where == 't'\n and curr_id >= id_before_start and curr_id < id_before_end):\n response_rows.append(row)\n # expand all skipped lines\n elif (where == 'a'\n and curr_id >= id_before_start and curr_id <= id_after_end):\n response_rows.append(row)\n if context is not None and len(response_rows) >= 2*context:\n break\n\n # Create a usable structure for the JS part\n response = []\n response_rows = [_strip_invalid_xml(r) for r in response_rows]\n dom = ElementTree.parse(StringIO('<div>%s</div>' % \"\".join(response_rows)))\n for node in dom.getroot().getchildren():\n content = [[x.items(), x.text] for x in node.getchildren()]\n response.append([node.items(), content])\n return response","def _get_skipped_lines_response(rows, id_before, id_after, where, context):\n response_rows = []\n id_before_start = int(id_before)\n id_after_end = int(id_after)\n if context is not None:\n id_before_end = id_before_start+context\n id_after_start = id_after_end-context\n else:\n id_before_end = id_after_start = None\n\n for row in rows:\n m = re.match('^<tr( name=\"hook\")? id=\"pair-(?P<rowcount>\\d+)\">', row)\n if m:\n curr_id = int(m.groupdict().get(\"rowcount\"))\n # expand below marker line\n if (where == 'b'\n and curr_id > id_after_start and curr_id <= id_after_end):\n response_rows.append(row)\n # expand above marker line\n elif (where == 't'\n and curr_id >= id_before_start and curr_id < id_before_end):\n response_rows.append(row)\n # expand all skipped lines\n elif (where == 'a'\n and curr_id >= id_before_start and curr_id <= id_after_end):\n response_rows.append(row)\n if context is not None and len(response_rows) >= 2*context:\n break\n\n # Create a usable structure for the JS part\n response = []\n response_rows = [_strip_invalid_xml(r) for r in response_rows]\n dom = ElementTree.parse(StringIO('<div>%s</div>' % \"\".join(response_rows)))\n for node in dom.getroot().getchildren():\n content = [[x.items(), x.text] for x in node.getchildren()]\n response.append([node.items(), content])\n return response","def common_context_transformer(row_content):\n return {\n 'Action': row_content.get('action', {}).get('value'),\n 'App': row_content.get('app'),\n 'Protocol': row_content.get('protocol', {}).get('value'),\n 'DestinationIP': row_content.get('dest_ip', {}).get('value'),\n 'RuleMatched': row_content.get('rule_matched'),\n 'CharacteristicOfApp': row_content.get('characteristics_of_app'),\n 'LogSourceName': row_content.get('log_source_name'),\n 'IsNat': row_content.get('is_nat'),\n 'NatDestinationPort': row_content.get('nat_dest_port'),\n 'NatDestination': row_content.get('nat_dest', {}).get('value'),\n 'NatSource': row_content.get('nat_source', {}).get('value'),\n 'SourceIP': row_content.get('source_ip', {}).get('value'),\n 'AppCategory': row_content.get('app_category'),\n 'SourceLocation': row_content.get('source_location'),\n 'DestinationLocation': row_content.get('dest_location'),\n 'FileSHA256': row_content.get('file_sha_256'),\n 'FileName': row_content.get('file_name'),\n 'TimeGenerated': human_readable_time_from_epoch_time(row_content.get('time_generated', 0))\n }","def process_level_1(content):\n\tsoup = BeautifulSoup(content, features=\"html.parser\")\n\n\t#r = soup.findAll('div',{\"class\":\"listing-item__content\"})\n\tr = soup.findAll('div',{\"class\":\"listing-item search-listing-result__item\"})\n\tres=list()\n\t# extract information from the source code if the page \n\tfor i in r:\n\t\tlisting_id = str(i)[str(i).index('data-wa-data=\"')+len(\"data-wa-data=\")+1:str(i).index(\"|source=listings_results\")+len(\"|source=listings_results\")]\n\t\ttype_area = i.find('div',{'class':'listing-characteristic margin-bottom'}).text\n\t\tprice = i.find(\"div\",{\"class\":\"listing-price margin-bottom\"}).text\n\t\tpalce = i.find(\"div\",{\"class\":\"text--muted text--small\"}).text\n\t\tres.append({\"id_\":listing_id,\n\t\t \"area\":type_area,\n\t\t \"price\":price,\n\t\t \"place\":palce})\n\treturn res","def _extract_comment_values(line, status, comment, sources):\n \n line = line.strip( )\n\n if len(line) > 1:\n if line[1] == ':':\n sources = re.split(',[\\s]*', line[2:].strip( ))\n elif line[1] == '.':\n comment = line[2:].strip( )\n elif line[1] == ',':\n flags = re.split(',[\\s]*', line[2:].strip( ))\n if not 'fuzzy' in flags:\n status = store.STATUS_COMPLETE\n \n return status, comment, sources","def _get_file_content(realpath, ignore_undocumented=False):\n\n result = \"\"\"<h2>Module: %s</h2>\n <div class=\"alert alert-info\">\n <div style = \"details\">path: %s</div>\n <div style = \"details\">created: %s, last modified: %s</div></div>\"\"\" %(\n os.path.basename(realpath),\n urlparse.unquote(_convert_path_to_url(realpath)),\n time.ctime(os.path.getmtime(realpath)),\n time.ctime(os.path.getctime(realpath))\n )\n with open(realpath) as sourcefile:\n code = sourcefile.readlines()\n abstract_syntax_tree = ast.parse(''.join(code))\n description = ast.get_docstring(abstract_syntax_tree)\n if description:\n result += \"<h3>Summary:</h3> <div style = 'summary'>%s</div>\" % _convert_str_to_html(description)\n visitor = DocVisitor()\n visitor.visit(abstract_syntax_tree)\n parsed_code = visitor.get_doc()\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\n for entry in entries:\n if ignore_undocumented is False or entry.get(\"description\"):\n begin, end = entry.get(\"lines\")\n result += '<hr /><div><pre>' + \"\".join(code[begin:end]).rstrip().rstrip(\":\") +\"</pre>\"\n result += _convert_str_to_html(entry.get(\"description\"))+\"</div>\"\n\n return result","def get_comment_order(self):\n\n with g.stats.get_timer('comment_tree.get.1') as comment_tree_timer:\n comment_tree = CommentTree.by_link(self.link, comment_tree_timer)\n sort_name = self.sort.col\n sorter = get_comment_scores(\n self.link, sort_name, comment_tree.cids, comment_tree_timer)\n comment_tree_timer.intermediate('get_scores')\n\n if isinstance(self.sort, operators.shuffled):\n # randomize the scores of top level comments\n top_level_ids = comment_tree.tree.get(None, [])\n top_level_scores = [\n sorter[comment_id] for comment_id in top_level_ids]\n shuffle(top_level_scores)\n for i, comment_id in enumerate(top_level_ids):\n sorter[comment_id] = top_level_scores[i]\n\n self.timer.intermediate(\"load_storage\")\n\n comment_tree = self.modify_comment_tree(comment_tree)\n self.timer.intermediate(\"modify_comment_tree\")\n\n initial_candidates, offset_depth = self.get_initial_candidates(comment_tree)\n\n comment_tuples = self.get_initial_comment_list(comment_tree)\n if comment_tuples:\n # some comments have bypassed the sorting/inserting process, remove\n # them from `initial_candidates` so they won't be inserted again\n comment_tuple_ids = {\n comment_tuple.comment_id for comment_tuple in comment_tuples}\n initial_candidates = [\n comment_id for comment_id in initial_candidates\n if comment_id not in comment_tuple_ids\n ]\n\n candidates = []\n self.update_candidates(candidates, sorter, initial_candidates)\n self.timer.intermediate(\"pick_candidates\")\n\n # choose which comments to show\n while candidates and len(comment_tuples) < self.max_comments:\n sort_val, comment_id = heapq.heappop(candidates)\n if comment_id not in comment_tree.cids:\n continue\n\n comment_depth = comment_tree.depth[comment_id] - offset_depth\n if comment_depth >= self.max_depth:\n continue\n\n child_ids = comment_tree.tree.get(comment_id, [])\n\n comment_tuples.append(CommentTuple(\n comment_id=comment_id,\n depth=comment_depth,\n parent_id=comment_tree.parents[comment_id],\n num_children=comment_tree.num_children[comment_id],\n child_ids=child_ids,\n ))\n\n child_depth = comment_depth + 1\n if child_depth < self.max_depth:\n self.update_candidates(candidates, sorter, child_ids)\n\n self.timer.intermediate(\"pick_comments\")\n\n # add all not-selected top level comments to the comment_tuples list\n # so we can make MoreChildren for them later\n top_level_not_visible = {\n comment_id for sort_val, comment_id in candidates\n if comment_tree.depth.get(comment_id, 0) - offset_depth == 0\n }\n\n if top_level_not_visible:\n num_children_not_visible = sum(\n 1 + comment_tree.num_children[comment_id]\n for comment_id in top_level_not_visible\n )\n comment_tuples.append(MissingChildrenTuple(\n num_children=num_children_not_visible,\n child_ids=top_level_not_visible,\n ))\n\n self.timer.intermediate(\"handle_morechildren\")\n return comment_tuples","def _get_comments(self):\n if not hasattr(self, 'id'):\n raise BadReference('No matching issue on disk')\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))","def get_changes_metadata(docx):\n with zipfile.ZipFile(docx, mode='r') as docxzipfile:\n with docxzipfile.open(doc_filename) as docfile, \\\n docxzipfile.open(comments_filename) as commentfile:\n return sorted(\n itertools.chain(\n (('change', author, date) for (author, date) in _get_changes_metadata(etree.parse(docfile))),\n (('comment', author, date) for (author, date) in _get_changes_metadata(etree.parse(commentfile)))),\n key=lambda m: m[2]) # sort by date","def extract_censored_tb(tb, limit=None):\n # [3:] drops the top frames (which are Halp internals).\n items = traceback.extract_tb(tb, limit)[3:]\n if items and current_line_number:\n # The top item came from a '## ' line; fix its line number:\n filename, lineno, func_name, text = items[0]\n if filename == '<string>' and lineno == 1: # (should always be true)\n items[0] = filename, current_line_number, func_name, None\n return items","def tool_panel_contents( self, trans, **kwds ):\n filter_method = self._build_filter_method( trans )\n for _, item_type, elt in self._tool_panel.panel_items_iter():\n elt = filter_method( elt, item_type )\n if elt:\n yield elt","def comments(self) -> list:\n return self._node[\"app_data\"][\"ui_data\"].get(\"comments\", [])","def process_body(line):\n fields = line.split('\\t') # preserves newline\n infos = fields[7].split(';')\n\n whitelisted = [\n info for info in infos\n if any(\n info.startswith(x + '=') or info == x\n for x in WHITELISTED_ANNOTATIONS\n )\n ]\n\n fields[7] = ';'.join(whitelisted)\n return '\\t'.join(fields)","def calc_claim_content(doc, cfg):\n full_content = doc.get('title', '') + '\\n\\n' + doc.get('content', '')\n hl_fact_fields = [f for f in doc if is_fact_tax_hl_field(f)]\n ent_index = index_ent_spans(doc)\n logger.debug('Found %s entity spans in doc' % len(ent_index))\n result = [{\n 'fact_field': hl_span['field'],\n 'value': hl_span['value'],\n **extract_content(full_content, hl_span['span'], ent_index, cfg)\n }\n for hl_span in gen_hl_spans(doc, hl_fact_fields)]\n # for field in hl_fact_fields:\n # for hl_val in doc[field]:\n # items = hl_val.split('|')\n # item, hls = items[0], items[1:]\n # for hl in hls:\n # beg, end = hl.split('-')\n # result.append({\n # 'fact_field': field,\n # 'value': item,\n # 'content': full_content[int(beg):int(end)+1]\n # })\n return result","def header_filter(value,format,meta,markdown_filepath):\n anchor_id_prefix = slugify_string(markdown_filepath)\n\n # Generate a LaTeX anchor fo the header\n latex_anchor = generate_latex_label(make_header_id_unique(generate_pandoc_header_slug(markdown_filepath, stringify(value[2])), header_filter.used_ids))\n\n # Process header children using the right filter.\n header_content = walk(value[2], header_children_filter, format, meta)\n\n # Replace the old header with a new one with its children processed and\n # an added LaTeX anchor.\n return Header(\n value[0], \n value[1], \n header_content + [RawInline('tex',latex_anchor)]\n )","def _collapse_all(self):\n# global approved, conflicts, suggestions, unknown, cldr\n self.tree.item('approved', open=False, \\\n values=[self._count_children('approved'), ''])\n for child in self.tree.get_children('approved'):\n self.tree.item(child, tags='approved')\n\n self.tree.item('conflicts', open=False, \\\n values=[self._count_children('conflicts'), ''])\n for child in self.tree.get_children('conflicts'):\n self.tree.item(child, tags='conflicts')\n self.tree.item(child, open=False)\n for granchild in self.tree.get_children(child):\n self.tree.item(granchild, tags='conflicts',)\n \n self.tree.item('suggestions', open=False, \\\n values=[self._count_children('suggestions'), ''])\n for child in self.tree.get_children('suggestions'):\n self.tree.item(child, tags='suggestions')\n self.tree.item(child, open=False)\n for granchild in self.tree.get_children(child):\n self.tree.item(granchild, tags='suggestions')\n\n self.tree.item('unknown', open=False, \\\n values=[self._count_children('unknown'), ''])\n for child in self.tree.get_children('unknown'):\n self.tree.item(child, tags='unknown')\n self.tree.item(child, open=False)\n for granchild in self.tree.get_children(child):\n self.tree.item(granchild, tags='unknown')\n\n self.tree.item('cldr', open=False, \\\n values=[self._count_children('cldr'), ''])\n for child in self.tree.get_children('cldr'):\n self.tree.item(child, tags='cldr')\n self.tree.item(child, open=False)\n for granchild in self.tree.get_children(child):\n self.tree.item(granchild, tags='cldr')\n\n self.tree.tag_configure('approved', background='palegreen')\n self.tree.tag_configure('conflict', background='bisque')\n self.tree.tag_configure('suggestions', background='lightblue')\n self.tree.tag_configure('unknown', background='whitesmoke')\n self.tree.tag_configure('cldr', background='violet')","def option_parse_comments(self):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionParseComments/')))","def create_clean_content(self):\n clean_content = []\n searched_unique_single_word = []\n un_searched_unique_single_word = []\n searched_pair_word = []\n searched_unique_single_word_synonym = []\n\n for i in range(self.subhead.shape[0]):\n clean_content.append(\n self.filter_stop_words(self.subhead.Col7[i], self.stop_words)\n )\n searched_unique_single_word.append(\n self.get_searched_unique_single_word(\n self.subhead.Col7[i], self.stop_words\n )\n )\n un_searched_unique_single_word.append(\n self.get_un_searched_single_word(self.subhead.Col7[i], self.stop_words)\n )\n searched_pair_word.append(\n self.get_searched_paired_word(self.subhead.Col7[i], self.stop_words)\n )\n searched_unique_single_word_synonym.append(\n self.get_searched_single_word_synonym(\n self.subhead.Col7[i], self.stop_words\n )\n )\n\n self.subhead[\"clean_content\"] = clean_content\n self.subhead[\"searched_unique_single_word\"] = searched_unique_single_word\n self.subhead[\"un_searched_unique_single_word\"] = un_searched_unique_single_word\n self.subhead[\"searched_pair_word\"] = searched_pair_word\n self.subhead[\n \"searched_unique_single_word_synonym\"\n ] = searched_unique_single_word_synonym","def get_remark(self, number):\n CONTENT_START_COLUMN = 11\n\n # in case a non-integer is accidentally given\n number = int(number)\n if number < 0 or number > 999:\n raise ValueError(\"The number must be in range 0-999\")\n \n remark_string = f\"REMARK {number:>3d}\"\n # Find lines and omit ``REMARK XXX `` part\n remark_lines = [\n line[CONTENT_START_COLUMN:] for line in self.lines\n if line.startswith(remark_string)\n ]\n if len(remark_lines) == 0:\n return None\n # Remove first empty line\n remark_lines = remark_lines[1:]\n return remark_lines","def extract_comments(self, response):\n\n # use the comment_parser package to extract HTML and JS comments\n try:\n html_comments = comment_parser.extract_comments_from_str(response.text, mime=\"text/html\")\n except (UnterminatedCommentError, CP_ParseError):\n html_comments = []\n try:\n js_comments = comment_parser.extract_comments_from_str(response.text, mime=\"application/javascript\")\n except (UnterminatedCommentError, CP_ParseError):\n js_comments = []\n\n # put the discovered comments together\n comments = list()\n for comment in html_comments:\n comments.append({\"line\": comment.line_number(), \"comment\": \"<!--\" + comment.text() + \"-->\"})\n for comment in js_comments:\n if comment.is_multiline():\n comments.append({\"line\": comment.line_number(), \"comment\": \"/*\" + comment.text() + \"*/\"})\n else:\n comments.append({\"line\": comment.line_number(), \"comment\": \"//\" + comment.text()})\n\n # store the discovered comments w.r.t. the response's path & query\n if comments:\n parsed_url = urllib.parse.urlparse(response.url)\n if self.config[\"crawl_parameter_links\"].lower() == \"true\":\n self.comments[parsed_url.path + parsed_url.query] = comments\n else:\n self.comments[parsed_url.path] = comments","def _comments(self) -> List[\"BaseSegment\"]:\n return [seg for seg in self.segments if seg.is_type(\"comment\")]","def get_documented_in_lines(lines, module=None, filename=None):\n title_underline_re = re.compile(\"^[-=*_^#]{3,}\\s*$\")\n autodoc_re = re.compile(\".. auto(function|method|attribute|class|exception|module)::\\s*([A-Za-z0-9_.]+)\\s*$\")\n autosummary_re = re.compile(r'^\\.\\.\\s+autosummary::\\s*')\n module_re = re.compile(r'^\\.\\.\\s+(current)?module::\\s*([a-zA-Z0-9_.]+)\\s*$')\n autosummary_item_re = re.compile(r'^\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\s*.*?')\n toctree_arg_re = re.compile(r'^\\s+:toctree:\\s*(.*?)\\s*$')\n \n documented = {}\n \n current_title = []\n last_line = None\n toctree = None\n current_module = module\n in_autosummary = False\n \n for line in lines:\n try:\n if in_autosummary:\n m = toctree_arg_re.match(line)\n if m:\n toctree = m.group(1)\n continue\n\n if line.strip().startswith(':'):\n continue # skip options\n\n m = autosummary_item_re.match(line)\n if m:\n name = m.group(1).strip()\n if current_module and not name.startswith(current_module + '.'):\n name = \"%s.%s\" % (current_module, name)\n documented.setdefault(name, []).append(\n (filename, current_title, 'autosummary', toctree))\n continue\n if line.strip() == '':\n continue\n in_autosummary = False\n\n m = autosummary_re.match(line)\n if m:\n in_autosummary = True\n continue\n\n m = autodoc_re.search(line)\n if m:\n name = m.group(2).strip()\n if m.group(1) == \"module\":\n current_module = name\n documented.update(get_documented_in_docstring(\n name, filename=filename))\n elif current_module and not name.startswith(current_module+'.'):\n name = \"%s.%s\" % (current_module, name)\n documented.setdefault(name, []).append(\n (filename, current_title, \"auto\" + m.group(1), None))\n continue\n\n m = title_underline_re.match(line)\n if m and last_line:\n current_title = last_line.strip()\n continue\n\n m = module_re.match(line)\n if m:\n current_module = m.group(2)\n continue\n finally:\n last_line = line\n\n return documented","def show_expanded(tree, expand_macros, **kw):\n new_tree = []\n for stmt in tree:\n with hq as code:\n unhygienic[log](u[macropy.core.unparse(stmt)])\n new_tree.append(code)\n new_tree.append(stmt)\n\n return new_tree"],"string":"[\n \"def filter_comments(\\n content, filter_multiline_comment=True, keep_content_size=False\\n):\\n def _replace_comment(element):\\n \\\"\\\"\\\"Replace matched *element* in content.\\\"\\\"\\\"\\n replacement = \\\"\\\"\\n matched = element.group()\\n\\n # Ensure that only the comment part is being replaced\\n if not matched.startswith(\\\"/\\\"):\\n replacement += matched[0]\\n matched = matched[1:]\\n\\n count = matched.count(\\\"\\\\n\\\")\\n\\n # Add empty spaces with the size of the content if the size\\n # must be kept.\\n if keep_content_size:\\n _buffer = len(matched) - count\\n replacement += \\\" \\\" * _buffer + \\\"\\\\n\\\" * count\\n\\n # Otherwise simply keep the number of lines\\n else:\\n replacement += \\\"\\\\n\\\" * count\\n\\n return replacement\\n\\n content = _ONE_LINE_COMMENT_PATTERN.sub(_replace_comment, content)\\n\\n if filter_multiline_comment:\\n content = _MULTI_LINES_COMMENT_PATTERN.sub(_replace_comment, content)\\n\\n return content\",\n \"def _filter(self, text, context, encoding):\\n\\n content = []\\n soup = bs4.BeautifulSoup(text, self.parser)\\n soup = self.get_sub_node(soup)\\n blocks, attributes, comments = self.to_text(soup)\\n if self.comments:\\n for c, desc in comments:\\n content.append(filters.SourceText(c, context + ': ' + desc, encoding, self.type + 'comment'))\\n if self.attributes:\\n for a, desc in attributes:\\n content.append(filters.SourceText(a, context + ': ' + desc, encoding, self.type + 'attribute'))\\n for b, desc in blocks:\\n content.append(filters.SourceText(b, context + ': ' + desc, encoding, self.type + 'content'))\\n return content\",\n \"def process_comment(self, data):\\r\\n if not self.is_suppress:\\r\\n return [data]\",\n \"def uncollapse_special_comments(self, wrapped_by_id):\\n\\n if self.uncollapse_all:\\n dont_collapse = set(wrapped_by_id.keys())\\n elif self.comment:\\n dont_collapse = set([self.comment._id])\\n parent_id = self.comment.parent_id\\n while parent_id:\\n dont_collapse.add(parent_id)\\n if parent_id in wrapped_by_id:\\n parent_id = wrapped_by_id[parent_id].parent_id\\n else:\\n parent_id = None\\n elif self.children:\\n dont_collapse = set(self.children)\\n else:\\n dont_collapse = set()\\n\\n # we only care about preventing collapse of wrapped comments\\n dont_collapse &= set(wrapped_by_id.keys())\\n\\n maybe_collapse = set(wrapped_by_id.keys()) - dont_collapse\\n\\n for comment_id in maybe_collapse:\\n comment = wrapped_by_id[comment_id]\\n if comment.distinguished and comment.distinguished != \\\"no\\\":\\n dont_collapse.add(comment_id)\\n\\n maybe_collapse -= dont_collapse\\n\\n # ensure all ancestors of dont_collapse comments are not collapsed\\n if maybe_collapse:\\n for comment_id in sorted(dont_collapse):\\n # sort comments so we start with the most root level comments\\n comment = wrapped_by_id[comment_id]\\n parent_id = comment.parent_id\\n\\n counter = 0\\n while (parent_id and\\n parent_id not in dont_collapse and\\n parent_id in wrapped_by_id and\\n counter < g.max_comment_parent_walk):\\n dont_collapse.add(parent_id)\\n counter += 1\\n\\n comment = wrapped_by_id[parent_id]\\n parent_id = comment.parent_id\\n\\n for comment_id in dont_collapse:\\n comment = wrapped_by_id[comment_id]\\n if comment.collapsed:\\n comment.collapsed = False\\n comment.hidden = False\",\n \"def header_children_filter(key, value, format, meta):\\n if key == 'Code':\\n # Aparently, Pandoc does not like code inside headers. We turn code \\n # into plain strings.\\n return Emph([Str(value[1])])\\n elif key == 'RawInline' and value[0] == 'html':\\n return html_inline_filter(value,pandoc_filter.current_file,False)\\n else:\\n return None\",\n \"def _get_comment_map(self):\\r\\n def _visit(obj):\\r\\n res = []\\r\\n for child in obj.get('children', []):\\r\\n res.append((child['id'], child))\\r\\n if 'children' in child:\\r\\n res += _visit(child)\\r\\n return res\\r\\n return dict(_visit(self.thread))\",\n \"def get_comment(view, pt):\\n\\n shell_vars = view.meta_info(\\\"shellVariables\\\", pt)\\n if not shell_vars:\\n return ([], [])\\n\\n # transform the list of dicts into a single dict\\n all_vars = {}\\n for v in shell_vars:\\n if 'name' in v and 'value' in v:\\n all_vars[v['name']] = v['value']\\n\\n line_comments = []\\n block_comments = []\\n\\n # transform the dict into a single array of valid comments\\n suffixes = [\\\"\\\"] + [\\\"_\\\" + str(i) for i in range(1, 10)]\\n for suffix in suffixes:\\n start = all_vars.setdefault(\\\"TM_COMMENT_START\\\" + suffix)\\n end = all_vars.setdefault(\\\"TM_COMMENT_END\\\" + suffix)\\n\\n if start and end is None:\\n line_comments.append((start,))\\n elif start and end:\\n block_comments.append((start, end))\\n\\n return (line_comments, block_comments)\",\n \"def parse_comment(self, node):\\n\\n data = []\\n\\n if node is not None:\\n comment_id_pattern = re.compile('comment-(\\\\d+)')\\n for comment_node in node.find_all('div', class_='comment'):\\n item = {}\\n item['is_deletable'] = False\\n item['is_editable'] = False\\n \\n comment_id_result = comment_id_pattern.search(comment_node.get('id'))\\n if comment_id_result:\\n item['id'] = int(comment_id_result.group(1))\\n \\n comment_body_node = comment_node.find('div', class_='comment-body')\\n if comment_body_node is not None:\\n item['content'] = ''\\n for p in comment_body_node.find_all(recursive=False):\\n if 'class' in p.attrs and 'author' in p['class']:\\n item['author'] = p.get_text()\\n item['profile_url'] = self.get_link(p.get('href'))\\n author_id = self._parse_user_id_from_url(item['profile_url'])\\n if self.userId == author_id:\\n item['is_deletable'] = True\\n item['is_editable'] = True\\n elif 'class' in p.attrs and 'age' in p['class']:\\n item['date'] = p.abbr['title']\\n item['date_ago'] = timeago.format(self._parse_datetime(item['date']), datetime.now(TIMEZONE))\\n elif 'class' in p.attrs and 'edit' in p['class']:\\n continue\\n elif p.name == 'form':\\n continue\\n else:\\n item['content'] += str(p)\\n\\n data.append(item)\\n\\n return data\",\n \"def extract_from_comment(self, comment):\\n comment = re.sub(r'\\\\s+', ' ', comment.strip().strip(\\\"/*\\\").strip())\\n if len(comment) == 0:\\n return set(), set()\\n domain_terms, code_elements = self.extract_from_sentence(comment)\\n return domain_terms, code_elements\",\n \"def config(self, filter_includes=False):\\n def the_filter(k):\\n if filter_includes and k is not None and k.lower() == \\\"include\\\":\\n return False\\n else:\\n return True\\n \\n return \\\"\\\\n\\\".join([x.line for x in self.lines_ if the_filter(x.key)])\",\n \"def get_semeval_content_with_relcomments(element):\\n if element.tag == 'OrgQuestion':\\n return get_orgquestion_content(element)\\n\\n if element.tag == 'Thread':\\n return ' '.join(chain(\\n [get_relquestion_content(element.find('./RelQuestion'))],\\n [get_relcomment_content(comment)\\n for comment in element.findall('./RelComment')]\\n ))\\n\\n if element.tag == 'RelComment':\\n return get_relcomment_content(element)\\n\\n return None\",\n \"def parse_lit(self, lines):\\n comment_char = \\\"#\\\" # TODO: move this into a directive option\\n comment = re.compile(r\\\"^\\\\s*{}[ \\\\n]\\\".format(comment_char))\\n section_test = lambda val: bool(comment.match(val))\\n\\n sections = []\\n for is_doc, group in itertools.groupby(lines, section_test):\\n if is_doc:\\n text = [comment.sub(\\\"\\\", i).rstrip(\\\"\\\\r\\\\n\\\") for i in group]\\n else:\\n text = [i.rstrip(\\\"\\\\r\\\\n\\\") for i in group]\\n\\n sections.append((is_doc, text))\\n\\n return sections\",\n \"def _get_review_comments_body(\\n self, pull_request_number: int) -> List[Tuple[str, str]]:\\n review_comments = get_pull_request_review_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not review_comments:\\n return []\\n review_comments_msg = []\\n for comment in review_comments:\\n review_comments_msg.append((comment['path'], comment['body']))\\n return review_comments_msg\",\n \"def get_initial_comment_list(self, comment_tree):\\n return []\",\n \"def make_parsed_comments(self):\\n if not hasattr(self, 'separated_comments'):\\n self.separated_comments = self.separate_comments()\\n \\n # build comments list of dictionaries, one dictionary for each article\\n self.comments = []\\n for self.separated_comment in self.separated_comments:\\n try:\\n comment_data = self.get_comment_data(self.separated_comment)\\n self.comments.append(comment_data)\\n except Exception as e:\\n pass\\n return self.comments\",\n \"def _get_draft_details(request, comments):\\n last_key = None\\n output = []\\n linecache = {} # Maps (c.patch_key, c.left) to mapping (lineno, line)\\n modified_patches = []\\n fetch_base_failed = False\\n\\n for c in comments:\\n patch = c.patch_key.get()\\n if (patch.key, c.left) != last_key:\\n url = request.build_absolute_uri(\\n reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]))\\n output.append('\\\\n%s\\\\nFile %s (%s):' % (url, patch.filename,\\n c.left and \\\"left\\\" or \\\"right\\\"))\\n last_key = (patch.key, c.left)\\n if patch.no_base_file:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n else:\\n try:\\n if c.left:\\n old_lines = patch.get_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(old_lines, 1))\\n else:\\n new_lines = patch.get_patched_content().text.splitlines(True)\\n linecache[last_key] = dict(enumerate(new_lines, 1))\\n except FetchError:\\n linecache[last_key] = _patchlines2cache(\\n patching.ParsePatchToLines(patch.lines), c.left)\\n fetch_base_failed = True\\n context = linecache[last_key].get(c.lineno, '').strip()\\n url = request.build_absolute_uri(\\n '%s#%scode%d' % (reverse(diff, args=[request.issue.key.id(),\\n patch.patchset_key.id(),\\n patch.filename]),\\n c.left and \\\"old\\\" or \\\"new\\\",\\n c.lineno))\\n output.append('\\\\n%s\\\\n%s:%d: %s\\\\n%s' % (url, patch.filename, c.lineno,\\n context, c.text.rstrip()))\\n if modified_patches:\\n ndb.put_multi(modified_patches)\\n return '\\\\n'.join(output)\",\n \"def critic_view(self, m):\\n\\n if m.group('ins_open'):\\n return self._ins(m.group('ins_text'))\\n elif m.group('del_open'):\\n return self._del(m.group('del_text'))\\n elif m.group('sub_open'):\\n return (\\n self._del(m.group('sub_del_text')) +\\n self._ins(m.group('sub_ins_text'))\\n )\\n elif m.group('mark_open'):\\n return self._mark(m.group('mark_text'))\\n elif m.group('com_open'):\\n return self._comment(m.group('com_text'))\",\n \"def get_formatted_comments(self, threshold=400):\\n comments = IDossier(self).comments\\n if comments:\\n if threshold:\\n comments = truncate_ellipsis(comments, threshold)\\n return api.portal.get_tool(name='portal_transforms').convertTo(\\n 'text/html', comments, mimetype='text/x-web-intelligent').getData()\",\n \"def get_initial_comment_list(self, comment_tree):\\n comment_tuples = []\\n\\n if self.link.sticky_comment_id:\\n root_level_comments = comment_tree.tree.get(None, [])\\n sticky_comment_id = self.link.sticky_comment_id\\n if sticky_comment_id in root_level_comments:\\n comment_tuples.append(CommentTuple(\\n comment_id=sticky_comment_id,\\n depth=0,\\n parent_id=None,\\n num_children=comment_tree.num_children[sticky_comment_id],\\n child_ids=comment_tree.tree.get(sticky_comment_id, []),\\n ))\\n else:\\n g.log.warning(\\\"Non-top-level sticky comment detected on \\\"\\n \\\"link %r.\\\", self.link)\\n return comment_tuples\",\n \"def extract_comments(comments_file, output_filename=direc+\\\"/comments.txt\\\"):\\r\\n if not os.path.exists(output_filename.split(\\\"/\\\")[0]):\\r\\n os.makedirs(output_filename.split(\\\"/\\\")[0])\\r\\n\\r\\n print(\\\"Extracting comments from \\\" + comments_file + \\\"...\\\")\\r\\n comments_dict = {}\\r\\n with open(output_filename, \\\"w\\\", encoding=encoding) as f:\\r\\n current = 0\\r\\n for event, child in iterparse(comments_file, events=('start', 'end')):\\r\\n if current > SAMPLE_SIZE:\\r\\n break\\r\\n elif len(child.attrib) > 0 and event == \\\"start\\\":\\r\\n if child.attrib['PostId'] not in comments_dict:\\r\\n comments_dict[child.attrib['PostId']] = []\\r\\n comments_dict[child.attrib['PostId']].append(child.attrib['Id'])\\r\\n clean_comment = clean_markdown(child.attrib['Text'])\\r\\n line = child.attrib['Id'] + \\\"\\\\t\\\" + child.attrib['PostId'] + \\\"\\\\t\\\" + clean_comment + \\\"\\\\t\\\" + child.attrib['Score'] + \\\"\\\\n\\\"\\r\\n f.write(line)\\r\\n\\r\\n current += 1\\r\\n print_progress(current, SAMPLE_SIZE)\\r\\n print(\\\"\\\\nFinished extracting comments from \\\" + comments_file + \\\".\\\\n\\\")\\r\\n return comments_dict\",\n \"def get_primaries(exclude_group):\",\n \"def modify_comment_tree(self, comment_tree):\\n return comment_tree\",\n \"def parseComments(data):\\n global comments\\n reviewBegins = '<div style=\\\"margin-left:0.5em;\\\">'\\n reviewEnds = '<div style=\\\"padding-top: 10px; clear: both; width: 100%;\\\">'\\n stars_line = 'margin-right:5px;'\\n stars = re.compile('\\\\d+.\\\\d+ out of 5 stars')\\n header_line = '<span style=\\\"vertical-align:middle;\\\"'\\n helpful_line ='people found the following review helpful'\\n helpful = re.compile('\\\\d+ of \\\\d+ people found the following review helpful')\\n reviewText = '<span class=\\\"h3color tiny\\\">' # Actual review\\n\\n boundaries = commentsStartStopLineNmbr(data)\\n for i in range(boundaries[0], boundaries[1] + 1):\\n if reviewBegins in data[i]:\\n curcomment = Comment()\\n while reviewEnds not in data[i]:\\n # Parse stars\\n if stars_line in data[i]:\\n stars_found = re.search(stars, data[i])\\n if stars_found != None:\\n curcomment.stars = stars_found.group()\\n # Parse header\\n elif header_line in data[i]:\\n line = data[i]\\n begin = line.find('<b>') + 3\\n end = line.find('</b>')\\n curcomment.header = line[begin : end]\\n # Parse helpfulness\\n elif helpful_line in data[i]:\\n helpful_found = data[i].replace(\\\",\\\", \\\"\\\")\\n helpful_found = re.search(helpful, helpful_found)\\n if helpful_found != None:\\n curcomment.helpful = helpful_found.group()\\n # Parse body text\\n elif reviewText in data[i]:\\n i += 3\\n if '<span class=\\\"small\\\"' in data[i]: # Yep, dirty trick :(\\n i += 3\\n data[i] = stripHtmlTags(data[i])\\n curcomment.comment = re.sub(\\\"\\\\s+\\\", \\\" \\\", data[i])\\n i += 1\\n comments.append(curcomment.getonelinecomment())\\n #comments.append(curcomment.__repr__())\",\n \"def cleaning_pipeline(self, tree: dict):\\n tree = self.remove_redundant(tree)\\n tree[\\\"selftext\\\"] = self.clean_text(tree[\\\"selftext\\\"])\\n tree[\\\"title\\\"] = self.clean_text(tree[\\\"title\\\"])\\n\\n empty_comments = []\\n for id, comment in tree[\\\"comments\\\"].items():\\n if \\\"body\\\" in comment and \\\"parent_id\\\" in comment:\\n comment[\\\"body\\\"] = self.clean_text(comment[\\\"body\\\"])\\n comment[\\\"parent_id\\\"] = comment[\\\"parent_id\\\"][3:]\\n else:\\n empty_comments.append(id)\\n print(\\\"Skipping empty comment : \\\", id, tree[\\\"comments\\\"][id])\\n\\n tree = self.resolve_empty_comments(tree, empty_comments)\\n\\n tree = self.correct_replies(tree)\\n\\n return tree\",\n \"def _strip_comments(file_contents):\\n lines_without_comments = []\\n for line in file_contents:\\n comment_position = line.find(COMMENT_INDICATOR)\\n if comment_position != -1:\\n lines_without_comments.append(line[:comment_position])\\n else:\\n lines_without_comments.append(line)\\n return lines_without_comments\",\n \"def get_summary(self):\\n return self.internal_comments.filter(is_summary=True).order_by('-modified_date').first()\",\n \"def getAllComments(self):\\r\\n return [(ind, comment) for ind, comment in enumerate(self.comments)]\",\n \"def get_lines(self, criteria):\\n rootiter = self.store.get_iter_first()\\n lines = []\\n\\n def sub_get_lines(treeiter):\\n \\\"\\\"\\\"\\n Get the checked children\\n \\\"\\\"\\\"\\n while treeiter != None:\\n tup = self.store[treeiter]\\n if criteria(tup):\\n lines.append({\\n 'jid': tup[0],\\n 'country': tup[3],\\n 'ip': tup[4]})\\n if self.store.iter_has_child(treeiter):\\n childiter = self.store.iter_children(treeiter)\\n sub_get_lines(childiter)\\n treeiter = self.store.iter_next(treeiter)\\n sub_get_lines(rootiter)\\n return lines\",\n \"def return_filtered_comments(submission):\\n submission.comment_sort = COMMENT_SORT_BY\\n submission.comment_limit = COMMENT_LIMIT\\n filtered_comments = []\\n for top_level_comment in submission.comments:\\n if isinstance(top_level_comment, praw.models.MoreComments):\\n continue\\n # Here you can fetch data off the comment.\\n comment = top_level_comment.body\\n\\n # ensure that the comment does not contain any words in blacklist\\n # and also it is less than COMMENT_MAX_WORDS\\n fail_test = 0\\n lcomment = comment.lower()\\n for badword in blacklist:\\n if badword not in lcomment and len(comment) < COMMENT_MAX_WORDS:\\n pass\\n else:\\n fail_test += 1\\n if not fail_test:\\n filtered_comments.append(replace_words(comment).capitalize())\\n\\n return filtered_comments\",\n \"def list_content(lines):\\n s0 = slices['MAT']\\n s1 = slices['MF']\\n s2 = slices['MT']\\n content = set(((int(l[s0]), int(l[s1]), int(l[s2])) for l in lines))\\n\\n # remove section delimiters\\n for c in content.copy():\\n if 0 in c:\\n content.discard(c)\\n return content\",\n \"def _get_comment_order(self):\\n\\n comment_tuples = CommentOrdererBase.get_comment_order(self)\\n if not comment_tuples:\\n return comment_tuples\\n elif isinstance(comment_tuples[-1], MissingChildrenTuple):\\n missing_children_tuple = comment_tuples.pop()\\n else:\\n missing_children_tuple = None\\n\\n special_responder_ids = self.link.responder_ids\\n\\n # unfortunately we need to look up all the Comments for QA\\n comment_ids = {ct.comment_id for ct in comment_tuples}\\n comments_by_id = Comment._byID(comment_ids, data=True)\\n\\n # figure out which comments will be kept (all others are discarded)\\n kept_comment_ids = set()\\n for comment_tuple in comment_tuples:\\n if comment_tuple.depth == 0:\\n kept_comment_ids.add(comment_tuple.comment_id)\\n continue\\n\\n comment = comments_by_id[comment_tuple.comment_id]\\n parent = comments_by_id[comment.parent_id] if comment.parent_id else None\\n\\n if comment.author_id in special_responder_ids:\\n kept_comment_ids.add(comment_tuple.comment_id)\\n continue\\n\\n if parent and parent.author_id in special_responder_ids:\\n kept_comment_ids.add(comment_tuple.comment_id)\\n continue\\n\\n if hasattr(comment, \\\"distinguished\\\") and comment.distinguished != \\\"no\\\":\\n kept_comment_ids.add(comment_tuple.comment_id)\\n continue\\n\\n # add all ancestors to kept_comment_ids\\n for comment_id in sorted(kept_comment_ids):\\n # sort the comments so we start with the most root level comments\\n comment = comments_by_id[comment_id]\\n parent_id = comment.parent_id\\n\\n counter = 0\\n while (parent_id and\\n parent_id not in kept_comment_ids and\\n counter < g.max_comment_parent_walk):\\n kept_comment_ids.add(parent_id)\\n counter += 1\\n\\n comment = comments_by_id[parent_id]\\n parent_id = comment.parent_id\\n\\n # remove all comment tuples that aren't in kept_comment_ids\\n comment_tuples = [comment_tuple for comment_tuple in comment_tuples\\n if comment_tuple.comment_id in kept_comment_ids\\n ]\\n\\n if missing_children_tuple:\\n comment_tuples.append(missing_children_tuple)\\n\\n return comment_tuples\",\n \"def flatten_sections_filter_keys(report, key_filter=None):\\n allitems = []\\n\\n if not key_filter:\\n def walk_dict(d):\\n if isinstance(d, dict):\\n for kk in d:\\n if isinstance(d[kk], dict):\\n walk_dict(d[kk])\\n else:\\n allitems.append((kk, d[kk]))\\n else:\\n raise Exception('did not handle this case')\\n return\\n walk_dict(report.sections)\\n\\n return allitems\\n else:\\n def walk_dict(d):\\n if isinstance(d, dict):\\n for kk in d:\\n if isinstance(d[kk], dict):\\n walk_dict(d[kk])\\n else:\\n if key_filter(kk):\\n allitems.append((kk, d[kk]))\\n else:\\n raise Exception('did not handle this case')\\n return\\n walk_dict(report.sections)\\n\\n return allitems\",\n \"def get_all_transform_comments_str(s):\\n\\n program_lines = s.split(\\\"\\\\n\\\")\\n result = []\\n\\n for i in range(len(program_lines)):\\n line = program_lines[i]\\n\\n if line.lstrip(' ').startswith(\\\"#transform\\\"):\\n transform_node = get_ast(line).body[0].value\\n transform_node.lineno = i + 1\\n result.append(transform_node)\\n\\n return result\",\n \"def deleteComments(self: Self, event: Event = None) -> None:\\n #@+<< deleteComments docstring >>\\n #@+node:ekr.20171123135625.37: *3* << deleteComments docstring >>\\n #@@pagewidth 50\\n #@-<< deleteComments docstring >>\\n c, p, u, w = self, self.p, self.undoer, self.frame.body.wrapper\\n #\\n # \\\"Before\\\" snapshot.\\n bunch = u.beforeChangeBody(p)\\n #\\n # Initial data.\\n head, lines, tail, oldSel, oldYview = self.getBodyLines()\\n if not lines:\\n g.warning('no text selected')\\n return\\n # The default language in effect at p.\\n language = c.frame.body.colorizer.scanLanguageDirectives(p)\\n if c.hasAmbiguousLanguage(p):\\n language = c.getLanguageAtCursor(p, language)\\n d1, d2, d3 = g.set_delims_from_language(language)\\n #\\n # Calculate the result.\\n changed, result = False, []\\n if d1:\\n # Remove the single-line comment delim in front of each line\\n d1b = d1 + ' '\\n n1, n1b = len(d1), len(d1b)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n if g.match(s, i, d1b):\\n result.append(s[:i] + s[i + n1b :])\\n changed = True\\n elif g.match(s, i, d1):\\n result.append(s[:i] + s[i + n1 :])\\n changed = True\\n else:\\n result.append(s)\\n else:\\n # Remove the block comment delimiters from each line.\\n n2, n3 = len(d2), len(d3)\\n for s in lines:\\n i = g.skip_ws(s, 0)\\n j = s.find(d3, i + n2)\\n if g.match(s, i, d2) and j > -1:\\n first = i + n2\\n if g.match(s, first, ' '):\\n first += 1\\n last = j\\n if g.match(s, last - 1, ' '):\\n last -= 1\\n result.append(s[:i] + s[first:last] + s[j + n3 :])\\n changed = True\\n else:\\n result.append(s)\\n if not changed:\\n return\\n #\\n # Set p.b and w's text first.\\n middle = ''.join(result)\\n p.b = head + middle + tail # Sets dirty and changed bits.\\n w.setAllText(head + middle + tail)\\n #\\n # Set the selection range and scroll position.\\n i = len(head)\\n j = ins = max(i, len(head) + len(middle) - 1)\\n w.setSelectionRange(i, j, insert=ins)\\n w.setYScrollPosition(oldYview)\\n #\\n # \\\"after\\\" snapshot.\\n u.afterChangeBody(p, 'Indent Region', bunch)\",\n \"def get_annotated_content_infos(course_id, thread, user, user_info):\\r\\n infos = {}\\r\\n\\r\\n def annotate(content):\\r\\n infos[str(content['id'])] = get_annotated_content_info(course_id, content, user, user_info)\\r\\n for child in content.get('children', []):\\r\\n annotate(child)\\r\\n annotate(thread)\\r\\n return infos\",\n \"def _get_issue_comments_body(self, pull_request_number: int) -> List[str]:\\n issue_comments = get_pull_request_issue_comments(\\n self._repo_name, pull_request_number, self._auth)\\n if not issue_comments:\\n return []\\n issue_comments_msg = []\\n for comment in issue_comments:\\n issue_comments_msg.append(comment['body'])\\n return issue_comments_msg\",\n \"def get_comments_from_submission_id(submission_id):\\n flat_comments = []\\n tree_comments = []\\n\\n submission = (REDDIT.submission(id=submission_id))\\n print(submission.num_comments)\\n print(submission.shortlink)\\n\\n # sort comments by best and get the flattened list\\n submission.comment_sort = 'confidence'\\n\\n # tree comments traversal\\n submission.comments.replace_more(limit=1)\\n for comm in submission.comments.list():\\n tree_comments.append(comm)\\n\\n flat_comments = list(submission.comments)\\n\\n return flat_comments, tree_comments\",\n \"def get_node_comments(self, node_id: str) -> Optional[str]:\\n comments = []\\n\\n for pipeline in self.pipelines:\\n comment_list = pipeline.comments\\n for comment in comment_list:\\n associated_node_id_list = comment.get(\\\"associated_id_refs\\\", [])\\n for ref in associated_node_id_list:\\n if ref[\\\"node_ref\\\"] == node_id:\\n comments.append(comment.get(\\\"content\\\", \\\"\\\"))\\n\\n # remove empty (or whitespace-only) comment strings\\n comments = [c for c in comments if c.strip()]\\n comment_str = \\\"\\\\n\\\\n\\\".join(comments)\\n if not comment_str:\\n return None\\n\\n return comment_str\",\n \"def _split_into_body_and_options(\\n section_content: str,\\n) -> Tuple[str, Optional[str], Dict[int, bool]]:\\n lines = section_content.strip().splitlines()\\n\\n skipif_expr = None\\n flag_settings = {}\\n i = 0\\n for line in lines:\\n stripped = line.strip()\\n if _OPTION_SKIPIF_RE.match(stripped):\\n skipif_match = _OPTION_SKIPIF_RE.match(stripped)\\n assert skipif_match is not None\\n skipif_expr = skipif_match.group(1)\\n i += 1\\n elif _OPTION_DIRECTIVE_RE.match(stripped):\\n directive_match = _OPTION_DIRECTIVE_RE.match(stripped)\\n assert directive_match is not None\\n option_strings = directive_match.group(1).replace(\\\",\\\", \\\" \\\").split()\\n for option in option_strings:\\n if (\\n option[0] not in \\\"+-\\\"\\n or option[1:] not in doctest.OPTIONFLAGS_BY_NAME\\n ):\\n raise ValueError(f\\\"doctest has an invalid option {option}\\\")\\n flag = doctest.OPTIONFLAGS_BY_NAME[option[1:]]\\n flag_settings[flag] = option[0] == \\\"+\\\"\\n i += 1\\n elif stripped == \\\":hide:\\\":\\n i += 1\\n else:\\n break\\n\\n if i == len(lines):\\n raise ValueError(\\\"no code/output\\\")\\n\\n body = \\\"\\\\n\\\".join(lines[i:]).lstrip()\\n if not body:\\n raise ValueError(\\\"no code/output\\\")\\n\\n if i and lines[i].strip():\\n # no newline between option block and body\\n raise ValueError(f\\\"invalid option block: {section_content!r}\\\")\\n\\n return body, skipif_expr, flag_settings\",\n \"def getTopComments(self):\\n return self.topComments\",\n \"def parse_comments_html(advertise: Dict[str, Any]) -> Optional[List[str]]:\\n if \\\"comments_html\\\" in advertise.keys():\\n\\n filtred_comments: str = advertise[\\\"comments_html\\\"][200::]\\n\\n tmp: List[str] = re.split(\\\"[ \\\\n\\\\t]{2,}\\\", filtred_comments)\\n if '' in tmp:\\n tmp.remove('')\\n\\n # Breaking comments\\n master: List[List[str]] = []\\n tmp_vec: List[str] = []\\n for line in tmp:\\n\\n if re.search(\\\"de \\\\d{4,}\\\", line): # matches 'de 2018' that signals the end of comment\\n master.append(tmp_vec)\\n tmp_vec = []\\n else:\\n tmp_vec.append(line)\\n\\n # Cleaning comments\\n for comment in master:\\n if \\\"...\\\" in comment:\\n comment.remove(\\\"...\\\")\\n if \\\"O usuário contratou o serviço em\\\" in comment:\\n comment.remove(\\\"O usuário contratou o serviço em\\\")\\n\\n return [\\\" \\\".join(m) for m in master]\",\n \"def extractMarkup(text):\\n\\n groups = []\\n indent = None\\n buff = []\\n comment = None\\n i = len(\\\"'''harbor: \\\")\\n for line in text:\\n line = line + ' '\\n\\n if (line.lstrip())[:i] in [\\\"'''harbor: \\\",'\\\"\\\"\\\"harbor: '] and indent == None:\\n indent = len(line) - len(line.lstrip())\\n comment = (line.lstrip())[:3]\\n buff = Markup(line[indent+i:].strip(),[])\\n elif line.strip() == comment and indent != None:\\n indent = None\\n groups.append(buff)\\n buff = []\\n elif indent != None:\\n buff = Markup(buff.dest,buff.contents + [line[indent:]])\\n return groups\",\n \"def read_patch_comments(self) -> dict:\\n comment: List[str] = []\\n patch_comments = {}\\n for line in self.spec_content.section(\\\"%package\\\"):\\n # An empty line clears the comment lines collected so far.\\n if not line.strip():\\n comment = []\\n # Remember a comment line.\\n if line.startswith(\\\"#\\\"):\\n comment.append(line[1:].strip())\\n # Associate comments with patches and clear the comments\\n # collected.\\n if line.lower().startswith(\\\"patch\\\"):\\n patch_name = Path(line.split(\\\":\\\", 1)[1].strip()).name\\n patch_comments[patch_name] = comment\\n comment = []\\n return patch_comments\",\n \"def filter_top_section(text):\\n head = re.search(r'==.*?==', text)\\n idx = head.span(0)[0] if head else len(text)\\n return text[:idx] #(text[:idx], text[idx:])\",\n \"def get_comment_data(self, comment):\\n # remove double spaces but not triple ones; we use triple spaces to split commenter and parent_commenter\\n pattern = '(?<! ) {2}(?! )'\\n comment = re.sub(pattern, ' ', comment).strip() # also strip leading and trailing spaces\\n\\n # get names\\n ix = re.search('•', comment).span()[-1]\\n names = [x.strip() for x in (comment[:ix]).strip().strip('•').split(' ')]\\n try:\\n commenter, parent_commenter = names\\n except:\\n commenter, parent_commenter = names[0], ''\\n\\n # handle deleted comments\\n pattern = 'This comment was deleted.−+−+'\\n commenter = commenter.replace(pattern, '').strip()\\n \\n # get post and upvotes\\n comment_upvotes = comment[ix:].split('ago')[-1].strip(' ')\\n ix = re.search('(see more)\\\\w+', comment_upvotes) # redefine ix as index that separates post message from post upvotes\\n clean_comment, upvotes = comment_upvotes[:ix.span()[0]], comment_upvotes[ix.span()[0]:].replace('see more', '')\\n\\n # build dictionary\\n d = dict(zip( ['commenter', 'parent_commenter', 'comment', 'upvotes']\\n , [commenter, parent_commenter.strip(), clean_comment.strip(), upvotes.strip()]))\\n\\n return d\",\n \"def _parse_data(self):\\n current_block = []\\n current_section = \\\"docstring\\\"\\n\\n # if we get a line that starts with #, this is a new comment or\\n # part of a block comment. Otherwise, it means the current block\\n # comment has ended.\\n\\n for this in self.data:\\n # Beginning of a new section at top level\\n if self.regex_section.findall(this):\\n name = self.regex_section.findall(this)[0]\\n current_section = name.strip(\\\":\\\")\\n self.sections[current_section] = \\\"\\\".join(current_block)\\n current_block = []\\n current_section = None\\n elif this.startswith(\\\"#\\\"): # a comment at top level\\n current_block.append(this)\\n elif this.strip() == \\\"\\\": # an empty line\\n # this was the main comment, or an isolated comment\\n current_block = []\\n else: # a non-empty line to skip\\n current_block = []\\n\\n for key in self._get_expected_sections():\\n if key not in self.sections.keys():\\n logger.warning(\\\"section %s not dealt by the parsing function\\\" % key)\",\n \"def split(self, filter):\\n split = dict()\\n for label, traces in [\\n (True, self.acceptedTraces),\\n (False, self.rejectedTraces),\\n ]:\\n split[label] = {True: [], False: [],}\\n for trace in traces:\\n split[label][bool(filter(trace, label))].append(trace)\\n ans = []\\n for value in (True, False):\\n traces = __class__(\\n numVariables=self.numVariables,\\n tracesToAccept=split[True][value],\\n tracesToReject=split[False][value],\\n operators=self.operators,\\n depth=self.depthOfSolution,\\n possibleSolution=self.possibleSolution,\\n )\\n ans.append(traces)\\n return tuple(ans)\",\n \"def get_comment_information_by_id(comment_id):\\n comment = REDDIT.comment(comment_id)\\n print(comment.body)\\n print(vars(comment))\",\n \"def comment_for_run (ins, exp, runnum) :\\n return dict_of_recs_for_run(ins, exp, runnum)['comment']\",\n \"def get_complex_content(data):\\n lines = []\\n for prop, headline in [('in-reply-to', 'In reply to'),\\n ('like-of', 'Liked'),\\n ('repost-of', 'Reposted'),\\n ('bookmark-of', 'Bookmarked')]:\\n for target in get_possible_array_value(data, prop):\\n lines.append('<p>{} <a class=\\\"u-{}\\\" href=\\\"{}\\\">{}</a></p>'.format(\\n headline, prop, target, prettify_url(target)))\\n\\n content = (data.get('content[html]') or data.get('content') or\\n data.get('summary'))\\n if content:\\n lines.append(content)\\n\\n return '\\\\n'.join(lines)\",\n \"def coalesceChunks(self):\\n # using StringIO() for better performance\\n coalesced1 = StringIO()\\n for chunk in self.chunks:\\n print(chunk.text, end=\\\"\\\", file=coalesced1)\\n\\n coalesced2 = self.unMarkupCommentsAndStrings(\\n coalesced1.getvalue())\\n\\n return coalesced2\",\n \"def critic_parse(self, m):\\n accept = self.config[\\\"mode\\\"] == 'accept'\\n if m.group('ins_open'):\\n return m.group('ins_text') if accept else ''\\n elif m.group('del_open'):\\n return '' if accept else m.group('del_text')\\n elif m.group('mark_open'):\\n return m.group('mark_text')\\n elif m.group('com_open'):\\n return ''\\n elif m.group('sub_open'):\\n return m.group('sub_ins_text') if accept else m.group('sub_del_text')\",\n \"def extract_traces(self):\\n for blocks in self._iterate_blocks():\\n blocks = [block[\\\"_source\\\"][\\\"number\\\"] for block in blocks]\\n self._extract_traces_chunk(blocks)\",\n \"def separate_comments(self):\\n if not hasattr(self, 'cleaned_html'):\\n self.cleaned_html = self.clean_html()\\n \\n self.separated_comments = self.cleaned_html.split(self.post_splitter)\\n return self.separated_comments\",\n \"def filter_comments(asm_utf):\\n comments = []\\n # removes nones\\n a = filter(lambda x: x != None, asm_utf)\\n # splits on comment token\\n comments = [re.split(\\\";\\\", line) for line in a]\\n # takes only those that have a comment token\\n comments = list(filter(lambda x: len(x) > 1, comments))\\n # strips the whitespace from those tokens\\n comments = [line[1].strip() for line in comments]\\n # removes the singleton chars\\n comments = list(filter(lambda x: len(x) > 1, comments))\\n # regex to remove section markers and extraneous tabs\\n # left over by poor reading of files\\n comments = [re.sub('([-=].*[-=]|\\\\t)', '', line) for line in comments]\\n comments = list(filter(lambda x: x != '', comments))\\n return comments\",\n \"def isolate_relevant_information(self):\\n\\n def get_formula(oncat_formula):\\n \\\"\\\"\\\"will need to go from something like\\n \\\"${value/10e11}`\\\"\\n to something more pythonic\\n \\\"{value/10e11}\\\"\\\"\\\"\\n regular_expression = r'\\\\$(?P<formula>.+)\\\\`'\\n m = re.search(regular_expression, oncat_formula)\\n if m:\\n return m.group('formula')\\n else:\\n return \\\"\\\"\\n\\n template_information = {}\\n for _index, _element in enumerate(self._oncat_default_template):\\n _title = _element[\\\"name\\\"]\\n _path = _element[\\\"path\\\"]\\n if \\\"units\\\" in _element:\\n _units = _element[\\\"units\\\"]\\n else:\\n _units = \\\"\\\"\\n if \\\"transform\\\" in _element:\\n _formula = get_formula(_element[\\\"transform\\\"])\\n else:\\n _formula = \\\"\\\"\\n template_information[_index] = {'title': _title,\\n 'path': _path,\\n 'units': _units,\\n 'formula': _formula}\\n self.template_information = template_information\",\n \"def out(self):\\n return {'filenum': self.filenum, 'linenum': self.linenum, 'type': self.ast_type,\\n 'source': self.source if self.save_element_source else None}\",\n \"def _get_multi_line_comment(node):\\n return _get_comment_from_node(node)\",\n \"def getcomments(object):\\r\\n try:\\r\\n lines, lnum = findsource(object)\\r\\n except (IOError, TypeError):\\r\\n return None\\r\\n\\r\\n if ismodule(object):\\r\\n # Look for a comment block at the top of the file.\\r\\n start = 0\\r\\n if lines and lines[0][:2] == '#!': start = 1\\r\\n while start < len(lines) and string.strip(lines[start]) in ('', '#'):\\r\\n start = start + 1\\r\\n if start < len(lines) and lines[start][:1] == '#':\\r\\n comments = []\\r\\n end = start\\r\\n while end < len(lines) and lines[end][:1] == '#':\\r\\n comments.append(string.expandtabs(lines[end]))\\r\\n end = end + 1\\r\\n return string.join(comments, '')\\r\\n\\r\\n # Look for a preceding block of comments at the same indentation.\\r\\n elif lnum > 0:\\r\\n indent = indentsize(lines[lnum])\\r\\n end = lnum - 1\\r\\n if end >= 0 and string.lstrip(lines[end])[:1] == '#' and \\\\\\r\\n indentsize(lines[end]) == indent:\\r\\n comments = [string.lstrip(string.expandtabs(lines[end]))]\\r\\n if end > 0:\\r\\n end = end - 1\\r\\n comment = string.lstrip(string.expandtabs(lines[end]))\\r\\n while comment[:1] == '#' and indentsize(lines[end]) == indent:\\r\\n comments[:0] = [comment]\\r\\n end = end - 1\\r\\n if end < 0: break\\r\\n comment = string.lstrip(string.expandtabs(lines[end]))\\r\\n while comments and string.strip(comments[0]) == '#':\\r\\n comments[:1] = []\\r\\n while comments and string.strip(comments[-1]) == '#':\\r\\n comments[-1:] = []\\r\\n return string.join(comments, '')\",\n \"def get_expanded_def_and_includes(self):\\n self.expanded_def = {}\\n self.includes = {}\\n if 'merge' in self.sdef['df'].keys():\\n self.process_merge(self.expanded_def, self.sdef['df']['merge'], self.includes)\\n self.merge_def(self.expanded_def, self.sdef, self.includes)\\n # merge any attributes to self.attributes for later processing\\n if 'attributes' in self.expanded_def:\\n self.attributes.update(self.expanded_def['attributes'])\\n del self.expanded_def['attributes']\",\n \"def order_lines_layouted(self):\\n self.ensure_one()\\n report_pages = [[]]\\n #print(list(groupby(self.order_line, lambda l: l.layout_category_id)))\\n for category, lines in groupby(self.order_line, lambda l: l.layout_category_id):\\n\\n if report_pages[-1] and report_pages[-1][-1]['pagebreak']:\\n report_pages.append([])\\n report_pages[-1].append({\\n 'parent': category.parent.name,\\n 'name': category and category.name or _('Uncategorized'),\\n 'subtotal': category and category.subtotal,\\n 'pagebreak': category and category.pagebreak,\\n 'lines': list(lines)\\n })\\n\\n return report_pages\",\n \"def pandoc_filter(key, value, format, meta):\\n if key == 'Link':\\n value[1][0] = process_link_destination(value[1][0], pandoc_filter.current_file)\\n if len(value[1][0]) == 0:\\n print_warning(\\n \\\"Found empty link ([%s]()) in file [%s]\\\" % \\n (stringify(value[0]), pandoc_filter.current_file)\\n )\\n # Process link children in AST tree\\n value[0] = walk(value[0],pandoc_filter,format,meta)\\n return Link(value[0],value[1])\\n elif key == 'Image':\\n src_image_path = value[1][0]\\n value[1][0] = make_image_path_absolute(value[1][0], pandoc_filter.current_file)\\n if is_image_broken(value[1][0]):\\n print_warning(\\n (\\n 'Ignoring local image not found [%s] in file [%s]' +\\n '- Warning added to PDF'\\n ) % (\\n unicode(src_image_path).encode('utf-8'),\\n unicode(pandoc_filter.current_file).encode('utf-8')\\n )\\n )\\n return RawInline('tex', print_image_not_found(src_image_path.encode('utf-8')))\\n else:\\n return Image(value[0],value[1])\\n elif key == 'Header':\\n return header_filter(value,format,meta,pandoc_filter.current_file)\\n elif key == 'RawInline' and value[0] == 'html':\\n html_filter_result = html_inline_filter(value, pandoc_filter.current_file,True)\\n if html_filter_result is not None:\\n return html_filter_result\\n else:\\n file_marker = extract_file_marker(key,value)\\n if file_marker is not None:\\n pandoc_filter.current_file = file_marker\\n return None\",\n \"def collapsed(self) -> None:\",\n \"def get_all_transform_comments(a):\\n\\n return [n for n in find_all(a, ast.Str)\\n if n.s.startswith(STR_COMMENT_PREFIX + \\\"#transform\\\")]\",\n \"def lines(filename, exclude_imports=True, exclude_comments=True, exclude_tests=True, exclude_globals=True, exclude_blank=True, verbose=False, is_c=False, s=None):\\n if s is None:\\n s = open(filename, 'rt').read()\\n\\n L = s.split('\\\\n')\\n \\n # Hack to strip out triple and single quote string lines in a heuristic (unreliable) way, which avoids parsing Cython\\n if not is_c:\\n for i in range(len(L)):\\n if L[i].strip().startswith(\\\"'\\\") and L[i].strip().endswith(\\\"'\\\"):\\n L[i] = ''\\n i = 0\\n while i < len(L):\\n found = False\\n for triple_quote in ['\\\"\\\"\\\"', \\\"'''\\\"]:\\n if L[i].strip().startswith(triple_quote):\\n L[i] = L[i].strip()[3:]\\n for j in range(i, len(L)):\\n if triple_quote in L[j]:\\n found = True\\n L[j] = ''\\n if found:\\n break\\n i = j+1\\n if not found:\\n i += 1\\n else:\\n begin_comment = '/*'\\n end_comment = '*/'\\n i = 0\\n while i < len(L):\\n found = False\\n if begin_comment in L[i]:\\n rest = L[i][L[i].index(begin_comment)+len(begin_comment):]\\n L[i] = L[i][:L[i].index(begin_comment)]\\n if end_comment in rest:\\n found = True\\n i += 1\\n else:\\n for j in range(i+1, len(L)):\\n if end_comment in L[j]:\\n found = True\\n L[j] = L[j][L[j].index(end_comment)+len(end_comment):]\\n else:\\n L[j] = ''\\n if found:\\n break\\n i = j + 1\\n if not found:\\n i += 1\\n\\n# util.print_header('Lines before exclude_tests:' + filename, '\\\\n'.join(L))\\n\\n # Hack to strip out def test() and other methods in a heuristic (unreliable) way, which avoids parsing Cython\\n if exclude_tests:\\n # Also exclude makeColorMatrix so that our camera pipe is apples-to-apples comparable with reported lines in Halide paper\\n if not is_c:\\n methods = 'test run_test_all mandelbrot_gray mandelbrot_color composite_numpy composite_numexpr makeColorMatrix'.split()\\n else:\\n methods = ['int main', 'void main']\\n i = 0\\n while i < len(L):\\n L_i_strip = L[i].strip()\\n if ((not is_c and (any(L_i_strip.startswith('def ' + method) for method in methods) or\\n any(L_i_strip.startswith('cdef ' + method) for method in methods))) or\\n (is_c and (any(L_i_strip.startswith(method) for method in methods)))):\\n L[i] = ''\\n for j in range(i+1, len(L)):\\n L_j_strip = L[j].strip()\\n c_ok = True\\n if is_c:\\n c_ok = L_j_strip != '{' and L_j_strip != '}'\\n if not L[j].startswith(' ') and not L[j].startswith('\\\\t') and not len(L[j].strip()) == 0 and c_ok:\\n break\\n else:\\n L[j] = ''\\n i = j\\n elif (L[i].strip().startswith('test(') or L[i].strip().startswith('run_test_all(')) and not is_c:\\n L[i] = ''\\n i += 1\\n else:\\n i += 1\\n\\n# util.print_header('Lines before exclude_imports:' + filename, '\\\\n'.join(L))\\n if exclude_imports:\\n if not is_c:\\n L = [x for x in L if not x.lstrip().startswith('import') and not x.lstrip().startswith('cimport') and not x.startswith('cdef extern')]\\n else:\\n L = [x for x in L if not x.lstrip().startswith('#include')]\\n# util.print_header('Lines before exclude_comments:' + filename, '\\\\n'.join(L))\\n if exclude_comments:\\n if not is_c:\\n L = [x for x in L if not x.lstrip().startswith('#') and not x.strip() == 'pass']\\n else:\\n L = [x for x in L if not x.lstrip().startswith('//')]\\n# util.print_header('Lines before exclude_globals:' + filename, '\\\\n'.join(L))\\n if exclude_globals and not is_c:\\n L = [x for x in L if (x.startswith(' ') or x.startswith('\\\\t') or x.startswith('def') or x.startswith('cdef')) and (not x.lstrip().startswith('has_'))]\\n# util.print_header('Lines before exclude_blank:' + filename, '\\\\n'.join(L))\\n\\n if is_c:\\n # Also exclude makeColorMatrix so that C camera pipe is apples-to-apples comparable with reported lines in Halide paper\\n L = [x for x in L if not x.lstrip().startswith('matrix_3200') and not x.lstrip().startswith('matrix_7000')]\\n if exclude_blank:\\n L = [x for x in L if not len(x.strip()) == 0]\\n\\n if verbose:\\n util.print_header('Final lines for:' + filename, '\\\\n'.join(L))\\n\\n return len(L)\",\n \"def test_get_comments():\\n comments = list(get_comments(TEST_SUBREDDIT, TEST_START_DATE, TEST_END_DATE, TEST_MAX))\\n\\n # prints the dictionary of variables for each comment\\n for x in comments:\\n print(x.d_)\",\n \"def content(self):\\n K = self.domain\\n elements, _ = self.to_flat_nz()\\n return dup_content(elements, K)\",\n \"def find_obs_request_comment(self, request_id=None, project_name=None):\\n if self.do_comments:\\n comments = self.commentapi.get_comments(request_id=request_id, project_name=project_name)\\n for c in comments.values():\\n m = comment_marker_re.match(c['comment'])\\n if m:\\n return {\\n 'id': c['id'],\\n 'state': m.group('state'),\\n 'result': m.group('result'),\\n 'comment': c['comment'],\\n 'revision': m.group('revision')}\\n return {}\",\n \"def unMarkupCommentsAndStrings(self, content):\\n\\n def replaceMarkups(match):\\n groupdict = match.groupdict()\\n if groupdict[\\\"str\\\"] is not None:\\n return self.strings[int(match.group(\\\"str\\\"))]\\n elif groupdict[\\\"comment\\\"] is not None:\\n return self.comments[int(match.group(\\\"comment\\\"))]\\n else:\\n assert False\\n\\n unMarkedup = markups.sub(replaceMarkups, content)\\n\\n return unMarkedup\",\n \"def comments(self):\\n return self.container['comments']\",\n \"def filter_lines(lines, filter_regex, groups=None):\\n pattern = re.compile(filter_regex)\\n for line in lines:\\n match = pattern.search(line)\\n if match:\\n if groups is None:\\n yield line\\n elif len(groups) == 1:\\n yield match.group(groups[0])\\n else:\\n matched_groups = match.groupdict()\\n yield tuple(matched_groups.get(group) for group in groups)\",\n \"def process_all(self):\\n global multi_comment_line_mode\\n multi_comment_line_mode = False\\n for line in self.fileToProcess:\\n line = line.strip() # creating a strip line, with no whitespace in the beginning and in the end\\n # multi_comment_line_mode = False\\n # first, we want to filter all the lines which are comments or part of comments\\n while line != '':\\n ignoring_status,newline = self.shouldTheLineBeIgnored(line)\\n if ignoring_status:\\n break # we are ignoring the line\\n elif (not ignoring_status) and (newline != '') and newline != '$endOfMultiLine':\\n line = newline\\n continue\\n elif not ignoring_status and newline == '$endOfMultiLine':\\n break\\n else:\\n line = self.isThereApartToIgnore(line) #getting the good line\\n line = line.strip()\\n if line.endswith('$endOfMultiLine'):\\n # line = line[:-1]\\n line = line[:-15]\\n # in this case we don't want to ignore the current line\\n # if multi_comment_line_mode:\\n # # this comes from the\\n list_of_line_strings = re.split('(\\\\W)', line) # the default of this method is to remove all the white spaces\\n list_of_line_strings = list(filter(None, list_of_line_strings))\\n global i\\n i = 0\\n global first_index\\n first_index = 0\\n global second_index\\n second_index = 0\\n len_of_list = len(list_of_line_strings)\\n while i < len_of_list:\\n # first adding the string literals\\n if (list_of_line_strings[i] == '\\\"' and i == 0) or (i>0 and list_of_line_strings[i] == '\\\"' and\\n list_of_line_strings[i-1]!='*'):\\n first_index = i\\n i = i + 1\\n if i == len(list_of_line_strings):\\n break\\n while list_of_line_strings[i] != '\\\"':\\n i = i + 1\\n if i>=len(list_of_line_strings):\\n # in case it's the end\\n i = first_index\\n break\\n else:\\n continue\\n second_index = i\\n list_of_line_strings[first_index:second_index + 1] = [\\n ''.join(list_of_line_strings[first_index:second_index + 1])]\\n i = i + 2\\n len_of_list = len(list_of_line_strings)\\n else:\\n i = i + 1\\n j=0\\n global skip_mode\\n skip_mode = False\\n global counter\\n counter = 0\\n for string in list_of_line_strings:\\n if j != len(list_of_line_strings)-1:\\n j+=1\\n if counter == 1:\\n counter = 0\\n continue\\n if skip_mode and not (string == '*' and list_of_line_strings[j] == '/'):\\n continue\\n if skip_mode and string == '*' and list_of_line_strings[j] == '/':\\n skip_mode = False\\n counter = 1\\n continue\\n if string == \\\"/\\\" and (list_of_line_strings[j] == \\\"/\\\" ):\\n # this is a comment that appeared in the line\\n break # in this case, there are no more chars to read because it's a note\\n if string == \\\"/\\\" and list_of_line_strings[j] == \\\"*\\\":\\n skip_mode = True\\n counter = 1\\n continue # entering a skip mode\\n if string.strip() == '':\\n continue\\n self.currStringToProcess = string\\n type = self.tokenType()\\n self.createToken(type,self.currStringToProcess)\\n break\",\n \"def get_content(self):\\r\\n content = []\\r\\n for regiongroup in self.region_groups:\\r\\n for region in regiongroup.get_content():\\r\\n # Add date, unique_name and project to the metadata\\r\\n region[0]['date'] = self.extracted_date\\r\\n region[0]['unique_name'] = self.unique_name\\r\\n try:\\r\\n project = os.path.split(\\r\\n os.path.split(self.unique_name)[0]\\r\\n )[1]\\r\\n except IndexError:\\r\\n project = ''\\r\\n region[0]['project'] = project\\r\\n content.append(region)\\r\\n return content\",\n \"def get_comments(self,comments):\\n all_comments = []\\n for comment in comments:\\n try :\\n all_comments.append({\\n 'comment':comment['data']['body'],\\n 'score':comment['data']['score']\\n })\\n except: pass\\n return all_comments\",\n \"def _get_comment_from_node(node):\\n\\n def _remove_non_comment_ending(lines):\\n for index, line in enumerate(lines):\\n if not line.strip().startswith(\\\"#\\\"):\\n return lines[:index]\\n\\n return lines # pragma: no cover\\n\\n def _replace_newlines(match):\\n newlines = match.group(\\\"newlines\\\") or \\\"\\\"\\n\\n if len(newlines) < 2:\\n return \\\" \\\"\\n\\n return newlines[:-1] # Remove one newline\\n\\n code = node.get_code()\\n lines = _remove_beginning_newlines(code.split(\\\"\\\\n\\\"))\\n lines = _remove_non_comment_ending(lines)\\n matches = [_COMMENT_EXPRESSION.match(line).group(\\\"text\\\") for line in lines]\\n\\n if not matches:\\n return \\\"\\\"\\n\\n clean_comment = \\\"\\\\n\\\".join(matches).strip(\\\"\\\\n\\\")\\n unindented_comment = textwrap.dedent(clean_comment)\\n collapsed_comment = _MULTIPLE_NEWLINE_MATCH.sub(\\n _replace_newlines, unindented_comment\\n )\\n\\n return collapsed_comment\",\n \"def read_comment(comment):\\n comment_dict = {}\\n\\n debug(\\\"parse tab in comment.\\\")\\n comment_dict_from_tab, comment = parse_tab_in_comment(comment)\\n debug(\\\"parsed dict: %s.\\\" % comment_dict_from_tab)\\n comment_dict.update(comment_dict_from_tab)\\n\\n debug(\\\"parse space in comment.\\\")\\n comment_dict_from_space, comment = parse_space_in_comment(comment)\\n debug(\\\"parsed dict: %s.\\\" % comment_dict_from_space)\\n comment_dict.update(comment_dict_from_space)\\n\\n debug(\\\"parse keyword in comment.\\\")\\n comment_dict_from_keyword, comment = parse_keyword_in_comment(comment)\\n debug(\\\"parsed dict: %s.\\\" % comment_dict_from_keyword)\\n comment_dict.update(comment_dict_from_keyword)\\n # keyword based separation.\\n return comment_dict\",\n \"def filter_lines(view_lines):\\n\\n # this still doesn't work because we need to filter xml above the line level\\n # do newlines from the server ever contain meaningful data or are they pointless?\\n # is all the newline data given by a terminating xml-type tag?\\n\\n # filter lines that start with an exclude string - non-regex\\n excludes = ['<prompt time=\\\"']\\n for exclude in excludes:\\n view_lines = [line for line in view_lines if line[0 : len(exclude)] != exclude]\\n\\n # first lets just rip out the xml... later we will want to process it back into the stream\\n # mostly we can use the xml just to update the state, if that's the case then if we miss\\n # one then it's no proble, we just catch the next one... provided they are regular enough.\\n # if they are not, or set state once, then we definitely want to catch every one\\n xml_free_lines = list()\\n for line in view_lines:\\n\\n # assuming lines only have xml if they start with xml? interesting idea, not sure if real\\n i = 0\\n xml_free_line_segments = list()\\n xml_line_segments = list()\\n xml_free_line_part = b\\\"\\\"\\n xml_line_part = b\\\"\\\"\\n ordered_parsed_line = list() # give a tuple of string, type\\n\\n # ISSUE: i'm pretty sure this is dropping a letter off the first non-xml line segment (or more)\\n # make a bunch of line segments\\n # note that line is a bytes() type, indexing line[i] returns int\\n # if we slice into it line[i:i+1] we get a bytes() type of length 1\\n while i < len(line):\\n\\n if line[i : i + 1] != b\\\"<\\\":\\n xml_free_line_part += line[i : i + 1]\\n\\n else:\\n\\n # increment until you get out of the xml tag or out of the line\\n while i < len(line) and line[i : i + 1] != b\\\">\\\":\\n xml_line_part += line[i : i + 1]\\n i += 1\\n\\n # toss the last b'>' on the end!\\n xml_line_part += line[i : i + 1]\\n\\n # store the xml part off\\n xml_line_segments.append(xml_line_part)\\n ordered_parsed_line.append((\\\"xml\\\", xml_line_part))\\n xml_line_part = b\\\"\\\" # reset the xml part\\n\\n # store xml free part off\\n if len(xml_free_line_part) > 1:\\n xml_free_line_segments.append(xml_free_line_part)\\n ordered_parsed_line.append((\\\"text\\\", xml_free_line_part))\\n xml_free_line_part = b\\\"\\\" # reset the xml_free_line_part\\n\\n i += 1 # covers incrementing past the '>' and incrementing if not yet in a '<'\\n\\n \\\"\\\"\\\"\\n # https://lxml.de/tutorial.html\\n # if the xml cannot be parsed, we just want to catch it and decide what to do\\n try:\\n xml = [lxml.etree.XML(xml_line) for xml_line in xml_line_segments]\\n xml_tags = [x.tag for x in xml]\\n # just testing lxml tag parsing\\n if b'streamWindow' in xml_tags:\\n xml_free_lines.append(b'streamWindow skipped...')\\n\\n except lxml.etree.XMLSyntaxError:\\n xml = list() # no tags\\n # toss any failing XML onto the text stream for manual parsing?\\n # we can follow this approach even if we replace or wrap lxml with a manual parser\\n xml_free_lines.extend(xml_line_segments)\\n \\\"\\\"\\\"\\n # do stuff with the xml components of the line\\n op_line = ordered_parsed_line\\n\\n # strip the line back down to text\\n clean_line = [x[1].replace(b\\\">\\\", b\\\">\\\") for x in op_line if x[0] == \\\"text\\\"]\\n xml_free_lines.append(b\\\"\\\".join(clean_line))\\n\\n # send a hunk of xml so we can see what happened\\n xml_line = [x[1].replace(b\\\">\\\", b\\\">\\\") for x in op_line if x[0] == \\\"xml\\\"]\\n xml_free_lines.append(b\\\"\\\".join(xml_line))\\n\\n # just point it here for now so we don't have to change the return\\n view_lines = xml_free_lines\\n\\n \\\"\\\"\\\"\\n EXCLUDES = [\\n r'<prompt.*>',\\n r'</prompt.*>',\\n ]\\n\\n SUBS = [\\n (r'<.*>', ''),\\n ]\\n\\n # drop empty lines before the regex to save processing\\n # what about lines with whitespace only...\\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\\n\\n for exclude in EXCLUDES:\\n view_lines = [str(line) for line in view_lines if not re.search(exclude, str(line))]\\n\\n for expr, sub in SUBS:\\n view_lines = [re.sub(expr, sub, str(line)) for line in view_lines]\\n\\n # drop empty lines after the regex so they aren't shown\\n view_lines = [line for line in view_lines if line != b'' or line != b'>']\\n \\\"\\\"\\\"\\n\\n return view_lines\",\n \"def _get_skipped_lines_response(rows, id_before, id_after, where, context):\\n response_rows = []\\n id_before_start = int(id_before)\\n id_after_end = int(id_after)\\n if context is not None:\\n id_before_end = id_before_start+context\\n id_after_start = id_after_end-context\\n else:\\n id_before_end = id_after_start = None\\n\\n for row in rows:\\n m = re.match('^<tr( name=\\\"hook\\\")? id=\\\"pair-(?P<rowcount>\\\\d+)\\\">', row)\\n if m:\\n curr_id = int(m.groupdict().get(\\\"rowcount\\\"))\\n # expand below marker line\\n if (where == 'b'\\n and curr_id > id_after_start and curr_id <= id_after_end):\\n response_rows.append(row)\\n # expand above marker line\\n elif (where == 't'\\n and curr_id >= id_before_start and curr_id < id_before_end):\\n response_rows.append(row)\\n # expand all skipped lines\\n elif (where == 'a'\\n and curr_id >= id_before_start and curr_id <= id_after_end):\\n response_rows.append(row)\\n if context is not None and len(response_rows) >= 2*context:\\n break\\n\\n # Create a usable structure for the JS part\\n response = []\\n response_rows = [_strip_invalid_xml(r) for r in response_rows]\\n dom = ElementTree.parse(StringIO('<div>%s</div>' % \\\"\\\".join(response_rows)))\\n for node in dom.getroot().getchildren():\\n content = [[x.items(), x.text] for x in node.getchildren()]\\n response.append([node.items(), content])\\n return response\",\n \"def _get_skipped_lines_response(rows, id_before, id_after, where, context):\\n response_rows = []\\n id_before_start = int(id_before)\\n id_after_end = int(id_after)\\n if context is not None:\\n id_before_end = id_before_start+context\\n id_after_start = id_after_end-context\\n else:\\n id_before_end = id_after_start = None\\n\\n for row in rows:\\n m = re.match('^<tr( name=\\\"hook\\\")? id=\\\"pair-(?P<rowcount>\\\\d+)\\\">', row)\\n if m:\\n curr_id = int(m.groupdict().get(\\\"rowcount\\\"))\\n # expand below marker line\\n if (where == 'b'\\n and curr_id > id_after_start and curr_id <= id_after_end):\\n response_rows.append(row)\\n # expand above marker line\\n elif (where == 't'\\n and curr_id >= id_before_start and curr_id < id_before_end):\\n response_rows.append(row)\\n # expand all skipped lines\\n elif (where == 'a'\\n and curr_id >= id_before_start and curr_id <= id_after_end):\\n response_rows.append(row)\\n if context is not None and len(response_rows) >= 2*context:\\n break\\n\\n # Create a usable structure for the JS part\\n response = []\\n response_rows = [_strip_invalid_xml(r) for r in response_rows]\\n dom = ElementTree.parse(StringIO('<div>%s</div>' % \\\"\\\".join(response_rows)))\\n for node in dom.getroot().getchildren():\\n content = [[x.items(), x.text] for x in node.getchildren()]\\n response.append([node.items(), content])\\n return response\",\n \"def common_context_transformer(row_content):\\n return {\\n 'Action': row_content.get('action', {}).get('value'),\\n 'App': row_content.get('app'),\\n 'Protocol': row_content.get('protocol', {}).get('value'),\\n 'DestinationIP': row_content.get('dest_ip', {}).get('value'),\\n 'RuleMatched': row_content.get('rule_matched'),\\n 'CharacteristicOfApp': row_content.get('characteristics_of_app'),\\n 'LogSourceName': row_content.get('log_source_name'),\\n 'IsNat': row_content.get('is_nat'),\\n 'NatDestinationPort': row_content.get('nat_dest_port'),\\n 'NatDestination': row_content.get('nat_dest', {}).get('value'),\\n 'NatSource': row_content.get('nat_source', {}).get('value'),\\n 'SourceIP': row_content.get('source_ip', {}).get('value'),\\n 'AppCategory': row_content.get('app_category'),\\n 'SourceLocation': row_content.get('source_location'),\\n 'DestinationLocation': row_content.get('dest_location'),\\n 'FileSHA256': row_content.get('file_sha_256'),\\n 'FileName': row_content.get('file_name'),\\n 'TimeGenerated': human_readable_time_from_epoch_time(row_content.get('time_generated', 0))\\n }\",\n \"def process_level_1(content):\\n\\tsoup = BeautifulSoup(content, features=\\\"html.parser\\\")\\n\\n\\t#r = soup.findAll('div',{\\\"class\\\":\\\"listing-item__content\\\"})\\n\\tr = soup.findAll('div',{\\\"class\\\":\\\"listing-item search-listing-result__item\\\"})\\n\\tres=list()\\n\\t# extract information from the source code if the page \\n\\tfor i in r:\\n\\t\\tlisting_id = str(i)[str(i).index('data-wa-data=\\\"')+len(\\\"data-wa-data=\\\")+1:str(i).index(\\\"|source=listings_results\\\")+len(\\\"|source=listings_results\\\")]\\n\\t\\ttype_area = i.find('div',{'class':'listing-characteristic margin-bottom'}).text\\n\\t\\tprice = i.find(\\\"div\\\",{\\\"class\\\":\\\"listing-price margin-bottom\\\"}).text\\n\\t\\tpalce = i.find(\\\"div\\\",{\\\"class\\\":\\\"text--muted text--small\\\"}).text\\n\\t\\tres.append({\\\"id_\\\":listing_id,\\n\\t\\t \\\"area\\\":type_area,\\n\\t\\t \\\"price\\\":price,\\n\\t\\t \\\"place\\\":palce})\\n\\treturn res\",\n \"def _extract_comment_values(line, status, comment, sources):\\n \\n line = line.strip( )\\n\\n if len(line) > 1:\\n if line[1] == ':':\\n sources = re.split(',[\\\\s]*', line[2:].strip( ))\\n elif line[1] == '.':\\n comment = line[2:].strip( )\\n elif line[1] == ',':\\n flags = re.split(',[\\\\s]*', line[2:].strip( ))\\n if not 'fuzzy' in flags:\\n status = store.STATUS_COMPLETE\\n \\n return status, comment, sources\",\n \"def _get_file_content(realpath, ignore_undocumented=False):\\n\\n result = \\\"\\\"\\\"<h2>Module: %s</h2>\\n <div class=\\\"alert alert-info\\\">\\n <div style = \\\"details\\\">path: %s</div>\\n <div style = \\\"details\\\">created: %s, last modified: %s</div></div>\\\"\\\"\\\" %(\\n os.path.basename(realpath),\\n urlparse.unquote(_convert_path_to_url(realpath)),\\n time.ctime(os.path.getmtime(realpath)),\\n time.ctime(os.path.getctime(realpath))\\n )\\n with open(realpath) as sourcefile:\\n code = sourcefile.readlines()\\n abstract_syntax_tree = ast.parse(''.join(code))\\n description = ast.get_docstring(abstract_syntax_tree)\\n if description:\\n result += \\\"<h3>Summary:</h3> <div style = 'summary'>%s</div>\\\" % _convert_str_to_html(description)\\n visitor = DocVisitor()\\n visitor.visit(abstract_syntax_tree)\\n parsed_code = visitor.get_doc()\\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\\n for entry in entries:\\n if ignore_undocumented is False or entry.get(\\\"description\\\"):\\n begin, end = entry.get(\\\"lines\\\")\\n result += '<hr /><div><pre>' + \\\"\\\".join(code[begin:end]).rstrip().rstrip(\\\":\\\") +\\\"</pre>\\\"\\n result += _convert_str_to_html(entry.get(\\\"description\\\"))+\\\"</div>\\\"\\n\\n return result\",\n \"def get_comment_order(self):\\n\\n with g.stats.get_timer('comment_tree.get.1') as comment_tree_timer:\\n comment_tree = CommentTree.by_link(self.link, comment_tree_timer)\\n sort_name = self.sort.col\\n sorter = get_comment_scores(\\n self.link, sort_name, comment_tree.cids, comment_tree_timer)\\n comment_tree_timer.intermediate('get_scores')\\n\\n if isinstance(self.sort, operators.shuffled):\\n # randomize the scores of top level comments\\n top_level_ids = comment_tree.tree.get(None, [])\\n top_level_scores = [\\n sorter[comment_id] for comment_id in top_level_ids]\\n shuffle(top_level_scores)\\n for i, comment_id in enumerate(top_level_ids):\\n sorter[comment_id] = top_level_scores[i]\\n\\n self.timer.intermediate(\\\"load_storage\\\")\\n\\n comment_tree = self.modify_comment_tree(comment_tree)\\n self.timer.intermediate(\\\"modify_comment_tree\\\")\\n\\n initial_candidates, offset_depth = self.get_initial_candidates(comment_tree)\\n\\n comment_tuples = self.get_initial_comment_list(comment_tree)\\n if comment_tuples:\\n # some comments have bypassed the sorting/inserting process, remove\\n # them from `initial_candidates` so they won't be inserted again\\n comment_tuple_ids = {\\n comment_tuple.comment_id for comment_tuple in comment_tuples}\\n initial_candidates = [\\n comment_id for comment_id in initial_candidates\\n if comment_id not in comment_tuple_ids\\n ]\\n\\n candidates = []\\n self.update_candidates(candidates, sorter, initial_candidates)\\n self.timer.intermediate(\\\"pick_candidates\\\")\\n\\n # choose which comments to show\\n while candidates and len(comment_tuples) < self.max_comments:\\n sort_val, comment_id = heapq.heappop(candidates)\\n if comment_id not in comment_tree.cids:\\n continue\\n\\n comment_depth = comment_tree.depth[comment_id] - offset_depth\\n if comment_depth >= self.max_depth:\\n continue\\n\\n child_ids = comment_tree.tree.get(comment_id, [])\\n\\n comment_tuples.append(CommentTuple(\\n comment_id=comment_id,\\n depth=comment_depth,\\n parent_id=comment_tree.parents[comment_id],\\n num_children=comment_tree.num_children[comment_id],\\n child_ids=child_ids,\\n ))\\n\\n child_depth = comment_depth + 1\\n if child_depth < self.max_depth:\\n self.update_candidates(candidates, sorter, child_ids)\\n\\n self.timer.intermediate(\\\"pick_comments\\\")\\n\\n # add all not-selected top level comments to the comment_tuples list\\n # so we can make MoreChildren for them later\\n top_level_not_visible = {\\n comment_id for sort_val, comment_id in candidates\\n if comment_tree.depth.get(comment_id, 0) - offset_depth == 0\\n }\\n\\n if top_level_not_visible:\\n num_children_not_visible = sum(\\n 1 + comment_tree.num_children[comment_id]\\n for comment_id in top_level_not_visible\\n )\\n comment_tuples.append(MissingChildrenTuple(\\n num_children=num_children_not_visible,\\n child_ids=top_level_not_visible,\\n ))\\n\\n self.timer.intermediate(\\\"handle_morechildren\\\")\\n return comment_tuples\",\n \"def _get_comments(self):\\n if not hasattr(self, 'id'):\\n raise BadReference('No matching issue on disk')\\n return filter(lambda x: len(x) == 40, os.listdir(self.paths['comments']))\",\n \"def get_changes_metadata(docx):\\n with zipfile.ZipFile(docx, mode='r') as docxzipfile:\\n with docxzipfile.open(doc_filename) as docfile, \\\\\\n docxzipfile.open(comments_filename) as commentfile:\\n return sorted(\\n itertools.chain(\\n (('change', author, date) for (author, date) in _get_changes_metadata(etree.parse(docfile))),\\n (('comment', author, date) for (author, date) in _get_changes_metadata(etree.parse(commentfile)))),\\n key=lambda m: m[2]) # sort by date\",\n \"def extract_censored_tb(tb, limit=None):\\n # [3:] drops the top frames (which are Halp internals).\\n items = traceback.extract_tb(tb, limit)[3:]\\n if items and current_line_number:\\n # The top item came from a '## ' line; fix its line number:\\n filename, lineno, func_name, text = items[0]\\n if filename == '<string>' and lineno == 1: # (should always be true)\\n items[0] = filename, current_line_number, func_name, None\\n return items\",\n \"def tool_panel_contents( self, trans, **kwds ):\\n filter_method = self._build_filter_method( trans )\\n for _, item_type, elt in self._tool_panel.panel_items_iter():\\n elt = filter_method( elt, item_type )\\n if elt:\\n yield elt\",\n \"def comments(self) -> list:\\n return self._node[\\\"app_data\\\"][\\\"ui_data\\\"].get(\\\"comments\\\", [])\",\n \"def process_body(line):\\n fields = line.split('\\\\t') # preserves newline\\n infos = fields[7].split(';')\\n\\n whitelisted = [\\n info for info in infos\\n if any(\\n info.startswith(x + '=') or info == x\\n for x in WHITELISTED_ANNOTATIONS\\n )\\n ]\\n\\n fields[7] = ';'.join(whitelisted)\\n return '\\\\t'.join(fields)\",\n \"def calc_claim_content(doc, cfg):\\n full_content = doc.get('title', '') + '\\\\n\\\\n' + doc.get('content', '')\\n hl_fact_fields = [f for f in doc if is_fact_tax_hl_field(f)]\\n ent_index = index_ent_spans(doc)\\n logger.debug('Found %s entity spans in doc' % len(ent_index))\\n result = [{\\n 'fact_field': hl_span['field'],\\n 'value': hl_span['value'],\\n **extract_content(full_content, hl_span['span'], ent_index, cfg)\\n }\\n for hl_span in gen_hl_spans(doc, hl_fact_fields)]\\n # for field in hl_fact_fields:\\n # for hl_val in doc[field]:\\n # items = hl_val.split('|')\\n # item, hls = items[0], items[1:]\\n # for hl in hls:\\n # beg, end = hl.split('-')\\n # result.append({\\n # 'fact_field': field,\\n # 'value': item,\\n # 'content': full_content[int(beg):int(end)+1]\\n # })\\n return result\",\n \"def header_filter(value,format,meta,markdown_filepath):\\n anchor_id_prefix = slugify_string(markdown_filepath)\\n\\n # Generate a LaTeX anchor fo the header\\n latex_anchor = generate_latex_label(make_header_id_unique(generate_pandoc_header_slug(markdown_filepath, stringify(value[2])), header_filter.used_ids))\\n\\n # Process header children using the right filter.\\n header_content = walk(value[2], header_children_filter, format, meta)\\n\\n # Replace the old header with a new one with its children processed and\\n # an added LaTeX anchor.\\n return Header(\\n value[0], \\n value[1], \\n header_content + [RawInline('tex',latex_anchor)]\\n )\",\n \"def _collapse_all(self):\\n# global approved, conflicts, suggestions, unknown, cldr\\n self.tree.item('approved', open=False, \\\\\\n values=[self._count_children('approved'), ''])\\n for child in self.tree.get_children('approved'):\\n self.tree.item(child, tags='approved')\\n\\n self.tree.item('conflicts', open=False, \\\\\\n values=[self._count_children('conflicts'), ''])\\n for child in self.tree.get_children('conflicts'):\\n self.tree.item(child, tags='conflicts')\\n self.tree.item(child, open=False)\\n for granchild in self.tree.get_children(child):\\n self.tree.item(granchild, tags='conflicts',)\\n \\n self.tree.item('suggestions', open=False, \\\\\\n values=[self._count_children('suggestions'), ''])\\n for child in self.tree.get_children('suggestions'):\\n self.tree.item(child, tags='suggestions')\\n self.tree.item(child, open=False)\\n for granchild in self.tree.get_children(child):\\n self.tree.item(granchild, tags='suggestions')\\n\\n self.tree.item('unknown', open=False, \\\\\\n values=[self._count_children('unknown'), ''])\\n for child in self.tree.get_children('unknown'):\\n self.tree.item(child, tags='unknown')\\n self.tree.item(child, open=False)\\n for granchild in self.tree.get_children(child):\\n self.tree.item(granchild, tags='unknown')\\n\\n self.tree.item('cldr', open=False, \\\\\\n values=[self._count_children('cldr'), ''])\\n for child in self.tree.get_children('cldr'):\\n self.tree.item(child, tags='cldr')\\n self.tree.item(child, open=False)\\n for granchild in self.tree.get_children(child):\\n self.tree.item(granchild, tags='cldr')\\n\\n self.tree.tag_configure('approved', background='palegreen')\\n self.tree.tag_configure('conflict', background='bisque')\\n self.tree.tag_configure('suggestions', background='lightblue')\\n self.tree.tag_configure('unknown', background='whitesmoke')\\n self.tree.tag_configure('cldr', background='violet')\",\n \"def option_parse_comments(self):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionParseComments/')))\",\n \"def create_clean_content(self):\\n clean_content = []\\n searched_unique_single_word = []\\n un_searched_unique_single_word = []\\n searched_pair_word = []\\n searched_unique_single_word_synonym = []\\n\\n for i in range(self.subhead.shape[0]):\\n clean_content.append(\\n self.filter_stop_words(self.subhead.Col7[i], self.stop_words)\\n )\\n searched_unique_single_word.append(\\n self.get_searched_unique_single_word(\\n self.subhead.Col7[i], self.stop_words\\n )\\n )\\n un_searched_unique_single_word.append(\\n self.get_un_searched_single_word(self.subhead.Col7[i], self.stop_words)\\n )\\n searched_pair_word.append(\\n self.get_searched_paired_word(self.subhead.Col7[i], self.stop_words)\\n )\\n searched_unique_single_word_synonym.append(\\n self.get_searched_single_word_synonym(\\n self.subhead.Col7[i], self.stop_words\\n )\\n )\\n\\n self.subhead[\\\"clean_content\\\"] = clean_content\\n self.subhead[\\\"searched_unique_single_word\\\"] = searched_unique_single_word\\n self.subhead[\\\"un_searched_unique_single_word\\\"] = un_searched_unique_single_word\\n self.subhead[\\\"searched_pair_word\\\"] = searched_pair_word\\n self.subhead[\\n \\\"searched_unique_single_word_synonym\\\"\\n ] = searched_unique_single_word_synonym\",\n \"def get_remark(self, number):\\n CONTENT_START_COLUMN = 11\\n\\n # in case a non-integer is accidentally given\\n number = int(number)\\n if number < 0 or number > 999:\\n raise ValueError(\\\"The number must be in range 0-999\\\")\\n \\n remark_string = f\\\"REMARK {number:>3d}\\\"\\n # Find lines and omit ``REMARK XXX `` part\\n remark_lines = [\\n line[CONTENT_START_COLUMN:] for line in self.lines\\n if line.startswith(remark_string)\\n ]\\n if len(remark_lines) == 0:\\n return None\\n # Remove first empty line\\n remark_lines = remark_lines[1:]\\n return remark_lines\",\n \"def extract_comments(self, response):\\n\\n # use the comment_parser package to extract HTML and JS comments\\n try:\\n html_comments = comment_parser.extract_comments_from_str(response.text, mime=\\\"text/html\\\")\\n except (UnterminatedCommentError, CP_ParseError):\\n html_comments = []\\n try:\\n js_comments = comment_parser.extract_comments_from_str(response.text, mime=\\\"application/javascript\\\")\\n except (UnterminatedCommentError, CP_ParseError):\\n js_comments = []\\n\\n # put the discovered comments together\\n comments = list()\\n for comment in html_comments:\\n comments.append({\\\"line\\\": comment.line_number(), \\\"comment\\\": \\\"<!--\\\" + comment.text() + \\\"-->\\\"})\\n for comment in js_comments:\\n if comment.is_multiline():\\n comments.append({\\\"line\\\": comment.line_number(), \\\"comment\\\": \\\"/*\\\" + comment.text() + \\\"*/\\\"})\\n else:\\n comments.append({\\\"line\\\": comment.line_number(), \\\"comment\\\": \\\"//\\\" + comment.text()})\\n\\n # store the discovered comments w.r.t. the response's path & query\\n if comments:\\n parsed_url = urllib.parse.urlparse(response.url)\\n if self.config[\\\"crawl_parameter_links\\\"].lower() == \\\"true\\\":\\n self.comments[parsed_url.path + parsed_url.query] = comments\\n else:\\n self.comments[parsed_url.path] = comments\",\n \"def _comments(self) -> List[\\\"BaseSegment\\\"]:\\n return [seg for seg in self.segments if seg.is_type(\\\"comment\\\")]\",\n \"def get_documented_in_lines(lines, module=None, filename=None):\\n title_underline_re = re.compile(\\\"^[-=*_^#]{3,}\\\\s*$\\\")\\n autodoc_re = re.compile(\\\".. auto(function|method|attribute|class|exception|module)::\\\\s*([A-Za-z0-9_.]+)\\\\s*$\\\")\\n autosummary_re = re.compile(r'^\\\\.\\\\.\\\\s+autosummary::\\\\s*')\\n module_re = re.compile(r'^\\\\.\\\\.\\\\s+(current)?module::\\\\s*([a-zA-Z0-9_.]+)\\\\s*$')\\n autosummary_item_re = re.compile(r'^\\\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\\\s*.*?')\\n toctree_arg_re = re.compile(r'^\\\\s+:toctree:\\\\s*(.*?)\\\\s*$')\\n \\n documented = {}\\n \\n current_title = []\\n last_line = None\\n toctree = None\\n current_module = module\\n in_autosummary = False\\n \\n for line in lines:\\n try:\\n if in_autosummary:\\n m = toctree_arg_re.match(line)\\n if m:\\n toctree = m.group(1)\\n continue\\n\\n if line.strip().startswith(':'):\\n continue # skip options\\n\\n m = autosummary_item_re.match(line)\\n if m:\\n name = m.group(1).strip()\\n if current_module and not name.startswith(current_module + '.'):\\n name = \\\"%s.%s\\\" % (current_module, name)\\n documented.setdefault(name, []).append(\\n (filename, current_title, 'autosummary', toctree))\\n continue\\n if line.strip() == '':\\n continue\\n in_autosummary = False\\n\\n m = autosummary_re.match(line)\\n if m:\\n in_autosummary = True\\n continue\\n\\n m = autodoc_re.search(line)\\n if m:\\n name = m.group(2).strip()\\n if m.group(1) == \\\"module\\\":\\n current_module = name\\n documented.update(get_documented_in_docstring(\\n name, filename=filename))\\n elif current_module and not name.startswith(current_module+'.'):\\n name = \\\"%s.%s\\\" % (current_module, name)\\n documented.setdefault(name, []).append(\\n (filename, current_title, \\\"auto\\\" + m.group(1), None))\\n continue\\n\\n m = title_underline_re.match(line)\\n if m and last_line:\\n current_title = last_line.strip()\\n continue\\n\\n m = module_re.match(line)\\n if m:\\n current_module = m.group(2)\\n continue\\n finally:\\n last_line = line\\n\\n return documented\",\n \"def show_expanded(tree, expand_macros, **kw):\\n new_tree = []\\n for stmt in tree:\\n with hq as code:\\n unhygienic[log](u[macropy.core.unparse(stmt)])\\n new_tree.append(code)\\n new_tree.append(stmt)\\n\\n return new_tree\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.53617066","0.49494117","0.48269865","0.47749653","0.47021854","0.46672785","0.46630976","0.46363974","0.45885256","0.45649537","0.45570302","0.45216203","0.44642898","0.44569367","0.44267008","0.43709692","0.43698663","0.42966306","0.4290518","0.42780748","0.42686164","0.42641485","0.4245407","0.42283052","0.42195168","0.42194372","0.42145795","0.42119923","0.42029268","0.41965795","0.4194287","0.41851354","0.41767514","0.41665357","0.41631335","0.41310433","0.41283372","0.41167593","0.41079807","0.409478","0.40921575","0.40880647","0.40810308","0.4079398","0.40609273","0.40532732","0.40521017","0.40385497","0.40345073","0.40184876","0.40163055","0.40116608","0.3991957","0.39882413","0.39821082","0.39759624","0.39643946","0.39402628","0.39401788","0.39394954","0.39385244","0.3937519","0.3927652","0.3926695","0.39200416","0.3916983","0.39022207","0.38998127","0.38981608","0.38968018","0.38953963","0.3884752","0.38842472","0.38839027","0.38713926","0.38662767","0.3858633","0.38585067","0.38585067","0.3858357","0.38509163","0.38366607","0.38364485","0.38316563","0.38309795","0.38263017","0.38067955","0.3802071","0.3801171","0.37887594","0.37799484","0.3779109","0.37758708","0.3773457","0.37725526","0.3771646","0.37652576","0.37597534","0.3756761","0.37559548"],"string":"[\n \"0.53617066\",\n \"0.49494117\",\n \"0.48269865\",\n \"0.47749653\",\n \"0.47021854\",\n \"0.46672785\",\n \"0.46630976\",\n \"0.46363974\",\n \"0.45885256\",\n \"0.45649537\",\n \"0.45570302\",\n \"0.45216203\",\n \"0.44642898\",\n \"0.44569367\",\n \"0.44267008\",\n \"0.43709692\",\n \"0.43698663\",\n \"0.42966306\",\n \"0.4290518\",\n \"0.42780748\",\n \"0.42686164\",\n \"0.42641485\",\n \"0.4245407\",\n \"0.42283052\",\n \"0.42195168\",\n \"0.42194372\",\n \"0.42145795\",\n \"0.42119923\",\n \"0.42029268\",\n \"0.41965795\",\n \"0.4194287\",\n \"0.41851354\",\n \"0.41767514\",\n \"0.41665357\",\n \"0.41631335\",\n \"0.41310433\",\n \"0.41283372\",\n \"0.41167593\",\n \"0.41079807\",\n \"0.409478\",\n \"0.40921575\",\n \"0.40880647\",\n \"0.40810308\",\n \"0.4079398\",\n \"0.40609273\",\n \"0.40532732\",\n \"0.40521017\",\n \"0.40385497\",\n \"0.40345073\",\n \"0.40184876\",\n \"0.40163055\",\n \"0.40116608\",\n \"0.3991957\",\n \"0.39882413\",\n \"0.39821082\",\n \"0.39759624\",\n \"0.39643946\",\n \"0.39402628\",\n \"0.39401788\",\n \"0.39394954\",\n \"0.39385244\",\n \"0.3937519\",\n \"0.3927652\",\n \"0.3926695\",\n \"0.39200416\",\n \"0.3916983\",\n \"0.39022207\",\n \"0.38998127\",\n \"0.38981608\",\n \"0.38968018\",\n \"0.38953963\",\n \"0.3884752\",\n \"0.38842472\",\n \"0.38839027\",\n \"0.38713926\",\n \"0.38662767\",\n \"0.3858633\",\n \"0.38585067\",\n \"0.38585067\",\n \"0.3858357\",\n \"0.38509163\",\n \"0.38366607\",\n \"0.38364485\",\n \"0.38316563\",\n \"0.38309795\",\n \"0.38263017\",\n \"0.38067955\",\n \"0.3802071\",\n \"0.3801171\",\n \"0.37887594\",\n \"0.37799484\",\n \"0.3779109\",\n \"0.37758708\",\n \"0.3773457\",\n \"0.37725526\",\n \"0.3771646\",\n \"0.37652576\",\n \"0.37597534\",\n \"0.3756761\",\n \"0.37559548\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71825683"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85184,"cells":{"query":{"kind":"string","value":"Replace matched element in content."},"document":{"kind":"string","value":"def _replace_element(element):\n # Guess line number\n count = element.group().count(\"\\n\")\n\n # Ensure that the replacement string keep the same length that\n # the original content to be able to use the match positions\n _buffer = len(element.group()) - count - 2\n\n if len(element.group()) > 2:\n line_number = content[:element.start()].count(\"\\n\")+1\n collapsed_content[line_number] = (\n _initial_content[element.start():element.end()]\n )\n\n return \"<>{buffer}{lines}\".format(\n buffer=\" \" * _buffer,\n lines=\"\\n\" * count\n )"},"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 _update_content(self, content, siteurl):\n if not content:\n return content\n\n hrefs = self._get_intrasite_link_regex()\n return hrefs.sub(lambda m: self._link_replacer(siteurl, m), content)","def string_replace_xml_text(element, pattern, value):\n if element.text:\n element.text = element.text.replace(pattern, value.decode('utf8'))\n for c in element.getchildren():\n string_replace_xml_text(c, pattern, value)","def replaceElement(self, *args):\n return _libsbml.Submodel_replaceElement(self, *args)","def _replace(self, p, e):\n node = self._validate_position(p)\n old = node.element\n node.element = e\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old = node.element\n node.element = e\n return old","def _replace(self, p, data):\n node = self._validate(p)\n old = node._element\n node._element = data\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old = node._element\n node._element = e\n return old","def updateContent(content, **kwargs):","def _replace(self, p, e):\n node = self._validate(p)\n old = node._element\n node._element = e\n return old","def _replace(self, p, e):\n node = self._validate(p)\n old_value = node._element\n node._element = e\n return old_value","def _update_content(self, content, siteurl):\r\n if not content:\r\n return content\r\n\r\n instrasite_link_regex = self.settings['INTRASITE_LINK_REGEX']\r\n regex = r\"\"\"\r\n (?P<markup><\\s*[^\\>]* # match tag with all url-value attributes\r\n (?:href|src|poster|data|cite|formaction|action)\\s*=)\r\n\r\n (?P<quote>[\"\\']) # require value to be quoted\r\n (?P<path>{0}(?P<value>.*?)) # the url value\r\n \\2\"\"\".format(instrasite_link_regex)\r\n hrefs = re.compile(regex, re.X)\r\n\r\n def replacer(m):\r\n what = m.group('what')\r\n value = urlparse(m.group('value'))\r\n path = value.path\r\n origin = m.group('path')\r\n\r\n # XXX Put this in a different location.\r\n if what == 'filename':\r\n if path.startswith('/'):\r\n path = path[1:]\r\n else:\r\n # relative to the source path of this content\r\n path = self.get_relative_source_path(\r\n os.path.join(self.relative_dir, path)\r\n )\r\n\r\n if path not in self._context['filenames']:\r\n unquoted_path = path.replace('%20', ' ')\r\n\r\n if unquoted_path in self._context['filenames']:\r\n path = unquoted_path\r\n\r\n if path in self._context['filenames']:\r\n origin = '/'.join((siteurl,\r\n self._context['filenames'][path].url))\r\n origin = origin.replace('\\\\', '/') # for Windows paths.\r\n else:\r\n logger.warning((\"Unable to find {fn}, skipping url\"\r\n \" replacement\".format(fn=value),\r\n \"Other resources were not found\"\r\n \" and their urls not replaced\"))\r\n elif what == 'category':\r\n origin = Category(path, self.settings).url\r\n elif what == 'tag':\r\n origin = Tag(path, self.settings).url\r\n\r\n # keep all other parts, such as query, fragment, etc.\r\n parts = list(value)\r\n parts[2] = origin\r\n origin = urlunparse(parts)\r\n\r\n return ''.join((m.group('markup'), m.group('quote'), origin,\r\n m.group('quote')))\r\n\r\n return hrefs.sub(replacer, content)","def replace_by_xml(self, xml_str, el_idx=0):\n root_el = self.parse_xml(xml_str)\n self.replace_by_etree(root_el, el_idx)","def replace(\n haystack : Exp, haystack_context : Context, haystack_pool : Pool,\n needle : Exp, needle_context : Context, needle_pool : Pool,\n replacement : Exp) -> Exp:\n return _Replacer(haystack_context, haystack_pool, needle, needle_context, needle_pool, replacement).visit(haystack)","def replace(self, element):\n for i, sibling in enumerate(self.parent._children):\n if sibling is self:\n self.parent._children[i] = element\n element.parent_docid = self.parent_docid","def addReplacedElement(self, *args):\n return _libsbml.CompSBasePlugin_addReplacedElement(self, *args)","def ReplaceElement(self, position, element):\n self.__context.builder.DocumentElementReplace(self._blip_data.wave_id,\n self._blip_data.wavelet_id,\n self._blip_data.blip_id,\n position, element)","def run(self, content):\n parts = []\n offset = 0\n for match in self.regexp.finditer(content):\n parts.append(content[offset:match.start(0)])\n parts.append(self.replace(match))\n offset = match.end(0)\n parts.append(content[offset:])\n return ''.join(parts)","def replace(self, text):\n if self.should_skip(text):\n return text\n return self.replacer.sub(self._callback, text)","def replace(self, p, e):\n original = self._validate(p)\n old_value = original._element # temporarily store old element\n original._element = e # replace with new element\n\n return old_value","def inject_on_div(div_id, original, content_to_inject):\n m = re.match(\".*(<div.*id=\\\"\"+ div_id +\"\\\".*>)(.*)(</div>).*\", original, re.DOTALL)\n return re.sub(m.group(1) + m.group(2) + m.group(3), m.group(1) + content_to_inject + m.group(3) , original)","def update_content(self):\n raise NotImplementedError","def replace(self, oldtext, newtext):\r\n return self","def replace(self, pattern, substitute, pattern_type=None):\n\t\tpattern = convert_pattern(pattern, pattern_type)\n\t\twith self.AutoSplitlines():\n\t\t\tself.lines = [(pattern.sub(substitute, line) if pattern.search(line) else line) for line in self.lines]","def replace_content(g):\n g[0] = 88\n g[1] = 22\n g[2] = 44\n print(\"g = \", g)","def _replace(self, match_layer_node, replacement_layer_node):\n if self._is_functional_model(self.model):\n self._replace_functional(match_layer_node, replacement_layer_node)\n else:\n self._replace_sequential(match_layer_node, replacement_layer_node)","def replace_all(self, content):\n if (not self.exists()):\n raise IOError(\"File at '{}' does not exist.\".format(self.location))\n with open(self.location, 'w') as f:\n f.write(content)","def sed(self, search, replace):\n\n for section in self.sections:\n for i, block in enumerate(section.blocks):\n if block == search:\n section.blocks[i] = replace\n self.all_damaged = True\n self.dirty = True","def replace_by_etree(self, root_el, el_idx=0):\n el = self.get_element_by_name(root_el.tag, el_idx)\n el[:] = list(root_el)\n el.attrib = root_el.attrib","def test_replace(self):\n\n regex = \"th\"\n expected = \"Hello, htis is Fun Ilrys. I just wanted to know how htings goes around hte tests.\" # pylint: disable=line-too-long\n actual = Regex(self.data, regex, replace_with=\"ht\").replace()\n\n self.assertEqual(expected, actual)\n\n # Test of the case that there is not replace_with\n regex = \"th\"\n expected = self.data\n actual = Regex(self.data, regex).replace()\n\n self.assertEqual(expected, actual)","def replace_in_file(file_path, find, replace):\n\tcontent = read_file(file_path)\n\tcontent = content.replace(find, replace)\n\twrite_file(file_path, content)","def replacingBasicElementsFromEpubLibre(text):\n text = re.sub(r'<div class=\"vineta\"><img[^<]*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n \n \n # Replace some elements with atributes with other cleaner elements\n\n text = re.sub(r'<p class=\"ind\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<p class=\"cursiva\\d*\">(.*?)</p>', r'<p><seg rend=\"italic\">\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"calibre[0-9]+\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\\d*\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"salto[0-9]+\">', r'<milestone unit=\"section\"/>\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoc\">', r'<milestone unit=\"section\"/>\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"sinopsis\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"ilustra\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE) \n text = re.sub(r'<div class=\"info\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<br class=\"calibre9\" />', r' ', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<sup(|[^>]*)>(<a[^>]*?>)?\\[.*?\\](</a>)?</sup>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span(|[^>]*)>\\s*</span>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<a(|[^>]*)>\\s*</a>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(tlogo|tautor|ttitulo|trevision|tfirma)\">.*?</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<h1 class=\"ttitulo\">(.*?)</h1>\\s*(<p class=\"titulo\">.*?</p>)', r'<head>\\1: \\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<img[^>]*?>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(bloque|ala)?derecha[0-9]*\">(.*?)</p>', r'<ab>\\2</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asangre[0-9]?\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<p class=\"centrado1\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<p class=\"extenso\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"(normal|calibre)[0-9]*\">(.*?)</span>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p><span class=\"(cap[0-9]*|versalita|smallcaps)\">(..?)</span>', r'<p>\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"(versalita|smallcaps)[0-9]*\">(.*?)</span>', r'<seg rend=\"smallcaps\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<div class=\"(?:poema[0-9]*|poe|versos|estrofas|citar\\d*|verso\\d*|versosinpie\\d*|centro|centrado|poemaizqcursi\\d*|poemaizq|poemacursi\\d*)\">(.*?)</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"center\">\\s+<table class=\"text\">\\s+<tr class=\"calibre\\d*\">\\s+<td class=\"calibre\\d*\">(\\s+.*?)</td>\\s+</tr>\\s+</table>\\s+</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE) \n\n text = re.sub(r'<blockquote class=\"(?:versos?\\d*)\">(.*?)</blockquote>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n\n \n text = re.sub(r'(<lg>\\s*)<p class=\"izq\">', r'\\1<l>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"poemaizqcursi\">(.*?)</p>', r'<lg>\\n<l>\\1</l>\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"verso\">(.*?)</p>', r'<l>\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"normal1\">(.*?)</p>', r'<l>\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"cursiva\">(.*?)</p>', r'<p><seg rend=\"italic\">\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<em(|[^>]*)>(.*?)</em>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n\n text = re.sub(r'<p class=\"estrofa1\">', r'\\n\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<i(|[^>]*)>(.*?)</i>', r'<seg rend=\"italic\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<b(|[^>]*)>(.*?)</b>', r'<seg rend=\"bold\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<sup(|[^>]*)>(.*?)</sup>', r'<seg rend=\"sup\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"cursiva[0-9]*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<sub(|[^>]*)>(.*?)</sub>', r'<seg rend=\"subscript\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<small(|[^>]*)>(.*?)</small>', r'<seg rend=\"small\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"nosep\\d*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"nosep\\d*\">(.*?)</span>', r'<seg rend=\"italic\">\\1</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<strong(|[^>]*)>(.*?)</strong>', r'<seg rend=\"bold\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"cita\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"micita\">(.*?)</p>', r'<quote>\\n<p>\\1</p>\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"acotacion\\d*\">(.*?)</div>', r'<quote>\\n\\1\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<cite.*?>(.*?)</cite>', r'<seg type=\"cite\">\\1</seg>', text, flags=re.DOTALL|re.IGNORECASE)\n \n # Setting quotes in floatingText element\n text = re.sub(r'<div class=\"(?:mi)?cita\">(.*?)</div>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<blockquote class=\"bloque\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"salto25x\">([IVXCL\\d]+)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"salto25x\\d+\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\n \n \n text = re.sub(r'<div class=\"bloquederecha1\">(.+?)</div>', r'<quote>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"cursiva[0-9]*\">', r'<div rend=\"italic\">', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"calibre\" id=\"calibre_link-[0-9]+\">', r'<div>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\">[… ]+?</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asteriscos\">[\\* ∗]+</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\">\\[…\\]</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"asteriscos\\d*\">[\\. ]+</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<hr (class=\"calibre\\d*\" )?/>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<milestone unit=\"section\"/>\\s+)+', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<div class=\"(?:banner|text\\d+)\">(.*?)</div>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"banner\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"carta\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'<blockquote class=\"cita\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div>\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<blockquote class=\"calibre\\d*\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n<div type=\"section\">\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<html.*?<body>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'</body></html>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>)\\s*(<head>.*?</head>)', r'\\1</div>\\n<div>\\n\\2', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"(?:subh?|inicio|numtitulo|subt)\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<h[1-6][^>]*>(.*?)</h[1-6]>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(tsub|sub)?tit(ulo)?[0-9]*\">(.*?)</p>', r'<head>\\3</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(subcapitulo|capitulonombre|h\\d+)\">(.*?)</p>', r'<head>\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"tit-cap\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'</head>\\s*<p class=\"(subtil|subcap)\">(.*?)</p>', r': \\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<span class=\"ncap\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"ncap\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"palabra\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"sigla\\d*\">(.*?)</span>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<p>—?)<span class=\"inicial\">(.*?)</span>', r'\\1\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<p>—?¿?)<big class=\"calibre\\d*\">(.*?)</big>', r'\\1\\2', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<head>\\s*</head>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p [^>]*?>\\s*\\* *\\* *\\*</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"sep\">\\* \\* \\*</p>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'</head>\\s*<head>', r': ', text, flags=re.DOTALL|re.IGNORECASE)\n #text = re.sub(r'(</head>)(\\s*<head>)', r'\\1\\n<div>\\n\\2', text, flags=re.DOTALL|re.IGNORECASE)\n\n\n \"\"\"\n #Setting divs after ps. Used for 219\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</p>|</div>)(\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\1\\n<div>\\2</div>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n\n # Cleaning some <milestone />\n text = re.sub(r'(<div>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</div>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(</head>\\s*)<milestone unit=\"section\"/>', r'\\1', text, flags=re.DOTALL|re.IGNORECASE)\n\n # Setting some floatingTexts\n #text = re.sub(r'(<div(| [^>]*?)>((?!<div).)*</div>)(\\s*<p)', r'<floatingText>\\n<body>\\n\\1\\n</body>\\n</floatingText>\\n\\4', text, flags=re.DOTALL|re.IGNORECASE)\n\n #text = re.sub(r'(<div(|[^>]+?)>.*?</div>)(\\s*<p)', r'<floatingText>\\n<body>\\n<div>\\n\\1\\n</div>\\n</body>\\n</floatingText>\\n\\3', text, flags=re.DOTALL|re.IGNORECASE)\n \n # Floating Texts\n\n text = re.sub(r'<p(| [^>]+)>[\\s\\r\\n]*</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'\\n[ \\t]+', r'\\n', text, flags=re.IGNORECASE)\n text = re.sub(r'[\\r\\n]+', r'\\r\\n', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div>[\\r?\\n]*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'(<div>((?!<div>).)*</div>\\r?\\n)\\Z', r'<!--\\1-->', text, flags=re.DOTALL|re.IGNORECASE)\n \n\n text = re.sub(r'<div class=\"cita?[0-9]*\">(.*?)</div>', r'<quote>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"cita[0-9]*\">(.*?</p>)', r'<quote>\\n<p>\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\n\n \n text = re.sub(r'<br class=\"calibre[0-9]*\" />', r'', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'(<p>—?. ?)<span class=\"palabra\">(.*?)</span>', r'\\1<seg rend=\"small\">\\2</seg>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\"><span class=\"inicial\">(.*)</span><span class=\"palabra\">(.*?)</span>', r'<p>\\1\\2', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"saltoinicio\"><span class=\"inicial\">(.*)</span>', r'<p>\\1', text, flags=re.IGNORECASE)\n text = re.sub(r'<p>(.)<span>(.*)</span>', r'<p>\\1\\2', text, flags=re.IGNORECASE)\n text = re.sub(r'<span class=\"inicial\">(.*)</span>', r'\\1', text, flags=re.IGNORECASE)\n\n \n text = re.sub(r'(<head>.*?)<seg rend=\"(smallcaps|small)\">(.*?)</seg>(.*?</head>)', r'\\1\\3\\4', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<div[^>]*?>\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n \n text = re.sub(r'<div class=\"(?:tablacentro\\d*|center)\">\\s*<table class=\"text\\d*\">\\s*<tr class=\"calibre\\d*\">\\s*<td class=\"calibre\\d*\">(.*?)\\s*</td>\\s*</tr>\\s*</table>\\s*</div>', r'<lg>\\1\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n\n text = re.sub(r'<p class=\"traduccion\">(.*?)</p>', r'<ab type=\"translation\">\\1</ab>', text, flags=re.IGNORECASE)\n\n #text = re.sub(r'<p class=\"centrado\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"centrado\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n \n #text = re.sub(r'<blockquote class=\"calibre18\">(.*?)</blockquote>', r'<floatingText>\\n<body>\\n\\1\\n</body>\\n</floatingText>\\n', text, flags=re.DOTALL|re.IGNORECASE)\n\n \"\"\"\n #The next lines were used for 232, a theater-like novel\n \n text = re.sub(r'<p>(.*?</seg>)(\\.\\—.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n #The next lines were used for 109, a theater-like novel\n text = re.sub(r'<p>(.*?</seg>\\.)(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\"italic\">.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<seg rend=\"italic\">(\\(.*?)</seg>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n #The next lines were used for 224, a theater-like novel\n text = re.sub(r'<p>(.<seg rend=\"small\">.*?</seg>\\.)(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n #text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\"italic\">.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<seg rend=\"italic\">(\\(.*?)</seg>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n \"\"\"\n \"\"\"\n # Code used for paradox rey\n text = re.sub(r'<div class=\"clear\">\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"banner\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"francesa\\d*\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n \"\"\"\n text = re.sub(r'<p class=\"personaje\">(.*?)</p>\\s*<p>(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<span class=\"descrip\">(.*?)</span>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"(?:descrip\\d*|entrada|fin)\">(.*?)</p>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<p class=\"cuadro\">(.*?)</p>', r'<head>\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"descrip1\">(.*?)</div>', r'<stage>\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"puntos\">.*?</div>', r'<milestone unit=\"section\"/>', text, flags=re.DOTALL|re.IGNORECASE)\n text = re.sub(r'<div class=\"tablacentro\">(.*?)</div>', r'<lg>\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\n \"\"\"\n text = re.sub(r'<p class=\"decla\">(.*?\\. )(.*?)</p>', r'<sp>\\n<speaker>\\1</speaker>\\n<p>\\2</p>\\n</sp>', text, flags=re.IGNORECASE)\n text = re.sub(r'<p class=\"(?:descrip|decla1)\">(.*?)</p>', r'<stage>\\1</stage>', text, flags=re.IGNORECASE)\n\n\n text = re.sub(r'(<seg\\s+rend\\s*=\\s*\"small(?:caps)?\">)(.*?)(?=</seg>)', lambda m: m.group(1) + m.group(2).lower(), text)\n \n text = re.sub(r'(<seg\\s+rend\\s*=\\s*\"small(?:caps)?\">)(.*?)(</seg>)', r'\\2', text, flags=re.IGNORECASE)\n \n text = re.sub(r'<big[^>]*?>(.*?)</big>', r'\\1', text, flags=re.IGNORECASE) \n text = re.sub(r'<div class=\"serif\" id=\"calibre_link-\\d+\">', r'<div>', text, flags=re.IGNORECASE) \n text = re.sub(r'<div class=\"sinmargen\" id=\"calibre_link-\\d+\">', r'<div>', text, flags=re.IGNORECASE) \n\n text = re.sub(r'<p class=\"(?:carta|firma\\d+)\">(.*?)</p>', r'<ab>\\1</ab>', text, flags=re.IGNORECASE) \n\n\n\n return text","def replace_with(*, replacement, f=DECORATED):\n return replacement","def replace_with(self, replacement_arg):\n replacement = BinaryNode.or_none(replacement_arg)\n\n # Do not proceed if replacement is invalid\n # Nothing to do if replacing node with itself\n if replacement == self:\n return self\n\n # Link parent\n parent = self.get_parent()\n if parent is not None:\n if self.is_left_child():\n parent.set_left(replacement)\n elif self.is_right_child():\n parent.set_right(replacement)\n elif self.tree is not None:\n # Replacing head\n self.tree.head = replacement\n\n # Remove node from tree\n self.set_parent(None)","def replace(node, key, value):\n if isinstance(node, (Document, Object)):\n data = dict(node)\n elif isinstance(node, Array):\n data = list(node)\n else:\n raise TypeError(\n \"Expected Core API container type. Got '%s'.\" % type(node)\n )\n\n data[key] = value\n if isinstance(node, Document):\n return type(node)(url=node.url, title=node.title, content=data)\n return type(node)(data)","def change_content(options):\n call_command('''grep -r -l -- '%(patrn)s' . | tr '\\\\n' '\\\\0' | xargs -0 sed -i \"s/%(patrn)s/%(repl)s/g\"''', options)","def replaceChild(self, *args):\n return _libsbml.ASTNode_replaceChild(self, *args)","def in_place_substitute(self):\r\n if self.substitute is not None:\r\n node = self.convert_type()\r\n self.leaf_replace(node) # for internals only\r\n self.root_replace(node)","def set_content(self, content):\n if check_data_exist(content) is True:\n self.content = content.text","def replaceChild(self, *args):\n return _libsbml.ASTBasePlugin_replaceChild(self, *args)","def _replace_keyword(self, keyword, replacement, count=0):\n\n def replace_with_inline(e, doc):\n if type(e) == Str and e.text == keyword:\n doc.num_matches += 1\n if not count or doc.num_matches <= count:\n return replacement\n\n def replace_with_block(e, doc):\n '''\n It's difficult to replace a keyword with an entire Block element.\n\n This is because the keyword is of type Str (an Inline) and the parent\n object of a Str can only contain Inlines and not Blocks\n (e.g. Para can contain Inlines, not Divs)\n\n Implications:\n\n 1) If the Str that contains the keyword is inside another\n Inline instead of a Block (e.g. Div -> Emph -> Str)\n then we have to do a trick:\n when .walk() touches an Emph that contains Str(keyword),\n it replaces the Emph with Str(keyword).\n\n 2) If the element that contains the Str(keyword) has multiple children,\n then we are in a bind as replacing it will destroy information.\n Thus, we can't do do it\n\n 3) If the element that contains the Str(keyword) does so in a DictContainer\n instead of a ListContainer, then we cannot retrieve the \"first and only\n element\" easily, so we also abort (happens with metadata elements).\n '''\n\n # Here we can check that e.content is ListContainer (i.e. not DictContainer)\n # or check that e is not a Metavalue (\"not isinstance(e, MetaValue)\")\n\n if hasattr(e, 'content') and isinstance(e.content, ListContainer) and len(e.content) == 1:\n ee = e.content[0]\n if type(ee) == Str and ee.text == keyword:\n if isinstance(e, Block):\n doc.num_matches += 1\n if not count or doc.num_matches <= count:\n return replacement\n elif isinstance(e, Inline):\n return Str(keyword)\n else:\n pass # not implemented\n\n doc = self.doc\n if doc is None:\n raise Exception('No root document')\n doc.num_matches = 0\n if isinstance(replacement, Inline):\n return self.walk(replace_with_inline, doc)\n elif isinstance(replacement, Block):\n return self.walk(replace_with_block, doc)\n else:\n raise NotImplementedError(type(replacement))","def replace_text(self,\n\t text,\n\t fname,\n\t pattern=None,\n\t expect=None,\n\t shutit_pexpect_child=None,\n\t note=None,\n\t before=False,\n\t force=False,\n\t line_oriented=True,\n\t loglevel=logging.DEBUG):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\treturn self.change_text(text,\n\t\t fname,\n\t\t pattern,\n\t\t expect,\n\t\t shutit_pexpect_child,\n\t\t before,\n\t\t force,\n\t\t note=note,\n\t\t line_oriented=line_oriented,\n\t\t replace=True,\n\t\t loglevel=loglevel)","def replace_with_text(self):\r\n self.parser.stripTags(self.get_top_node(), 'b', 'strong', 'i', 'br', 'sup')","def set_content(self, content):\n\n # pylint: disable=W0201\n self.clear()\n self.content = content","def replace_data(self, original, replacement, pattern=None, use_regex=False, queries=[]):\n import hxl.filters\n replacement = hxl.filters.ReplaceDataFilter.Replacement(original, replacement, pattern, use_regex)\n return hxl.filters.ReplaceDataFilter(self, [replacement], queries=queries)","def replace_all(self):\n i = 0\n while self.textedit.textCursor().hasSelection():\n self.textedit.textCursor().insertText(self.ui.textToReplace.text())\n self.find()\n i += 1\n self.show_message(unicode(self.tr(\"Replaced {0} occurrence(s)\")).format(i))","def set_content(self, content):\n self.content = content","def set_content(self, content):\n self.content = content","def replace_tag_value( msg, tag, value ) :\n _TAG_RE = re.compile('\\x01' + str(tag) + '=' + '[\\s\\w:-]*' + '\\x01')\n msg = _TAG_RE.sub('\\x01' + str(tag) + '=' + str(value) + '\\x01', msg,1)\n return msg","def Replace(expression, find, replace, start=1, count=-1):\n if find:\n return expression[:start - 1] + expression[start - 1:].replace(find, replace, count)\n else:\n return expression","def substituteNodes(node, replacements):\n p = node.parentNode\n for r in replacements:\n p.insertBefore(r, node)\n p.removeChild(node)","def rep(self,tag,nstr):\n tmp = []\n for line in self.content: \n if tag in line:\n tmp.append(line.replace(tag,nstr))\n else:\n tmp.append(line)\n self.content = tmp","def findAndReplace(self):\n\n # Prompts user for find regex and replace text\n findText, replaceText = Model.FindAndReplaceDialogBox.getResults(self)\n\n # Gets the current selection from the current tab\n selectionModel = self.getCurrentView().selectionModel()\n\n # Pass to panda\n self.getCurrentPanda().findAndReplace(findText, replaceText, selectionModel)","def DocumentElementReplace(self, wave_id, wavelet_id, blip_id, position,\n element):\n op = Operation(DOCUMENT_ELEMENT_REPLACE, wave_id, wavelet_id, blip_id,\n index=position,\n prop=element)\n self.__context.AddOperation(op)","def refresh(self, new_content):\n pass","def replace(self, replacer):\n for e in self.entries:\n e.update(replacer.replace(str(e)))","def replaceXMLObject(self, **kw):\n LOG(\"replaceXMLObject\", INFO, \"xml = %s\" %(kw.get('xml_string', '')))\n return self._createAddOrReplaceNode('Replace', **kw)","def fill_template(template, replacements):\n content = template\n for src, target in replacements.iteritems():\n content = content.replace(src, target)\n return content","def xreplace(self, rule):\n value, _ = self._xreplace(rule)\n return value","def replace_chunk(\n content: str, chunk: str, tags: str, inline: bool = False, **kwargs\n) -> str:\n \n r = re.compile(\n rf\"<!-- {tags} starts -->.*<!-- {tags} ends -->\",\n re.DOTALL,\n )\n if not inline:\n chunk = f\"\\n{chunk}\\n\"\n chunk = f\"<!-- {tags} starts -->{chunk}<!-- {tags} ends -->\"\n return r.sub(chunk, content)","def replaceNode(self, cur):\n if cur is None: cur__o = None\n else: cur__o = cur._o\n ret = libxml2mod.xmlReplaceNode(self._o, cur__o)\n if ret is None:raise treeError('xmlReplaceNode() failed')\n __tmp = xmlNode(_obj=ret)\n return __tmp","def _test_and_set(root, tag, default=None, params={}, quote=False):\n var = xml_utils.find_nodes_by_tag(root, tag)\n\n if var:\n # Only check the first one\n return el_utils.replace_el_with_var(var[0].text,\n params=params,\n quote=quote)\n else:\n return default","def replace(self):\n\n if self.replace_with is not None: # pylint: disable=no-member\n return substrings(\n self.regex,\n self.replace_with, # pylint: disable=no-member\n self.data,\n self.occurences, # pylint: disable=no-member\n )\n return self.data","def do_replace(self, tx, item):\n sql = \"\"\"REPLACE INTO des_raw_parsed_data (id, content, url, source, exception_detail, exception_code, site, template_id, domain, classify, subclass)\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\"\"\"\n content = json.dumps(dict(item[\"other_parameter\"]),ensure_ascii=False)\n # if content:\n # content = content.decode('unicode_escape')\n args = (\n item[\"uuid\"],\n content,\n item[\"url\"],\n item[\"source\"],\n json.dumps(item[\"exception\"],ensure_ascii=False),\n item[\"exception_code\"],\n item[\"site\"],\n item[\"template_id\"],\n item[\"domain\"],\n item[\"classify\"],\n item[\"subclass\"]\n )\n\n tx.execute(sql, args)","def getReplacedElement(self, *args):\n return _libsbml.CompSBasePlugin_getReplacedElement(self, *args)","def set_content(self, content):\n self.data['content'] = content","def replace_code(self, pattern, repl):\n regex = re.compile(pattern, re.DOTALL)\n for cell in self.content.cells:\n if cell.cell_type == \"code\" and regex.findall(cell.source):\n cell.source = regex.sub(repl, cell.source)\n print(f\"- code removed from {self.filename}\")","def replace(match_obj):\n return match_obj.group(0)[1:]","def replace_instance(s, to_replace, replacement):\n index=0\n matchedIndeces=0\n while index<len(s):\n if s[index]==to_replace[matchedIndeces]:\n matchedIndeces+=1\n if matchedIndeces>=len(to_replace):\n s=s[:index-(matchedIndeces-1)]+replacement+s[index+1:]\n index-=matchedIndeces-1\n matchedIndeces=0\n else:\n matchedIndeces=0\n index+=1\n return s","def replace(content, root_url):\n soup = BeautifulSoup(content, BEAUTIFULSOUP_BUILDER)\n soup.header.decompose()\n for tags, attribute in PROXY_ATTRIBUTES:\n for tag in soup.find_all(tags, **{attribute: True}):\n tag_old = tag\n value = tag[attribute]\n match = PROXY_PATH_RE.match(value)\n if match is not None:\n value = match.groups()[0]\n tag[attribute] = url_path_join(root_url, value)\n # log.debug(\"REPLACE: tag_attribute_old: %s tag_attribute_new: %s\", value, tag[attribute])\n return str(soup)","def find_replace_all(self):\n old_term = self.text_find.get()\n new_term = self.text_replace.get()\n while True:\n idx = '1.0'\n idx = self.text.search(old_term, idx, nocase=1,\n stopindex=tk.END)\n lastidx = '% s+% dc' % (idx, len(old_term))\n if not idx:\n break\n self.text.delete(idx, lastidx)\n self.text.insert(idx, new_term)","def _update_object_content(name, input):\n content = input._content\n\n hrefs = re.compile(r'<\\s*[^\\>]*href\\s*=\\s*([\"\\'])(.*?)\\1')\n srcs = re.compile(r'<\\s*[^\\>]*src\\s*=\\s*([\"\\'])(.*?)\\1')\n\n matches = hrefs.findall(content)\n matches.extend(srcs.findall(content))\n relative_paths = []\n for found in matches:\n found = found[1]\n if found not in relative_paths:\n relative_paths.append(found)\n\n for relative_path in relative_paths:\n if not \"://\" in relative_path: # we don't want to rewrite protocols\n dest_path = os.sep.join((get_relative_path(name), \"static\",\n relative_path))\n content = content.replace(relative_path, dest_path)\n\n return content","def patch(text):\n if match := re.search(r'\\d+__\\d+__\\d+', text):\n tag = match.group(0)\n if tag not in ocds_tags:\n if ocds_version or not use_development_version:\n text = text.replace(tag, ocds_tag)\n else:\n text = text.replace(ocds_schema_base_url + tag, development_base_url)\n return text","def Replace(self, *args):\n return _BRepAlgo.BRepAlgo_AsDes_Replace(self, *args)","def setContent(self, content):\n self.__content = content","def DocumentReplace(self, wave_id, wavelet_id, blip_id, content):\n op = Operation(DOCUMENT_REPLACE, wave_id, wavelet_id, blip_id,\n prop=content)\n self.__context.AddOperation(op)","def replace_with_arg(self, src_arg, tgt_arg):","def replace(self, param):\n self.discard(param)\n self.add(param)","def replace(content,line,word,string):\n\tline = int(line)\n\tstring = string.strip().replace(\" \",\" &^&%+\").split()\n\tif len(content)<int(line):\n\t\tprint \"Error: No such line.\"\n\t\treturn (content,False)\n\tif word is not None:\n\t\tword = int(word)\n\t\tif len(content[line-1])<int(word) or line>len(content):\n\t\t\tprint \"Error: No such word.\"\n\t\t\treturn (content,False)\n\t\tword = word-1\n\t\tcontent[line-1] = content[line-1][:word]+string+content[line-1][word+1:]\n\t\t\n\telse:\n\t\tline = line-1\n\t\tcontent[line] = string\n\treturn (content,True)","def update(self, data):\n self.content = data","def zap_tag_contents(self, tag):\n if hasattr(tag, 'contents'):\n content_length = len(tag.contents)\n\n for x in range(0, content_length):\n if isinstance(tag.contents[x], bs4.element.Comment):\n self.zap_tag_contents(tag.contents[x])\n elif isinstance(tag.contents[x], bs4.element.NavigableString):\n unicode_entry = self.zapper.kill_gremlins(tag.contents[x])\n unicode_entry = unidecode(unicode_entry)\n tag.contents[x].replace_with(unicode_entry)\n elif isinstance(tag.contents[x], bs4.element.Tag):\n self.zap_tag_contents(tag.contents[x])","def _count_or_replace(\n self, content, query, replacement, ignore_case, search_targets):\n occurrences = 0\n flags = re.U\n if ignore_case:\n flags = flags | re.I\n if not isinstance(query, unicode):\n query = unicode(query, 'utf-8')\n if replacement and not isinstance(replacement, unicode):\n replacement = unicode(replacement, 'utf-8')\n reg = re.compile(re.escape(query), flags)\n # find all text nodes and text attributes\n current = content.documentElement\n replaced = False\n while current:\n if 'text' in search_targets:\n if current.nodeType == 3:\n # text node\n toscan = current.nodeValue\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n toscan = reg.sub(replacement, toscan)\n current.nodeValue = toscan\n replaced = True\n elif current.nodeName in (\n 'image', 'link', 'index', 'abbr', 'acronym'):\n attrs = ('title',)\n for attr in attrs:\n toscan = current.getAttribute(attr)\n if toscan:\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n current.setAttribute(\n attr, reg.sub(replacement, toscan))\n replaced = True\n if 'paths' in search_targets or 'urls' in search_targets:\n for name, attr in (\n ('image', 'link'),\n ('image', 'path'),\n ('link', 'url')):\n if current.nodeName == name:\n toscan = current.getAttribute(attr)\n if (toscan and\n ('paths' in search_targets and not\n self._reg_urls.match(toscan)) or\n ('urls' in search_targets and\n self._reg_absurls.match(toscan))):\n num = len(reg.findall(toscan))\n occurrences += num\n if num and replacement is not None:\n current.setAttribute(\n attr, reg.sub(replacement, toscan))\n replaced = True\n if current.childNodes.length:\n current = current.firstChild\n elif current.nextSibling:\n current = current.nextSibling\n else:\n while current.parentNode:\n current = current.parentNode\n if current.nextSibling:\n current = current.nextSibling\n break\n else:\n current = None\n if replaced:\n content._p_changed = True\n # XXX I assume this should always be done?\n if hasattr(aq_base(content), 'reindex_object'):\n content.reindex_object()\n return occurrences","def find_replace(text, list):\r\n\tfor pair in list:\r\n\t\tif pair[0] in text:\r\n\t\t\ttext = text.replace(pair[0], pair[1])\r\n\treturn text","def replace_with(self, replacement):\n\n # FIND NAMES IN replacement\n parts = list(regex_parameters.split(replacement, include_separators=True))\n\n def replacer(tokens):\n acc = []\n for s, n in zip(parts, parts[1:]):\n acc.append(s)\n acc.append(text(tokens[n]))\n acc.append(parts[-1])\n return \"\".join(acc)\n\n return self / replacer","def test_replace_group(self):\n pass","def test_replacement1(engine_contents, engine_locations):\n file_name = 'Triangle.java.xml'\n new_contents = copy.deepcopy(engine_contents)\n new_locations = copy.deepcopy(engine_locations)\n target1 = (file_name, 'expr_stmt', 3)\n assert not XmlEngine.do_replace(engine_contents, engine_locations, new_contents, new_locations, target1, target1)","def inject_content(self, content: str) -> None:\n self.content = content","def update_content(self, address, owner, content):\n page = self.get(address=address)\n page.check_address()\n revision = page.revision_set.create(page=page, content=content, owner=owner)\n page.update_html(content)\n return page","def edit(self, new_content: str) -> None:\n\n # YOUR CODE HERE\n self.content = new_content","def content(self, content):\n\n self._content = content","def content(self, content):\n\n self._content = content","def replace(self, *args, **kwargs): # real signature unknown\r\n pass","def substitute_elements(self, subs, **kwargs):\n return self","def replace(self, label, data):\n self._validate_can_write()\n self._validate_labels(label, must_exist=True)\n with self._h5file('r+') as h5file:\n attrs = get_decoded(h5file[label].attrs, 'Deflate', 'Description')\n del h5file[label]\n self.insert(label, data, attrs['Description'], attrs['Deflate'])","def regexpExec(self, content):\n ret = libxml2mod.xmlRegexpExec(self._o, content)\n return ret","def merge_content(self, other):\n self.__content += other.__content","def add_substitution(self, pattern, repl):\r\n\r\n self.substitutions.append( (re.compile(pattern), repl) )","def replace_constant(self, src, dst):\n replace_count = 0\n for ii in self.__sections:\n for jj in range(len(ii.content)):\n line = ii.content[jj]\n replaced = re.sub(r'(\\$%s|\\$%s)' % (src, hex(src)), r'$%s' % hex(dst), line)\n if line != replaced:\n ii.content[jj] = replaced\n replace_count += 1\n if 1 > replace_count:\n raise RuntimeError(\"could not find constant to be replaced\")\n elif 1 < replace_count:\n raise RuntimeError(\"found constant to be replaced more than once, source destroyed\")","def performReplacement(self):\n return _libsbml.Replacing_performReplacement(self)","def replace(self, **kwargs: Any) -> UiField:\n return dc.replace(self, **kwargs)","def update_well(self, row, col, content):\n self.plate.get_well(row, col).composition.update(content)"],"string":"[\n \"def _update_content(self, content, siteurl):\\n if not content:\\n return content\\n\\n hrefs = self._get_intrasite_link_regex()\\n return hrefs.sub(lambda m: self._link_replacer(siteurl, m), content)\",\n \"def string_replace_xml_text(element, pattern, value):\\n if element.text:\\n element.text = element.text.replace(pattern, value.decode('utf8'))\\n for c in element.getchildren():\\n string_replace_xml_text(c, pattern, value)\",\n \"def replaceElement(self, *args):\\n return _libsbml.Submodel_replaceElement(self, *args)\",\n \"def _replace(self, p, e):\\n node = self._validate_position(p)\\n old = node.element\\n node.element = e\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node.element\\n node.element = e\\n return old\",\n \"def _replace(self, p, data):\\n node = self._validate(p)\\n old = node._element\\n node._element = data\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node._element\\n node._element = e\\n return old\",\n \"def updateContent(content, **kwargs):\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old = node._element\\n node._element = e\\n return old\",\n \"def _replace(self, p, e):\\n node = self._validate(p)\\n old_value = node._element\\n node._element = e\\n return old_value\",\n \"def _update_content(self, content, siteurl):\\r\\n if not content:\\r\\n return content\\r\\n\\r\\n instrasite_link_regex = self.settings['INTRASITE_LINK_REGEX']\\r\\n regex = r\\\"\\\"\\\"\\r\\n (?P<markup><\\\\s*[^\\\\>]* # match tag with all url-value attributes\\r\\n (?:href|src|poster|data|cite|formaction|action)\\\\s*=)\\r\\n\\r\\n (?P<quote>[\\\"\\\\']) # require value to be quoted\\r\\n (?P<path>{0}(?P<value>.*?)) # the url value\\r\\n \\\\2\\\"\\\"\\\".format(instrasite_link_regex)\\r\\n hrefs = re.compile(regex, re.X)\\r\\n\\r\\n def replacer(m):\\r\\n what = m.group('what')\\r\\n value = urlparse(m.group('value'))\\r\\n path = value.path\\r\\n origin = m.group('path')\\r\\n\\r\\n # XXX Put this in a different location.\\r\\n if what == 'filename':\\r\\n if path.startswith('/'):\\r\\n path = path[1:]\\r\\n else:\\r\\n # relative to the source path of this content\\r\\n path = self.get_relative_source_path(\\r\\n os.path.join(self.relative_dir, path)\\r\\n )\\r\\n\\r\\n if path not in self._context['filenames']:\\r\\n unquoted_path = path.replace('%20', ' ')\\r\\n\\r\\n if unquoted_path in self._context['filenames']:\\r\\n path = unquoted_path\\r\\n\\r\\n if path in self._context['filenames']:\\r\\n origin = '/'.join((siteurl,\\r\\n self._context['filenames'][path].url))\\r\\n origin = origin.replace('\\\\\\\\', '/') # for Windows paths.\\r\\n else:\\r\\n logger.warning((\\\"Unable to find {fn}, skipping url\\\"\\r\\n \\\" replacement\\\".format(fn=value),\\r\\n \\\"Other resources were not found\\\"\\r\\n \\\" and their urls not replaced\\\"))\\r\\n elif what == 'category':\\r\\n origin = Category(path, self.settings).url\\r\\n elif what == 'tag':\\r\\n origin = Tag(path, self.settings).url\\r\\n\\r\\n # keep all other parts, such as query, fragment, etc.\\r\\n parts = list(value)\\r\\n parts[2] = origin\\r\\n origin = urlunparse(parts)\\r\\n\\r\\n return ''.join((m.group('markup'), m.group('quote'), origin,\\r\\n m.group('quote')))\\r\\n\\r\\n return hrefs.sub(replacer, content)\",\n \"def replace_by_xml(self, xml_str, el_idx=0):\\n root_el = self.parse_xml(xml_str)\\n self.replace_by_etree(root_el, el_idx)\",\n \"def replace(\\n haystack : Exp, haystack_context : Context, haystack_pool : Pool,\\n needle : Exp, needle_context : Context, needle_pool : Pool,\\n replacement : Exp) -> Exp:\\n return _Replacer(haystack_context, haystack_pool, needle, needle_context, needle_pool, replacement).visit(haystack)\",\n \"def replace(self, element):\\n for i, sibling in enumerate(self.parent._children):\\n if sibling is self:\\n self.parent._children[i] = element\\n element.parent_docid = self.parent_docid\",\n \"def addReplacedElement(self, *args):\\n return _libsbml.CompSBasePlugin_addReplacedElement(self, *args)\",\n \"def ReplaceElement(self, position, element):\\n self.__context.builder.DocumentElementReplace(self._blip_data.wave_id,\\n self._blip_data.wavelet_id,\\n self._blip_data.blip_id,\\n position, element)\",\n \"def run(self, content):\\n parts = []\\n offset = 0\\n for match in self.regexp.finditer(content):\\n parts.append(content[offset:match.start(0)])\\n parts.append(self.replace(match))\\n offset = match.end(0)\\n parts.append(content[offset:])\\n return ''.join(parts)\",\n \"def replace(self, text):\\n if self.should_skip(text):\\n return text\\n return self.replacer.sub(self._callback, text)\",\n \"def replace(self, p, e):\\n original = self._validate(p)\\n old_value = original._element # temporarily store old element\\n original._element = e # replace with new element\\n\\n return old_value\",\n \"def inject_on_div(div_id, original, content_to_inject):\\n m = re.match(\\\".*(<div.*id=\\\\\\\"\\\"+ div_id +\\\"\\\\\\\".*>)(.*)(</div>).*\\\", original, re.DOTALL)\\n return re.sub(m.group(1) + m.group(2) + m.group(3), m.group(1) + content_to_inject + m.group(3) , original)\",\n \"def update_content(self):\\n raise NotImplementedError\",\n \"def replace(self, oldtext, newtext):\\r\\n return self\",\n \"def replace(self, pattern, substitute, pattern_type=None):\\n\\t\\tpattern = convert_pattern(pattern, pattern_type)\\n\\t\\twith self.AutoSplitlines():\\n\\t\\t\\tself.lines = [(pattern.sub(substitute, line) if pattern.search(line) else line) for line in self.lines]\",\n \"def replace_content(g):\\n g[0] = 88\\n g[1] = 22\\n g[2] = 44\\n print(\\\"g = \\\", g)\",\n \"def _replace(self, match_layer_node, replacement_layer_node):\\n if self._is_functional_model(self.model):\\n self._replace_functional(match_layer_node, replacement_layer_node)\\n else:\\n self._replace_sequential(match_layer_node, replacement_layer_node)\",\n \"def replace_all(self, content):\\n if (not self.exists()):\\n raise IOError(\\\"File at '{}' does not exist.\\\".format(self.location))\\n with open(self.location, 'w') as f:\\n f.write(content)\",\n \"def sed(self, search, replace):\\n\\n for section in self.sections:\\n for i, block in enumerate(section.blocks):\\n if block == search:\\n section.blocks[i] = replace\\n self.all_damaged = True\\n self.dirty = True\",\n \"def replace_by_etree(self, root_el, el_idx=0):\\n el = self.get_element_by_name(root_el.tag, el_idx)\\n el[:] = list(root_el)\\n el.attrib = root_el.attrib\",\n \"def test_replace(self):\\n\\n regex = \\\"th\\\"\\n expected = \\\"Hello, htis is Fun Ilrys. I just wanted to know how htings goes around hte tests.\\\" # pylint: disable=line-too-long\\n actual = Regex(self.data, regex, replace_with=\\\"ht\\\").replace()\\n\\n self.assertEqual(expected, actual)\\n\\n # Test of the case that there is not replace_with\\n regex = \\\"th\\\"\\n expected = self.data\\n actual = Regex(self.data, regex).replace()\\n\\n self.assertEqual(expected, actual)\",\n \"def replace_in_file(file_path, find, replace):\\n\\tcontent = read_file(file_path)\\n\\tcontent = content.replace(find, replace)\\n\\twrite_file(file_path, content)\",\n \"def replacingBasicElementsFromEpubLibre(text):\\n text = re.sub(r'<div class=\\\"vineta\\\"><img[^<]*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n \\n # Replace some elements with atributes with other cleaner elements\\n\\n text = re.sub(r'<p class=\\\"ind\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<p class=\\\"cursiva\\\\d*\\\">(.*?)</p>', r'<p><seg rend=\\\"italic\\\">\\\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"calibre[0-9]+\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\\d*\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"salto[0-9]+\\\">', r'<milestone unit=\\\"section\\\"/>\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoc\\\">', r'<milestone unit=\\\"section\\\"/>\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"sinopsis\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"ilustra\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"info\\\">.*?</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<br class=\\\"calibre9\\\" />', r' ', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<sup(|[^>]*)>(<a[^>]*?>)?\\\\[.*?\\\\](</a>)?</sup>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span(|[^>]*)>\\\\s*</span>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<a(|[^>]*)>\\\\s*</a>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(tlogo|tautor|ttitulo|trevision|tfirma)\\\">.*?</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<h1 class=\\\"ttitulo\\\">(.*?)</h1>\\\\s*(<p class=\\\"titulo\\\">.*?</p>)', r'<head>\\\\1: \\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<img[^>]*?>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(bloque|ala)?derecha[0-9]*\\\">(.*?)</p>', r'<ab>\\\\2</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asangre[0-9]?\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<p class=\\\"centrado1\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<p class=\\\"extenso\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"(normal|calibre)[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p><span class=\\\"(cap[0-9]*|versalita|smallcaps)\\\">(..?)</span>', r'<p>\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"(versalita|smallcaps)[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"smallcaps\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"(?:poema[0-9]*|poe|versos|estrofas|citar\\\\d*|verso\\\\d*|versosinpie\\\\d*|centro|centrado|poemaizqcursi\\\\d*|poemaizq|poemacursi\\\\d*)\\\">(.*?)</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"center\\\">\\\\s+<table class=\\\"text\\\">\\\\s+<tr class=\\\"calibre\\\\d*\\\">\\\\s+<td class=\\\"calibre\\\\d*\\\">(\\\\s+.*?)</td>\\\\s+</tr>\\\\s+</table>\\\\s+</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE) \\n\\n text = re.sub(r'<blockquote class=\\\"(?:versos?\\\\d*)\\\">(.*?)</blockquote>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\n text = re.sub(r'(<lg>\\\\s*)<p class=\\\"izq\\\">', r'\\\\1<l>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"poemaizqcursi\\\">(.*?)</p>', r'<lg>\\\\n<l>\\\\1</l>\\\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"verso\\\">(.*?)</p>', r'<l>\\\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"normal1\\\">(.*?)</p>', r'<l>\\\\1</l>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cursiva\\\">(.*?)</p>', r'<p><seg rend=\\\"italic\\\">\\\\1</seg></p>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<em(|[^>]*)>(.*?)</em>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"estrofa1\\\">', r'\\\\n\\\\n<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<i(|[^>]*)>(.*?)</i>', r'<seg rend=\\\"italic\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<b(|[^>]*)>(.*?)</b>', r'<seg rend=\\\"bold\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<sup(|[^>]*)>(.*?)</sup>', r'<seg rend=\\\"sup\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"cursiva[0-9]*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<sub(|[^>]*)>(.*?)</sub>', r'<seg rend=\\\"subscript\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<small(|[^>]*)>(.*?)</small>', r'<seg rend=\\\"small\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"nosep\\\\d*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"nosep\\\\d*\\\">(.*?)</span>', r'<seg rend=\\\"italic\\\">\\\\1</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<strong(|[^>]*)>(.*?)</strong>', r'<seg rend=\\\"bold\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cita\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"micita\\\">(.*?)</p>', r'<quote>\\\\n<p>\\\\1</p>\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"acotacion\\\\d*\\\">(.*?)</div>', r'<quote>\\\\n\\\\1\\\\n</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<cite.*?>(.*?)</cite>', r'<seg type=\\\"cite\\\">\\\\1</seg>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n # Setting quotes in floatingText element\\n text = re.sub(r'<div class=\\\"(?:mi)?cita\\\">(.*?)</div>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<blockquote class=\\\"bloque\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"salto25x\\\">([IVXCL\\\\d]+)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"salto25x\\\\d+\\\">', r'<p>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n \\n text = re.sub(r'<div class=\\\"bloquederecha1\\\">(.+?)</div>', r'<quote>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"cursiva[0-9]*\\\">', r'<div rend=\\\"italic\\\">', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"calibre\\\" id=\\\"calibre_link-[0-9]+\\\">', r'<div>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\">[… ]+?</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asteriscos\\\">[\\\\* ∗]+</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\">\\\\[…\\\\]</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"asteriscos\\\\d*\\\">[\\\\. ]+</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<hr (class=\\\"calibre\\\\d*\\\" )?/>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<milestone unit=\\\"section\\\"/>\\\\s+)+', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<div class=\\\"(?:banner|text\\\\d+)\\\">(.*?)</div>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"banner\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"carta\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'<blockquote class=\\\"cita\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div>\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<blockquote class=\\\"calibre\\\\d*\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n<div type=\\\"section\\\">\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<html.*?<body>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'</body></html>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>)\\\\s*(<head>.*?</head>)', r'\\\\1</div>\\\\n<div>\\\\n\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"(?:subh?|inicio|numtitulo|subt)\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<h[1-6][^>]*>(.*?)</h[1-6]>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(tsub|sub)?tit(ulo)?[0-9]*\\\">(.*?)</p>', r'<head>\\\\3</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(subcapitulo|capitulonombre|h\\\\d+)\\\">(.*?)</p>', r'<head>\\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"tit-cap\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'</head>\\\\s*<p class=\\\"(subtil|subcap)\\\">(.*?)</p>', r': \\\\2</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<span class=\\\"ncap\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"ncap\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"palabra\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"sigla\\\\d*\\\">(.*?)</span>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<p>—?)<span class=\\\"inicial\\\">(.*?)</span>', r'\\\\1\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<p>—?¿?)<big class=\\\"calibre\\\\d*\\\">(.*?)</big>', r'\\\\1\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<head>\\\\s*</head>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p [^>]*?>\\\\s*\\\\* *\\\\* *\\\\*</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"sep\\\">\\\\* \\\\* \\\\*</p>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'</head>\\\\s*<head>', r': ', text, flags=re.DOTALL|re.IGNORECASE)\\n #text = re.sub(r'(</head>)(\\\\s*<head>)', r'\\\\1\\\\n<div>\\\\n\\\\2', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n\\n \\\"\\\"\\\"\\n #Setting divs after ps. Used for 219\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</p>|</div>)(\\\\s*<head>.*?</head>.*?)(<head>|</div>|<div>)', r'\\\\1\\\\n<div>\\\\2</div>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n\\n # Cleaning some <milestone />\\n text = re.sub(r'(<div>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</div>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(</head>\\\\s*)<milestone unit=\\\"section\\\"/>', r'\\\\1', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n # Setting some floatingTexts\\n #text = re.sub(r'(<div(| [^>]*?)>((?!<div).)*</div>)(\\\\s*<p)', r'<floatingText>\\\\n<body>\\\\n\\\\1\\\\n</body>\\\\n</floatingText>\\\\n\\\\4', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n #text = re.sub(r'(<div(|[^>]+?)>.*?</div>)(\\\\s*<p)', r'<floatingText>\\\\n<body>\\\\n<div>\\\\n\\\\1\\\\n</div>\\\\n</body>\\\\n</floatingText>\\\\n\\\\3', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n # Floating Texts\\n\\n text = re.sub(r'<p(| [^>]+)>[\\\\s\\\\r\\\\n]*</p>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'\\\\n[ \\\\t]+', r'\\\\n', text, flags=re.IGNORECASE)\\n text = re.sub(r'[\\\\r\\\\n]+', r'\\\\r\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div>[\\\\r?\\\\n]*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'(<div>((?!<div>).)*</div>\\\\r?\\\\n)\\\\Z', r'<!--\\\\1-->', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n\\n text = re.sub(r'<div class=\\\"cita?[0-9]*\\\">(.*?)</div>', r'<quote>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"cita[0-9]*\\\">(.*?</p>)', r'<quote>\\\\n<p>\\\\1</quote>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\n text = re.sub(r'<br class=\\\"calibre[0-9]*\\\" />', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'(<p>—?. ?)<span class=\\\"palabra\\\">(.*?)</span>', r'\\\\1<seg rend=\\\"small\\\">\\\\2</seg>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\"><span class=\\\"inicial\\\">(.*)</span><span class=\\\"palabra\\\">(.*?)</span>', r'<p>\\\\1\\\\2', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"saltoinicio\\\"><span class=\\\"inicial\\\">(.*)</span>', r'<p>\\\\1', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p>(.)<span>(.*)</span>', r'<p>\\\\1\\\\2', text, flags=re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"inicial\\\">(.*)</span>', r'\\\\1', text, flags=re.IGNORECASE)\\n\\n \\n text = re.sub(r'(<head>.*?)<seg rend=\\\"(smallcaps|small)\\\">(.*?)</seg>(.*?</head>)', r'\\\\1\\\\3\\\\4', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<div[^>]*?>\\\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n text = re.sub(r'<div class=\\\"(?:tablacentro\\\\d*|center)\\\">\\\\s*<table class=\\\"text\\\\d*\\\">\\\\s*<tr class=\\\"calibre\\\\d*\\\">\\\\s*<td class=\\\"calibre\\\\d*\\\">(.*?)\\\\s*</td>\\\\s*</tr>\\\\s*</table>\\\\s*</div>', r'<lg>\\\\1\\\\n</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n text = re.sub(r'<p class=\\\"traduccion\\\">(.*?)</p>', r'<ab type=\\\"translation\\\">\\\\1</ab>', text, flags=re.IGNORECASE)\\n\\n #text = re.sub(r'<p class=\\\"centrado\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"centrado\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\n #text = re.sub(r'<blockquote class=\\\"calibre18\\\">(.*?)</blockquote>', r'<floatingText>\\\\n<body>\\\\n\\\\1\\\\n</body>\\\\n</floatingText>\\\\n', text, flags=re.DOTALL|re.IGNORECASE)\\n\\n \\\"\\\"\\\"\\n #The next lines were used for 232, a theater-like novel\\n \\n text = re.sub(r'<p>(.*?</seg>)(\\\\.\\\\—.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n #The next lines were used for 109, a theater-like novel\\n text = re.sub(r'<p>(.*?</seg>\\\\.)(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\\\"italic\\\">.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<seg rend=\\\"italic\\\">(\\\\(.*?)</seg>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n #The next lines were used for 224, a theater-like novel\\n text = re.sub(r'<p>(.<seg rend=\\\"small\\\">.*?</seg>\\\\.)(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n #text = re.sub(r'<p>(.*?</seg>)( +<seg rend=\\\"italic\\\">.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<seg rend=\\\"italic\\\">(\\\\(.*?)</seg>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n # Code used for paradox rey\\n text = re.sub(r'<div class=\\\"clear\\\">\\\\s*</div>', r'', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"banner\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"francesa\\\\d*\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n text = re.sub(r'<p class=\\\"personaje\\\">(.*?)</p>\\\\s*<p>(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<span class=\\\"descrip\\\">(.*?)</span>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(?:descrip\\\\d*|entrada|fin)\\\">(.*?)</p>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"cuadro\\\">(.*?)</p>', r'<head>\\\\1</head>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"descrip1\\\">(.*?)</div>', r'<stage>\\\\1</stage>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"puntos\\\">.*?</div>', r'<milestone unit=\\\"section\\\"/>', text, flags=re.DOTALL|re.IGNORECASE)\\n text = re.sub(r'<div class=\\\"tablacentro\\\">(.*?)</div>', r'<lg>\\\\1</lg>', text, flags=re.DOTALL|re.IGNORECASE)\\n \\\"\\\"\\\"\\n text = re.sub(r'<p class=\\\"decla\\\">(.*?\\\\. )(.*?)</p>', r'<sp>\\\\n<speaker>\\\\1</speaker>\\\\n<p>\\\\2</p>\\\\n</sp>', text, flags=re.IGNORECASE)\\n text = re.sub(r'<p class=\\\"(?:descrip|decla1)\\\">(.*?)</p>', r'<stage>\\\\1</stage>', text, flags=re.IGNORECASE)\\n\\n\\n text = re.sub(r'(<seg\\\\s+rend\\\\s*=\\\\s*\\\"small(?:caps)?\\\">)(.*?)(?=</seg>)', lambda m: m.group(1) + m.group(2).lower(), text)\\n \\n text = re.sub(r'(<seg\\\\s+rend\\\\s*=\\\\s*\\\"small(?:caps)?\\\">)(.*?)(</seg>)', r'\\\\2', text, flags=re.IGNORECASE)\\n \\n text = re.sub(r'<big[^>]*?>(.*?)</big>', r'\\\\1', text, flags=re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"serif\\\" id=\\\"calibre_link-\\\\d+\\\">', r'<div>', text, flags=re.IGNORECASE) \\n text = re.sub(r'<div class=\\\"sinmargen\\\" id=\\\"calibre_link-\\\\d+\\\">', r'<div>', text, flags=re.IGNORECASE) \\n\\n text = re.sub(r'<p class=\\\"(?:carta|firma\\\\d+)\\\">(.*?)</p>', r'<ab>\\\\1</ab>', text, flags=re.IGNORECASE) \\n\\n\\n\\n return text\",\n \"def replace_with(*, replacement, f=DECORATED):\\n return replacement\",\n \"def replace_with(self, replacement_arg):\\n replacement = BinaryNode.or_none(replacement_arg)\\n\\n # Do not proceed if replacement is invalid\\n # Nothing to do if replacing node with itself\\n if replacement == self:\\n return self\\n\\n # Link parent\\n parent = self.get_parent()\\n if parent is not None:\\n if self.is_left_child():\\n parent.set_left(replacement)\\n elif self.is_right_child():\\n parent.set_right(replacement)\\n elif self.tree is not None:\\n # Replacing head\\n self.tree.head = replacement\\n\\n # Remove node from tree\\n self.set_parent(None)\",\n \"def replace(node, key, value):\\n if isinstance(node, (Document, Object)):\\n data = dict(node)\\n elif isinstance(node, Array):\\n data = list(node)\\n else:\\n raise TypeError(\\n \\\"Expected Core API container type. Got '%s'.\\\" % type(node)\\n )\\n\\n data[key] = value\\n if isinstance(node, Document):\\n return type(node)(url=node.url, title=node.title, content=data)\\n return type(node)(data)\",\n \"def change_content(options):\\n call_command('''grep -r -l -- '%(patrn)s' . | tr '\\\\\\\\n' '\\\\\\\\0' | xargs -0 sed -i \\\"s/%(patrn)s/%(repl)s/g\\\"''', options)\",\n \"def replaceChild(self, *args):\\n return _libsbml.ASTNode_replaceChild(self, *args)\",\n \"def in_place_substitute(self):\\r\\n if self.substitute is not None:\\r\\n node = self.convert_type()\\r\\n self.leaf_replace(node) # for internals only\\r\\n self.root_replace(node)\",\n \"def set_content(self, content):\\n if check_data_exist(content) is True:\\n self.content = content.text\",\n \"def replaceChild(self, *args):\\n return _libsbml.ASTBasePlugin_replaceChild(self, *args)\",\n \"def _replace_keyword(self, keyword, replacement, count=0):\\n\\n def replace_with_inline(e, doc):\\n if type(e) == Str and e.text == keyword:\\n doc.num_matches += 1\\n if not count or doc.num_matches <= count:\\n return replacement\\n\\n def replace_with_block(e, doc):\\n '''\\n It's difficult to replace a keyword with an entire Block element.\\n\\n This is because the keyword is of type Str (an Inline) and the parent\\n object of a Str can only contain Inlines and not Blocks\\n (e.g. Para can contain Inlines, not Divs)\\n\\n Implications:\\n\\n 1) If the Str that contains the keyword is inside another\\n Inline instead of a Block (e.g. Div -> Emph -> Str)\\n then we have to do a trick:\\n when .walk() touches an Emph that contains Str(keyword),\\n it replaces the Emph with Str(keyword).\\n\\n 2) If the element that contains the Str(keyword) has multiple children,\\n then we are in a bind as replacing it will destroy information.\\n Thus, we can't do do it\\n\\n 3) If the element that contains the Str(keyword) does so in a DictContainer\\n instead of a ListContainer, then we cannot retrieve the \\\"first and only\\n element\\\" easily, so we also abort (happens with metadata elements).\\n '''\\n\\n # Here we can check that e.content is ListContainer (i.e. not DictContainer)\\n # or check that e is not a Metavalue (\\\"not isinstance(e, MetaValue)\\\")\\n\\n if hasattr(e, 'content') and isinstance(e.content, ListContainer) and len(e.content) == 1:\\n ee = e.content[0]\\n if type(ee) == Str and ee.text == keyword:\\n if isinstance(e, Block):\\n doc.num_matches += 1\\n if not count or doc.num_matches <= count:\\n return replacement\\n elif isinstance(e, Inline):\\n return Str(keyword)\\n else:\\n pass # not implemented\\n\\n doc = self.doc\\n if doc is None:\\n raise Exception('No root document')\\n doc.num_matches = 0\\n if isinstance(replacement, Inline):\\n return self.walk(replace_with_inline, doc)\\n elif isinstance(replacement, Block):\\n return self.walk(replace_with_block, doc)\\n else:\\n raise NotImplementedError(type(replacement))\",\n \"def replace_text(self,\\n\\t text,\\n\\t fname,\\n\\t pattern=None,\\n\\t expect=None,\\n\\t shutit_pexpect_child=None,\\n\\t note=None,\\n\\t before=False,\\n\\t force=False,\\n\\t line_oriented=True,\\n\\t loglevel=logging.DEBUG):\\n\\t\\tshutit_global.shutit_global_object.yield_to_draw()\\n\\t\\treturn self.change_text(text,\\n\\t\\t fname,\\n\\t\\t pattern,\\n\\t\\t expect,\\n\\t\\t shutit_pexpect_child,\\n\\t\\t before,\\n\\t\\t force,\\n\\t\\t note=note,\\n\\t\\t line_oriented=line_oriented,\\n\\t\\t replace=True,\\n\\t\\t loglevel=loglevel)\",\n \"def replace_with_text(self):\\r\\n self.parser.stripTags(self.get_top_node(), 'b', 'strong', 'i', 'br', 'sup')\",\n \"def set_content(self, content):\\n\\n # pylint: disable=W0201\\n self.clear()\\n self.content = content\",\n \"def replace_data(self, original, replacement, pattern=None, use_regex=False, queries=[]):\\n import hxl.filters\\n replacement = hxl.filters.ReplaceDataFilter.Replacement(original, replacement, pattern, use_regex)\\n return hxl.filters.ReplaceDataFilter(self, [replacement], queries=queries)\",\n \"def replace_all(self):\\n i = 0\\n while self.textedit.textCursor().hasSelection():\\n self.textedit.textCursor().insertText(self.ui.textToReplace.text())\\n self.find()\\n i += 1\\n self.show_message(unicode(self.tr(\\\"Replaced {0} occurrence(s)\\\")).format(i))\",\n \"def set_content(self, content):\\n self.content = content\",\n \"def set_content(self, content):\\n self.content = content\",\n \"def replace_tag_value( msg, tag, value ) :\\n _TAG_RE = re.compile('\\\\x01' + str(tag) + '=' + '[\\\\s\\\\w:-]*' + '\\\\x01')\\n msg = _TAG_RE.sub('\\\\x01' + str(tag) + '=' + str(value) + '\\\\x01', msg,1)\\n return msg\",\n \"def Replace(expression, find, replace, start=1, count=-1):\\n if find:\\n return expression[:start - 1] + expression[start - 1:].replace(find, replace, count)\\n else:\\n return expression\",\n \"def substituteNodes(node, replacements):\\n p = node.parentNode\\n for r in replacements:\\n p.insertBefore(r, node)\\n p.removeChild(node)\",\n \"def rep(self,tag,nstr):\\n tmp = []\\n for line in self.content: \\n if tag in line:\\n tmp.append(line.replace(tag,nstr))\\n else:\\n tmp.append(line)\\n self.content = tmp\",\n \"def findAndReplace(self):\\n\\n # Prompts user for find regex and replace text\\n findText, replaceText = Model.FindAndReplaceDialogBox.getResults(self)\\n\\n # Gets the current selection from the current tab\\n selectionModel = self.getCurrentView().selectionModel()\\n\\n # Pass to panda\\n self.getCurrentPanda().findAndReplace(findText, replaceText, selectionModel)\",\n \"def DocumentElementReplace(self, wave_id, wavelet_id, blip_id, position,\\n element):\\n op = Operation(DOCUMENT_ELEMENT_REPLACE, wave_id, wavelet_id, blip_id,\\n index=position,\\n prop=element)\\n self.__context.AddOperation(op)\",\n \"def refresh(self, new_content):\\n pass\",\n \"def replace(self, replacer):\\n for e in self.entries:\\n e.update(replacer.replace(str(e)))\",\n \"def replaceXMLObject(self, **kw):\\n LOG(\\\"replaceXMLObject\\\", INFO, \\\"xml = %s\\\" %(kw.get('xml_string', '')))\\n return self._createAddOrReplaceNode('Replace', **kw)\",\n \"def fill_template(template, replacements):\\n content = template\\n for src, target in replacements.iteritems():\\n content = content.replace(src, target)\\n return content\",\n \"def xreplace(self, rule):\\n value, _ = self._xreplace(rule)\\n return value\",\n \"def replace_chunk(\\n content: str, chunk: str, tags: str, inline: bool = False, **kwargs\\n) -> str:\\n \\n r = re.compile(\\n rf\\\"<!-- {tags} starts -->.*<!-- {tags} ends -->\\\",\\n re.DOTALL,\\n )\\n if not inline:\\n chunk = f\\\"\\\\n{chunk}\\\\n\\\"\\n chunk = f\\\"<!-- {tags} starts -->{chunk}<!-- {tags} ends -->\\\"\\n return r.sub(chunk, content)\",\n \"def replaceNode(self, cur):\\n if cur is None: cur__o = None\\n else: cur__o = cur._o\\n ret = libxml2mod.xmlReplaceNode(self._o, cur__o)\\n if ret is None:raise treeError('xmlReplaceNode() failed')\\n __tmp = xmlNode(_obj=ret)\\n return __tmp\",\n \"def _test_and_set(root, tag, default=None, params={}, quote=False):\\n var = xml_utils.find_nodes_by_tag(root, tag)\\n\\n if var:\\n # Only check the first one\\n return el_utils.replace_el_with_var(var[0].text,\\n params=params,\\n quote=quote)\\n else:\\n return default\",\n \"def replace(self):\\n\\n if self.replace_with is not None: # pylint: disable=no-member\\n return substrings(\\n self.regex,\\n self.replace_with, # pylint: disable=no-member\\n self.data,\\n self.occurences, # pylint: disable=no-member\\n )\\n return self.data\",\n \"def do_replace(self, tx, item):\\n sql = \\\"\\\"\\\"REPLACE INTO des_raw_parsed_data (id, content, url, source, exception_detail, exception_code, site, template_id, domain, classify, subclass)\\n VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)\\\"\\\"\\\"\\n content = json.dumps(dict(item[\\\"other_parameter\\\"]),ensure_ascii=False)\\n # if content:\\n # content = content.decode('unicode_escape')\\n args = (\\n item[\\\"uuid\\\"],\\n content,\\n item[\\\"url\\\"],\\n item[\\\"source\\\"],\\n json.dumps(item[\\\"exception\\\"],ensure_ascii=False),\\n item[\\\"exception_code\\\"],\\n item[\\\"site\\\"],\\n item[\\\"template_id\\\"],\\n item[\\\"domain\\\"],\\n item[\\\"classify\\\"],\\n item[\\\"subclass\\\"]\\n )\\n\\n tx.execute(sql, args)\",\n \"def getReplacedElement(self, *args):\\n return _libsbml.CompSBasePlugin_getReplacedElement(self, *args)\",\n \"def set_content(self, content):\\n self.data['content'] = content\",\n \"def replace_code(self, pattern, repl):\\n regex = re.compile(pattern, re.DOTALL)\\n for cell in self.content.cells:\\n if cell.cell_type == \\\"code\\\" and regex.findall(cell.source):\\n cell.source = regex.sub(repl, cell.source)\\n print(f\\\"- code removed from {self.filename}\\\")\",\n \"def replace(match_obj):\\n return match_obj.group(0)[1:]\",\n \"def replace_instance(s, to_replace, replacement):\\n index=0\\n matchedIndeces=0\\n while index<len(s):\\n if s[index]==to_replace[matchedIndeces]:\\n matchedIndeces+=1\\n if matchedIndeces>=len(to_replace):\\n s=s[:index-(matchedIndeces-1)]+replacement+s[index+1:]\\n index-=matchedIndeces-1\\n matchedIndeces=0\\n else:\\n matchedIndeces=0\\n index+=1\\n return s\",\n \"def replace(content, root_url):\\n soup = BeautifulSoup(content, BEAUTIFULSOUP_BUILDER)\\n soup.header.decompose()\\n for tags, attribute in PROXY_ATTRIBUTES:\\n for tag in soup.find_all(tags, **{attribute: True}):\\n tag_old = tag\\n value = tag[attribute]\\n match = PROXY_PATH_RE.match(value)\\n if match is not None:\\n value = match.groups()[0]\\n tag[attribute] = url_path_join(root_url, value)\\n # log.debug(\\\"REPLACE: tag_attribute_old: %s tag_attribute_new: %s\\\", value, tag[attribute])\\n return str(soup)\",\n \"def find_replace_all(self):\\n old_term = self.text_find.get()\\n new_term = self.text_replace.get()\\n while True:\\n idx = '1.0'\\n idx = self.text.search(old_term, idx, nocase=1,\\n stopindex=tk.END)\\n lastidx = '% s+% dc' % (idx, len(old_term))\\n if not idx:\\n break\\n self.text.delete(idx, lastidx)\\n self.text.insert(idx, new_term)\",\n \"def _update_object_content(name, input):\\n content = input._content\\n\\n hrefs = re.compile(r'<\\\\s*[^\\\\>]*href\\\\s*=\\\\s*([\\\"\\\\'])(.*?)\\\\1')\\n srcs = re.compile(r'<\\\\s*[^\\\\>]*src\\\\s*=\\\\s*([\\\"\\\\'])(.*?)\\\\1')\\n\\n matches = hrefs.findall(content)\\n matches.extend(srcs.findall(content))\\n relative_paths = []\\n for found in matches:\\n found = found[1]\\n if found not in relative_paths:\\n relative_paths.append(found)\\n\\n for relative_path in relative_paths:\\n if not \\\"://\\\" in relative_path: # we don't want to rewrite protocols\\n dest_path = os.sep.join((get_relative_path(name), \\\"static\\\",\\n relative_path))\\n content = content.replace(relative_path, dest_path)\\n\\n return content\",\n \"def patch(text):\\n if match := re.search(r'\\\\d+__\\\\d+__\\\\d+', text):\\n tag = match.group(0)\\n if tag not in ocds_tags:\\n if ocds_version or not use_development_version:\\n text = text.replace(tag, ocds_tag)\\n else:\\n text = text.replace(ocds_schema_base_url + tag, development_base_url)\\n return text\",\n \"def Replace(self, *args):\\n return _BRepAlgo.BRepAlgo_AsDes_Replace(self, *args)\",\n \"def setContent(self, content):\\n self.__content = content\",\n \"def DocumentReplace(self, wave_id, wavelet_id, blip_id, content):\\n op = Operation(DOCUMENT_REPLACE, wave_id, wavelet_id, blip_id,\\n prop=content)\\n self.__context.AddOperation(op)\",\n \"def replace_with_arg(self, src_arg, tgt_arg):\",\n \"def replace(self, param):\\n self.discard(param)\\n self.add(param)\",\n \"def replace(content,line,word,string):\\n\\tline = int(line)\\n\\tstring = string.strip().replace(\\\" \\\",\\\" &^&%+\\\").split()\\n\\tif len(content)<int(line):\\n\\t\\tprint \\\"Error: No such line.\\\"\\n\\t\\treturn (content,False)\\n\\tif word is not None:\\n\\t\\tword = int(word)\\n\\t\\tif len(content[line-1])<int(word) or line>len(content):\\n\\t\\t\\tprint \\\"Error: No such word.\\\"\\n\\t\\t\\treturn (content,False)\\n\\t\\tword = word-1\\n\\t\\tcontent[line-1] = content[line-1][:word]+string+content[line-1][word+1:]\\n\\t\\t\\n\\telse:\\n\\t\\tline = line-1\\n\\t\\tcontent[line] = string\\n\\treturn (content,True)\",\n \"def update(self, data):\\n self.content = data\",\n \"def zap_tag_contents(self, tag):\\n if hasattr(tag, 'contents'):\\n content_length = len(tag.contents)\\n\\n for x in range(0, content_length):\\n if isinstance(tag.contents[x], bs4.element.Comment):\\n self.zap_tag_contents(tag.contents[x])\\n elif isinstance(tag.contents[x], bs4.element.NavigableString):\\n unicode_entry = self.zapper.kill_gremlins(tag.contents[x])\\n unicode_entry = unidecode(unicode_entry)\\n tag.contents[x].replace_with(unicode_entry)\\n elif isinstance(tag.contents[x], bs4.element.Tag):\\n self.zap_tag_contents(tag.contents[x])\",\n \"def _count_or_replace(\\n self, content, query, replacement, ignore_case, search_targets):\\n occurrences = 0\\n flags = re.U\\n if ignore_case:\\n flags = flags | re.I\\n if not isinstance(query, unicode):\\n query = unicode(query, 'utf-8')\\n if replacement and not isinstance(replacement, unicode):\\n replacement = unicode(replacement, 'utf-8')\\n reg = re.compile(re.escape(query), flags)\\n # find all text nodes and text attributes\\n current = content.documentElement\\n replaced = False\\n while current:\\n if 'text' in search_targets:\\n if current.nodeType == 3:\\n # text node\\n toscan = current.nodeValue\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n toscan = reg.sub(replacement, toscan)\\n current.nodeValue = toscan\\n replaced = True\\n elif current.nodeName in (\\n 'image', 'link', 'index', 'abbr', 'acronym'):\\n attrs = ('title',)\\n for attr in attrs:\\n toscan = current.getAttribute(attr)\\n if toscan:\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n current.setAttribute(\\n attr, reg.sub(replacement, toscan))\\n replaced = True\\n if 'paths' in search_targets or 'urls' in search_targets:\\n for name, attr in (\\n ('image', 'link'),\\n ('image', 'path'),\\n ('link', 'url')):\\n if current.nodeName == name:\\n toscan = current.getAttribute(attr)\\n if (toscan and\\n ('paths' in search_targets and not\\n self._reg_urls.match(toscan)) or\\n ('urls' in search_targets and\\n self._reg_absurls.match(toscan))):\\n num = len(reg.findall(toscan))\\n occurrences += num\\n if num and replacement is not None:\\n current.setAttribute(\\n attr, reg.sub(replacement, toscan))\\n replaced = True\\n if current.childNodes.length:\\n current = current.firstChild\\n elif current.nextSibling:\\n current = current.nextSibling\\n else:\\n while current.parentNode:\\n current = current.parentNode\\n if current.nextSibling:\\n current = current.nextSibling\\n break\\n else:\\n current = None\\n if replaced:\\n content._p_changed = True\\n # XXX I assume this should always be done?\\n if hasattr(aq_base(content), 'reindex_object'):\\n content.reindex_object()\\n return occurrences\",\n \"def find_replace(text, list):\\r\\n\\tfor pair in list:\\r\\n\\t\\tif pair[0] in text:\\r\\n\\t\\t\\ttext = text.replace(pair[0], pair[1])\\r\\n\\treturn text\",\n \"def replace_with(self, replacement):\\n\\n # FIND NAMES IN replacement\\n parts = list(regex_parameters.split(replacement, include_separators=True))\\n\\n def replacer(tokens):\\n acc = []\\n for s, n in zip(parts, parts[1:]):\\n acc.append(s)\\n acc.append(text(tokens[n]))\\n acc.append(parts[-1])\\n return \\\"\\\".join(acc)\\n\\n return self / replacer\",\n \"def test_replace_group(self):\\n pass\",\n \"def test_replacement1(engine_contents, engine_locations):\\n file_name = 'Triangle.java.xml'\\n new_contents = copy.deepcopy(engine_contents)\\n new_locations = copy.deepcopy(engine_locations)\\n target1 = (file_name, 'expr_stmt', 3)\\n assert not XmlEngine.do_replace(engine_contents, engine_locations, new_contents, new_locations, target1, target1)\",\n \"def inject_content(self, content: str) -> None:\\n self.content = content\",\n \"def update_content(self, address, owner, content):\\n page = self.get(address=address)\\n page.check_address()\\n revision = page.revision_set.create(page=page, content=content, owner=owner)\\n page.update_html(content)\\n return page\",\n \"def edit(self, new_content: str) -> None:\\n\\n # YOUR CODE HERE\\n self.content = new_content\",\n \"def content(self, content):\\n\\n self._content = content\",\n \"def content(self, content):\\n\\n self._content = content\",\n \"def replace(self, *args, **kwargs): # real signature unknown\\r\\n pass\",\n \"def substitute_elements(self, subs, **kwargs):\\n return self\",\n \"def replace(self, label, data):\\n self._validate_can_write()\\n self._validate_labels(label, must_exist=True)\\n with self._h5file('r+') as h5file:\\n attrs = get_decoded(h5file[label].attrs, 'Deflate', 'Description')\\n del h5file[label]\\n self.insert(label, data, attrs['Description'], attrs['Deflate'])\",\n \"def regexpExec(self, content):\\n ret = libxml2mod.xmlRegexpExec(self._o, content)\\n return ret\",\n \"def merge_content(self, other):\\n self.__content += other.__content\",\n \"def add_substitution(self, pattern, repl):\\r\\n\\r\\n self.substitutions.append( (re.compile(pattern), repl) )\",\n \"def replace_constant(self, src, dst):\\n replace_count = 0\\n for ii in self.__sections:\\n for jj in range(len(ii.content)):\\n line = ii.content[jj]\\n replaced = re.sub(r'(\\\\$%s|\\\\$%s)' % (src, hex(src)), r'$%s' % hex(dst), line)\\n if line != replaced:\\n ii.content[jj] = replaced\\n replace_count += 1\\n if 1 > replace_count:\\n raise RuntimeError(\\\"could not find constant to be replaced\\\")\\n elif 1 < replace_count:\\n raise RuntimeError(\\\"found constant to be replaced more than once, source destroyed\\\")\",\n \"def performReplacement(self):\\n return _libsbml.Replacing_performReplacement(self)\",\n \"def replace(self, **kwargs: Any) -> UiField:\\n return dc.replace(self, **kwargs)\",\n \"def update_well(self, row, col, content):\\n self.plate.get_well(row, col).composition.update(content)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6515308","0.6332452","0.62553614","0.61960304","0.6170884","0.6162246","0.6047259","0.60279584","0.60038835","0.5947182","0.58738005","0.5823154","0.5736322","0.5640052","0.5575298","0.55390126","0.5501876","0.5462999","0.5449665","0.54481953","0.5429287","0.54270405","0.5419557","0.54091096","0.53985655","0.5388554","0.5377131","0.535448","0.5330729","0.5322331","0.52958876","0.5286781","0.5258991","0.5251955","0.524588","0.5242719","0.5229057","0.52281964","0.5228149","0.5217918","0.52060527","0.51995677","0.5194059","0.5183777","0.516674","0.5155041","0.5155041","0.51485336","0.5144272","0.51405716","0.5139115","0.5129531","0.5122871","0.51148444","0.51107156","0.5108839","0.5096752","0.50746125","0.5063711","0.50491416","0.5045423","0.503969","0.50308126","0.502869","0.50156","0.5012278","0.50027496","0.49884775","0.49822745","0.4980944","0.49754515","0.49739784","0.49661472","0.4961652","0.4958183","0.49484614","0.4935497","0.49305344","0.492815","0.4919785","0.49173847","0.4916492","0.4913445","0.4900054","0.4895477","0.48849794","0.48847148","0.48818967","0.4875442","0.4875442","0.48696706","0.4865927","0.48620668","0.48475358","0.4839794","0.48277682","0.48096436","0.4796967","0.47962475","0.47912368"],"string":"[\n \"0.6515308\",\n \"0.6332452\",\n \"0.62553614\",\n \"0.61960304\",\n \"0.6170884\",\n \"0.6162246\",\n \"0.6047259\",\n \"0.60279584\",\n \"0.60038835\",\n \"0.5947182\",\n \"0.58738005\",\n \"0.5823154\",\n \"0.5736322\",\n \"0.5640052\",\n \"0.5575298\",\n \"0.55390126\",\n \"0.5501876\",\n \"0.5462999\",\n \"0.5449665\",\n \"0.54481953\",\n \"0.5429287\",\n \"0.54270405\",\n \"0.5419557\",\n \"0.54091096\",\n \"0.53985655\",\n \"0.5388554\",\n \"0.5377131\",\n \"0.535448\",\n \"0.5330729\",\n \"0.5322331\",\n \"0.52958876\",\n \"0.5286781\",\n \"0.5258991\",\n \"0.5251955\",\n \"0.524588\",\n \"0.5242719\",\n \"0.5229057\",\n \"0.52281964\",\n \"0.5228149\",\n \"0.5217918\",\n \"0.52060527\",\n \"0.51995677\",\n \"0.5194059\",\n \"0.5183777\",\n \"0.516674\",\n \"0.5155041\",\n \"0.5155041\",\n \"0.51485336\",\n \"0.5144272\",\n \"0.51405716\",\n \"0.5139115\",\n \"0.5129531\",\n \"0.5122871\",\n \"0.51148444\",\n \"0.51107156\",\n \"0.5108839\",\n \"0.5096752\",\n \"0.50746125\",\n \"0.5063711\",\n \"0.50491416\",\n \"0.5045423\",\n \"0.503969\",\n \"0.50308126\",\n \"0.502869\",\n \"0.50156\",\n \"0.5012278\",\n \"0.50027496\",\n \"0.49884775\",\n \"0.49822745\",\n \"0.4980944\",\n \"0.49754515\",\n \"0.49739784\",\n \"0.49661472\",\n \"0.4961652\",\n \"0.4958183\",\n \"0.49484614\",\n \"0.4935497\",\n \"0.49305344\",\n \"0.492815\",\n \"0.4919785\",\n \"0.49173847\",\n \"0.4916492\",\n \"0.4913445\",\n \"0.4900054\",\n \"0.4895477\",\n \"0.48849794\",\n \"0.48847148\",\n \"0.48818967\",\n \"0.4875442\",\n \"0.4875442\",\n \"0.48696706\",\n \"0.4865927\",\n \"0.48620668\",\n \"0.48475358\",\n \"0.4839794\",\n \"0.48277682\",\n \"0.48096436\",\n \"0.4796967\",\n \"0.47962475\",\n \"0.47912368\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6922728"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85185,"cells":{"query":{"kind":"string","value":"Return docstrings for an element at a specific line_number. Loop into the file lines in reverse, starting from the element's line_number in order to parse the docstring if available."},"document":{"kind":"string","value":"def get_docstring(line_number, lines):\n docstring = None\n\n for index in reversed(range(line_number-1)):\n line = lines[index].strip()\n if len(line) == 0 or line.startswith(\"//\"):\n # Do not look for docstring when more than two blank lines precede\n # the element.\n if index < line_number - 1:\n return\n\n continue\n\n # Start of the docstring (from the end)\n if docstring is None:\n # If the entire docstring fit in one line\n match = re.search(\"(?<=/\\*\\* ).*(?= \\*/)\", line)\n if match is not None:\n return match.group()\n\n # No docstring\n if not line.startswith(\"*/\"):\n return\n\n docstring = []\n\n # Valid docstring line starts with a '*'\n elif re.search(\"^\\*( *| +.+)$\", line) is not None:\n indentation = 2 if len(line) > 1 else 1\n docstring.append(line[indentation:].rstrip())\n\n # Beginning of valid docstrings starts with '/**'\n elif line.startswith(\"/**\"):\n return \"\\n\".join(docstring[::-1])\n\n # Error in the docstring\n else:\n return"},"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 convert_doxygen_docstring(lines, name):\n\n lines = lines[:]\n newlines = []\n indent = 0\n reading_desc = False\n\n while lines:\n line = lines.pop(0)\n if line.startswith(\"////\"):\n continue\n\n line = line.rstrip()\n if line.startswith('///<'):\n strline = line[4:]\n else:\n strline = line\n\n strline = strline.lstrip('/ \\t')\n\n if strline == \"**\" or strline == \"*/\":\n continue\n\n if strline.startswith(\"** \"):\n strline = strline[3:]\n elif strline.startswith(\"* \"):\n strline = strline[2:]\n elif strline == \"*\":\n strline = \"\"\n\n strline = strline.lstrip(' \\t')\n\n if strline.startswith('@'):\n special = strline.split(' ', 1)[0][1:]\n if special == 'par' and strline.endswith(':') and lines and '@code' in lines[0]:\n newlines.append(' '*indent + strline[5:] + ':')\n newlines.append('')\n line = lines.pop(0)\n offset = line.index('@code')\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"verbatim\" or special == \"code\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. code-block:: guess')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@endverbatim' in line or '@endcode' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == \"f[\":\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. math::')\n newlines.append('')\n offset = line.index('@' + special)\n while lines:\n line = lines.pop(0)\n if '@f]' in line:\n break\n newlines.append(' ' + line[offset:])\n\n newlines.append('')\n continue\n elif special == 'param':\n #TODO\n #if extra is not None:\n # _, name, desc = strline.split(' ', 2)\n # extra['param:' + name] = desc\n continue\n elif special == 'deprecated':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n\n # I'd love to use the proper Sphinx deprecated tag, but it\n # requires a version number, whereas Doxygen doesn't.\n newlines.append('*Deprecated:* ' + convert_doxygen_format(value, name))\n newlines.append('')\n continue\n elif special in ('brief', 'return', 'returns'):\n #TODO\n #if extra is not None:\n # _, value = strline.split(' ', 1)\n # extra[special] = value\n continue\n elif special == 'details':\n strline = strline[9:]\n elif special == 'sa' or special == 'see':\n if newlines and newlines[-1]:\n newlines.append('')\n\n _, value = strline.split(' ', 1)\n values = value.split(',')\n\n for i, value in enumerate(values):\n result = resolve_reference(value.partition('(')[0], name)\n if result:\n values[i] = ':{0}:`{1}`'.format(*result)\n else:\n values[i] = ':obj:`{0}`'.format(value)\n\n if special == 'see':\n newlines.append('See {}.'.format(', '.join(values)))\n else:\n newlines.append('See also {}.'.format(', '.join(values)))\n newlines.append('')\n continue\n elif special in ('note', 'warning'):\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. %s:: ' % (special))\n newlines.append('')\n newlines.append(' ' + convert_doxygen_format(strline[2 + len(special):], name))\n while lines and lines[0].strip(' *\\t/'):\n line = lines.pop(0).lstrip(' *\\t')\n newlines.append(' ' + convert_doxygen_format(line, name))\n\n newlines.append('')\n continue\n elif special == 'since':\n if newlines and newlines[-1]:\n newlines.append('')\n\n newlines.append('.. versionadded:: ' + strline[7:])\n newlines.append('')\n continue\n else:\n print(\"Unhandled documentation tag: @\" + special)\n\n if strline or len(newlines) > 0:\n newlines.append(' '*indent + convert_doxygen_format(strline, name))\n\n return newlines","def read_documentation(self, fid):\r\n\r\n lin = self.read_line(fid)\r\n while lin[0] != ':':\r\n self.documentation.append(lin)\r\n lin = self.read_line(fid)\r\n return lin","def get_documented_in_lines(lines, module=None, filename=None):\r\n title_underline_re = re.compile(\"^[-=*_^#]{3,}\\s*$\")\r\n autodoc_re = re.compile(\".. auto(function|method|attribute|class \\\r\n |exception|module)::\\s*([A-Za-z0-9_.]+)\\s*$\")\r\n autosummary_re = re.compile(r'^\\.\\.\\s+autosummary::\\s*')\r\n module_re = re.compile(\r\n r'^\\.\\.\\s+(current)?module::\\s*([a-zA-Z0-9_.]+)\\s*$')\r\n autosummary_item_re = re.compile(r'^\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\s*')\r\n toctree_arg_re = re.compile(r'^\\s+:toctree:\\s*(.*?)\\s*$')\r\n\r\n documented = {}\r\n\r\n current_title = []\r\n last_line = None\r\n toctree = None\r\n current_module = module\r\n in_autosummary = False\r\n\r\n for line in lines:\r\n try:\r\n if in_autosummary:\r\n m = toctree_arg_re.match(line)\r\n if m:\r\n toctree = m.group(1)\r\n continue\r\n\r\n if line.strip().startswith(':'):\r\n continue # skip options\r\n\r\n m = autosummary_item_re.match(line)\r\n if m:\r\n name = m.group(1).strip()\r\n if current_module and not name.startswith(\r\n current_module + '.'):\r\n name = \"%s.%s\" % (current_module, name)\r\n\r\n documented.setdefault(name, []).append(\r\n (filename, current_title, 'autosummary', toctree))\r\n continue\r\n if line.strip() == '':\r\n continue\r\n in_autosummary = False\r\n\r\n m = autosummary_re.match(line)\r\n if m:\r\n in_autosummary = True\r\n continue\r\n\r\n m = autodoc_re.search(line)\r\n if m:\r\n name = m.group(2).strip()\r\n if m.group(1) == \"module\":\r\n current_module = name\r\n documented.update(get_documented_in_docstring(\r\n name, filename=filename))\r\n elif current_module and not name.startswith(\r\n current_module + '.'):\r\n name = \"%s.%s\" % (current_module, name)\r\n\r\n documented.setdefault(name, []).append(\r\n (filename, current_title, \"auto\" + m.group(1), None))\r\n continue\r\n\r\n m = title_underline_re.match(line)\r\n if m and last_line:\r\n current_title = last_line.strip()\r\n continue\r\n\r\n m = module_re.match(line)\r\n if m:\r\n current_module = m.group(2)\r\n continue\r\n finally:\r\n last_line = line\r\n\r\n return documented","def get_documented_in_lines(lines, module=None, filename=None):\n title_underline_re = re.compile(\"^[-=*_^#]{3,}\\s*$\")\n autodoc_re = re.compile(\".. auto(function|method|attribute|class|exception|module)::\\s*([A-Za-z0-9_.]+)\\s*$\")\n autosummary_re = re.compile(r'^\\.\\.\\s+autosummary::\\s*')\n module_re = re.compile(r'^\\.\\.\\s+(current)?module::\\s*([a-zA-Z0-9_.]+)\\s*$')\n autosummary_item_re = re.compile(r'^\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\s*.*?')\n toctree_arg_re = re.compile(r'^\\s+:toctree:\\s*(.*?)\\s*$')\n \n documented = {}\n \n current_title = []\n last_line = None\n toctree = None\n current_module = module\n in_autosummary = False\n \n for line in lines:\n try:\n if in_autosummary:\n m = toctree_arg_re.match(line)\n if m:\n toctree = m.group(1)\n continue\n\n if line.strip().startswith(':'):\n continue # skip options\n\n m = autosummary_item_re.match(line)\n if m:\n name = m.group(1).strip()\n if current_module and not name.startswith(current_module + '.'):\n name = \"%s.%s\" % (current_module, name)\n documented.setdefault(name, []).append(\n (filename, current_title, 'autosummary', toctree))\n continue\n if line.strip() == '':\n continue\n in_autosummary = False\n\n m = autosummary_re.match(line)\n if m:\n in_autosummary = True\n continue\n\n m = autodoc_re.search(line)\n if m:\n name = m.group(2).strip()\n if m.group(1) == \"module\":\n current_module = name\n documented.update(get_documented_in_docstring(\n name, filename=filename))\n elif current_module and not name.startswith(current_module+'.'):\n name = \"%s.%s\" % (current_module, name)\n documented.setdefault(name, []).append(\n (filename, current_title, \"auto\" + m.group(1), None))\n continue\n\n m = title_underline_re.match(line)\n if m and last_line:\n current_title = last_line.strip()\n continue\n\n m = module_re.match(line)\n if m:\n current_module = m.group(2)\n continue\n finally:\n last_line = line\n\n return documented","def getDoc(file, line, offset):\n args = {\"file\": file, \"line\": line, \"offset\": offset}\n response = send_request(\"quickinfo\", args)\n return get_response_body(response)","def get_documented_in_docstring(name, module=None, filename=None):\r\n try:\r\n obj, real_name = import_by_name(name)\r\n lines = pydoc.getdoc(obj).splitlines()\r\n return get_documented_in_lines(lines, module=name, filename=filename)\r\n except AttributeError:\r\n pass\r\n except ImportError, e:\r\n print \"Failed to import '%s': %s\" % (name, e)\r\n return {}","def get_documented_in_docstring(name, module=None, filename=None):\n try:\n obj, real_name = import_by_name(name)\n lines = pydoc.getdoc(obj).splitlines()\n return get_documented_in_lines(lines, module=name, filename=filename)\n except AttributeError:\n pass\n except ImportError, e:\n print \"Failed to import '%s': %s\" % (name, e)\n return {}","def get_doc_str(cls, fptr, i):\n\n # Save triple double and single quotes in variables\n single_quotes = \"'\" * 3\n double_quotes = '\"' * 3\n quotes = None\n j = -1\n doc_str = []\n\n # Increment i to point to possible start of docstring\n i += 1\n\n # Get line indent\n try:\n base_indent = cls.indent(fptr, i)\n except IndexError:\n return []\n\n # Search first occurrence of triple quotes before increment in indent\n for j in range(i, len(fptr)):\n\n # If indentation changes, return empty docstring\n if cls.indent(fptr, j) != base_indent:\n return []\n\n if single_quotes in fptr[j]:\n\n # Append doc string line to doc_str list\n doc_str.append(fptr[j].strip().strip(\"'\"))\n if fptr[j].count(single_quotes) == 2:\n # Is a one line doc_str\n return doc_str\n\n # Quotes to single quotes\n quotes = single_quotes\n\n elif double_quotes in fptr[j]:\n\n # Append doc string line to doc_str list\n doc_str.append(fptr[j].strip().strip('\"'))\n if fptr[j].count(double_quotes) == 2:\n # Is a one line doc_str\n return doc_str\n\n # Quotes to double quotes\n quotes = double_quotes\n\n # If first set of quotes are fount set j and break from loop\n if quotes:\n j += 1\n break\n\n # Check if starting quotes are found\n if not quotes:\n \n # If quotes are not found, quit function\n return doc_str\n\n # While ending quotes not found add string to doc_string\n while quotes not in fptr[j]:\n # Add line to doc_str and increment line pointer\n doc_str.append(fptr[j].strip().strip(quotes))\n j += 1\n\n # Add closing line to docstring and return result\n doc_str.append(fptr[j].strip().strip(quotes))\n return doc_str","def docnum(self, n):\r\n return self.scored_list[n]","def docstring(func):\n try:\n lines = func.__doc__.strip().split(\"\\n\")\n return [line.strip() for line in lines]\n except AttributeError:\n return None","def get_docs(self):\n return self.retrieve_docstring()","def get_docs(self):\n return self.retrieve_docstring()","def get_docs(self):\n return self.retrieve_docstring()","def adoc_command(event: Event = None, verbose: bool = True) -> File_List:\n #@+<< adoc command docstring >>\n #@+node:ekr.20190515115100.1: *4* << adoc command docstring >>\n #@-<< adoc command docstring >>\n c = event and event.get('c')\n if not c:\n return None\n return c.markupCommands.adoc_command(event, preview=False, verbose=verbose)","def main_docstring():","def docLines(self):\n summary, description = self._getDocParts()\n if description:\n return summary + [\"\"] + description\n return summary","def get_description_lines(docstring):\n if prepare_docstring is None:\n raise ImportError('sphinx must be installed to use this function.')\n\n if not isinstance(docstring, basestring):\n return []\n lines = []\n for line in prepare_docstring(docstring):\n if DESCRIPTION_END_RE.match(line):\n break\n lines.append(line)\n if lines and lines[-1] != '':\n lines.append('')\n return lines","def get_docstrings(self, file_contents):\n\n double_quotes_regex = '(\"\"\"[^\"\"\"]*\"\"\")'\n single_quotes_regex = \"('''[^''']*''')\"\n\n docstrings = re.findall(double_quotes_regex + \"|\" + single_quotes_regex, file_contents)\n # Flatten the list of tuples produced by the use of \"|\" in a regex string\n docstrings = [item for sublist in docstrings for item in sublist if len(item) > 0]\n # Remove trailing characters (\"\"\"/''')\n return [x[3:-3] for x in docstrings]","def extract_docstring(loaded):\n\n source = loaded['cells'][0]['source']\n\n assert source[0].strip() == '\"\"\"'\n assert source[-1].strip() == '\"\"\"'\n\n return ' '.join(i.strip() for i in source[1:-1])","def get_docblocks(self): # type: () -> List[Tuple[str, str]]\n docstring = inspect.getdoc(self)\n result = []\n buffer = OrderedDict()\n\n for path, entry in self._config.items():\n if entry._docstring:\n result.append((docstring, self._config_to_toml(buffer, tomlkit.document())))\n\n docstring = entry._docstring\n buffer = OrderedDict()\n\n buffer[path] = entry\n\n result.append((docstring, self._config_to_toml(buffer, tomlkit.document())))\n return result","def __doc__(self, ???):","def collect_docstring(lines):\n lines = dropwhile(lambda x: not x.startswith('\"\"\"'), lines)\n doc = \"\"\n for line in lines:\n doc += line\n if doc.endswith('\"\"\"\\n'):\n break\n\n return doc[3:-4].replace(\"\\r\", \"\").replace(\"\\n\", \" \")","def docstring(func: Callable) -> list[str] | None:\n try:\n lines = func.__doc__.strip().split(\"\\n\") # type: ignore\n return [line.strip() for line in lines]\n except AttributeError:\n return None","def DocString():\n return","def parse_file(\n filename: str, yamldocs: List[Dict[str, Any]], scollection: db.Standard_collection\n) -> Optional[List[defs.Document]]:\n\n resulting_objects = []\n for contents in yamldocs:\n links = []\n\n document: defs.Document\n register_callback: Callable[[Any, Any], Any]\n\n if not isinstance(\n contents, dict\n ): # basic object matching, make sure we at least have an object, go has this build in :(\n logger.fatal(\"Malformed file %s, skipping\" % filename)\n\n return None\n\n if contents.get(\"links\"):\n links = contents.pop(\"links\")\n\n if contents.get(\"doctype\") == defs.Credoctypes.CRE.value:\n document = defs.CRE(**contents)\n register_callback = register_cre\n elif contents.get(\"doctype\") == defs.Credoctypes.Standard.value:\n document = defs.Standard(**contents)\n register_callback = register_standard\n\n for link in links:\n doclink = parse_file(\n filename=filename,\n yamldocs=[link.get(\"document\")],\n scollection=scollection,\n )\n\n if doclink:\n if len(doclink) > 1:\n logger.fatal(\n \"Parsing single document returned 2 results this is a bug\"\n )\n document.add_link(\n defs.Link(\n document=doclink[0],\n ltype=link.get(\"type\"),\n tags=link.get(\"tags\"),\n )\n )\n if register_callback:\n register_callback(document, collection=scollection) # type: ignore\n else:\n logger.warning(\"Callback to register Document is None, likely missing data\")\n\n resulting_objects.append(document)\n return resulting_objects","def read_docstrings(lang):\n modname = \"turtle_docstringdict_%(language)s\" % {'language':lang.lower()}\n module = __import__(modname)\n docsdict = module.docsdict\n for key in docsdict:\n try:\n# eval(key).im_func.__doc__ = docsdict[key]\n eval(key).__doc__ = docsdict[key]\n except Exception:\n print(\"Bad docstring-entry: %s\" % key)","def _extract_docstring(self, value: str) -> tuple[str, Sequence[str]]:\n docstring = ''\n modules = []\n for line in value.splitlines():\n match = _DOCSTRING_PATTERN.match(line)\n if match:\n module = match.group(1).strip()\n # API docstring: <module>\n if module == self._api_name or module.startswith(self._api_name + '.'):\n modules.append(module)\n else:\n docstring += line + '\\n'\n return (docstring.strip(), modules)","def get_doc(filename: str) -> str:\n\n # Create the header.\n doc = \"# `\" + filename.split(\"/\")[-1] + \"`\\n\\n\"\n\n lines: List[str] = Path(filename).read_text().split(\"\\n\")\n\n for i in range(len(lines)):\n # Create a class description.\n if lines[i].startswith(\"class\"):\n # Skip private classes.\n match = re.search(\"class _(.*):\", lines[i])\n if match is not None:\n continue\n # Add the name of the class\n class_name = re.search(\"class (.*):\", lines[i]).group(1)\n doc += f\"## `{class_name}`\\n\\n\"\n # Add an example.\n class_example = f\"`from tdw.{filename[:-3].replace('/', '.')} import \" + re.sub(r\"(.*)\\((.*)\\)\", r'\\1',\n class_name) + \"`\"\n doc += class_example + \"\\n\\n\"\n doc += PyDocGen.get_class_description(lines, i)\n # Parse an enum.\n if re.search(r\"class (.*)\\(Enum\\):\", lines[i]) is not None:\n doc += \"\\n\\n\" + PyDocGen.get_enum_values(lines, i)\n doc += \"\\n\\n***\\n\\n\"\n # Create a function description.\n elif lines[i].strip().startswith(\"def\"):\n # Skip private functions.\n match = re.search(\"def _(.*)\", lines[i])\n if match is not None and \"__init__\" not in lines[i]:\n continue\n # Append the function description.\n doc += PyDocGen.get_function_documentation(lines, i) + \"\\n\\n***\\n\\n\"\n\n # Move the \"main class\" to the top of the document.\n main_class_name = ''.join(x.capitalize() or '_' for x in filename[:-3].split('_'))\n main_class = re.search(\"(## `\" + main_class_name + \"`((.|\\n)*))\", doc)\n if main_class is not None:\n main_class = main_class.group(1)\n doc_header = re.search(\"(.*)\\n\\n\", doc).group(0)\n doc_temp = doc.replace(main_class, \"\").replace(doc_header, \"\")\n doc = doc_header + main_class + doc_temp\n\n return doc","def description_from_docstring(self, fn):\n docstring = getattr(fn, '__doc__', None) or ''\n description = normalize_indent(docstring)\n return self.description(description)(fn)","def extract_docstring(node: ast.Str) -> Tuple[int, str]:\n lineno = extract_docstring_linenum(node)\n return lineno, inspect.cleandoc(node.s)","def goToDefinition(file, line, offset):\n args = {\"file\": file, \"line\": line, \"offset\": offset}\n response = send_request(\"definition\", args)\n return get_response_body(response)","def line(self, n):\n return self.__contents[n]","def docstrings(param1, param2):\n return \"example string\"","def get_docstring(self, entity_lines):\n entity = ''.join(entity_lines)\n result = re.search(r'(?sm)\\\"\\\"\\\"(.*?)\\\"\\\"\\\"', entity)\n if result is None:\n return ''\n return self._trim(result.groups()[0])","def doc_summary(lines):\n summary = []\n for line in lines:\n stripped = line.strip().lower()\n if (stripped.startswith('to use this normalizer') or\n stripped.startswith('use ``method')):\n continue\n if (line.startswith('Parameters') or line.startswith('Example')\n or line.startswith('.. note::')):\n break\n summary.append(line)\n return summary","def docstring_hack():\n pass","def process_item(filename):\n f = open(filename)\n main_part, references = '', ''\n in_restindex = False\n in_references = False\n for line in f:\n if in_restindex:\n if line.strip()=='/restindex': in_restindex = False\n continue\n if line.strip()=='restindex': in_restindex = True; continue\n if in_references:\n if line!='----------\\n': references += line\n continue\n if line=='References\\n': in_references = True; continue\n main_part += line\n return (main_part, references)","def inspect(filename):\n bfile = open(filename, 'rb')\n bdata = bfile.read()\n bfile.close()\n doc = loads(bdata)\n file_seq = []\n second = None\n for ver, snapshot in enumerate(doc.index):\n nb_obj = len(snapshot)\n cache = nb_obj * [None]\n mini_index = nb_obj * [None]\n for i in range(1, len(snapshot)):\n mini_index[i] = (snapshot[i]['o_gen'], snapshot[i]['o_ver'])\n if type(snapshot[0]) == list:\n second = snapshot[0].pop()\n snapshot[0] = snapshot[0][0]\n memoize_obj_in_cache([snapshot], doc.bdata, i, cache)\n snapshot[0]['content'] = cache[0]\n snapshot[0]['mini_index'] = mini_index\n if 'xref_stream' not in snapshot[0]:\n file_seq.append(snapshot[0])\n snapshot[0] = second\n for i in range(len(snapshot)):\n if snapshot[i]['o_num'] == 0 and 'xref_stream' in snapshot[i]:\n snapshot[i]['ignore'] = True\n continue\n memoize_obj_in_cache([snapshot], doc.bdata, i, cache)\n snapshot[i]['content'] = cache[i]\n snapshot[i]['mini_index'] = mini_index\n if i == 0: print(snapshot[i])\n file_seq.extend(snapshot)\n file_seq = [x for x in file_seq if x is not None and 'ignore' not in x]\n pos_index = {}\n\n STARTXREF = b'startxref'\n startxref_pos = 0\n while True:\n startxref_pos = bdata.find(STARTXREF, startxref_pos)\n if startxref_pos == -1:\n break\n i, j, _ = next_token(bdata, startxref_pos + len(STARTXREF))\n xref_pos = int(bdata[i:j])\n file_seq.append({'abs_pos':startxref_pos, 'o_num':-1, 'o_gen':-1, 'o_ver':startxref_pos,\n 'mini_index':None, 'content':xref_pos})\n startxref_pos += len(STARTXREF)\n\n EOF = b'%%EOF'\n eof_pos = 0\n while True:\n eof_pos = bdata.find(EOF, eof_pos)\n if eof_pos == -1:\n break\n file_seq.append({'abs_pos':eof_pos, 'o_num':-2, 'o_gen':-2, 'o_ver':eof_pos,\n 'mini_index':None, 'content':None})\n eof_pos += len(EOF)\n \n for obj in file_seq:\n if 'abs_pos' in obj and obj['o_num'] != -2:\n pos_index[obj['abs_pos']] = f\"{obj['o_num']}.{obj['o_gen']}.{obj['o_ver']}\"\n file_seq.sort(key=lambda x: x.get('abs_pos') or x.get('a_')) \n print(build_html(file_seq, pos_index, filename))","def extract_docstring_linenum(node: ast.Str) -> int:\n doc = node.s\n lineno = node.lineno\n if _string_lineno_is_end:\n # In older CPython versions, the AST only tells us the end line\n # number and we must approximate the start line number.\n # This approximation is correct if the docstring does not contain\n # explicit newlines ('\\n') or joined lines ('\\' at end of line).\n lineno -= doc.count('\\n')\n\n # Leading blank lines are stripped by cleandoc(), so we must\n # return the line number of the first non-blank line.\n for ch in doc:\n if ch == '\\n':\n lineno += 1\n elif not ch.isspace():\n break\n \n return lineno","def main(rc):\n with store_client(rc) as sclient:\n for doc in rc.documents:\n sclient.copydoc(doc)","def doc(self):\n return \"\\n\".join(self.docLines)","def _generate_autodoc(\n self, entry: _MemberDocumenterEntry,\n summary=False) -> Tuple[sphinx.addnodes.desc, Optional[str]]:\n\n rst_strings = docutils.statemachine.StringList()\n entry.documenter.directive.result = rst_strings\n\n if entry.overload and entry.overload.overload_id is not None:\n # Force autodoc to use the overload-specific signature. autodoc already\n # has an internal mechanism for overriding the docstrings based on the\n # `_new_docstrings` member.\n entry.documenter._new_docstrings = [ # pylint: disable=protected-access\n sphinx.util.docstrings.prepare_docstring(\n entry.overload.doc or '',\n tabsize=self.state.document.settings.tab_width)\n ]\n # Workaround for https://github.com/sphinx-doc/sphinx/pull/9518\n orig_get_doc = entry.documenter.get_doc\n\n def get_doc(ignore: Optional[int] = None) -> List[List[str]]:\n if entry.documenter._new_docstrings is not None: # pylint: disable=protected-access\n return entry.documenter._new_docstrings # pylint: disable=protected-access\n return orig_get_doc(ignore) # type: ignore\n\n entry.documenter.get_doc = get_doc\n\n else:\n # Force autodoc to obtain the docstring through its normal mechanism,\n # which includes the \"ModuleAnalyzer\" for reading docstrings of\n # variables/attributes that are only contained in the source code.\n entry.documenter._new_docstrings = None # pylint: disable=protected-access\n orig_get_doc = None\n\n if summary and entry.is_inherited:\n overridename = entry.name\n else:\n overridename = _get_python_object_name_for_signature(entry)\n entry.documenter.format_name = lambda: overridename\n\n # Record the documenter for use by _process_docstring in `autodoc.py`.\n current_documenter_map = self.env.temp_data.setdefault(\n 'tensorstore_autodoc_current_documenter', {})\n current_documenter_map[entry.documenter.fullname] = entry.documenter\n entry.documenter.generate()\n if orig_get_doc is not None:\n del entry.documenter.get_doc\n del current_documenter_map[entry.documenter.fullname]\n\n group_name = _postprocess_autodoc_rst_output(rst_strings, summary=summary)\n\n entry.documenter.titles_allowed = True\n nodes = [\n x for x in sphinx.ext.autodoc.directive.parse_generated_content(\n self.state, entry.documenter.directive.result, entry.documenter)\n if isinstance(x, sphinx.addnodes.desc)\n ]\n assert len(nodes) == 1\n node = nodes[0]\n\n if entry.subscript:\n _mark_subscript_parameterlist(node)\n if entry.full_name.endswith(_INIT_SUFFIX):\n _clean_init_signature(node)\n if entry.full_name.endswith(_CLASS_GETITEM_SUFFIX):\n _clean_class_getitem_signature(node)\n\n return node, group_name","def getlines(self, n, m):\n return self.__contents[n:m]","def get_line(file, linenum):\n try:\n with open(file, \"r\") as f:\n return f.readlines()[linenum - 1].replace(\"\\n\", \"\")\n except:\n return f\"[ERROR]: could not open '{file}'\"","def sphinx_command(event: Event, verbose: bool = True) -> File_List:\n #@+<< sphinx command docstring >>\n #@+node:ekr.20191017163422.2: *4* << sphinx command docstring >>\n #@-<< sphinx command docstring >>\n c = event and event.get('c')\n if not c:\n return None\n return c.markupCommands.sphinx_command(event, verbose=verbose)","def list_recent_lines(self, num):\n return self.list_lines_gen(self.go_backward, num=num)","def fini_doc(self):\n raise NotImplementedError()","def get_docs( mysource , basename ):\n import parser\n ast = parser.suite(mysource)\n return ModuleInfo(ast.totuple(1), basename)","def _get_file_content(realpath, ignore_undocumented=False):\n\n result = \"\"\"<h2>Module: %s</h2>\n <div class=\"alert alert-info\">\n <div style = \"details\">path: %s</div>\n <div style = \"details\">created: %s, last modified: %s</div></div>\"\"\" %(\n os.path.basename(realpath),\n urlparse.unquote(_convert_path_to_url(realpath)),\n time.ctime(os.path.getmtime(realpath)),\n time.ctime(os.path.getctime(realpath))\n )\n with open(realpath) as sourcefile:\n code = sourcefile.readlines()\n abstract_syntax_tree = ast.parse(''.join(code))\n description = ast.get_docstring(abstract_syntax_tree)\n if description:\n result += \"<h3>Summary:</h3> <div style = 'summary'>%s</div>\" % _convert_str_to_html(description)\n visitor = DocVisitor()\n visitor.visit(abstract_syntax_tree)\n parsed_code = visitor.get_doc()\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\n for entry in entries:\n if ignore_undocumented is False or entry.get(\"description\"):\n begin, end = entry.get(\"lines\")\n result += '<hr /><div><pre>' + \"\".join(code[begin:end]).rstrip().rstrip(\":\") +\"</pre>\"\n result += _convert_str_to_html(entry.get(\"description\"))+\"</div>\"\n\n return result","def convert_doxygen_format(line, name):\n\n line = line.replace('<b>', '**').replace('</b>', '**')\n\n # Single backticks in doxygen map to doubles in Sphinx\n line = line.replace('`', '``')\n\n # But double backticks are literal backticks\n line = line.replace('````', '\\\\`')\n\n # Search for method and class references. We pick them up either when they\n # have a scoping operator, or when they end with (), or we would match all\n # the words in the text!\n origline = line\n for m in re.finditer(r'\\b([a-zA-Z_][a-zA-Z0-9_.:]*)\\(\\)|\\b([a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_.:]*)\\b', origline):\n result = resolve_reference(m.group(0).rstrip('()'), name)\n if not result:\n continue\n\n if '::' in m.group():\n # We want a scoped name, apparently.\n ref = ':{0}:`{1}`'.format(*result)\n else:\n ref = ':{0}:`~{1}`'.format(*result)\n\n # Are we inside double-backticks?\n if origline[:m.start()].count('``') % 2 != 0:\n # Only replace if it's entirely wrapped in backticks.\n line = line.replace('``' + m.group() + '``', ref)\n else:\n line = line.replace(m.group(), ref)\n\n return line","def get_documentation(self, *args, **dargs):\n pass","def dsldocs_completers(self, event):\n # print(dir(event), event)\n command = \"%dsldocs\"\n if event.line.startswith(command):\n doc = Document(event.line.replace(command, \".docs\"))\n c = CleverCompleter()\n res = c.get_completions(doc, None)\n # print(res)\n return [x.text for x in res]","def _get_doc(results, index):\n return results[index]","def fetch_data(self, document, line):\n index = self.resolve_ref(document)\n return line[index]","def docstring(self):\n raw_description = self.qualifiers.get(\"description\")\n\n # short circuit if there isn't a description to process\n if not raw_description:\n _LOGGER.debug(\"No raw description found in MOF, substituting placeholder\")\n return \"No documentation in MOF\"\n\n # process the raw description, normalizing whitespace and special characters\n _LOGGER.debug(\"Normalizing raw description from MOF:\\n%s\", raw_description)\n normalized_lines = []\n for raw_line in raw_description:\n # split to normalize \\n in the entry\n normalized_line_elements = []\n for text in raw_line.split():\n # strip leading/trailing whitespace\n stripped_text = text.strip()\n # escape any special rst characters\n escaped_text = stripped_text.replace('*', '\\*')\n # add to normalized line elements\n normalized_line_elements.append(escaped_text)\n # create normalized line and save it\n normalized_line = \" \".join(normalized_line_elements)\n normalized_lines.append(normalized_line)\n\n # create and return the normalized line block\n normalized_description = \"\\n\".join(normalized_lines)\n _LOGGER.debug(\"Normalized description is:\\n%s\", normalized_description)\n return normalized_description","def get_doctests(self):\n parser = IgnoreOptionsDocTestParser()\n doctest_blocks = []\n filename = self.filename\n flags = self.flags\n for ast_node in self._get_docstring_nodes():\n try:\n examples = parser.get_examples(ast_node.s)\n except Exception:\n blob = ast_node.s\n if len(blob) > 60:\n blob = blob[:60] + '...'\n # TODO: let caller decide how to handle\n logger.warning(\"Can't parse docstring; ignoring: %r\", blob)\n continue\n for example in examples:\n lineno = ast_node.startpos.lineno + example.lineno\n colno = ast_node.startpos.colno + example.indent # dubious\n text = FileText(example.source, filename=filename,\n startpos=(lineno,colno))\n try:\n block = PythonBlock(text, flags=flags)\n block.ast_node # make sure we can parse\n except Exception:\n blob = text.joined\n if len(blob) > 60:\n blob = blob[:60] + '...'\n logger.warning(\"Can't parse doctest; ignoring: %r\", blob)\n continue\n doctest_blocks.append(block)\n return doctest_blocks","def extract_docstrings_from_file_overview() -> Dict[str, Dict[str, str]]:\n with open(DEVELOPER_DOC_PATH, \"r\") as file:\n doc_data = file.readlines()\n\n existing_doc_dict: Dict[str, Dict[str, str]] = {}\n\n # table is present from line TABLE_OFFSET to (length - 1)\n for doc_row in doc_data[TABLE_OFFSET - 1 :]:\n _, folder, filename, docstring, _ = doc_row.split(\"|\")\n folder, filename = folder.strip(), filename.strip()\n if folder:\n # For files under a folder but no folder value in overview file (eg. core.py)\n folder_name = folder\n existing_doc_dict[str(folder_name)] = {}\n if docstring.strip():\n if filename:\n existing_doc_dict[folder_name][filename] = docstring.strip()\n else:\n existing_doc_dict[folder_name][\"no_file_present\"] = docstring.strip()\n return existing_doc_dict","def find_javadoc(filename=None):\n\n pattern_upto_class = r'(\\/\\*\\*.*?\\*\\/).*?class'\n\n with open(filename) as file_content:\n content = file_content.read()\n\n return re.search(pattern_upto_class, content, re.DOTALL)","def get_refs(func):\n found = re.findall(\"References:(.*)\", func.__doc__, flags=re.DOTALL)\n if any(found):\n ref = \" \".join([s.strip() for s in found[0].split(\"\\n\")]).strip()\n return ref\n else:\n return \"\"","def test_get_toc_text(self) -> None:\n extraction = docx2python(RESOURCES / \"zen_of_python.docx\")\n assert extraction.document_runs == [\n [\n [[[\"Contents\"], [\"\\t\", \"Beautiful is better than ugly.\\t1\"], []]],\n [\n [\n [],\n [],\n [\"Beautiful is better than ugly.\"],\n [\"Explicit is better than implicit.\"],\n [\"Simple is better than complex.\"],\n [\"Complex is better than complicated.\"],\n [\"Flat is better than nested.\"],\n [\"Sparse is better than dense.\"],\n [\"Readability counts.\"],\n [\"Special cases aren't special enough to break the rules.\"],\n [\"Although practicality beats purity.\"],\n [\"Errors should never pass silently.\"],\n [\"Unless explicitly silenced.\"],\n [\"In the face of ambiguity, refuse the temptation to guess.\"],\n [\n \"There should be one-- and preferably only one --obvious way to do it.\"\n ],\n [\n \"Although that way may not be obvious at first unless you're Dutch.\"\n ],\n [\"Now is better than never.\"],\n [\"Although never is often better than *right* now.\"],\n [\"If the implementation is hard to explain, it's a bad idea.\"],\n [\n \"If the implementation is easy to explain, it may be a good idea.\"\n ],\n [\n \"Namespaces are one honking great idea -- let's do more of those!\"\n ],\n ]\n ],\n ]\n ]\n extraction.close()","def func_doc():","def autosummary_directive(dirname, arguments, options, content, lineno,\r\n content_offset, block_text, state, state_machine):\r\n import sphinx.addnodes\r\n\r\n names = []\r\n names += [x.strip() for x in content if x.strip()]\r\n\r\n table, warnings, real_names = get_autosummary(names, state,\r\n 'nosignatures' in options)\r\n node = table\r\n\r\n env = state.document.settings.env\r\n suffix = env.config.source_suffix\r\n all_docnames = env.found_docs.copy()\r\n dirname = posixpath.dirname(env.docname)\r\n\r\n if 'toctree' in options:\r\n tree_prefix = options['toctree'].strip()\r\n docnames = []\r\n for name in names:\r\n name = real_names.get(name, name)\r\n\r\n docname = tree_prefix + name\r\n if docname.endswith(suffix):\r\n docname = docname[:-len(suffix)]\r\n docname = posixpath.normpath(posixpath.join(dirname, docname))\r\n if docname not in env.found_docs:\r\n warnings.append(state.document.reporter.warning(\r\n 'toctree references unknown document %r' % docname,\r\n line=lineno))\r\n docnames.append(docname)\r\n\r\n tocnode = sphinx.addnodes.toctree()\r\n tocnode['includefiles'] = docnames\r\n tocnode['maxdepth'] = -1\r\n tocnode['glob'] = None\r\n tocnode['entries'] = []\r\n\r\n tocnode = autosummary_toc('', '', tocnode)\r\n return warnings + [node] + [tocnode]\r\n else:\r\n return warnings + [node]","def test_toc_numbered(\n toc_file: str, cli: CliRunner, temp_with_override, file_regression\n):\n path_output = temp_with_override.joinpath(\"book1\").absolute()\n p_toc = PATH_BOOKS.joinpath(\"toc\")\n path_toc = p_toc.joinpath(toc_file)\n result = cli.invoke(\n commands.build,\n [\n p_toc.as_posix(),\n \"--path-output\",\n path_output.as_posix(),\n \"--toc\",\n path_toc.as_posix(),\n \"-W\",\n ],\n )\n assert result.exit_code == 0, result.output\n\n path_toc_directive = path_output.joinpath(\"_build\", \"html\", \"index.html\")\n\n # get the tableofcontents markup\n soup = BeautifulSoup(path_toc_directive.read_text(encoding=\"utf8\"), \"html.parser\")\n toc = soup.select(\"nav.bd-links\")[0]\n file_regression.check(\n toc.prettify(),\n basename=toc_file.split(\".\")[0],\n extension=f\"{SPHINX_VERSION}.html\",\n )","def lsp_text_document_edits(self) -> Iterator[TextDocumentEdit]:\n changed_files = self.refactoring.get_changed_files()\n for path, changed_file in changed_files.items():\n uri = path.as_uri()\n document = self.workspace.get_document(uri)\n version = 0 if document.version is None else document.version\n text_edits = lsp_text_edits(document, changed_file)\n if text_edits:\n yield TextDocumentEdit(\n text_document=OptionalVersionedTextDocumentIdentifier(\n uri=uri,\n version=version,\n ),\n edits=text_edits,\n )","def xmlsnippet(self, code, lineno=1, colno=None, extralines=3, line_numbers=True):\n with self._lock:\n if not code:\n return\n if colno is not None:\n highlight_columns = (colno - 1, colno)\n else:\n highlight_columns = None\n _lineno = max(0, lineno - extralines)\n\n self.snippet(\n code,\n (_lineno, _lineno + extralines * 2 + 1),\n highlight_line=lineno,\n highlight_columns=highlight_columns,\n line_numbers=True,\n )\n return self","def getComments(source):\n\n markup = []\n for f in source:\n markup += extractMarkup(f)\n\n docs = collateDocs(markup)\n return docs","def pythondoc(self, irc, msg, args, num, req):\n self.googleq('http://docs.python.org/library/', req, num, irc)","def test_findDocumentation(self):\n doc = self.builder._findChanges(\n self.project, self.builder._DOC)\n self.assertEquals(\n doc,\n [(40, 'foo.bar.Baz.quux'),\n (41, 'writing Foo servers')])","def create_included_function_list_readme():\n import iteration_utilities\n from iteration_utilities import Iterable\n from itertools import chain\n from operator import itemgetter\n from astropy.table import Table\n from astropy.io.ascii import RST\n\n rtd_link = '`{name} <http://iteration-utilities.readthedocs.io/en/latest/api/{file}.html#{module}.{name}>`_'\n\n module_to_file = {'iteration_utilities': 'cfuncs',\n 'iteration_utilities._cfuncs': 'cfuncs',\n 'iteration_utilities._helpers._performance': 'helper',\n 'iteration_utilities._recipes._additional': 'additional',\n 'iteration_utilities._recipes._core': 'core',\n }\n\n it = Iterable(chain(iteration_utilities._cfuncs.__dict__.items(),\n iteration_utilities._helpers._performance.__dict__.items(),\n iteration_utilities._recipes._core.__dict__.items(),\n iteration_utilities._recipes._additional.__dict__.items())\n # Exclude PY2 variable and private functions\n ).filterfalse(lambda x: x[0].startswith(('PY2', '_'))\n # Exclude everything that has no __module__\n ).filter(lambda x: hasattr(x[1], '__module__')\n # Only include functions that come from the package\n ).filter(lambda x: x[1].__module__.startswith('iteration_utilities')\n # Remove duplicate names\n ).unique_everseen(itemgetter(0)\n # Sort lexically\n ).get_sorted(key=lambda x: x[0].lower())\n\n it = Iterable(it\n # Create a Sphinx link from function name and module\n ).map(lambda i: rtd_link.format(file = module_to_file[i[1].__module__],\n module = i[1].__module__,\n name = i[0])\n # Group into 4s so we get a 4 column Table\n ).grouper(4, fillvalue=''\n # Convert to list because Table expects it.\n ).as_list()\n\n return '\\n'.join(RST().write(Table(rows=it)))","def get_remark(self, number):\n CONTENT_START_COLUMN = 11\n\n # in case a non-integer is accidentally given\n number = int(number)\n if number < 0 or number > 999:\n raise ValueError(\"The number must be in range 0-999\")\n \n remark_string = f\"REMARK {number:>3d}\"\n # Find lines and omit ``REMARK XXX `` part\n remark_lines = [\n line[CONTENT_START_COLUMN:] for line in self.lines\n if line.startswith(remark_string)\n ]\n if len(remark_lines) == 0:\n return None\n # Remove first empty line\n remark_lines = remark_lines[1:]\n return remark_lines","def google_docstring_to_dict(\n docstring: Optional[str],\n file_import: Optional[Any] = None,\n ) -> Tuple[str, list, list]:\n\n if not docstring:\n return \"\", [], []\n\n regex_sections = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\\n(?P<desc>(?:(\\s|\\S)*?(\\n\\n|\\Z)))\"\n regex_titles = r\"^(?: {4}|\\t)(?P<name>\\*{0,4}\\w+|\\w+\\s\\w+):\"\n section_titles = re.findall(regex_titles, docstring, re.MULTILINE)\n regex_description_sections = r\"(?P<desc>\\A(\\s|\\S)*?)(\\n\\n|\\Z)\"\n descrition_sections = re.findall(\n regex_description_sections, docstring, re.MULTILINE\n )\n description = descrition_sections[0][0] if descrition_sections else \"\"\n sections = re.findall(regex_sections, docstring, re.MULTILINE)\n if not sections and not description:\n description = docstring\n input_list = []\n output_list = []\n if \"Args\" in section_titles or \"Context Outputs\" in section_titles:\n for section in sections:\n if \"Args\" in section:\n lines = section[1].split(\"\\n\")\n # get first indent number\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n arg_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for arg_line in arg_lines:\n in_arg, in_arg_type = MetadataToDict.parse_in_argument_lines(\n arg_line, file_import\n )\n if in_arg:\n input_list.append((in_arg, in_arg_type))\n\n if \"Context Outputs\" in section:\n lines = section[1].split(\"\\n\")\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\n out_lines = section[1].split(f'\\n{spaces_num*\" \"}')\n for out_line in out_lines:\n out_arg = MetadataToDict.parse_out_argument_lines(\n out_line,\n )\n if out_arg:\n output_list.append(out_arg)\n\n return description, input_list, output_list","def parse_docs(docs):\n if not docs:\n return __name__, \"<no documentation>\"\n docs = docs.strip().split('\\n')\n for i, line in enumerate(docs):\n docs[i] = line.strip()\n return docs[0], ' '.join(docs[1:]) if len(docs[1:]) else \"<no documentation>\"","def write_method_doc(file_name, entries):\r\n\r\n with open(file_name, 'w', newline='\\n') as f:\r\n f.write('<table border=\"0\">')\r\n f.write('<tr><td><b>Method</b></td><td><b>Description</b></td></tr>')\r\n for items in sorted(entries, key=itemgetter(3)):\r\n f.write('<tr><td valign=\"top\">%s</td><td>%s</td></tr>' %\r\n (items[3], doc_to_html(items[4])))\r\n f.write('</table>')","def get_docs_and_page():\n _, *args = sys.argv[:]\n if len(args) > 0:\n print(pydoc.getdoc(*args))\n return pydoc.getdoc(*args)","def __init__(self, *args, **kwargs) -> None:\n super().__init__(*args, **kwargs)\n self._lines: TokenLines = defaultdict(list)\n self._docstrings = get_docstring_tokens(self.file_tokens)","def idsFromDocumentation(filename):\n\tidsInOrder = []\n\tsegment = \"\"\n\twith open(filename) as f:\n\t\tfor l in f:\n\t\t\tif \"<h2\" in l:\n\t\t\t\tsegment = l.split(\">\")[1].split(\"<\")[0]\n\t\t\tif 'id=\"SCI_' in l:\n\t\t\t\tidFeature = l.split('\"')[1]\n\t\t\t\t#~ print(idFeature)\n\t\t\t\tidsInOrder.append([segment, idFeature])\n\treturn idsInOrder","def document(cls):\n header = cls.document_header()\n content = cls.document_content()\n index = cls.document_index()\n package = cls.package().name\n filename = inspect.getsourcefile(cls)\n try:\n lines = inspect.getsourcelines(cls)\n except IOError:\n lines = ([], 0)\n line = lines[1]+1\n return DocEntry(\n header, content, index=index,\n package=package, filename=filename, line=line)","def __get_line(file_path: str, line_no: int, errors: str = 'ignore') -> str:\n try:\n with open(file_path, mode='r',\n encoding='utf-8', errors=errors) as f:\n for line in f:\n line_no -= 1\n if line_no == 0:\n return line\n return ''\n except IOError:\n LOG.error(\"Failed to open file %s\", file_path)\n return ''","def file_iterator(file_path):\n with open(file_path, 'r') as f:\n\n for line in f:\n\n #each line is an example\n\n #each example is made of the function name and then a sequence of triplets\n #the triplets are (node, path, node)\n\n example_name, example_body = parse_line(line)\n\n #max length set while preprocessing, make sure none longer\n\n example_length = len(example_body)\n\n assert example_length <= MAX_LENGTH\n \n #need to pad all to maximum length\n\n example_body += [['<pad>', '<pad>', '<pad>']]*(MAX_LENGTH - example_length)\n \n assert len(example_body) == MAX_LENGTH\n\n yield example_name, example_body, example_length","def cppdoc(self, irc, msg, args, num, req):\n self.googleq('www.cplusplus.com/reference/', req, num, irc)","def document_number(self, **kw):\r\n for docnum in self.document_numbers(**kw):\r\n return docnum","def info(self, fun_number=None):\n if fun_number is None:\n return self.__doc__\n\n for line in open(os.path.join(os.path.abspath(os.path.split(__file__)[0]),\n self.info_filename)).readlines():\n if line.split(): # ie if not empty\n try: # empty lines are ignored\n fun = int(line.split()[0])\n if fun == fun_number:\n return 'F'+str(fun) + ' ' + ' '.join(line.split()[1:])\n except ValueError:\n continue # ignore annotations","def listGetString(self, doc, inLine):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n ret = libxml2mod.xmlNodeListGetString(doc__o, self._o, inLine)\n return ret","def store_documentation(self, file_path, *args, **dargs):\n pass","def adoc_with_preview_command(event: Event = None, verbose: bool = True) -> File_List:\n c = event and event.get('c')\n if not c:\n return None\n return c.markupCommands.adoc_command(event, preview=True, verbose=verbose)","def doctest_markup(in_lines):\n out_lines = list(in_lines)[:]\n err_tuples = []\n for pos, this in enumerate(out_lines):\n # Check for 'leave the rest' markup\n if this.strip() == '#23dt skip rest':\n break\n # Check for docest line with markup\n mark_match = MARK_COMMENT.search(this)\n if mark_match is None:\n continue\n docbits, marked_line, marker, markup = mark_match.groups()\n place_line_match = PLACE_LINE_EXPRS.match(markup)\n if place_line_match is None:\n msg = ('Found markup \"%s\" in line \"%s\" but wrong syntax' %\n (markup, this))\n err_tuples.append((this, msg))\n continue\n place_expr, line_expr = place_line_match.groups()\n exec_globals = {'here': pos, 'next': pos+1}\n if place_expr.strip() == '':\n place = pos\n else:\n try:\n place = eval(place_expr, exec_globals)\n except:\n msg = ('Error finding place with \"%s\" in line \"%s\"' %\n (place_expr, this))\n err_tuples.append((this, msg))\n continue\n # Prevent processing operating on 23dt comment part of line\n if place == pos:\n line = marked_line\n else:\n line = out_lines[place]\n # Shorthand\n if line_expr == 'bytes':\n # Any strings on the given line are byte strings\n pre, mid, post = INDENT_SPLITTER.match(line).groups()\n try:\n res = byter(mid)\n except:\n err = sys.exc_info()[1]\n msg = ('Error \"%s\" parsing \"%s\"' % (err, err))\n err_tuples.append((this, msg))\n continue\n res = pre + res + post\n else:\n exec_globals.update({'line': line, 'lines': out_lines})\n # If line_expr starts with 'replace', implies \"line.replace\"\n if line_expr.startswith('replace('):\n line_expr = 'line.' + line_expr\n elif line_expr == 'BytesIO':\n line_expr = \"line.replace('StringIO', 'BytesIO')\"\n try:\n res = eval(line_expr, exec_globals)\n except:\n err = sys.exc_info()[1]\n msg = ('Error \"%s\" working on \"%s\" at line %d with \"%s\"' %\n (err, line, place, line_expr))\n err_tuples.append((this, msg))\n continue\n # Put back comment if removed\n if place == pos:\n res = docbits + res + marker + markup\n if res != line:\n out_lines[place] = res\n return out_lines, err_tuples","def _magic_docs(self, brief=False, rest=False):\n mman = self.shell.magics_manager\n docs = mman.lsmagic_docs(brief, missing='No documentation')\n\n if rest:\n format_string = '**%s%s**::\\n\\n%s\\n\\n'\n else:\n format_string = '%s%s:\\n%s\\n'\n\n return ''.join(\n [format_string % (magic_escapes['line'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['line'].items())]\n +\n [format_string % (magic_escapes['cell'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['cell'].items())]\n )","def _generate_examples(self, filepath):\n\n key = 1\n with tf.io.gfile.GFile(filepath, \"r\") as f:\n tokens = []\n tags = []\n langs = []\n for line in f:\n line = line.rstrip()\n # pylint: disable=g-explicit-bool-comparison\n if line.startswith(\"-DOCSTART-\") or line == \"\":\n if tokens:\n spans = get_spans(tokens, tags)\n yield key, {\n \"tokens\": tokens,\n \"tags\": tags,\n \"langs\": langs,\n \"spans\": spans\n }\n key += 1\n tokens = []\n tags = []\n langs = []\n else:\n # wikiann data is tab separated\n fields = line.split(\"\\t\")\n # strip out language prefix\n langs.append(fields[0].split(\":\")[0])\n tokens.append(\":\".join(fields[0].split(\":\")[1:]))\n if len(fields) > 1:\n tags.append(fields[-1])\n else:\n # examples have no label in test set\n tags.append(\"O\")\n if tokens:\n spans = get_spans(tokens, tags)\n yield key, {\n \"tokens\": tokens,\n \"tags\": tags,\n \"langs\": langs,\n \"spans\": spans\n }","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def _add_doc(func, doc):\r\n func.__doc__ = doc","def __init__(self, module_filename, module_name,\n docindex=None, url_func=None, name_to_docs=None,\n tab_width=8):\n # Get the source version, if possible.\n try: module_filename = py_src_filename(module_filename)\n except: pass\n \n #: The filename of the module we're colorizing.\n self.module_filename = module_filename\n \n #: The dotted name of the module we're colorizing.\n self.module_name = module_name\n\n #: A docindex, used to create href links from identifiers to\n #: the API documentation for their values.\n self.docindex = docindex\n\n #: A mapping from short names to lists of ValueDoc, used to\n #: decide which values an identifier might map to when creating\n #: href links from identifiers to the API docs for their values.\n self.name_to_docs = name_to_docs\n \n #: A function that maps APIDoc -> URL, used to create href\n #: links from identifiers to the API documentation for their\n #: values.\n self.url_func = url_func\n\n #: The index in C{text} of the last character of the last\n #: token we've processed.\n self.pos = 0\n\n #: A list that maps line numbers to character offsets in\n #: C{text}. In particular, line C{M{i}} begins at character\n #: C{line_offset[i]} in C{text}. Since line numbers begin at\n #: 1, the first element of C{line_offsets} is C{None}.\n self.line_offsets = []\n\n #: A list of C{(toktype, toktext)} for all tokens on the\n #: logical line that we are currently processing. Once a\n #: complete line of tokens has been collected in C{cur_line},\n #: it is sent to L{handle_line} for processing.\n self.cur_line = []\n\n #: A list of the names of the class or functions that include\n #: the current block. C{context} has one element for each\n #: level of indentation; C{context[i]} is the name of the class\n #: or function defined by the C{i}th level of indentation, or\n #: C{None} if that level of indentation doesn't correspond to a\n #: class or function definition.\n self.context = []\n\n #: A list, corresponding one-to-one with L{self.context},\n #: indicating the type of each entry. Each element of\n #: C{context_types} is one of: C{'func'}, C{'class'}, C{None}.\n self.context_types = []\n\n #: A list of indentation strings for each of the current\n #: block's indents. I.e., the current total indentation can\n #: be found by taking C{''.join(self.indents)}.\n self.indents = []\n\n #: The line number of the line we're currently processing.\n self.lineno = 0\n\n #: The name of the class or function whose definition started\n #: on the previous logical line, or C{None} if the previous\n #: logical line was not a class or function definition.\n self.def_name = None\n\n #: The type of the class or function whose definition started\n #: on the previous logical line, or C{None} if the previous\n #: logical line was not a class or function definition.\n #: Can be C{'func'}, C{'class'}, C{None}.\n self.def_type = None\n\n #: The number of spaces to replace each tab in source code with\n self.tab_width = tab_width","def read_equations(self) -> None:\n eq_file = open('Equations', 'r')\n line = eq_file.readline()\n while line.strip() != 'END OF DOCUMENTATION':\n line = eq_file.readline()\n # End of documentation\n line = eq_file.readline()\n while line:\n self.equation_list.append(line.strip())\n line = eq_file.readline()","def doc(obj):\n return Documentation.fromObject(obj).first","def get_doc_link(\n self,\n file: Literal[\n \"client\",\n \"service_resource\",\n \"waiters\",\n \"paginators\",\n \"type_defs\",\n \"literals\",\n ],\n *parts: str,\n ) -> str:\n link = f\"{self.get_local_doc_link()}{file}/\"\n if not parts:\n return link\n anchor = \"\".join([get_anchor_link(part) for part in parts])\n return f\"{link}#{anchor}\"","def parse(input):\n\t\n\toutput = []\n\t\n\t# Comment delimiter of the docstring\n\tcommentDelim = '\"\"\"'\n\t\n\t# Some regexes\n\ttriggerRe = re.compile(\"^(\\s*)(def .+:|class .+:)\")\n\tcommentStartRe = re.compile('^\\s*(%s)' % commentDelim)\n\tcommentEndRe = re.compile('(%s)\\s*$' % commentDelim)\n\temptyRe = re.compile(\"^\\s*$\")\n\thashLineRe = re.compile(\"^\\s*#.*$\")\n\timportLineRe = re.compile(\"^\\s*(import |from .+ import)\")\n\t\n\t# split input into lines\n\tlines = input.split(\"\\n\")\n\t\n\t# flags, buffers, ...\n\tfileHeadFlag = True\n\ttriggerWordFlag = False\n\tcommentFlag = False\n\tcomment = []\n\ttriggerWs = \"\"\n\ttriggerLines = None\n\t\n\t# process each line\n\tfor line in enumerate(lines):\n\n\t\tmatch = re.search(triggerRe, line[1])\n\t\tif match:\n\t\t\tif triggerWordFlag and triggerLines:\n\t\t\t\toutput.append(\"\\n\".join(triggerLines))\n\t\t\t\n\t\t\ttriggerWordFlag = True\n\t\t\ttriggerWs = match.group(1)\n\t\t\tfileHeadFlag = False\n\t\t\ttriggerLines = [line[1]]\n\t\t\tcontinue\n\n\t\t# file header or active keyword trigger?\n\t\tif fileHeadFlag or triggerWordFlag:\n\t\t\t# comment end of multiline comment found\n\t\t\tif re.search(commentEndRe, line[1]) and commentFlag:\n\t\t\t\tcomment.append( line[1][ : line[1].rfind(commentDelim) ] )\n\t\t\t\toutput.append(makeCommentBlock(comment, triggerWs, (triggerLines is None)))\n\t\t\t\tif triggerLines:\n\t\t\t\t\toutput.append(\"\\n\".join(triggerLines))\n\t\t\t\tcomment = []\n\t\t\t\tcommentFlag = False\n\t\t\t\ttriggerWs = \"\"\n\t\t\t\ttriggerLines = None\n\t\t\t\ttriggerWordFlag = False\n\t\t\t\t\n\t\t\t# comment start found\n\t\t\telif re.search(commentStartRe, line[1]):\n\t\n\t\t\t\tif re.search(commentEndRe, line[1][line[1].find(commentDelim)+len(commentDelim) :]):\n\t\t\t\t\t# singleline comment\n\t\t\t\t\tcomment.append(line[1][line[1].find(commentDelim)+len(commentDelim) : line[1].rfind(commentDelim)])\n\t\t\t\t\toutput.append(makeCommentBlock(comment, triggerWs))\n\t\t\t\t\t\n\t\t\t\t\tif triggerLines:\n\t\t\t\t\t\toutput.append(\"\\n\".join(triggerLines))\n\t\t\t\t\t\t\n\t\t\t\t\tcomment = []\n\t\t\t\t\tcommentFlag = False\n\t\t\t\t\ttriggerWs = \"\"\n\t\t\t\t\ttriggerLines = None\n\t\t\t\t\ttriggerWordFlag = False\n\t\t\t\t\t\n\t\t\t\telse:\n\t\t\t\t\t# multiline comment begin\n\t\t\t\t\tcommentFlag = True\n\t\t\t\t\tcomment.append(\n\t\t\t\t\t\tline[1][line[1].find(commentDelim)+len(commentDelim):]\n\t\t\t\t\t)\n\t\n\t\t\t# active multiline comment -> append comment\n\t\t\telif commentFlag:\n\t\t\t\tcomment.append(line[1])\n\t\t\t\n\t\t\t# still searching for comment\n\t\t\telif re.search(emptyRe, line[1]):\n\t\t\t\tif triggerLines:\n\t\t\t\t\ttriggerLines.append(line[1])\n\t\t\t\telse:\n\t\t\t\t\toutput.append(line[1])\n\t\t\t\n\t\t\t# searching for file header\n\t\t\telif fileHeadFlag:\n\t\t\t\tif not (re.search(hashLineRe, line[1]) or re.search(emptyRe, line[1]) or re.search(importLineRe, line[1])):\n\t\t\t\t\t# fileheader over -> disable search\n\t\t\t\t\tfileHeadFlag = False\n\t\t\t\toutput.append(line[1])\n\t\t\t\n\t\t\t# no comment, disable comment search mode\n\t\t\telse:\n\t\t\t\ttriggerWordFlag = False\n\t\t\t\tif triggerLines:\n\t\t\t\t\toutput.append(\"\\n\".join(triggerLines))\n\t\t\t\ttriggerLines = None\n\t\t\t\toutput.append(line[1])\n\t\t\n\t\t# just append the line\n\t\telse:\n\t\t\toutput.append(line[1])\n\t\n\t# return output\n\treturn \"\\n\".join(output)","def getdoc(object):\r\n try:\r\n doc = object.__doc__\r\n except AttributeError:\r\n return None\r\n if not isinstance(doc, types.StringTypes):\r\n return None\r\n return cleandoc(doc)","def get_line(trj_file):\n\twith open(trj_file) as file:\n\t\tfor i in file:\n\t\t\tyield i","def check_doc(document):\n try:\n assert document[0].startswith(\"#doc \")\n except AssertionError:\n print(\"The document does not start with '#doc' but instead\", document[0])\n doc_id = document[0].split()[1]\n for i in range(1, len(document)):\n line = document[i]\n try:\n assert int(line.split()[0]) == i - 1\n except (ValueError, AssertionError):\n print(\"Document\", doc_id, \"line\", i, \":\", line, \"expect line index\",\n i - 1, \", found\", line.split()[0])","def open_file(file,n,n1=0):\n\tfin = open(file)\n\tbook_lines = []\n\tcount = 0\n\tfor line in fin:\n\t\tword = line.strip()\n\t\tcount += 1\n\t\tif count > n:\n\t\t\tbook_lines.append(word)\n\treturn book_lines"],"string":"[\n \"def convert_doxygen_docstring(lines, name):\\n\\n lines = lines[:]\\n newlines = []\\n indent = 0\\n reading_desc = False\\n\\n while lines:\\n line = lines.pop(0)\\n if line.startswith(\\\"////\\\"):\\n continue\\n\\n line = line.rstrip()\\n if line.startswith('///<'):\\n strline = line[4:]\\n else:\\n strline = line\\n\\n strline = strline.lstrip('/ \\\\t')\\n\\n if strline == \\\"**\\\" or strline == \\\"*/\\\":\\n continue\\n\\n if strline.startswith(\\\"** \\\"):\\n strline = strline[3:]\\n elif strline.startswith(\\\"* \\\"):\\n strline = strline[2:]\\n elif strline == \\\"*\\\":\\n strline = \\\"\\\"\\n\\n strline = strline.lstrip(' \\\\t')\\n\\n if strline.startswith('@'):\\n special = strline.split(' ', 1)[0][1:]\\n if special == 'par' and strline.endswith(':') and lines and '@code' in lines[0]:\\n newlines.append(' '*indent + strline[5:] + ':')\\n newlines.append('')\\n line = lines.pop(0)\\n offset = line.index('@code')\\n while lines:\\n line = lines.pop(0)\\n if '@endverbatim' in line or '@endcode' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == \\\"verbatim\\\" or special == \\\"code\\\":\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. code-block:: guess')\\n newlines.append('')\\n offset = line.index('@' + special)\\n while lines:\\n line = lines.pop(0)\\n if '@endverbatim' in line or '@endcode' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == \\\"f[\\\":\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. math::')\\n newlines.append('')\\n offset = line.index('@' + special)\\n while lines:\\n line = lines.pop(0)\\n if '@f]' in line:\\n break\\n newlines.append(' ' + line[offset:])\\n\\n newlines.append('')\\n continue\\n elif special == 'param':\\n #TODO\\n #if extra is not None:\\n # _, name, desc = strline.split(' ', 2)\\n # extra['param:' + name] = desc\\n continue\\n elif special == 'deprecated':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n _, value = strline.split(' ', 1)\\n\\n # I'd love to use the proper Sphinx deprecated tag, but it\\n # requires a version number, whereas Doxygen doesn't.\\n newlines.append('*Deprecated:* ' + convert_doxygen_format(value, name))\\n newlines.append('')\\n continue\\n elif special in ('brief', 'return', 'returns'):\\n #TODO\\n #if extra is not None:\\n # _, value = strline.split(' ', 1)\\n # extra[special] = value\\n continue\\n elif special == 'details':\\n strline = strline[9:]\\n elif special == 'sa' or special == 'see':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n _, value = strline.split(' ', 1)\\n values = value.split(',')\\n\\n for i, value in enumerate(values):\\n result = resolve_reference(value.partition('(')[0], name)\\n if result:\\n values[i] = ':{0}:`{1}`'.format(*result)\\n else:\\n values[i] = ':obj:`{0}`'.format(value)\\n\\n if special == 'see':\\n newlines.append('See {}.'.format(', '.join(values)))\\n else:\\n newlines.append('See also {}.'.format(', '.join(values)))\\n newlines.append('')\\n continue\\n elif special in ('note', 'warning'):\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. %s:: ' % (special))\\n newlines.append('')\\n newlines.append(' ' + convert_doxygen_format(strline[2 + len(special):], name))\\n while lines and lines[0].strip(' *\\\\t/'):\\n line = lines.pop(0).lstrip(' *\\\\t')\\n newlines.append(' ' + convert_doxygen_format(line, name))\\n\\n newlines.append('')\\n continue\\n elif special == 'since':\\n if newlines and newlines[-1]:\\n newlines.append('')\\n\\n newlines.append('.. versionadded:: ' + strline[7:])\\n newlines.append('')\\n continue\\n else:\\n print(\\\"Unhandled documentation tag: @\\\" + special)\\n\\n if strline or len(newlines) > 0:\\n newlines.append(' '*indent + convert_doxygen_format(strline, name))\\n\\n return newlines\",\n \"def read_documentation(self, fid):\\r\\n\\r\\n lin = self.read_line(fid)\\r\\n while lin[0] != ':':\\r\\n self.documentation.append(lin)\\r\\n lin = self.read_line(fid)\\r\\n return lin\",\n \"def get_documented_in_lines(lines, module=None, filename=None):\\r\\n title_underline_re = re.compile(\\\"^[-=*_^#]{3,}\\\\s*$\\\")\\r\\n autodoc_re = re.compile(\\\".. auto(function|method|attribute|class \\\\\\r\\n |exception|module)::\\\\s*([A-Za-z0-9_.]+)\\\\s*$\\\")\\r\\n autosummary_re = re.compile(r'^\\\\.\\\\.\\\\s+autosummary::\\\\s*')\\r\\n module_re = re.compile(\\r\\n r'^\\\\.\\\\.\\\\s+(current)?module::\\\\s*([a-zA-Z0-9_.]+)\\\\s*$')\\r\\n autosummary_item_re = re.compile(r'^\\\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\\\s*')\\r\\n toctree_arg_re = re.compile(r'^\\\\s+:toctree:\\\\s*(.*?)\\\\s*$')\\r\\n\\r\\n documented = {}\\r\\n\\r\\n current_title = []\\r\\n last_line = None\\r\\n toctree = None\\r\\n current_module = module\\r\\n in_autosummary = False\\r\\n\\r\\n for line in lines:\\r\\n try:\\r\\n if in_autosummary:\\r\\n m = toctree_arg_re.match(line)\\r\\n if m:\\r\\n toctree = m.group(1)\\r\\n continue\\r\\n\\r\\n if line.strip().startswith(':'):\\r\\n continue # skip options\\r\\n\\r\\n m = autosummary_item_re.match(line)\\r\\n if m:\\r\\n name = m.group(1).strip()\\r\\n if current_module and not name.startswith(\\r\\n current_module + '.'):\\r\\n name = \\\"%s.%s\\\" % (current_module, name)\\r\\n\\r\\n documented.setdefault(name, []).append(\\r\\n (filename, current_title, 'autosummary', toctree))\\r\\n continue\\r\\n if line.strip() == '':\\r\\n continue\\r\\n in_autosummary = False\\r\\n\\r\\n m = autosummary_re.match(line)\\r\\n if m:\\r\\n in_autosummary = True\\r\\n continue\\r\\n\\r\\n m = autodoc_re.search(line)\\r\\n if m:\\r\\n name = m.group(2).strip()\\r\\n if m.group(1) == \\\"module\\\":\\r\\n current_module = name\\r\\n documented.update(get_documented_in_docstring(\\r\\n name, filename=filename))\\r\\n elif current_module and not name.startswith(\\r\\n current_module + '.'):\\r\\n name = \\\"%s.%s\\\" % (current_module, name)\\r\\n\\r\\n documented.setdefault(name, []).append(\\r\\n (filename, current_title, \\\"auto\\\" + m.group(1), None))\\r\\n continue\\r\\n\\r\\n m = title_underline_re.match(line)\\r\\n if m and last_line:\\r\\n current_title = last_line.strip()\\r\\n continue\\r\\n\\r\\n m = module_re.match(line)\\r\\n if m:\\r\\n current_module = m.group(2)\\r\\n continue\\r\\n finally:\\r\\n last_line = line\\r\\n\\r\\n return documented\",\n \"def get_documented_in_lines(lines, module=None, filename=None):\\n title_underline_re = re.compile(\\\"^[-=*_^#]{3,}\\\\s*$\\\")\\n autodoc_re = re.compile(\\\".. auto(function|method|attribute|class|exception|module)::\\\\s*([A-Za-z0-9_.]+)\\\\s*$\\\")\\n autosummary_re = re.compile(r'^\\\\.\\\\.\\\\s+autosummary::\\\\s*')\\n module_re = re.compile(r'^\\\\.\\\\.\\\\s+(current)?module::\\\\s*([a-zA-Z0-9_.]+)\\\\s*$')\\n autosummary_item_re = re.compile(r'^\\\\s+([_a-zA-Z][a-zA-Z0-9_.]*)\\\\s*.*?')\\n toctree_arg_re = re.compile(r'^\\\\s+:toctree:\\\\s*(.*?)\\\\s*$')\\n \\n documented = {}\\n \\n current_title = []\\n last_line = None\\n toctree = None\\n current_module = module\\n in_autosummary = False\\n \\n for line in lines:\\n try:\\n if in_autosummary:\\n m = toctree_arg_re.match(line)\\n if m:\\n toctree = m.group(1)\\n continue\\n\\n if line.strip().startswith(':'):\\n continue # skip options\\n\\n m = autosummary_item_re.match(line)\\n if m:\\n name = m.group(1).strip()\\n if current_module and not name.startswith(current_module + '.'):\\n name = \\\"%s.%s\\\" % (current_module, name)\\n documented.setdefault(name, []).append(\\n (filename, current_title, 'autosummary', toctree))\\n continue\\n if line.strip() == '':\\n continue\\n in_autosummary = False\\n\\n m = autosummary_re.match(line)\\n if m:\\n in_autosummary = True\\n continue\\n\\n m = autodoc_re.search(line)\\n if m:\\n name = m.group(2).strip()\\n if m.group(1) == \\\"module\\\":\\n current_module = name\\n documented.update(get_documented_in_docstring(\\n name, filename=filename))\\n elif current_module and not name.startswith(current_module+'.'):\\n name = \\\"%s.%s\\\" % (current_module, name)\\n documented.setdefault(name, []).append(\\n (filename, current_title, \\\"auto\\\" + m.group(1), None))\\n continue\\n\\n m = title_underline_re.match(line)\\n if m and last_line:\\n current_title = last_line.strip()\\n continue\\n\\n m = module_re.match(line)\\n if m:\\n current_module = m.group(2)\\n continue\\n finally:\\n last_line = line\\n\\n return documented\",\n \"def getDoc(file, line, offset):\\n args = {\\\"file\\\": file, \\\"line\\\": line, \\\"offset\\\": offset}\\n response = send_request(\\\"quickinfo\\\", args)\\n return get_response_body(response)\",\n \"def get_documented_in_docstring(name, module=None, filename=None):\\r\\n try:\\r\\n obj, real_name = import_by_name(name)\\r\\n lines = pydoc.getdoc(obj).splitlines()\\r\\n return get_documented_in_lines(lines, module=name, filename=filename)\\r\\n except AttributeError:\\r\\n pass\\r\\n except ImportError, e:\\r\\n print \\\"Failed to import '%s': %s\\\" % (name, e)\\r\\n return {}\",\n \"def get_documented_in_docstring(name, module=None, filename=None):\\n try:\\n obj, real_name = import_by_name(name)\\n lines = pydoc.getdoc(obj).splitlines()\\n return get_documented_in_lines(lines, module=name, filename=filename)\\n except AttributeError:\\n pass\\n except ImportError, e:\\n print \\\"Failed to import '%s': %s\\\" % (name, e)\\n return {}\",\n \"def get_doc_str(cls, fptr, i):\\n\\n # Save triple double and single quotes in variables\\n single_quotes = \\\"'\\\" * 3\\n double_quotes = '\\\"' * 3\\n quotes = None\\n j = -1\\n doc_str = []\\n\\n # Increment i to point to possible start of docstring\\n i += 1\\n\\n # Get line indent\\n try:\\n base_indent = cls.indent(fptr, i)\\n except IndexError:\\n return []\\n\\n # Search first occurrence of triple quotes before increment in indent\\n for j in range(i, len(fptr)):\\n\\n # If indentation changes, return empty docstring\\n if cls.indent(fptr, j) != base_indent:\\n return []\\n\\n if single_quotes in fptr[j]:\\n\\n # Append doc string line to doc_str list\\n doc_str.append(fptr[j].strip().strip(\\\"'\\\"))\\n if fptr[j].count(single_quotes) == 2:\\n # Is a one line doc_str\\n return doc_str\\n\\n # Quotes to single quotes\\n quotes = single_quotes\\n\\n elif double_quotes in fptr[j]:\\n\\n # Append doc string line to doc_str list\\n doc_str.append(fptr[j].strip().strip('\\\"'))\\n if fptr[j].count(double_quotes) == 2:\\n # Is a one line doc_str\\n return doc_str\\n\\n # Quotes to double quotes\\n quotes = double_quotes\\n\\n # If first set of quotes are fount set j and break from loop\\n if quotes:\\n j += 1\\n break\\n\\n # Check if starting quotes are found\\n if not quotes:\\n \\n # If quotes are not found, quit function\\n return doc_str\\n\\n # While ending quotes not found add string to doc_string\\n while quotes not in fptr[j]:\\n # Add line to doc_str and increment line pointer\\n doc_str.append(fptr[j].strip().strip(quotes))\\n j += 1\\n\\n # Add closing line to docstring and return result\\n doc_str.append(fptr[j].strip().strip(quotes))\\n return doc_str\",\n \"def docnum(self, n):\\r\\n return self.scored_list[n]\",\n \"def docstring(func):\\n try:\\n lines = func.__doc__.strip().split(\\\"\\\\n\\\")\\n return [line.strip() for line in lines]\\n except AttributeError:\\n return None\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def get_docs(self):\\n return self.retrieve_docstring()\",\n \"def adoc_command(event: Event = None, verbose: bool = True) -> File_List:\\n #@+<< adoc command docstring >>\\n #@+node:ekr.20190515115100.1: *4* << adoc command docstring >>\\n #@-<< adoc command docstring >>\\n c = event and event.get('c')\\n if not c:\\n return None\\n return c.markupCommands.adoc_command(event, preview=False, verbose=verbose)\",\n \"def main_docstring():\",\n \"def docLines(self):\\n summary, description = self._getDocParts()\\n if description:\\n return summary + [\\\"\\\"] + description\\n return summary\",\n \"def get_description_lines(docstring):\\n if prepare_docstring is None:\\n raise ImportError('sphinx must be installed to use this function.')\\n\\n if not isinstance(docstring, basestring):\\n return []\\n lines = []\\n for line in prepare_docstring(docstring):\\n if DESCRIPTION_END_RE.match(line):\\n break\\n lines.append(line)\\n if lines and lines[-1] != '':\\n lines.append('')\\n return lines\",\n \"def get_docstrings(self, file_contents):\\n\\n double_quotes_regex = '(\\\"\\\"\\\"[^\\\"\\\"\\\"]*\\\"\\\"\\\")'\\n single_quotes_regex = \\\"('''[^''']*''')\\\"\\n\\n docstrings = re.findall(double_quotes_regex + \\\"|\\\" + single_quotes_regex, file_contents)\\n # Flatten the list of tuples produced by the use of \\\"|\\\" in a regex string\\n docstrings = [item for sublist in docstrings for item in sublist if len(item) > 0]\\n # Remove trailing characters (\\\"\\\"\\\"/''')\\n return [x[3:-3] for x in docstrings]\",\n \"def extract_docstring(loaded):\\n\\n source = loaded['cells'][0]['source']\\n\\n assert source[0].strip() == '\\\"\\\"\\\"'\\n assert source[-1].strip() == '\\\"\\\"\\\"'\\n\\n return ' '.join(i.strip() for i in source[1:-1])\",\n \"def get_docblocks(self): # type: () -> List[Tuple[str, str]]\\n docstring = inspect.getdoc(self)\\n result = []\\n buffer = OrderedDict()\\n\\n for path, entry in self._config.items():\\n if entry._docstring:\\n result.append((docstring, self._config_to_toml(buffer, tomlkit.document())))\\n\\n docstring = entry._docstring\\n buffer = OrderedDict()\\n\\n buffer[path] = entry\\n\\n result.append((docstring, self._config_to_toml(buffer, tomlkit.document())))\\n return result\",\n \"def __doc__(self, ???):\",\n \"def collect_docstring(lines):\\n lines = dropwhile(lambda x: not x.startswith('\\\"\\\"\\\"'), lines)\\n doc = \\\"\\\"\\n for line in lines:\\n doc += line\\n if doc.endswith('\\\"\\\"\\\"\\\\n'):\\n break\\n\\n return doc[3:-4].replace(\\\"\\\\r\\\", \\\"\\\").replace(\\\"\\\\n\\\", \\\" \\\")\",\n \"def docstring(func: Callable) -> list[str] | None:\\n try:\\n lines = func.__doc__.strip().split(\\\"\\\\n\\\") # type: ignore\\n return [line.strip() for line in lines]\\n except AttributeError:\\n return None\",\n \"def DocString():\\n return\",\n \"def parse_file(\\n filename: str, yamldocs: List[Dict[str, Any]], scollection: db.Standard_collection\\n) -> Optional[List[defs.Document]]:\\n\\n resulting_objects = []\\n for contents in yamldocs:\\n links = []\\n\\n document: defs.Document\\n register_callback: Callable[[Any, Any], Any]\\n\\n if not isinstance(\\n contents, dict\\n ): # basic object matching, make sure we at least have an object, go has this build in :(\\n logger.fatal(\\\"Malformed file %s, skipping\\\" % filename)\\n\\n return None\\n\\n if contents.get(\\\"links\\\"):\\n links = contents.pop(\\\"links\\\")\\n\\n if contents.get(\\\"doctype\\\") == defs.Credoctypes.CRE.value:\\n document = defs.CRE(**contents)\\n register_callback = register_cre\\n elif contents.get(\\\"doctype\\\") == defs.Credoctypes.Standard.value:\\n document = defs.Standard(**contents)\\n register_callback = register_standard\\n\\n for link in links:\\n doclink = parse_file(\\n filename=filename,\\n yamldocs=[link.get(\\\"document\\\")],\\n scollection=scollection,\\n )\\n\\n if doclink:\\n if len(doclink) > 1:\\n logger.fatal(\\n \\\"Parsing single document returned 2 results this is a bug\\\"\\n )\\n document.add_link(\\n defs.Link(\\n document=doclink[0],\\n ltype=link.get(\\\"type\\\"),\\n tags=link.get(\\\"tags\\\"),\\n )\\n )\\n if register_callback:\\n register_callback(document, collection=scollection) # type: ignore\\n else:\\n logger.warning(\\\"Callback to register Document is None, likely missing data\\\")\\n\\n resulting_objects.append(document)\\n return resulting_objects\",\n \"def read_docstrings(lang):\\n modname = \\\"turtle_docstringdict_%(language)s\\\" % {'language':lang.lower()}\\n module = __import__(modname)\\n docsdict = module.docsdict\\n for key in docsdict:\\n try:\\n# eval(key).im_func.__doc__ = docsdict[key]\\n eval(key).__doc__ = docsdict[key]\\n except Exception:\\n print(\\\"Bad docstring-entry: %s\\\" % key)\",\n \"def _extract_docstring(self, value: str) -> tuple[str, Sequence[str]]:\\n docstring = ''\\n modules = []\\n for line in value.splitlines():\\n match = _DOCSTRING_PATTERN.match(line)\\n if match:\\n module = match.group(1).strip()\\n # API docstring: <module>\\n if module == self._api_name or module.startswith(self._api_name + '.'):\\n modules.append(module)\\n else:\\n docstring += line + '\\\\n'\\n return (docstring.strip(), modules)\",\n \"def get_doc(filename: str) -> str:\\n\\n # Create the header.\\n doc = \\\"# `\\\" + filename.split(\\\"/\\\")[-1] + \\\"`\\\\n\\\\n\\\"\\n\\n lines: List[str] = Path(filename).read_text().split(\\\"\\\\n\\\")\\n\\n for i in range(len(lines)):\\n # Create a class description.\\n if lines[i].startswith(\\\"class\\\"):\\n # Skip private classes.\\n match = re.search(\\\"class _(.*):\\\", lines[i])\\n if match is not None:\\n continue\\n # Add the name of the class\\n class_name = re.search(\\\"class (.*):\\\", lines[i]).group(1)\\n doc += f\\\"## `{class_name}`\\\\n\\\\n\\\"\\n # Add an example.\\n class_example = f\\\"`from tdw.{filename[:-3].replace('/', '.')} import \\\" + re.sub(r\\\"(.*)\\\\((.*)\\\\)\\\", r'\\\\1',\\n class_name) + \\\"`\\\"\\n doc += class_example + \\\"\\\\n\\\\n\\\"\\n doc += PyDocGen.get_class_description(lines, i)\\n # Parse an enum.\\n if re.search(r\\\"class (.*)\\\\(Enum\\\\):\\\", lines[i]) is not None:\\n doc += \\\"\\\\n\\\\n\\\" + PyDocGen.get_enum_values(lines, i)\\n doc += \\\"\\\\n\\\\n***\\\\n\\\\n\\\"\\n # Create a function description.\\n elif lines[i].strip().startswith(\\\"def\\\"):\\n # Skip private functions.\\n match = re.search(\\\"def _(.*)\\\", lines[i])\\n if match is not None and \\\"__init__\\\" not in lines[i]:\\n continue\\n # Append the function description.\\n doc += PyDocGen.get_function_documentation(lines, i) + \\\"\\\\n\\\\n***\\\\n\\\\n\\\"\\n\\n # Move the \\\"main class\\\" to the top of the document.\\n main_class_name = ''.join(x.capitalize() or '_' for x in filename[:-3].split('_'))\\n main_class = re.search(\\\"(## `\\\" + main_class_name + \\\"`((.|\\\\n)*))\\\", doc)\\n if main_class is not None:\\n main_class = main_class.group(1)\\n doc_header = re.search(\\\"(.*)\\\\n\\\\n\\\", doc).group(0)\\n doc_temp = doc.replace(main_class, \\\"\\\").replace(doc_header, \\\"\\\")\\n doc = doc_header + main_class + doc_temp\\n\\n return doc\",\n \"def description_from_docstring(self, fn):\\n docstring = getattr(fn, '__doc__', None) or ''\\n description = normalize_indent(docstring)\\n return self.description(description)(fn)\",\n \"def extract_docstring(node: ast.Str) -> Tuple[int, str]:\\n lineno = extract_docstring_linenum(node)\\n return lineno, inspect.cleandoc(node.s)\",\n \"def goToDefinition(file, line, offset):\\n args = {\\\"file\\\": file, \\\"line\\\": line, \\\"offset\\\": offset}\\n response = send_request(\\\"definition\\\", args)\\n return get_response_body(response)\",\n \"def line(self, n):\\n return self.__contents[n]\",\n \"def docstrings(param1, param2):\\n return \\\"example string\\\"\",\n \"def get_docstring(self, entity_lines):\\n entity = ''.join(entity_lines)\\n result = re.search(r'(?sm)\\\\\\\"\\\\\\\"\\\\\\\"(.*?)\\\\\\\"\\\\\\\"\\\\\\\"', entity)\\n if result is None:\\n return ''\\n return self._trim(result.groups()[0])\",\n \"def doc_summary(lines):\\n summary = []\\n for line in lines:\\n stripped = line.strip().lower()\\n if (stripped.startswith('to use this normalizer') or\\n stripped.startswith('use ``method')):\\n continue\\n if (line.startswith('Parameters') or line.startswith('Example')\\n or line.startswith('.. note::')):\\n break\\n summary.append(line)\\n return summary\",\n \"def docstring_hack():\\n pass\",\n \"def process_item(filename):\\n f = open(filename)\\n main_part, references = '', ''\\n in_restindex = False\\n in_references = False\\n for line in f:\\n if in_restindex:\\n if line.strip()=='/restindex': in_restindex = False\\n continue\\n if line.strip()=='restindex': in_restindex = True; continue\\n if in_references:\\n if line!='----------\\\\n': references += line\\n continue\\n if line=='References\\\\n': in_references = True; continue\\n main_part += line\\n return (main_part, references)\",\n \"def inspect(filename):\\n bfile = open(filename, 'rb')\\n bdata = bfile.read()\\n bfile.close()\\n doc = loads(bdata)\\n file_seq = []\\n second = None\\n for ver, snapshot in enumerate(doc.index):\\n nb_obj = len(snapshot)\\n cache = nb_obj * [None]\\n mini_index = nb_obj * [None]\\n for i in range(1, len(snapshot)):\\n mini_index[i] = (snapshot[i]['o_gen'], snapshot[i]['o_ver'])\\n if type(snapshot[0]) == list:\\n second = snapshot[0].pop()\\n snapshot[0] = snapshot[0][0]\\n memoize_obj_in_cache([snapshot], doc.bdata, i, cache)\\n snapshot[0]['content'] = cache[0]\\n snapshot[0]['mini_index'] = mini_index\\n if 'xref_stream' not in snapshot[0]:\\n file_seq.append(snapshot[0])\\n snapshot[0] = second\\n for i in range(len(snapshot)):\\n if snapshot[i]['o_num'] == 0 and 'xref_stream' in snapshot[i]:\\n snapshot[i]['ignore'] = True\\n continue\\n memoize_obj_in_cache([snapshot], doc.bdata, i, cache)\\n snapshot[i]['content'] = cache[i]\\n snapshot[i]['mini_index'] = mini_index\\n if i == 0: print(snapshot[i])\\n file_seq.extend(snapshot)\\n file_seq = [x for x in file_seq if x is not None and 'ignore' not in x]\\n pos_index = {}\\n\\n STARTXREF = b'startxref'\\n startxref_pos = 0\\n while True:\\n startxref_pos = bdata.find(STARTXREF, startxref_pos)\\n if startxref_pos == -1:\\n break\\n i, j, _ = next_token(bdata, startxref_pos + len(STARTXREF))\\n xref_pos = int(bdata[i:j])\\n file_seq.append({'abs_pos':startxref_pos, 'o_num':-1, 'o_gen':-1, 'o_ver':startxref_pos,\\n 'mini_index':None, 'content':xref_pos})\\n startxref_pos += len(STARTXREF)\\n\\n EOF = b'%%EOF'\\n eof_pos = 0\\n while True:\\n eof_pos = bdata.find(EOF, eof_pos)\\n if eof_pos == -1:\\n break\\n file_seq.append({'abs_pos':eof_pos, 'o_num':-2, 'o_gen':-2, 'o_ver':eof_pos,\\n 'mini_index':None, 'content':None})\\n eof_pos += len(EOF)\\n \\n for obj in file_seq:\\n if 'abs_pos' in obj and obj['o_num'] != -2:\\n pos_index[obj['abs_pos']] = f\\\"{obj['o_num']}.{obj['o_gen']}.{obj['o_ver']}\\\"\\n file_seq.sort(key=lambda x: x.get('abs_pos') or x.get('a_')) \\n print(build_html(file_seq, pos_index, filename))\",\n \"def extract_docstring_linenum(node: ast.Str) -> int:\\n doc = node.s\\n lineno = node.lineno\\n if _string_lineno_is_end:\\n # In older CPython versions, the AST only tells us the end line\\n # number and we must approximate the start line number.\\n # This approximation is correct if the docstring does not contain\\n # explicit newlines ('\\\\n') or joined lines ('\\\\' at end of line).\\n lineno -= doc.count('\\\\n')\\n\\n # Leading blank lines are stripped by cleandoc(), so we must\\n # return the line number of the first non-blank line.\\n for ch in doc:\\n if ch == '\\\\n':\\n lineno += 1\\n elif not ch.isspace():\\n break\\n \\n return lineno\",\n \"def main(rc):\\n with store_client(rc) as sclient:\\n for doc in rc.documents:\\n sclient.copydoc(doc)\",\n \"def doc(self):\\n return \\\"\\\\n\\\".join(self.docLines)\",\n \"def _generate_autodoc(\\n self, entry: _MemberDocumenterEntry,\\n summary=False) -> Tuple[sphinx.addnodes.desc, Optional[str]]:\\n\\n rst_strings = docutils.statemachine.StringList()\\n entry.documenter.directive.result = rst_strings\\n\\n if entry.overload and entry.overload.overload_id is not None:\\n # Force autodoc to use the overload-specific signature. autodoc already\\n # has an internal mechanism for overriding the docstrings based on the\\n # `_new_docstrings` member.\\n entry.documenter._new_docstrings = [ # pylint: disable=protected-access\\n sphinx.util.docstrings.prepare_docstring(\\n entry.overload.doc or '',\\n tabsize=self.state.document.settings.tab_width)\\n ]\\n # Workaround for https://github.com/sphinx-doc/sphinx/pull/9518\\n orig_get_doc = entry.documenter.get_doc\\n\\n def get_doc(ignore: Optional[int] = None) -> List[List[str]]:\\n if entry.documenter._new_docstrings is not None: # pylint: disable=protected-access\\n return entry.documenter._new_docstrings # pylint: disable=protected-access\\n return orig_get_doc(ignore) # type: ignore\\n\\n entry.documenter.get_doc = get_doc\\n\\n else:\\n # Force autodoc to obtain the docstring through its normal mechanism,\\n # which includes the \\\"ModuleAnalyzer\\\" for reading docstrings of\\n # variables/attributes that are only contained in the source code.\\n entry.documenter._new_docstrings = None # pylint: disable=protected-access\\n orig_get_doc = None\\n\\n if summary and entry.is_inherited:\\n overridename = entry.name\\n else:\\n overridename = _get_python_object_name_for_signature(entry)\\n entry.documenter.format_name = lambda: overridename\\n\\n # Record the documenter for use by _process_docstring in `autodoc.py`.\\n current_documenter_map = self.env.temp_data.setdefault(\\n 'tensorstore_autodoc_current_documenter', {})\\n current_documenter_map[entry.documenter.fullname] = entry.documenter\\n entry.documenter.generate()\\n if orig_get_doc is not None:\\n del entry.documenter.get_doc\\n del current_documenter_map[entry.documenter.fullname]\\n\\n group_name = _postprocess_autodoc_rst_output(rst_strings, summary=summary)\\n\\n entry.documenter.titles_allowed = True\\n nodes = [\\n x for x in sphinx.ext.autodoc.directive.parse_generated_content(\\n self.state, entry.documenter.directive.result, entry.documenter)\\n if isinstance(x, sphinx.addnodes.desc)\\n ]\\n assert len(nodes) == 1\\n node = nodes[0]\\n\\n if entry.subscript:\\n _mark_subscript_parameterlist(node)\\n if entry.full_name.endswith(_INIT_SUFFIX):\\n _clean_init_signature(node)\\n if entry.full_name.endswith(_CLASS_GETITEM_SUFFIX):\\n _clean_class_getitem_signature(node)\\n\\n return node, group_name\",\n \"def getlines(self, n, m):\\n return self.__contents[n:m]\",\n \"def get_line(file, linenum):\\n try:\\n with open(file, \\\"r\\\") as f:\\n return f.readlines()[linenum - 1].replace(\\\"\\\\n\\\", \\\"\\\")\\n except:\\n return f\\\"[ERROR]: could not open '{file}'\\\"\",\n \"def sphinx_command(event: Event, verbose: bool = True) -> File_List:\\n #@+<< sphinx command docstring >>\\n #@+node:ekr.20191017163422.2: *4* << sphinx command docstring >>\\n #@-<< sphinx command docstring >>\\n c = event and event.get('c')\\n if not c:\\n return None\\n return c.markupCommands.sphinx_command(event, verbose=verbose)\",\n \"def list_recent_lines(self, num):\\n return self.list_lines_gen(self.go_backward, num=num)\",\n \"def fini_doc(self):\\n raise NotImplementedError()\",\n \"def get_docs( mysource , basename ):\\n import parser\\n ast = parser.suite(mysource)\\n return ModuleInfo(ast.totuple(1), basename)\",\n \"def _get_file_content(realpath, ignore_undocumented=False):\\n\\n result = \\\"\\\"\\\"<h2>Module: %s</h2>\\n <div class=\\\"alert alert-info\\\">\\n <div style = \\\"details\\\">path: %s</div>\\n <div style = \\\"details\\\">created: %s, last modified: %s</div></div>\\\"\\\"\\\" %(\\n os.path.basename(realpath),\\n urlparse.unquote(_convert_path_to_url(realpath)),\\n time.ctime(os.path.getmtime(realpath)),\\n time.ctime(os.path.getctime(realpath))\\n )\\n with open(realpath) as sourcefile:\\n code = sourcefile.readlines()\\n abstract_syntax_tree = ast.parse(''.join(code))\\n description = ast.get_docstring(abstract_syntax_tree)\\n if description:\\n result += \\\"<h3>Summary:</h3> <div style = 'summary'>%s</div>\\\" % _convert_str_to_html(description)\\n visitor = DocVisitor()\\n visitor.visit(abstract_syntax_tree)\\n parsed_code = visitor.get_doc()\\n entries = [ parsed_code[key] for key in sorted(parsed_code.keys())]\\n for entry in entries:\\n if ignore_undocumented is False or entry.get(\\\"description\\\"):\\n begin, end = entry.get(\\\"lines\\\")\\n result += '<hr /><div><pre>' + \\\"\\\".join(code[begin:end]).rstrip().rstrip(\\\":\\\") +\\\"</pre>\\\"\\n result += _convert_str_to_html(entry.get(\\\"description\\\"))+\\\"</div>\\\"\\n\\n return result\",\n \"def convert_doxygen_format(line, name):\\n\\n line = line.replace('<b>', '**').replace('</b>', '**')\\n\\n # Single backticks in doxygen map to doubles in Sphinx\\n line = line.replace('`', '``')\\n\\n # But double backticks are literal backticks\\n line = line.replace('````', '\\\\\\\\`')\\n\\n # Search for method and class references. We pick them up either when they\\n # have a scoping operator, or when they end with (), or we would match all\\n # the words in the text!\\n origline = line\\n for m in re.finditer(r'\\\\b([a-zA-Z_][a-zA-Z0-9_.:]*)\\\\(\\\\)|\\\\b([a-zA-Z_][a-zA-Z0-9_]*::[a-zA-Z_][a-zA-Z0-9_.:]*)\\\\b', origline):\\n result = resolve_reference(m.group(0).rstrip('()'), name)\\n if not result:\\n continue\\n\\n if '::' in m.group():\\n # We want a scoped name, apparently.\\n ref = ':{0}:`{1}`'.format(*result)\\n else:\\n ref = ':{0}:`~{1}`'.format(*result)\\n\\n # Are we inside double-backticks?\\n if origline[:m.start()].count('``') % 2 != 0:\\n # Only replace if it's entirely wrapped in backticks.\\n line = line.replace('``' + m.group() + '``', ref)\\n else:\\n line = line.replace(m.group(), ref)\\n\\n return line\",\n \"def get_documentation(self, *args, **dargs):\\n pass\",\n \"def dsldocs_completers(self, event):\\n # print(dir(event), event)\\n command = \\\"%dsldocs\\\"\\n if event.line.startswith(command):\\n doc = Document(event.line.replace(command, \\\".docs\\\"))\\n c = CleverCompleter()\\n res = c.get_completions(doc, None)\\n # print(res)\\n return [x.text for x in res]\",\n \"def _get_doc(results, index):\\n return results[index]\",\n \"def fetch_data(self, document, line):\\n index = self.resolve_ref(document)\\n return line[index]\",\n \"def docstring(self):\\n raw_description = self.qualifiers.get(\\\"description\\\")\\n\\n # short circuit if there isn't a description to process\\n if not raw_description:\\n _LOGGER.debug(\\\"No raw description found in MOF, substituting placeholder\\\")\\n return \\\"No documentation in MOF\\\"\\n\\n # process the raw description, normalizing whitespace and special characters\\n _LOGGER.debug(\\\"Normalizing raw description from MOF:\\\\n%s\\\", raw_description)\\n normalized_lines = []\\n for raw_line in raw_description:\\n # split to normalize \\\\n in the entry\\n normalized_line_elements = []\\n for text in raw_line.split():\\n # strip leading/trailing whitespace\\n stripped_text = text.strip()\\n # escape any special rst characters\\n escaped_text = stripped_text.replace('*', '\\\\*')\\n # add to normalized line elements\\n normalized_line_elements.append(escaped_text)\\n # create normalized line and save it\\n normalized_line = \\\" \\\".join(normalized_line_elements)\\n normalized_lines.append(normalized_line)\\n\\n # create and return the normalized line block\\n normalized_description = \\\"\\\\n\\\".join(normalized_lines)\\n _LOGGER.debug(\\\"Normalized description is:\\\\n%s\\\", normalized_description)\\n return normalized_description\",\n \"def get_doctests(self):\\n parser = IgnoreOptionsDocTestParser()\\n doctest_blocks = []\\n filename = self.filename\\n flags = self.flags\\n for ast_node in self._get_docstring_nodes():\\n try:\\n examples = parser.get_examples(ast_node.s)\\n except Exception:\\n blob = ast_node.s\\n if len(blob) > 60:\\n blob = blob[:60] + '...'\\n # TODO: let caller decide how to handle\\n logger.warning(\\\"Can't parse docstring; ignoring: %r\\\", blob)\\n continue\\n for example in examples:\\n lineno = ast_node.startpos.lineno + example.lineno\\n colno = ast_node.startpos.colno + example.indent # dubious\\n text = FileText(example.source, filename=filename,\\n startpos=(lineno,colno))\\n try:\\n block = PythonBlock(text, flags=flags)\\n block.ast_node # make sure we can parse\\n except Exception:\\n blob = text.joined\\n if len(blob) > 60:\\n blob = blob[:60] + '...'\\n logger.warning(\\\"Can't parse doctest; ignoring: %r\\\", blob)\\n continue\\n doctest_blocks.append(block)\\n return doctest_blocks\",\n \"def extract_docstrings_from_file_overview() -> Dict[str, Dict[str, str]]:\\n with open(DEVELOPER_DOC_PATH, \\\"r\\\") as file:\\n doc_data = file.readlines()\\n\\n existing_doc_dict: Dict[str, Dict[str, str]] = {}\\n\\n # table is present from line TABLE_OFFSET to (length - 1)\\n for doc_row in doc_data[TABLE_OFFSET - 1 :]:\\n _, folder, filename, docstring, _ = doc_row.split(\\\"|\\\")\\n folder, filename = folder.strip(), filename.strip()\\n if folder:\\n # For files under a folder but no folder value in overview file (eg. core.py)\\n folder_name = folder\\n existing_doc_dict[str(folder_name)] = {}\\n if docstring.strip():\\n if filename:\\n existing_doc_dict[folder_name][filename] = docstring.strip()\\n else:\\n existing_doc_dict[folder_name][\\\"no_file_present\\\"] = docstring.strip()\\n return existing_doc_dict\",\n \"def find_javadoc(filename=None):\\n\\n pattern_upto_class = r'(\\\\/\\\\*\\\\*.*?\\\\*\\\\/).*?class'\\n\\n with open(filename) as file_content:\\n content = file_content.read()\\n\\n return re.search(pattern_upto_class, content, re.DOTALL)\",\n \"def get_refs(func):\\n found = re.findall(\\\"References:(.*)\\\", func.__doc__, flags=re.DOTALL)\\n if any(found):\\n ref = \\\" \\\".join([s.strip() for s in found[0].split(\\\"\\\\n\\\")]).strip()\\n return ref\\n else:\\n return \\\"\\\"\",\n \"def test_get_toc_text(self) -> None:\\n extraction = docx2python(RESOURCES / \\\"zen_of_python.docx\\\")\\n assert extraction.document_runs == [\\n [\\n [[[\\\"Contents\\\"], [\\\"\\\\t\\\", \\\"Beautiful is better than ugly.\\\\t1\\\"], []]],\\n [\\n [\\n [],\\n [],\\n [\\\"Beautiful is better than ugly.\\\"],\\n [\\\"Explicit is better than implicit.\\\"],\\n [\\\"Simple is better than complex.\\\"],\\n [\\\"Complex is better than complicated.\\\"],\\n [\\\"Flat is better than nested.\\\"],\\n [\\\"Sparse is better than dense.\\\"],\\n [\\\"Readability counts.\\\"],\\n [\\\"Special cases aren't special enough to break the rules.\\\"],\\n [\\\"Although practicality beats purity.\\\"],\\n [\\\"Errors should never pass silently.\\\"],\\n [\\\"Unless explicitly silenced.\\\"],\\n [\\\"In the face of ambiguity, refuse the temptation to guess.\\\"],\\n [\\n \\\"There should be one-- and preferably only one --obvious way to do it.\\\"\\n ],\\n [\\n \\\"Although that way may not be obvious at first unless you're Dutch.\\\"\\n ],\\n [\\\"Now is better than never.\\\"],\\n [\\\"Although never is often better than *right* now.\\\"],\\n [\\\"If the implementation is hard to explain, it's a bad idea.\\\"],\\n [\\n \\\"If the implementation is easy to explain, it may be a good idea.\\\"\\n ],\\n [\\n \\\"Namespaces are one honking great idea -- let's do more of those!\\\"\\n ],\\n ]\\n ],\\n ]\\n ]\\n extraction.close()\",\n \"def func_doc():\",\n \"def autosummary_directive(dirname, arguments, options, content, lineno,\\r\\n content_offset, block_text, state, state_machine):\\r\\n import sphinx.addnodes\\r\\n\\r\\n names = []\\r\\n names += [x.strip() for x in content if x.strip()]\\r\\n\\r\\n table, warnings, real_names = get_autosummary(names, state,\\r\\n 'nosignatures' in options)\\r\\n node = table\\r\\n\\r\\n env = state.document.settings.env\\r\\n suffix = env.config.source_suffix\\r\\n all_docnames = env.found_docs.copy()\\r\\n dirname = posixpath.dirname(env.docname)\\r\\n\\r\\n if 'toctree' in options:\\r\\n tree_prefix = options['toctree'].strip()\\r\\n docnames = []\\r\\n for name in names:\\r\\n name = real_names.get(name, name)\\r\\n\\r\\n docname = tree_prefix + name\\r\\n if docname.endswith(suffix):\\r\\n docname = docname[:-len(suffix)]\\r\\n docname = posixpath.normpath(posixpath.join(dirname, docname))\\r\\n if docname not in env.found_docs:\\r\\n warnings.append(state.document.reporter.warning(\\r\\n 'toctree references unknown document %r' % docname,\\r\\n line=lineno))\\r\\n docnames.append(docname)\\r\\n\\r\\n tocnode = sphinx.addnodes.toctree()\\r\\n tocnode['includefiles'] = docnames\\r\\n tocnode['maxdepth'] = -1\\r\\n tocnode['glob'] = None\\r\\n tocnode['entries'] = []\\r\\n\\r\\n tocnode = autosummary_toc('', '', tocnode)\\r\\n return warnings + [node] + [tocnode]\\r\\n else:\\r\\n return warnings + [node]\",\n \"def test_toc_numbered(\\n toc_file: str, cli: CliRunner, temp_with_override, file_regression\\n):\\n path_output = temp_with_override.joinpath(\\\"book1\\\").absolute()\\n p_toc = PATH_BOOKS.joinpath(\\\"toc\\\")\\n path_toc = p_toc.joinpath(toc_file)\\n result = cli.invoke(\\n commands.build,\\n [\\n p_toc.as_posix(),\\n \\\"--path-output\\\",\\n path_output.as_posix(),\\n \\\"--toc\\\",\\n path_toc.as_posix(),\\n \\\"-W\\\",\\n ],\\n )\\n assert result.exit_code == 0, result.output\\n\\n path_toc_directive = path_output.joinpath(\\\"_build\\\", \\\"html\\\", \\\"index.html\\\")\\n\\n # get the tableofcontents markup\\n soup = BeautifulSoup(path_toc_directive.read_text(encoding=\\\"utf8\\\"), \\\"html.parser\\\")\\n toc = soup.select(\\\"nav.bd-links\\\")[0]\\n file_regression.check(\\n toc.prettify(),\\n basename=toc_file.split(\\\".\\\")[0],\\n extension=f\\\"{SPHINX_VERSION}.html\\\",\\n )\",\n \"def lsp_text_document_edits(self) -> Iterator[TextDocumentEdit]:\\n changed_files = self.refactoring.get_changed_files()\\n for path, changed_file in changed_files.items():\\n uri = path.as_uri()\\n document = self.workspace.get_document(uri)\\n version = 0 if document.version is None else document.version\\n text_edits = lsp_text_edits(document, changed_file)\\n if text_edits:\\n yield TextDocumentEdit(\\n text_document=OptionalVersionedTextDocumentIdentifier(\\n uri=uri,\\n version=version,\\n ),\\n edits=text_edits,\\n )\",\n \"def xmlsnippet(self, code, lineno=1, colno=None, extralines=3, line_numbers=True):\\n with self._lock:\\n if not code:\\n return\\n if colno is not None:\\n highlight_columns = (colno - 1, colno)\\n else:\\n highlight_columns = None\\n _lineno = max(0, lineno - extralines)\\n\\n self.snippet(\\n code,\\n (_lineno, _lineno + extralines * 2 + 1),\\n highlight_line=lineno,\\n highlight_columns=highlight_columns,\\n line_numbers=True,\\n )\\n return self\",\n \"def getComments(source):\\n\\n markup = []\\n for f in source:\\n markup += extractMarkup(f)\\n\\n docs = collateDocs(markup)\\n return docs\",\n \"def pythondoc(self, irc, msg, args, num, req):\\n self.googleq('http://docs.python.org/library/', req, num, irc)\",\n \"def test_findDocumentation(self):\\n doc = self.builder._findChanges(\\n self.project, self.builder._DOC)\\n self.assertEquals(\\n doc,\\n [(40, 'foo.bar.Baz.quux'),\\n (41, 'writing Foo servers')])\",\n \"def create_included_function_list_readme():\\n import iteration_utilities\\n from iteration_utilities import Iterable\\n from itertools import chain\\n from operator import itemgetter\\n from astropy.table import Table\\n from astropy.io.ascii import RST\\n\\n rtd_link = '`{name} <http://iteration-utilities.readthedocs.io/en/latest/api/{file}.html#{module}.{name}>`_'\\n\\n module_to_file = {'iteration_utilities': 'cfuncs',\\n 'iteration_utilities._cfuncs': 'cfuncs',\\n 'iteration_utilities._helpers._performance': 'helper',\\n 'iteration_utilities._recipes._additional': 'additional',\\n 'iteration_utilities._recipes._core': 'core',\\n }\\n\\n it = Iterable(chain(iteration_utilities._cfuncs.__dict__.items(),\\n iteration_utilities._helpers._performance.__dict__.items(),\\n iteration_utilities._recipes._core.__dict__.items(),\\n iteration_utilities._recipes._additional.__dict__.items())\\n # Exclude PY2 variable and private functions\\n ).filterfalse(lambda x: x[0].startswith(('PY2', '_'))\\n # Exclude everything that has no __module__\\n ).filter(lambda x: hasattr(x[1], '__module__')\\n # Only include functions that come from the package\\n ).filter(lambda x: x[1].__module__.startswith('iteration_utilities')\\n # Remove duplicate names\\n ).unique_everseen(itemgetter(0)\\n # Sort lexically\\n ).get_sorted(key=lambda x: x[0].lower())\\n\\n it = Iterable(it\\n # Create a Sphinx link from function name and module\\n ).map(lambda i: rtd_link.format(file = module_to_file[i[1].__module__],\\n module = i[1].__module__,\\n name = i[0])\\n # Group into 4s so we get a 4 column Table\\n ).grouper(4, fillvalue=''\\n # Convert to list because Table expects it.\\n ).as_list()\\n\\n return '\\\\n'.join(RST().write(Table(rows=it)))\",\n \"def get_remark(self, number):\\n CONTENT_START_COLUMN = 11\\n\\n # in case a non-integer is accidentally given\\n number = int(number)\\n if number < 0 or number > 999:\\n raise ValueError(\\\"The number must be in range 0-999\\\")\\n \\n remark_string = f\\\"REMARK {number:>3d}\\\"\\n # Find lines and omit ``REMARK XXX `` part\\n remark_lines = [\\n line[CONTENT_START_COLUMN:] for line in self.lines\\n if line.startswith(remark_string)\\n ]\\n if len(remark_lines) == 0:\\n return None\\n # Remove first empty line\\n remark_lines = remark_lines[1:]\\n return remark_lines\",\n \"def google_docstring_to_dict(\\n docstring: Optional[str],\\n file_import: Optional[Any] = None,\\n ) -> Tuple[str, list, list]:\\n\\n if not docstring:\\n return \\\"\\\", [], []\\n\\n regex_sections = r\\\"^(?: {4}|\\\\t)(?P<name>\\\\*{0,4}\\\\w+|\\\\w+\\\\s\\\\w+):\\\\n(?P<desc>(?:(\\\\s|\\\\S)*?(\\\\n\\\\n|\\\\Z)))\\\"\\n regex_titles = r\\\"^(?: {4}|\\\\t)(?P<name>\\\\*{0,4}\\\\w+|\\\\w+\\\\s\\\\w+):\\\"\\n section_titles = re.findall(regex_titles, docstring, re.MULTILINE)\\n regex_description_sections = r\\\"(?P<desc>\\\\A(\\\\s|\\\\S)*?)(\\\\n\\\\n|\\\\Z)\\\"\\n descrition_sections = re.findall(\\n regex_description_sections, docstring, re.MULTILINE\\n )\\n description = descrition_sections[0][0] if descrition_sections else \\\"\\\"\\n sections = re.findall(regex_sections, docstring, re.MULTILINE)\\n if not sections and not description:\\n description = docstring\\n input_list = []\\n output_list = []\\n if \\\"Args\\\" in section_titles or \\\"Context Outputs\\\" in section_titles:\\n for section in sections:\\n if \\\"Args\\\" in section:\\n lines = section[1].split(\\\"\\\\n\\\")\\n # get first indent number\\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\\n arg_lines = section[1].split(f'\\\\n{spaces_num*\\\" \\\"}')\\n for arg_line in arg_lines:\\n in_arg, in_arg_type = MetadataToDict.parse_in_argument_lines(\\n arg_line, file_import\\n )\\n if in_arg:\\n input_list.append((in_arg, in_arg_type))\\n\\n if \\\"Context Outputs\\\" in section:\\n lines = section[1].split(\\\"\\\\n\\\")\\n spaces_num = len(lines[0]) - len(lines[0].lstrip())\\n out_lines = section[1].split(f'\\\\n{spaces_num*\\\" \\\"}')\\n for out_line in out_lines:\\n out_arg = MetadataToDict.parse_out_argument_lines(\\n out_line,\\n )\\n if out_arg:\\n output_list.append(out_arg)\\n\\n return description, input_list, output_list\",\n \"def parse_docs(docs):\\n if not docs:\\n return __name__, \\\"<no documentation>\\\"\\n docs = docs.strip().split('\\\\n')\\n for i, line in enumerate(docs):\\n docs[i] = line.strip()\\n return docs[0], ' '.join(docs[1:]) if len(docs[1:]) else \\\"<no documentation>\\\"\",\n \"def write_method_doc(file_name, entries):\\r\\n\\r\\n with open(file_name, 'w', newline='\\\\n') as f:\\r\\n f.write('<table border=\\\"0\\\">')\\r\\n f.write('<tr><td><b>Method</b></td><td><b>Description</b></td></tr>')\\r\\n for items in sorted(entries, key=itemgetter(3)):\\r\\n f.write('<tr><td valign=\\\"top\\\">%s</td><td>%s</td></tr>' %\\r\\n (items[3], doc_to_html(items[4])))\\r\\n f.write('</table>')\",\n \"def get_docs_and_page():\\n _, *args = sys.argv[:]\\n if len(args) > 0:\\n print(pydoc.getdoc(*args))\\n return pydoc.getdoc(*args)\",\n \"def __init__(self, *args, **kwargs) -> None:\\n super().__init__(*args, **kwargs)\\n self._lines: TokenLines = defaultdict(list)\\n self._docstrings = get_docstring_tokens(self.file_tokens)\",\n \"def idsFromDocumentation(filename):\\n\\tidsInOrder = []\\n\\tsegment = \\\"\\\"\\n\\twith open(filename) as f:\\n\\t\\tfor l in f:\\n\\t\\t\\tif \\\"<h2\\\" in l:\\n\\t\\t\\t\\tsegment = l.split(\\\">\\\")[1].split(\\\"<\\\")[0]\\n\\t\\t\\tif 'id=\\\"SCI_' in l:\\n\\t\\t\\t\\tidFeature = l.split('\\\"')[1]\\n\\t\\t\\t\\t#~ print(idFeature)\\n\\t\\t\\t\\tidsInOrder.append([segment, idFeature])\\n\\treturn idsInOrder\",\n \"def document(cls):\\n header = cls.document_header()\\n content = cls.document_content()\\n index = cls.document_index()\\n package = cls.package().name\\n filename = inspect.getsourcefile(cls)\\n try:\\n lines = inspect.getsourcelines(cls)\\n except IOError:\\n lines = ([], 0)\\n line = lines[1]+1\\n return DocEntry(\\n header, content, index=index,\\n package=package, filename=filename, line=line)\",\n \"def __get_line(file_path: str, line_no: int, errors: str = 'ignore') -> str:\\n try:\\n with open(file_path, mode='r',\\n encoding='utf-8', errors=errors) as f:\\n for line in f:\\n line_no -= 1\\n if line_no == 0:\\n return line\\n return ''\\n except IOError:\\n LOG.error(\\\"Failed to open file %s\\\", file_path)\\n return ''\",\n \"def file_iterator(file_path):\\n with open(file_path, 'r') as f:\\n\\n for line in f:\\n\\n #each line is an example\\n\\n #each example is made of the function name and then a sequence of triplets\\n #the triplets are (node, path, node)\\n\\n example_name, example_body = parse_line(line)\\n\\n #max length set while preprocessing, make sure none longer\\n\\n example_length = len(example_body)\\n\\n assert example_length <= MAX_LENGTH\\n \\n #need to pad all to maximum length\\n\\n example_body += [['<pad>', '<pad>', '<pad>']]*(MAX_LENGTH - example_length)\\n \\n assert len(example_body) == MAX_LENGTH\\n\\n yield example_name, example_body, example_length\",\n \"def cppdoc(self, irc, msg, args, num, req):\\n self.googleq('www.cplusplus.com/reference/', req, num, irc)\",\n \"def document_number(self, **kw):\\r\\n for docnum in self.document_numbers(**kw):\\r\\n return docnum\",\n \"def info(self, fun_number=None):\\n if fun_number is None:\\n return self.__doc__\\n\\n for line in open(os.path.join(os.path.abspath(os.path.split(__file__)[0]),\\n self.info_filename)).readlines():\\n if line.split(): # ie if not empty\\n try: # empty lines are ignored\\n fun = int(line.split()[0])\\n if fun == fun_number:\\n return 'F'+str(fun) + ' ' + ' '.join(line.split()[1:])\\n except ValueError:\\n continue # ignore annotations\",\n \"def listGetString(self, doc, inLine):\\n if doc is None: doc__o = None\\n else: doc__o = doc._o\\n ret = libxml2mod.xmlNodeListGetString(doc__o, self._o, inLine)\\n return ret\",\n \"def store_documentation(self, file_path, *args, **dargs):\\n pass\",\n \"def adoc_with_preview_command(event: Event = None, verbose: bool = True) -> File_List:\\n c = event and event.get('c')\\n if not c:\\n return None\\n return c.markupCommands.adoc_command(event, preview=True, verbose=verbose)\",\n \"def doctest_markup(in_lines):\\n out_lines = list(in_lines)[:]\\n err_tuples = []\\n for pos, this in enumerate(out_lines):\\n # Check for 'leave the rest' markup\\n if this.strip() == '#23dt skip rest':\\n break\\n # Check for docest line with markup\\n mark_match = MARK_COMMENT.search(this)\\n if mark_match is None:\\n continue\\n docbits, marked_line, marker, markup = mark_match.groups()\\n place_line_match = PLACE_LINE_EXPRS.match(markup)\\n if place_line_match is None:\\n msg = ('Found markup \\\"%s\\\" in line \\\"%s\\\" but wrong syntax' %\\n (markup, this))\\n err_tuples.append((this, msg))\\n continue\\n place_expr, line_expr = place_line_match.groups()\\n exec_globals = {'here': pos, 'next': pos+1}\\n if place_expr.strip() == '':\\n place = pos\\n else:\\n try:\\n place = eval(place_expr, exec_globals)\\n except:\\n msg = ('Error finding place with \\\"%s\\\" in line \\\"%s\\\"' %\\n (place_expr, this))\\n err_tuples.append((this, msg))\\n continue\\n # Prevent processing operating on 23dt comment part of line\\n if place == pos:\\n line = marked_line\\n else:\\n line = out_lines[place]\\n # Shorthand\\n if line_expr == 'bytes':\\n # Any strings on the given line are byte strings\\n pre, mid, post = INDENT_SPLITTER.match(line).groups()\\n try:\\n res = byter(mid)\\n except:\\n err = sys.exc_info()[1]\\n msg = ('Error \\\"%s\\\" parsing \\\"%s\\\"' % (err, err))\\n err_tuples.append((this, msg))\\n continue\\n res = pre + res + post\\n else:\\n exec_globals.update({'line': line, 'lines': out_lines})\\n # If line_expr starts with 'replace', implies \\\"line.replace\\\"\\n if line_expr.startswith('replace('):\\n line_expr = 'line.' + line_expr\\n elif line_expr == 'BytesIO':\\n line_expr = \\\"line.replace('StringIO', 'BytesIO')\\\"\\n try:\\n res = eval(line_expr, exec_globals)\\n except:\\n err = sys.exc_info()[1]\\n msg = ('Error \\\"%s\\\" working on \\\"%s\\\" at line %d with \\\"%s\\\"' %\\n (err, line, place, line_expr))\\n err_tuples.append((this, msg))\\n continue\\n # Put back comment if removed\\n if place == pos:\\n res = docbits + res + marker + markup\\n if res != line:\\n out_lines[place] = res\\n return out_lines, err_tuples\",\n \"def _magic_docs(self, brief=False, rest=False):\\n mman = self.shell.magics_manager\\n docs = mman.lsmagic_docs(brief, missing='No documentation')\\n\\n if rest:\\n format_string = '**%s%s**::\\\\n\\\\n%s\\\\n\\\\n'\\n else:\\n format_string = '%s%s:\\\\n%s\\\\n'\\n\\n return ''.join(\\n [format_string % (magic_escapes['line'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['line'].items())]\\n +\\n [format_string % (magic_escapes['cell'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['cell'].items())]\\n )\",\n \"def _generate_examples(self, filepath):\\n\\n key = 1\\n with tf.io.gfile.GFile(filepath, \\\"r\\\") as f:\\n tokens = []\\n tags = []\\n langs = []\\n for line in f:\\n line = line.rstrip()\\n # pylint: disable=g-explicit-bool-comparison\\n if line.startswith(\\\"-DOCSTART-\\\") or line == \\\"\\\":\\n if tokens:\\n spans = get_spans(tokens, tags)\\n yield key, {\\n \\\"tokens\\\": tokens,\\n \\\"tags\\\": tags,\\n \\\"langs\\\": langs,\\n \\\"spans\\\": spans\\n }\\n key += 1\\n tokens = []\\n tags = []\\n langs = []\\n else:\\n # wikiann data is tab separated\\n fields = line.split(\\\"\\\\t\\\")\\n # strip out language prefix\\n langs.append(fields[0].split(\\\":\\\")[0])\\n tokens.append(\\\":\\\".join(fields[0].split(\\\":\\\")[1:]))\\n if len(fields) > 1:\\n tags.append(fields[-1])\\n else:\\n # examples have no label in test set\\n tags.append(\\\"O\\\")\\n if tokens:\\n spans = get_spans(tokens, tags)\\n yield key, {\\n \\\"tokens\\\": tokens,\\n \\\"tags\\\": tags,\\n \\\"langs\\\": langs,\\n \\\"spans\\\": spans\\n }\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def _add_doc(func, doc):\\r\\n func.__doc__ = doc\",\n \"def __init__(self, module_filename, module_name,\\n docindex=None, url_func=None, name_to_docs=None,\\n tab_width=8):\\n # Get the source version, if possible.\\n try: module_filename = py_src_filename(module_filename)\\n except: pass\\n \\n #: The filename of the module we're colorizing.\\n self.module_filename = module_filename\\n \\n #: The dotted name of the module we're colorizing.\\n self.module_name = module_name\\n\\n #: A docindex, used to create href links from identifiers to\\n #: the API documentation for their values.\\n self.docindex = docindex\\n\\n #: A mapping from short names to lists of ValueDoc, used to\\n #: decide which values an identifier might map to when creating\\n #: href links from identifiers to the API docs for their values.\\n self.name_to_docs = name_to_docs\\n \\n #: A function that maps APIDoc -> URL, used to create href\\n #: links from identifiers to the API documentation for their\\n #: values.\\n self.url_func = url_func\\n\\n #: The index in C{text} of the last character of the last\\n #: token we've processed.\\n self.pos = 0\\n\\n #: A list that maps line numbers to character offsets in\\n #: C{text}. In particular, line C{M{i}} begins at character\\n #: C{line_offset[i]} in C{text}. Since line numbers begin at\\n #: 1, the first element of C{line_offsets} is C{None}.\\n self.line_offsets = []\\n\\n #: A list of C{(toktype, toktext)} for all tokens on the\\n #: logical line that we are currently processing. Once a\\n #: complete line of tokens has been collected in C{cur_line},\\n #: it is sent to L{handle_line} for processing.\\n self.cur_line = []\\n\\n #: A list of the names of the class or functions that include\\n #: the current block. C{context} has one element for each\\n #: level of indentation; C{context[i]} is the name of the class\\n #: or function defined by the C{i}th level of indentation, or\\n #: C{None} if that level of indentation doesn't correspond to a\\n #: class or function definition.\\n self.context = []\\n\\n #: A list, corresponding one-to-one with L{self.context},\\n #: indicating the type of each entry. Each element of\\n #: C{context_types} is one of: C{'func'}, C{'class'}, C{None}.\\n self.context_types = []\\n\\n #: A list of indentation strings for each of the current\\n #: block's indents. I.e., the current total indentation can\\n #: be found by taking C{''.join(self.indents)}.\\n self.indents = []\\n\\n #: The line number of the line we're currently processing.\\n self.lineno = 0\\n\\n #: The name of the class or function whose definition started\\n #: on the previous logical line, or C{None} if the previous\\n #: logical line was not a class or function definition.\\n self.def_name = None\\n\\n #: The type of the class or function whose definition started\\n #: on the previous logical line, or C{None} if the previous\\n #: logical line was not a class or function definition.\\n #: Can be C{'func'}, C{'class'}, C{None}.\\n self.def_type = None\\n\\n #: The number of spaces to replace each tab in source code with\\n self.tab_width = tab_width\",\n \"def read_equations(self) -> None:\\n eq_file = open('Equations', 'r')\\n line = eq_file.readline()\\n while line.strip() != 'END OF DOCUMENTATION':\\n line = eq_file.readline()\\n # End of documentation\\n line = eq_file.readline()\\n while line:\\n self.equation_list.append(line.strip())\\n line = eq_file.readline()\",\n \"def doc(obj):\\n return Documentation.fromObject(obj).first\",\n \"def get_doc_link(\\n self,\\n file: Literal[\\n \\\"client\\\",\\n \\\"service_resource\\\",\\n \\\"waiters\\\",\\n \\\"paginators\\\",\\n \\\"type_defs\\\",\\n \\\"literals\\\",\\n ],\\n *parts: str,\\n ) -> str:\\n link = f\\\"{self.get_local_doc_link()}{file}/\\\"\\n if not parts:\\n return link\\n anchor = \\\"\\\".join([get_anchor_link(part) for part in parts])\\n return f\\\"{link}#{anchor}\\\"\",\n \"def parse(input):\\n\\t\\n\\toutput = []\\n\\t\\n\\t# Comment delimiter of the docstring\\n\\tcommentDelim = '\\\"\\\"\\\"'\\n\\t\\n\\t# Some regexes\\n\\ttriggerRe = re.compile(\\\"^(\\\\s*)(def .+:|class .+:)\\\")\\n\\tcommentStartRe = re.compile('^\\\\s*(%s)' % commentDelim)\\n\\tcommentEndRe = re.compile('(%s)\\\\s*$' % commentDelim)\\n\\temptyRe = re.compile(\\\"^\\\\s*$\\\")\\n\\thashLineRe = re.compile(\\\"^\\\\s*#.*$\\\")\\n\\timportLineRe = re.compile(\\\"^\\\\s*(import |from .+ import)\\\")\\n\\t\\n\\t# split input into lines\\n\\tlines = input.split(\\\"\\\\n\\\")\\n\\t\\n\\t# flags, buffers, ...\\n\\tfileHeadFlag = True\\n\\ttriggerWordFlag = False\\n\\tcommentFlag = False\\n\\tcomment = []\\n\\ttriggerWs = \\\"\\\"\\n\\ttriggerLines = None\\n\\t\\n\\t# process each line\\n\\tfor line in enumerate(lines):\\n\\n\\t\\tmatch = re.search(triggerRe, line[1])\\n\\t\\tif match:\\n\\t\\t\\tif triggerWordFlag and triggerLines:\\n\\t\\t\\t\\toutput.append(\\\"\\\\n\\\".join(triggerLines))\\n\\t\\t\\t\\n\\t\\t\\ttriggerWordFlag = True\\n\\t\\t\\ttriggerWs = match.group(1)\\n\\t\\t\\tfileHeadFlag = False\\n\\t\\t\\ttriggerLines = [line[1]]\\n\\t\\t\\tcontinue\\n\\n\\t\\t# file header or active keyword trigger?\\n\\t\\tif fileHeadFlag or triggerWordFlag:\\n\\t\\t\\t# comment end of multiline comment found\\n\\t\\t\\tif re.search(commentEndRe, line[1]) and commentFlag:\\n\\t\\t\\t\\tcomment.append( line[1][ : line[1].rfind(commentDelim) ] )\\n\\t\\t\\t\\toutput.append(makeCommentBlock(comment, triggerWs, (triggerLines is None)))\\n\\t\\t\\t\\tif triggerLines:\\n\\t\\t\\t\\t\\toutput.append(\\\"\\\\n\\\".join(triggerLines))\\n\\t\\t\\t\\tcomment = []\\n\\t\\t\\t\\tcommentFlag = False\\n\\t\\t\\t\\ttriggerWs = \\\"\\\"\\n\\t\\t\\t\\ttriggerLines = None\\n\\t\\t\\t\\ttriggerWordFlag = False\\n\\t\\t\\t\\t\\n\\t\\t\\t# comment start found\\n\\t\\t\\telif re.search(commentStartRe, line[1]):\\n\\t\\n\\t\\t\\t\\tif re.search(commentEndRe, line[1][line[1].find(commentDelim)+len(commentDelim) :]):\\n\\t\\t\\t\\t\\t# singleline comment\\n\\t\\t\\t\\t\\tcomment.append(line[1][line[1].find(commentDelim)+len(commentDelim) : line[1].rfind(commentDelim)])\\n\\t\\t\\t\\t\\toutput.append(makeCommentBlock(comment, triggerWs))\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif triggerLines:\\n\\t\\t\\t\\t\\t\\toutput.append(\\\"\\\\n\\\".join(triggerLines))\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tcomment = []\\n\\t\\t\\t\\t\\tcommentFlag = False\\n\\t\\t\\t\\t\\ttriggerWs = \\\"\\\"\\n\\t\\t\\t\\t\\ttriggerLines = None\\n\\t\\t\\t\\t\\ttriggerWordFlag = False\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# multiline comment begin\\n\\t\\t\\t\\t\\tcommentFlag = True\\n\\t\\t\\t\\t\\tcomment.append(\\n\\t\\t\\t\\t\\t\\tline[1][line[1].find(commentDelim)+len(commentDelim):]\\n\\t\\t\\t\\t\\t)\\n\\t\\n\\t\\t\\t# active multiline comment -> append comment\\n\\t\\t\\telif commentFlag:\\n\\t\\t\\t\\tcomment.append(line[1])\\n\\t\\t\\t\\n\\t\\t\\t# still searching for comment\\n\\t\\t\\telif re.search(emptyRe, line[1]):\\n\\t\\t\\t\\tif triggerLines:\\n\\t\\t\\t\\t\\ttriggerLines.append(line[1])\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\toutput.append(line[1])\\n\\t\\t\\t\\n\\t\\t\\t# searching for file header\\n\\t\\t\\telif fileHeadFlag:\\n\\t\\t\\t\\tif not (re.search(hashLineRe, line[1]) or re.search(emptyRe, line[1]) or re.search(importLineRe, line[1])):\\n\\t\\t\\t\\t\\t# fileheader over -> disable search\\n\\t\\t\\t\\t\\tfileHeadFlag = False\\n\\t\\t\\t\\toutput.append(line[1])\\n\\t\\t\\t\\n\\t\\t\\t# no comment, disable comment search mode\\n\\t\\t\\telse:\\n\\t\\t\\t\\ttriggerWordFlag = False\\n\\t\\t\\t\\tif triggerLines:\\n\\t\\t\\t\\t\\toutput.append(\\\"\\\\n\\\".join(triggerLines))\\n\\t\\t\\t\\ttriggerLines = None\\n\\t\\t\\t\\toutput.append(line[1])\\n\\t\\t\\n\\t\\t# just append the line\\n\\t\\telse:\\n\\t\\t\\toutput.append(line[1])\\n\\t\\n\\t# return output\\n\\treturn \\\"\\\\n\\\".join(output)\",\n \"def getdoc(object):\\r\\n try:\\r\\n doc = object.__doc__\\r\\n except AttributeError:\\r\\n return None\\r\\n if not isinstance(doc, types.StringTypes):\\r\\n return None\\r\\n return cleandoc(doc)\",\n \"def get_line(trj_file):\\n\\twith open(trj_file) as file:\\n\\t\\tfor i in file:\\n\\t\\t\\tyield i\",\n \"def check_doc(document):\\n try:\\n assert document[0].startswith(\\\"#doc \\\")\\n except AssertionError:\\n print(\\\"The document does not start with '#doc' but instead\\\", document[0])\\n doc_id = document[0].split()[1]\\n for i in range(1, len(document)):\\n line = document[i]\\n try:\\n assert int(line.split()[0]) == i - 1\\n except (ValueError, AssertionError):\\n print(\\\"Document\\\", doc_id, \\\"line\\\", i, \\\":\\\", line, \\\"expect line index\\\",\\n i - 1, \\\", found\\\", line.split()[0])\",\n \"def open_file(file,n,n1=0):\\n\\tfin = open(file)\\n\\tbook_lines = []\\n\\tcount = 0\\n\\tfor line in fin:\\n\\t\\tword = line.strip()\\n\\t\\tcount += 1\\n\\t\\tif count > n:\\n\\t\\t\\tbook_lines.append(word)\\n\\treturn book_lines\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59708744","0.5864023","0.57362026","0.5729538","0.5353018","0.5304556","0.52516913","0.5187537","0.51576215","0.5119893","0.4906234","0.4906234","0.4906234","0.48642772","0.4851124","0.48384303","0.47899288","0.47810355","0.4746727","0.4719589","0.47194844","0.47093347","0.46912888","0.4685481","0.46840283","0.46796864","0.46682584","0.4667346","0.46667945","0.4658281","0.46401352","0.46399412","0.46300802","0.46295422","0.4619564","0.46162868","0.4599407","0.45833412","0.45832503","0.45697138","0.45592442","0.45492887","0.4542449","0.45409712","0.45340514","0.45263973","0.45236692","0.4489759","0.44894624","0.44810975","0.44553366","0.44366705","0.44361794","0.44220242","0.4411914","0.4407805","0.43935075","0.4392869","0.43921724","0.43907976","0.43811655","0.43768105","0.43596733","0.43565574","0.43504792","0.43497765","0.43450183","0.43438265","0.4343413","0.43432233","0.4336256","0.43362483","0.4321278","0.43180785","0.43146616","0.430662","0.43013877","0.42981315","0.42959985","0.4290655","0.42903358","0.42874944","0.42710996","0.42572647","0.42560613","0.42540908","0.42491543","0.42419523","0.42373067","0.42373067","0.42373067","0.423716","0.42345053","0.42339137","0.42278293","0.42261845","0.42198524","0.421626","0.42155144","0.4209865"],"string":"[\n \"0.59708744\",\n \"0.5864023\",\n \"0.57362026\",\n \"0.5729538\",\n \"0.5353018\",\n \"0.5304556\",\n \"0.52516913\",\n \"0.5187537\",\n \"0.51576215\",\n \"0.5119893\",\n \"0.4906234\",\n \"0.4906234\",\n \"0.4906234\",\n \"0.48642772\",\n \"0.4851124\",\n \"0.48384303\",\n \"0.47899288\",\n \"0.47810355\",\n \"0.4746727\",\n \"0.4719589\",\n \"0.47194844\",\n \"0.47093347\",\n \"0.46912888\",\n \"0.4685481\",\n \"0.46840283\",\n \"0.46796864\",\n \"0.46682584\",\n \"0.4667346\",\n \"0.46667945\",\n \"0.4658281\",\n \"0.46401352\",\n \"0.46399412\",\n \"0.46300802\",\n \"0.46295422\",\n \"0.4619564\",\n \"0.46162868\",\n \"0.4599407\",\n \"0.45833412\",\n \"0.45832503\",\n \"0.45697138\",\n \"0.45592442\",\n \"0.45492887\",\n \"0.4542449\",\n \"0.45409712\",\n \"0.45340514\",\n \"0.45263973\",\n \"0.45236692\",\n \"0.4489759\",\n \"0.44894624\",\n \"0.44810975\",\n \"0.44553366\",\n \"0.44366705\",\n \"0.44361794\",\n \"0.44220242\",\n \"0.4411914\",\n \"0.4407805\",\n \"0.43935075\",\n \"0.4392869\",\n \"0.43921724\",\n \"0.43907976\",\n \"0.43811655\",\n \"0.43768105\",\n \"0.43596733\",\n \"0.43565574\",\n \"0.43504792\",\n \"0.43497765\",\n \"0.43450183\",\n \"0.43438265\",\n \"0.4343413\",\n \"0.43432233\",\n \"0.4336256\",\n \"0.43362483\",\n \"0.4321278\",\n \"0.43180785\",\n \"0.43146616\",\n \"0.430662\",\n \"0.43013877\",\n \"0.42981315\",\n \"0.42959985\",\n \"0.4290655\",\n \"0.42903358\",\n \"0.42874944\",\n \"0.42710996\",\n \"0.42572647\",\n \"0.42560613\",\n \"0.42540908\",\n \"0.42491543\",\n \"0.42419523\",\n \"0.42373067\",\n \"0.42373067\",\n \"0.42373067\",\n \"0.423716\",\n \"0.42345053\",\n \"0.42339137\",\n \"0.42278293\",\n \"0.42261845\",\n \"0.42198524\",\n \"0.421626\",\n \"0.42155144\",\n \"0.4209865\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.67731166"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85186,"cells":{"query":{"kind":"string","value":"Return a list of schedd ads representing all the schedds in the pool."},"document":{"kind":"string","value":"def get_schedds(args=None):\n schedd_query = classad.ExprTree('!isUndefined(CMSGWMS_Type)')\n collectors = [\"cmssrv221.fnal.gov:9620\",\n \"cmsgwms-collector-tier0.cern.ch:9620\",\n \"cmssrv276.fnal.gov\"]\n\n schedd_ads = {}\n for host in collectors:\n coll = htcondor.Collector(host)\n try:\n schedds = coll.query(htcondor.AdTypes.Schedd,\n schedd_query,\n projection=[\"MyAddress\", \"ScheddIpAddr\", \"Name\"])\n except IOError, e:\n logging.warning(str(e))\n continue\n\n for schedd in schedds:\n try:\n schedd_ads[schedd['Name']] = schedd\n except KeyError:\n pass\n\n schedd_ads = schedd_ads.values()\n random.shuffle(schedd_ads)\n\n if args and args.schedd_filter:\n return [s for s in schedd_ads if s['Name'] in args.schedd_filter.split(',')]\n\n return schedd_ads"},"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 get_ads():\n return coll_ad.distinct(KEY_AD_ID)","def get_scnlist_all(self):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n logger.debug(\"Perform query to find scenes which need downloading.\")\n query_result = ses.query(EDDSentinel1ASF).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\n scns = list()\n if query_result is not None:\n for record in query_result:\n scns.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns","def list_pd(cls, pss_url):\n pds_url = cls.__get_url(pds_url)\n logger.debug(\"List PDS at %s\"%pds_url)\n pds_dir = saga.advert.directory(pds_url, saga.advert.Create | \n saga.advert.CreateParents | \n saga.advert.ReadWrite)\n \n pd_list = pds_dir.list()\n pd_full_urls = []\n for i in pd_list:\n pd_full_urls.append(pss_url + \"/\" + i) \n return pd_full_urls","def fill_ads_pool(self, ads_list, append=True):\n for ad in ads_list:\n if not isinstance(ad, Ad):\n raise RuntimeError(\"Only Ad objects can be stored with the method fill_ads_pool\")\n if ad.ad_category not in self.categories:\n raise RuntimeError(\"Only News objects with category stored in the Agent categories can be stored\"\n \"with the method fill_news_pool. An News with category \" + ad.ad_category +\n \" is trying to be stored, but only categories \" + str(self.categories) + \" can\"\n \"be handled by the Agent.\")\n if append:\n for ad in ads_list:\n self.ads_pool.append(ad)\n else:\n self.ads_pool = ads_list\n\n for ad in ads_list:\n cat_index = self.categories.index(ad.ad_category)\n if ad.exclude_competitors:\n ex_index = 1\n else:\n ex_index = 0\n self.ads_per_category[cat_index][ex_index].append(ad)","def listActiveShards(self):\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\n list = []\n for s in self.activeDistrictMap.values():\n if s.available:\n list.append(\n (s.doId, s.name, s.avatarCount,\n s.newAvatarCount))\n \n return list","def all_dicoms(self):\n return [dcm_ctr_pair[1:] for dcm_ctr_pair in self.data]","def _collect_all(self):","def getSlaves():","def getDisciplinesList():\n return Gw2Spidy._request('disciplines')['results']","def dsets(self):\n return list(self._dst_h5)","def get_all_bw_counters(self, instances):\n bw = []\n return bw","def get_advisories(self):\n\n advisories = []\n\n for i in range(len(self.__data['advisories'])):\n data = requests.get(self.__data['advisories'][i]['links']['self']['href'], headers=getHeaders()).json()\n this = {}\n this['id'] = data['id']\n this['name'] = data['name']\n advisories.append(this)\n\n return advisories","def get_scnlist_con2ard(self):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n\n logger.debug(\"Perform query to find scenes which need downloading.\")\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == True,\n EDDSentinel1ASF.ARDProduct == False,\n EDDSentinel1ASF.Invalid == False).order_by(\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\n\n scns2ard = list()\n if query_result is not None:\n for record in query_result:\n scns2ard.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2ard","def get_all_crawlers(self):\n try:\n conn = psycopg2.connect(\"dbname='{0}'\".format(DATABASE))\n cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\n cur.execute(\"SELECT * FROM host WHERE type = 'Crawler';\")\n results = cur.fetchall()\n cur.close()\n return results\n except Exception as e:\n print(e)","def get_all_asgs(cluster_tag):\n return get_asgs(cluster_tag, [])","def diseases(self):\n\t\treturn Disease.DiseasesByPatient(self.id, self.host)","def collect_all(self) -> list:\n raise NotImplementedError()","def get_all_created_contests(self):\n return self.contests['contests_forced'] + self.contests['contests']","def ballot_get_all_contests():\r\n all_contests = []\r\n result = ballot_list_contests(limit=100000000).get('result')\r\n if result:\r\n contests = batch('ballot_get_contest_by_id', [[r] for r in result]).get('result')\r\n if contests:\r\n all_contests = contests\r\n\r\n return all_contests","def get_random_db(self):\n rnd = random.random() * self.totals[-1]\n pool_index = bisect.bisect_right(self.totals, rnd)\n return list(self.pool)[pool_index]","def get_all_bw_counters(self, instances):\n\n bw = []\n return bw","def collect(self):\n import ray\n return ray.get([shard.get_data.remote() for shard in self.shard_list])","def list_crds(full, debug):\n for crd in manager.list_crds(full, debug):\n print(yaml.dump([crd], default_flow_style=False))","def getinstancelist():\n dbcursor_dict.execute(dbq.get_all_instance_list, )\n db_instance_list = dbcursor_dict.fetchall()\n return db_instance_list","def _get_many_series(self, seriesname, imdb=False):\n shows = []\n sids = [s for s in self.get_series_id(seriesname, imdb=imdb)]\n for s in sids:\n shows.append(self.get_series_by_id(s))\n log.debug('sids: %s', sids)\n return shows","def hent_alle_sager(self, aktive=True) -> List[Sag]:\n return self.session.query(Sag).all()","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 results = db.engine.execute(sql)\r\n categories = []\r\n for row in results:\r\n category = dict(id=row.id, name=row.name, short_name=row.short_name,\r\n description=row.description)\r\n categories.append(category)\r\n return categories","def get_all_vms_in_pool(self, name, dc, cluster):\n rp = self.get_pool(name, dc, cluster)\n return [vm for vm in rp.vm]","def stations():\n\n return station_list","def get_samples(self):\n result = []\n segmentsize=30\n # Reduce this to very little to get very large trainingsets\n stride=5\n noOfBuckets=40\n for start in range(0, len(self.data) - segmentsize, stride):\n if start + segmentsize <= len(self.data):\n segments_buckets = self.get_buckets(start, start + segmentsize, noOfBuckets)\n result.append(segments_buckets)\n return result","def getPoolData(self):\r\n # type: () -> (list[Data.Data])\r\n output = []\r\n # start from the beginning of the pool area\r\n ea = self.func_ea + self.getSize(withPool=False)\r\n while ea < self.getSize(withPool=True):\r\n # create and append the data item\r\n data = Data.Data(ea)\r\n output.append(data)\r\n # advance ea to the next item\r\n ea += data.getSize()\r\n return output","def get_scnlist_datacube(self, loaded=False):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n\n logger.debug(\"Perform query to find scenes which need converting to ARD.\")\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.ARDProduct == True,\n EDDSentinel1ASF.DCLoaded == loaded).order_by(\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\n scns2dcload = list()\n if query_result is not None:\n for record in query_result:\n scns2dcload.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2dcload","def getPools(self):\n data = self.connect('get','pools',None)\n return data","def get_all(self):\n return self._segments","def svcs_list(self) -> List[str]:\n return self._svcs_list","def get_dashboard_bags():\n conn = fetch_replica_db()\n now = datetime.datetime.now()\n bags = conn.bags.aggregate([\n {'$match': {'$or':[{'pid':{'$exists': False}}, {'pid': None}],\n 'cs.sd': {'$gte': now - datetime.timedelta(days=7)},\n 'cs.ss': {'$in': BAG_DASHBOARD_STATUSES}}},\n {'$group': {'_id': {'cn':'$cn','cs.sl':'$cs.sl'},\n 'count': {'$sum': 1}, 'bss': {'$addToSet': '$bs'}}},\n {'$sort': {'count': -1}}\n ])\n res = dict()\n for bag in bags.get('result', {}):\n if isinstance(bag, dict):\n origin = bag.get('_id').get('cs.sl')\n dest = bag.get('_id').get('cn')\n dstate = get_center_from_cache(dest).get('state')\n count = bag.get('count')\n bss = bag.get('bss')\n if not res.get(origin):\n res[origin] = list()\n res[origin].append({'dest': dest, 'dstate': dstate, 'count': count, 'bss': bss,})\n cache.set(BAG_DASHBOARD_CACHE_KEY, res, 60*20)","def _generate_rds_instances_and_sg(resource, session):\n for db_instance in resource.describe_db_instances()[\"DBInstances\"]:\n for security_group in db_instance[\"VpcSecurityGroups\"]:\n yield db_instance, security_group, _get_sg_name(security_group[\"VpcSecurityGroupId\"], session)","def GenRdmAdjList(N = 2, C = 0.5): # C is connectance (probability that any two nodes will have a connection). N is nodes, in this case species\n Ids = range(N) # range returns a list of the given range\n ALst = [] # creating a list\n for i in Ids:\n if sc.random.uniform(0,1,1) < C: # uniform probability distribution, if probability generated is less than C there is a link (I think)\n Lnk = sc.random.choice(Ids,2).tolist() # appends to a list (and coerces it to a list as opposed to numpy array)\n if Lnk[0] != Lnk[1]: #avoid self (e.g., cannibalistic) loops\n ALst.append(Lnk)\n return ALst","def _select_discs(self):\n sqlstmt = \"SELECT d FROM %s\" % self.VIEW\n return [d[0] for d in self.cursor.execute(sqlstmt)]","def get_all_cur_site_insts():\n return models.Curation_SiteInstance.objects.all()","def get_all_desserts():\n return get_data_from_category_name(\"Desserts\")","def countering():\r\n return []","def stratify(self):\n groups = self.group()\n folds = []\n for group in groups:\n folds.append(self.sample(group))\n return [sum([folds[j][i] for j in range(len(folds))], []) \\\n for i in range(self.nfolds)]","def madmp_list():\n for dmp in DataManagementPlan.query.all():\n click.echo(\"[DMP] %s\" % dmp.dmp_id)\n\n for dataset in dmp.datasets:\n recid = \"[no record]\"\n\n if dataset.record:\n pid = dataset.record.pid\n recid = \"[recid: %s]\" % pid.pid_value\n\n click.echo(\" [DS] %s %s\" % (dataset.dataset_id, recid))\n click.echo(\"\")","def spades(self):\n return sorted(tuple([v for v in self if v.suit == 'spades']), reverse=True)","def list_ps(cls, pss_url):\n pss_url = cls.__get_url(pss_url)\n logger.debug(\"List PS at %s\"%pss_url)\n pss_dir = saga.advert.directory(pss_url, saga.advert.Create | \n saga.advert.CreateParents | \n saga.advert.ReadWrite)\n \n ps_list = pss_dir.list()\n ps_full_urls = []\n for i in ps_list:\n ps_full_urls.append(pss_url + \"/\" + i) \n return ps_full_urls","def get_scrapps(self): \n scrapps = []\n self.validate_url()\n soup = self.get_content()\n links = soup.find_all(\"a\")\n table = soup.find_all('div',attrs={\"class\" : \"ph-person-home person-section\"})\n scrapp = Scrapp()\n for tag in table:\n try:\n text = tag.text.replace(\"\\n\",\" \").replace(\"\\r\",\" \").replace(\"\\xa0\",\" \")\n scrapp.add_meta('text',text)\n except KeyError:\n continue\n for link in links:\n try:\n if 'orcid' in link.attrs['href']:\n scrapp.add_meta(\"orcid_link\", link.attrs['href'])\n if \"researcherid\" in link.attrs['href']:\n scrapp.add_meta(\"researchid_link\", link.attrs['href'])\n if \"scholar.google\" in link.attrs['href']:\n scrapp.add_meta(\"googlescholar_link\", link.attrs['href'])\n except KeyError:\n # not all 'a' tags have the links we want\n continue\n scrapps.append(scrapp)\n return scrapps","def genAckList(self):\n\t\tresult = []\n\t\tfor p in self.rSegs:\n\t\t\tresult.append(p.segNo)\n\t\treturn result","def all_datasets():\n query = db.session.query(Dataset)\n result = [dict(name=q.name, description=q.description, id=q.id) for q in query]\n return result","def get_all_datasets_conf_ds():\n listOfDatasetDSConfig = []\n sqlObj = _DS_config_DS_SQL()\n results = sqlObj.select_all_DDI_DB()\n for element in results:\n listOfDatasetDSConfig.append(Dataset_conf_ds(element[0], element[1], element[2], element[3]))\n return listOfDatasetDSConfig","def get_seeds(spiderid, report):\n pass","async def allseries(self, ctx):\n\n await self.all_series_db.call(ctx)","def get_scnlist_tilecache(self):\n scns2tilecache = list()\n if self.calc_scn_tilecache():\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n logger.debug(\"Perform query to find scene.\")\n query_result = ses.query(EDDSentinel1ASF).filter(\n sqlalchemy.or_(\n EDDSentinel1ASF.ExtendedInfo.is_(None),\n sqlalchemy.not_(EDDSentinel1ASF.ExtendedInfo.has_key('tilecache'))),\n EDDSentinel1ASF.Invalid == False,\n EDDSentinel1ASF.ARDProduct == True).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\n if query_result is not None:\n for record in query_result:\n scns2tilecache.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2tilecache","def seeds(self) -> Collection[Tuple[str, int]]:\n return self._seeds","def get_local_schedds(schedd_base_name=socket.getfqdn()):\n schedd_list = []\n temp_list = htcondor.Collector().locateAll(htcondor.DaemonTypes.Schedd)\n for schedd in temp_list:\n if 'Name' not in schedd:\n continue\n if schedd_base_name in schedd['Name']:\n schedd_list.append(schedd)\n return schedd_list","def get_instance_essentials(self):\n ret = []\n for instance in self.all_instances:\n ret.append(instance.get_essentials())\n return ret","def get_app_pool_list(self) -> list:\n ah_write = self.get_iis_object()\n section = ah_write.GetAdminSection(\"system.applicationHost/applicationPools\", \"MACHINE/WEBROOT/APPHOST\")\n collection = section.Collection\n result = list()\n\n for i in range(collection.Count):\n site = collection[i]\n prop = site.Properties\n\n name = prop[\"name\"].Value\n managed_runtime_version = prop[\"managedRuntimeVersion\"].Value\n if prop[\"managedPipelineMode\"].Value:\n managed_pipeline_mode = \"classic\"\n else:\n managed_pipeline_mode = \"integrated\"\n if prop[\"enable32BitAppOnWin64\"].Value:\n bitness = 32\n else:\n bitness = 64\n\n result.append(AppPool(name, managed_runtime_version, managed_pipeline_mode, bitness))\n\n return result","def getSegments(self) -> List[int]:\n ...","def getListOfSDs(name = None,selector = None):\n sds = rhevGet(\"/api/datacenters/%s/storagedomains\"%getDcData(rhev_settings.DC,\"id\"))\n doc = libxml2.parseDoc(sds)\n ctxt = doc.xpathNewContext()\n res = ctxt.xpathEval(\"/storage_domains/storage_domain\")\n sdlist = []\n for sd in res:\n sdin = {}\n sdin[\"name\"] = sd.firstElementChild().get_content()\n sdin[\"id\"] = sd.prop(\"id\")\n sdlist.append(sdin)\n result = []\n if name:\n result = [sdin for sdin in sdlist if sdin[\"name\"].find(name) != -1]\n return result or sdlist","def aspset(self):\n try:\n return pset([x.aspset() for x in self])\n except Exception:\n try:\n return frozenpset([x.aspset() for x in self])\n except Exception:\n pass\n return frozenpset([x for x in self])","def get_assay_solutions(self):\n vocabs = []\n assay = self.get_assay()\n if not assay:\n return vocabs\n for solution_type_name in assay.needed_solutions:\n type_batches = find(Type=solution_type_name,\n expires={'query': datetime.today().date(),\n 'range': 'min'},\n sort_on='expires')\n\n tmp = []\n for batch in type_batches:\n tmp.append([batch.id,\n batch.Title,\n batch.expires.strftime('%Y-%m-%d')])\n vocabs.append([solution_type_name, tmp])\n return vocabs","def remove_ad_from_pool(self, ads_list):\n for i in range(-len(self.ads_pool), 0):\n if self.ads_pool[i] in ads_list:\n self.ads_pool.__delitem__(i)\n\n if self.ads_allocation_technique == \"resLP\":\n for ad in ads_list:\n cat_index = self.categories.index(ad.ad_category)\n if ad.exclude_competitors:\n ex_index = 1\n else:\n ex_index = 0\n self.ads_per_category[cat_index][ex_index].remove(ad)","def fetch_all(self):\n return list(iter(self))","def get_sp_list():\n bs = get_soup('https://en.wikipedia.org/wiki/List_of_S%26P_500_companies')\n sp_companies = bs.find_all('a', class_=\"external text\")\n return sp_companies","def get_card_sets(self, name: str) -> List:","def saps (self):\n return (node for id, node in self.network.nodes_iter(data=True) if\n node.type == Node.SAP)","def pool_list(mnode):\n cmd = \"gluster pool list\"\n return g.run(mnode, cmd)","def choose_random_site(self):\n return [self.rng.integers(low=0, high=self.num_spins - 1)]","def all_pdbs(self, species=None):\n\n return list(set(\n self.gtop_pdbs(species=species) +\n self.uniprot_pdbs(species=species)\n ))","def get_style_lst(db_name=DB_NAME):\n\n style_lst = []\n db_dest = 'database/' + db_name\n conn = sqlite3.connect(db_dest)\n cur = conn.cursor()\n\n statement = '''\n SELECT DISTINCT NumOfBd\n FROM Houses\n ORDER BY NumOfBd\n ;'''\n result = cur.execute(statement)\n result_lst = result.fetchall()\n for (num_of_bd,) in result_lst:\n style_lst.append(num_of_bd)\n\n conn.close()\n return style_lst","def get_drip_campaigns(self):\n return list(DripCampaign.objects(user_id=self.user_id))","def get_scnlist_download(self):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n\n logger.debug(\"Perform query to find scenes which need downloading.\")\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == False).filter(\n EDDSentinel1ASF.Remote_URL is not None).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\n\n scns2dwnld = list()\n if query_result is not None:\n for record in query_result:\n scns2dwnld.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2dwnld","def diamonds(self):\n return sorted(tuple([v for v in self if v.suit == 'diamonds']), reverse=True)","def get_adjectives(self):\n random.shuffle(self.adjectives)\n return self.adjectives","def getSets():","def device_adcs(self):\n return [\"SIS 3302\", \"SIS 3305\"]","def generate_scaffolds(self, dataset, cutoff=0.18):\n mols = []\n for ind, smiles in enumerate(dataset.ids):\n mols.append(Chem.MolFromSmiles(smiles))\n n_mols = len(mols)\n fps = [AllChem.GetMorganFingerprintAsBitVect(x, 2, 1024) for x in mols]\n\n scaffold_sets = ClusterFps(fps, cutoff=cutoff)\n scaffold_sets = sorted(scaffold_sets, key=lambda x: -len(x))\n scaffold_sets = [list(sfd) for sfd in scaffold_sets]\n return scaffold_sets","def get_hcr_records(self):\r\n result = []\r\n for category in self.categories:\r\n result.extend(category.get_hcr_records())\r\n return result","def construct(self, x):\n results = []\n x = self.pool0(x)\n results.append(x)\n x = self.pool1(x)\n results.append(x)\n x = self.pool2(x)\n results.append(x)\n x = self.pool3(x)\n results.append(x)\n return results","def craw_all():\n\n # min_kdb_id = 16_000 # 2021-06-06 16_392 is highest\n min_kdb_id = 4_000 # 4007 is actual lowest but rounding! https://www.db.yugioh-card.com/yugiohdb/card_search.action?ope=2&cid=4007\n base_query = \"[[Medium::TCG]]\"\n\n final_output = []\n has_res = True\n kdb_id = min_kdb_id\n step = 400\n\n num_req = 0\n while has_res:\n query = \"%s [[Database ID::>%s]] [[Database ID::<%s]]\" % (\n base_query,\n kdb_id,\n kdb_id + step,\n )\n num_req += 1\n print(num_req, query)\n\n data = ask_yugipedia(query, ALL_DISPLAYS, limit=500, do_sleep=10)\n check(data, ALL_DISPLAYS)\n has_res = bool(data)\n\n data[\"query\"] = query\n data[\"disp\"] = ALL_DISPLAYS\n if has_res:\n final_output.append(data)\n\n kdb_id += step + 1\n\n return final_output","def get_saved_shapings(self):\n query = 'SELECT * FROM CurrentShapings'\n with self._get_conn() as conn:\n results = conn.execute(query).fetchall()\n conn.close()\n # shapings = [{'tc': tc_obj, 'timeout': 123456}, ... ]\n shapings = []\n for result in results:\n shapings.append(\n {\n 'tc': result[SQLiteManager.SHAPING_TC_COL],\n 'timeout': result[SQLiteManager.SHAPING_TIMOUT_COL]\n }\n )\n return shapings","def get_dossiers_shared_with_group(self):\n dossier_brains = api.content.find(allowedRolesAndUsers=u'user:{}'.format(self.group_id))\n ndossiers = len(dossier_brains)\n print(\"found {} dossiers\".format(ndossiers))\n for i, dossier_brain in enumerate(dossier_brains):\n if i % 5000 == 0:\n self.collect_garbage(self.context)\n rss = self.get_rss() / 1024.0\n print(\"done with {}/{}; {:.1f}%; Memory: {}\".format(\n i, ndossiers, 100. * i / ndossiers, rss))\n dossier = dossier_brain.getObject()\n assignments = RoleAssignmentManager(dossier).get_assignments_by_principal_id(self.group_id)\n sharing_assignment = self._find_sharing_assignment(assignments)\n if sharing_assignment:\n yield (dossier, sharing_assignment)","def __next__(self):\n return [next(self.vdc)] + next(self.S)","def load_suppliers(self):\n return_list = []\n with Transaction().start(DBNAME, 1):\n partylist = self.Party.search([('categories', '=', self.category)])\n for i in partylist:\n dictionary = {}\n dictionary['code'] = str(i.pan)\n dictionary['name'] = i.name\n dictionary['address'] = i.addresses[0].full_address\n return_list.append(dictionary)\n return return_list","def get_scnlist_quicklook(self):\n scns2quicklook = list()\n if self.calc_scn_quicklook():\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session_sqlalc()\n logger.debug(\"Perform query to find scene.\")\n query_result = ses.query(EDDSentinel1ASF).filter(\n sqlalchemy.or_(\n EDDSentinel1ASF.ExtendedInfo.is_(None),\n sqlalchemy.not_(EDDSentinel1ASF.ExtendedInfo.has_key('quicklook'))),\n EDDSentinel1ASF.Invalid == False,\n EDDSentinel1ASF.ARDProduct == True).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\n if query_result is not None:\n for record in query_result:\n scns2quicklook.append(record.PID)\n ses.close()\n logger.debug(\"Closed the database session.\")\n return scns2quicklook","def get_all_sfps(self):\n return self._sfp_list","def get_all_as_groups(as_connection):\n as_groups_list = []\n get_as_groups = as_connection.get_all_groups()\n as_groups_list.extend(get_as_groups)\n\n token = get_as_groups.next_token\n while token is not None:\n get_as_groups = as_connection.get_all_groups(\n next_token=token)\n as_groups_list.extend(get_as_groups)\n token = get_as_groups.next_token\n print \"Processed {0} AutoScaling Group\"\\\n .format(len(as_groups_list))\n return as_groups_list","def instances(self):\r\n # It would be more efficient to do this with filters now\r\n # but not all services that implement EC2 API support filters.\r\n instances = []\r\n rs = self.connection.get_all_instances()\r\n for reservation in rs:\r\n uses_group = [g.name for g in reservation.groups if g.name == self.name]\r\n if uses_group:\r\n instances.extend(reservation.instances)\r\n return instances","def get_biases(self):\n return []","def new_deck(cla):\r\n\treturn [cla(i) for i in range(52)]","def get_as_instances(as_connection, as_group_name):\n as_all_instances_list = []\n as_instances_list = []\n get_as_instances = as_connection.get_all_autoscaling_instances()\n as_all_instances_list.extend(get_as_instances)\n\n token = get_as_instances.next_token\n while token is not None:\n get_as_groups = as_connection.get_all_autoscaling_instances(\n next_token=token)\n as_all_instances_list.extend(get_as_groups)\n token = get_as_groups.next_token\n\n for instance in as_all_instances_list:\n if instance.group_name in as_group_name:\n as_instances_list.append(instance.instance_id)\n return as_instances_list","def get_shares_banners():\n try:\n shares_banners = SharesBanner.objects.all()\n except SliderBanner.DoesNotExist:\n shares_banners = None\n return shares_banners","def get_dns_list(self):\n return self.get_ipv4_dns_list()","def availableSquares(self):\n List2=[]\n for item in self.all:\n if item.retrieve()==\"\":\n List2.append(item.name())\n return List2","def get_all_candidates(self) -> list:","def featurize_shard(shard):\n X = [] # to save the graph object\n L = []\n n_samples = len(shard)\n for idx in range(n_samples):\n print(\"processing sample %s\\n\" % str(idx))\n # iterate each pc in shard\n P = np.squeeze(np.array(shard[idx]))\n\n # do not need a clustering, use original points\n node_features = P\n adj_list, adj_matrix = gl.get_adjacency(node_features)\n Laplacian = gl.compute_laplacian(adj_list, normalized=False)\n X.append(node_features)\n L.append(Laplacian)\n\n return X, L","def collect():\n datadir = 'data'\n if 'OUTPUT_DATA_DIR' in os.environ:\n datadir = os.environ['OUTPUT_DATA_DIR']\n\n scraper_dir = os.path.join(os.getcwd(), 'scrapers')\n scrapers = get_scraper_list(scraper_dir)\n now = datetime.now()\n total_deals = []\n for scr_instance in scrapers:\n deals = scr_instance.get_deals()\n\n # Map a timestamp on each deal\n for item in deals:\n item.update({'timestamp': now.strftime('%Y-%m-%d')})\n\n print(\"\\n Collected {0} deals for {1} \\n\\n\".format(len(deals), scr))\n\n total_deals += deals\n\n filename = '{0}_resultset.json'.format(now.strftime('%Y%m%d_%H%I%S'))\n\n fh = open(os.path.join(datadir, filename), 'w+')\n fh.write(json.dumps(total_deals))\n fh.close()","def get_skeletons_from_mongodb(self):\n query = {\"date\":self.date}\n print \"query:\", query\n ret = self._store_client.query(query, skeleton_complete._type) # ret is a list of all queried msgs, returned as tuples. (msg, meta)\n\n # for (complete_skel_msg, meta) in ret:\n # do stuff\n return ret","def districts(self):\n catalog = getToolByName(self.context, 'portal_catalog')\n d = [dict(url=district.getURL(), title=district.Title,\n address=district.Description) for district in\n catalog({'object_provides': IDistrict.__identifier__,\n 'path': dict(query='/'.join(self.context.getPhysicalPath()),\n depth=1), 'sort_on': 'sortable_title'})]\n print d\n return d","def get_stats(self, epg_dn):\n # Apic saves up to 95 different objects with statistic information\n traffic_list = []\n for i in range(10, -1, -1):\n traffic = self.moDir.lookupByDn(epg_dn + '/HDl2IngrBytesAg15min-%s' % str(i))\n if traffic is not None:\n traffic_list.append(traffic)\n return traffic_list"],"string":"[\n \"def get_ads():\\n return coll_ad.distinct(KEY_AD_ID)\",\n \"def get_scnlist_all(self):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n logger.debug(\\\"Perform query to find scenes which need downloading.\\\")\\n query_result = ses.query(EDDSentinel1ASF).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n scns = list()\\n if query_result is not None:\\n for record in query_result:\\n scns.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns\",\n \"def list_pd(cls, pss_url):\\n pds_url = cls.__get_url(pds_url)\\n logger.debug(\\\"List PDS at %s\\\"%pds_url)\\n pds_dir = saga.advert.directory(pds_url, saga.advert.Create | \\n saga.advert.CreateParents | \\n saga.advert.ReadWrite)\\n \\n pd_list = pds_dir.list()\\n pd_full_urls = []\\n for i in pd_list:\\n pd_full_urls.append(pss_url + \\\"/\\\" + i) \\n return pd_full_urls\",\n \"def fill_ads_pool(self, ads_list, append=True):\\n for ad in ads_list:\\n if not isinstance(ad, Ad):\\n raise RuntimeError(\\\"Only Ad objects can be stored with the method fill_ads_pool\\\")\\n if ad.ad_category not in self.categories:\\n raise RuntimeError(\\\"Only News objects with category stored in the Agent categories can be stored\\\"\\n \\\"with the method fill_news_pool. An News with category \\\" + ad.ad_category +\\n \\\" is trying to be stored, but only categories \\\" + str(self.categories) + \\\" can\\\"\\n \\\"be handled by the Agent.\\\")\\n if append:\\n for ad in ads_list:\\n self.ads_pool.append(ad)\\n else:\\n self.ads_pool = ads_list\\n\\n for ad in ads_list:\\n cat_index = self.categories.index(ad.ad_category)\\n if ad.exclude_competitors:\\n ex_index = 1\\n else:\\n ex_index = 0\\n self.ads_per_category[cat_index][ex_index].append(ad)\",\n \"def listActiveShards(self):\\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\\n list = []\\n for s in self.activeDistrictMap.values():\\n if s.available:\\n list.append(\\n (s.doId, s.name, s.avatarCount,\\n s.newAvatarCount))\\n \\n return list\",\n \"def all_dicoms(self):\\n return [dcm_ctr_pair[1:] for dcm_ctr_pair in self.data]\",\n \"def _collect_all(self):\",\n \"def getSlaves():\",\n \"def getDisciplinesList():\\n return Gw2Spidy._request('disciplines')['results']\",\n \"def dsets(self):\\n return list(self._dst_h5)\",\n \"def get_all_bw_counters(self, instances):\\n bw = []\\n return bw\",\n \"def get_advisories(self):\\n\\n advisories = []\\n\\n for i in range(len(self.__data['advisories'])):\\n data = requests.get(self.__data['advisories'][i]['links']['self']['href'], headers=getHeaders()).json()\\n this = {}\\n this['id'] = data['id']\\n this['name'] = data['name']\\n advisories.append(this)\\n\\n return advisories\",\n \"def get_scnlist_con2ard(self):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n\\n logger.debug(\\\"Perform query to find scenes which need downloading.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == True,\\n EDDSentinel1ASF.ARDProduct == False,\\n EDDSentinel1ASF.Invalid == False).order_by(\\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n\\n scns2ard = list()\\n if query_result is not None:\\n for record in query_result:\\n scns2ard.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2ard\",\n \"def get_all_crawlers(self):\\n try:\\n conn = psycopg2.connect(\\\"dbname='{0}'\\\".format(DATABASE))\\n cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\\n cur.execute(\\\"SELECT * FROM host WHERE type = 'Crawler';\\\")\\n results = cur.fetchall()\\n cur.close()\\n return results\\n except Exception as e:\\n print(e)\",\n \"def get_all_asgs(cluster_tag):\\n return get_asgs(cluster_tag, [])\",\n \"def diseases(self):\\n\\t\\treturn Disease.DiseasesByPatient(self.id, self.host)\",\n \"def collect_all(self) -> list:\\n raise NotImplementedError()\",\n \"def get_all_created_contests(self):\\n return self.contests['contests_forced'] + self.contests['contests']\",\n \"def ballot_get_all_contests():\\r\\n all_contests = []\\r\\n result = ballot_list_contests(limit=100000000).get('result')\\r\\n if result:\\r\\n contests = batch('ballot_get_contest_by_id', [[r] for r in result]).get('result')\\r\\n if contests:\\r\\n all_contests = contests\\r\\n\\r\\n return all_contests\",\n \"def get_random_db(self):\\n rnd = random.random() * self.totals[-1]\\n pool_index = bisect.bisect_right(self.totals, rnd)\\n return list(self.pool)[pool_index]\",\n \"def get_all_bw_counters(self, instances):\\n\\n bw = []\\n return bw\",\n \"def collect(self):\\n import ray\\n return ray.get([shard.get_data.remote() for shard in self.shard_list])\",\n \"def list_crds(full, debug):\\n for crd in manager.list_crds(full, debug):\\n print(yaml.dump([crd], default_flow_style=False))\",\n \"def getinstancelist():\\n dbcursor_dict.execute(dbq.get_all_instance_list, )\\n db_instance_list = dbcursor_dict.fetchall()\\n return db_instance_list\",\n \"def _get_many_series(self, seriesname, imdb=False):\\n shows = []\\n sids = [s for s in self.get_series_id(seriesname, imdb=imdb)]\\n for s in sids:\\n shows.append(self.get_series_by_id(s))\\n log.debug('sids: %s', sids)\\n return shows\",\n \"def hent_alle_sager(self, aktive=True) -> List[Sag]:\\n return self.session.query(Sag).all()\",\n \"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 results = db.engine.execute(sql)\\r\\n categories = []\\r\\n for row in results:\\r\\n category = dict(id=row.id, name=row.name, short_name=row.short_name,\\r\\n description=row.description)\\r\\n categories.append(category)\\r\\n return categories\",\n \"def get_all_vms_in_pool(self, name, dc, cluster):\\n rp = self.get_pool(name, dc, cluster)\\n return [vm for vm in rp.vm]\",\n \"def stations():\\n\\n return station_list\",\n \"def get_samples(self):\\n result = []\\n segmentsize=30\\n # Reduce this to very little to get very large trainingsets\\n stride=5\\n noOfBuckets=40\\n for start in range(0, len(self.data) - segmentsize, stride):\\n if start + segmentsize <= len(self.data):\\n segments_buckets = self.get_buckets(start, start + segmentsize, noOfBuckets)\\n result.append(segments_buckets)\\n return result\",\n \"def getPoolData(self):\\r\\n # type: () -> (list[Data.Data])\\r\\n output = []\\r\\n # start from the beginning of the pool area\\r\\n ea = self.func_ea + self.getSize(withPool=False)\\r\\n while ea < self.getSize(withPool=True):\\r\\n # create and append the data item\\r\\n data = Data.Data(ea)\\r\\n output.append(data)\\r\\n # advance ea to the next item\\r\\n ea += data.getSize()\\r\\n return output\",\n \"def get_scnlist_datacube(self, loaded=False):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n\\n logger.debug(\\\"Perform query to find scenes which need converting to ARD.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.ARDProduct == True,\\n EDDSentinel1ASF.DCLoaded == loaded).order_by(\\n EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n scns2dcload = list()\\n if query_result is not None:\\n for record in query_result:\\n scns2dcload.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2dcload\",\n \"def getPools(self):\\n data = self.connect('get','pools',None)\\n return data\",\n \"def get_all(self):\\n return self._segments\",\n \"def svcs_list(self) -> List[str]:\\n return self._svcs_list\",\n \"def get_dashboard_bags():\\n conn = fetch_replica_db()\\n now = datetime.datetime.now()\\n bags = conn.bags.aggregate([\\n {'$match': {'$or':[{'pid':{'$exists': False}}, {'pid': None}],\\n 'cs.sd': {'$gte': now - datetime.timedelta(days=7)},\\n 'cs.ss': {'$in': BAG_DASHBOARD_STATUSES}}},\\n {'$group': {'_id': {'cn':'$cn','cs.sl':'$cs.sl'},\\n 'count': {'$sum': 1}, 'bss': {'$addToSet': '$bs'}}},\\n {'$sort': {'count': -1}}\\n ])\\n res = dict()\\n for bag in bags.get('result', {}):\\n if isinstance(bag, dict):\\n origin = bag.get('_id').get('cs.sl')\\n dest = bag.get('_id').get('cn')\\n dstate = get_center_from_cache(dest).get('state')\\n count = bag.get('count')\\n bss = bag.get('bss')\\n if not res.get(origin):\\n res[origin] = list()\\n res[origin].append({'dest': dest, 'dstate': dstate, 'count': count, 'bss': bss,})\\n cache.set(BAG_DASHBOARD_CACHE_KEY, res, 60*20)\",\n \"def _generate_rds_instances_and_sg(resource, session):\\n for db_instance in resource.describe_db_instances()[\\\"DBInstances\\\"]:\\n for security_group in db_instance[\\\"VpcSecurityGroups\\\"]:\\n yield db_instance, security_group, _get_sg_name(security_group[\\\"VpcSecurityGroupId\\\"], session)\",\n \"def GenRdmAdjList(N = 2, C = 0.5): # C is connectance (probability that any two nodes will have a connection). N is nodes, in this case species\\n Ids = range(N) # range returns a list of the given range\\n ALst = [] # creating a list\\n for i in Ids:\\n if sc.random.uniform(0,1,1) < C: # uniform probability distribution, if probability generated is less than C there is a link (I think)\\n Lnk = sc.random.choice(Ids,2).tolist() # appends to a list (and coerces it to a list as opposed to numpy array)\\n if Lnk[0] != Lnk[1]: #avoid self (e.g., cannibalistic) loops\\n ALst.append(Lnk)\\n return ALst\",\n \"def _select_discs(self):\\n sqlstmt = \\\"SELECT d FROM %s\\\" % self.VIEW\\n return [d[0] for d in self.cursor.execute(sqlstmt)]\",\n \"def get_all_cur_site_insts():\\n return models.Curation_SiteInstance.objects.all()\",\n \"def get_all_desserts():\\n return get_data_from_category_name(\\\"Desserts\\\")\",\n \"def countering():\\r\\n return []\",\n \"def stratify(self):\\n groups = self.group()\\n folds = []\\n for group in groups:\\n folds.append(self.sample(group))\\n return [sum([folds[j][i] for j in range(len(folds))], []) \\\\\\n for i in range(self.nfolds)]\",\n \"def madmp_list():\\n for dmp in DataManagementPlan.query.all():\\n click.echo(\\\"[DMP] %s\\\" % dmp.dmp_id)\\n\\n for dataset in dmp.datasets:\\n recid = \\\"[no record]\\\"\\n\\n if dataset.record:\\n pid = dataset.record.pid\\n recid = \\\"[recid: %s]\\\" % pid.pid_value\\n\\n click.echo(\\\" [DS] %s %s\\\" % (dataset.dataset_id, recid))\\n click.echo(\\\"\\\")\",\n \"def spades(self):\\n return sorted(tuple([v for v in self if v.suit == 'spades']), reverse=True)\",\n \"def list_ps(cls, pss_url):\\n pss_url = cls.__get_url(pss_url)\\n logger.debug(\\\"List PS at %s\\\"%pss_url)\\n pss_dir = saga.advert.directory(pss_url, saga.advert.Create | \\n saga.advert.CreateParents | \\n saga.advert.ReadWrite)\\n \\n ps_list = pss_dir.list()\\n ps_full_urls = []\\n for i in ps_list:\\n ps_full_urls.append(pss_url + \\\"/\\\" + i) \\n return ps_full_urls\",\n \"def get_scrapps(self): \\n scrapps = []\\n self.validate_url()\\n soup = self.get_content()\\n links = soup.find_all(\\\"a\\\")\\n table = soup.find_all('div',attrs={\\\"class\\\" : \\\"ph-person-home person-section\\\"})\\n scrapp = Scrapp()\\n for tag in table:\\n try:\\n text = tag.text.replace(\\\"\\\\n\\\",\\\" \\\").replace(\\\"\\\\r\\\",\\\" \\\").replace(\\\"\\\\xa0\\\",\\\" \\\")\\n scrapp.add_meta('text',text)\\n except KeyError:\\n continue\\n for link in links:\\n try:\\n if 'orcid' in link.attrs['href']:\\n scrapp.add_meta(\\\"orcid_link\\\", link.attrs['href'])\\n if \\\"researcherid\\\" in link.attrs['href']:\\n scrapp.add_meta(\\\"researchid_link\\\", link.attrs['href'])\\n if \\\"scholar.google\\\" in link.attrs['href']:\\n scrapp.add_meta(\\\"googlescholar_link\\\", link.attrs['href'])\\n except KeyError:\\n # not all 'a' tags have the links we want\\n continue\\n scrapps.append(scrapp)\\n return scrapps\",\n \"def genAckList(self):\\n\\t\\tresult = []\\n\\t\\tfor p in self.rSegs:\\n\\t\\t\\tresult.append(p.segNo)\\n\\t\\treturn result\",\n \"def all_datasets():\\n query = db.session.query(Dataset)\\n result = [dict(name=q.name, description=q.description, id=q.id) for q in query]\\n return result\",\n \"def get_all_datasets_conf_ds():\\n listOfDatasetDSConfig = []\\n sqlObj = _DS_config_DS_SQL()\\n results = sqlObj.select_all_DDI_DB()\\n for element in results:\\n listOfDatasetDSConfig.append(Dataset_conf_ds(element[0], element[1], element[2], element[3]))\\n return listOfDatasetDSConfig\",\n \"def get_seeds(spiderid, report):\\n pass\",\n \"async def allseries(self, ctx):\\n\\n await self.all_series_db.call(ctx)\",\n \"def get_scnlist_tilecache(self):\\n scns2tilecache = list()\\n if self.calc_scn_tilecache():\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n logger.debug(\\\"Perform query to find scene.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(\\n sqlalchemy.or_(\\n EDDSentinel1ASF.ExtendedInfo.is_(None),\\n sqlalchemy.not_(EDDSentinel1ASF.ExtendedInfo.has_key('tilecache'))),\\n EDDSentinel1ASF.Invalid == False,\\n EDDSentinel1ASF.ARDProduct == True).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n if query_result is not None:\\n for record in query_result:\\n scns2tilecache.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2tilecache\",\n \"def seeds(self) -> Collection[Tuple[str, int]]:\\n return self._seeds\",\n \"def get_local_schedds(schedd_base_name=socket.getfqdn()):\\n schedd_list = []\\n temp_list = htcondor.Collector().locateAll(htcondor.DaemonTypes.Schedd)\\n for schedd in temp_list:\\n if 'Name' not in schedd:\\n continue\\n if schedd_base_name in schedd['Name']:\\n schedd_list.append(schedd)\\n return schedd_list\",\n \"def get_instance_essentials(self):\\n ret = []\\n for instance in self.all_instances:\\n ret.append(instance.get_essentials())\\n return ret\",\n \"def get_app_pool_list(self) -> list:\\n ah_write = self.get_iis_object()\\n section = ah_write.GetAdminSection(\\\"system.applicationHost/applicationPools\\\", \\\"MACHINE/WEBROOT/APPHOST\\\")\\n collection = section.Collection\\n result = list()\\n\\n for i in range(collection.Count):\\n site = collection[i]\\n prop = site.Properties\\n\\n name = prop[\\\"name\\\"].Value\\n managed_runtime_version = prop[\\\"managedRuntimeVersion\\\"].Value\\n if prop[\\\"managedPipelineMode\\\"].Value:\\n managed_pipeline_mode = \\\"classic\\\"\\n else:\\n managed_pipeline_mode = \\\"integrated\\\"\\n if prop[\\\"enable32BitAppOnWin64\\\"].Value:\\n bitness = 32\\n else:\\n bitness = 64\\n\\n result.append(AppPool(name, managed_runtime_version, managed_pipeline_mode, bitness))\\n\\n return result\",\n \"def getSegments(self) -> List[int]:\\n ...\",\n \"def getListOfSDs(name = None,selector = None):\\n sds = rhevGet(\\\"/api/datacenters/%s/storagedomains\\\"%getDcData(rhev_settings.DC,\\\"id\\\"))\\n doc = libxml2.parseDoc(sds)\\n ctxt = doc.xpathNewContext()\\n res = ctxt.xpathEval(\\\"/storage_domains/storage_domain\\\")\\n sdlist = []\\n for sd in res:\\n sdin = {}\\n sdin[\\\"name\\\"] = sd.firstElementChild().get_content()\\n sdin[\\\"id\\\"] = sd.prop(\\\"id\\\")\\n sdlist.append(sdin)\\n result = []\\n if name:\\n result = [sdin for sdin in sdlist if sdin[\\\"name\\\"].find(name) != -1]\\n return result or sdlist\",\n \"def aspset(self):\\n try:\\n return pset([x.aspset() for x in self])\\n except Exception:\\n try:\\n return frozenpset([x.aspset() for x in self])\\n except Exception:\\n pass\\n return frozenpset([x for x in self])\",\n \"def get_assay_solutions(self):\\n vocabs = []\\n assay = self.get_assay()\\n if not assay:\\n return vocabs\\n for solution_type_name in assay.needed_solutions:\\n type_batches = find(Type=solution_type_name,\\n expires={'query': datetime.today().date(),\\n 'range': 'min'},\\n sort_on='expires')\\n\\n tmp = []\\n for batch in type_batches:\\n tmp.append([batch.id,\\n batch.Title,\\n batch.expires.strftime('%Y-%m-%d')])\\n vocabs.append([solution_type_name, tmp])\\n return vocabs\",\n \"def remove_ad_from_pool(self, ads_list):\\n for i in range(-len(self.ads_pool), 0):\\n if self.ads_pool[i] in ads_list:\\n self.ads_pool.__delitem__(i)\\n\\n if self.ads_allocation_technique == \\\"resLP\\\":\\n for ad in ads_list:\\n cat_index = self.categories.index(ad.ad_category)\\n if ad.exclude_competitors:\\n ex_index = 1\\n else:\\n ex_index = 0\\n self.ads_per_category[cat_index][ex_index].remove(ad)\",\n \"def fetch_all(self):\\n return list(iter(self))\",\n \"def get_sp_list():\\n bs = get_soup('https://en.wikipedia.org/wiki/List_of_S%26P_500_companies')\\n sp_companies = bs.find_all('a', class_=\\\"external text\\\")\\n return sp_companies\",\n \"def get_card_sets(self, name: str) -> List:\",\n \"def saps (self):\\n return (node for id, node in self.network.nodes_iter(data=True) if\\n node.type == Node.SAP)\",\n \"def pool_list(mnode):\\n cmd = \\\"gluster pool list\\\"\\n return g.run(mnode, cmd)\",\n \"def choose_random_site(self):\\n return [self.rng.integers(low=0, high=self.num_spins - 1)]\",\n \"def all_pdbs(self, species=None):\\n\\n return list(set(\\n self.gtop_pdbs(species=species) +\\n self.uniprot_pdbs(species=species)\\n ))\",\n \"def get_style_lst(db_name=DB_NAME):\\n\\n style_lst = []\\n db_dest = 'database/' + db_name\\n conn = sqlite3.connect(db_dest)\\n cur = conn.cursor()\\n\\n statement = '''\\n SELECT DISTINCT NumOfBd\\n FROM Houses\\n ORDER BY NumOfBd\\n ;'''\\n result = cur.execute(statement)\\n result_lst = result.fetchall()\\n for (num_of_bd,) in result_lst:\\n style_lst.append(num_of_bd)\\n\\n conn.close()\\n return style_lst\",\n \"def get_drip_campaigns(self):\\n return list(DripCampaign.objects(user_id=self.user_id))\",\n \"def get_scnlist_download(self):\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n\\n logger.debug(\\\"Perform query to find scenes which need downloading.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(EDDSentinel1ASF.Downloaded == False).filter(\\n EDDSentinel1ASF.Remote_URL is not None).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n\\n scns2dwnld = list()\\n if query_result is not None:\\n for record in query_result:\\n scns2dwnld.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2dwnld\",\n \"def diamonds(self):\\n return sorted(tuple([v for v in self if v.suit == 'diamonds']), reverse=True)\",\n \"def get_adjectives(self):\\n random.shuffle(self.adjectives)\\n return self.adjectives\",\n \"def getSets():\",\n \"def device_adcs(self):\\n return [\\\"SIS 3302\\\", \\\"SIS 3305\\\"]\",\n \"def generate_scaffolds(self, dataset, cutoff=0.18):\\n mols = []\\n for ind, smiles in enumerate(dataset.ids):\\n mols.append(Chem.MolFromSmiles(smiles))\\n n_mols = len(mols)\\n fps = [AllChem.GetMorganFingerprintAsBitVect(x, 2, 1024) for x in mols]\\n\\n scaffold_sets = ClusterFps(fps, cutoff=cutoff)\\n scaffold_sets = sorted(scaffold_sets, key=lambda x: -len(x))\\n scaffold_sets = [list(sfd) for sfd in scaffold_sets]\\n return scaffold_sets\",\n \"def get_hcr_records(self):\\r\\n result = []\\r\\n for category in self.categories:\\r\\n result.extend(category.get_hcr_records())\\r\\n return result\",\n \"def construct(self, x):\\n results = []\\n x = self.pool0(x)\\n results.append(x)\\n x = self.pool1(x)\\n results.append(x)\\n x = self.pool2(x)\\n results.append(x)\\n x = self.pool3(x)\\n results.append(x)\\n return results\",\n \"def craw_all():\\n\\n # min_kdb_id = 16_000 # 2021-06-06 16_392 is highest\\n min_kdb_id = 4_000 # 4007 is actual lowest but rounding! https://www.db.yugioh-card.com/yugiohdb/card_search.action?ope=2&cid=4007\\n base_query = \\\"[[Medium::TCG]]\\\"\\n\\n final_output = []\\n has_res = True\\n kdb_id = min_kdb_id\\n step = 400\\n\\n num_req = 0\\n while has_res:\\n query = \\\"%s [[Database ID::>%s]] [[Database ID::<%s]]\\\" % (\\n base_query,\\n kdb_id,\\n kdb_id + step,\\n )\\n num_req += 1\\n print(num_req, query)\\n\\n data = ask_yugipedia(query, ALL_DISPLAYS, limit=500, do_sleep=10)\\n check(data, ALL_DISPLAYS)\\n has_res = bool(data)\\n\\n data[\\\"query\\\"] = query\\n data[\\\"disp\\\"] = ALL_DISPLAYS\\n if has_res:\\n final_output.append(data)\\n\\n kdb_id += step + 1\\n\\n return final_output\",\n \"def get_saved_shapings(self):\\n query = 'SELECT * FROM CurrentShapings'\\n with self._get_conn() as conn:\\n results = conn.execute(query).fetchall()\\n conn.close()\\n # shapings = [{'tc': tc_obj, 'timeout': 123456}, ... ]\\n shapings = []\\n for result in results:\\n shapings.append(\\n {\\n 'tc': result[SQLiteManager.SHAPING_TC_COL],\\n 'timeout': result[SQLiteManager.SHAPING_TIMOUT_COL]\\n }\\n )\\n return shapings\",\n \"def get_dossiers_shared_with_group(self):\\n dossier_brains = api.content.find(allowedRolesAndUsers=u'user:{}'.format(self.group_id))\\n ndossiers = len(dossier_brains)\\n print(\\\"found {} dossiers\\\".format(ndossiers))\\n for i, dossier_brain in enumerate(dossier_brains):\\n if i % 5000 == 0:\\n self.collect_garbage(self.context)\\n rss = self.get_rss() / 1024.0\\n print(\\\"done with {}/{}; {:.1f}%; Memory: {}\\\".format(\\n i, ndossiers, 100. * i / ndossiers, rss))\\n dossier = dossier_brain.getObject()\\n assignments = RoleAssignmentManager(dossier).get_assignments_by_principal_id(self.group_id)\\n sharing_assignment = self._find_sharing_assignment(assignments)\\n if sharing_assignment:\\n yield (dossier, sharing_assignment)\",\n \"def __next__(self):\\n return [next(self.vdc)] + next(self.S)\",\n \"def load_suppliers(self):\\n return_list = []\\n with Transaction().start(DBNAME, 1):\\n partylist = self.Party.search([('categories', '=', self.category)])\\n for i in partylist:\\n dictionary = {}\\n dictionary['code'] = str(i.pan)\\n dictionary['name'] = i.name\\n dictionary['address'] = i.addresses[0].full_address\\n return_list.append(dictionary)\\n return return_list\",\n \"def get_scnlist_quicklook(self):\\n scns2quicklook = list()\\n if self.calc_scn_quicklook():\\n logger.debug(\\\"Creating Database Engine and Session.\\\")\\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\\n ses = session_sqlalc()\\n logger.debug(\\\"Perform query to find scene.\\\")\\n query_result = ses.query(EDDSentinel1ASF).filter(\\n sqlalchemy.or_(\\n EDDSentinel1ASF.ExtendedInfo.is_(None),\\n sqlalchemy.not_(EDDSentinel1ASF.ExtendedInfo.has_key('quicklook'))),\\n EDDSentinel1ASF.Invalid == False,\\n EDDSentinel1ASF.ARDProduct == True).order_by(EDDSentinel1ASF.Acquisition_Date.asc()).all()\\n if query_result is not None:\\n for record in query_result:\\n scns2quicklook.append(record.PID)\\n ses.close()\\n logger.debug(\\\"Closed the database session.\\\")\\n return scns2quicklook\",\n \"def get_all_sfps(self):\\n return self._sfp_list\",\n \"def get_all_as_groups(as_connection):\\n as_groups_list = []\\n get_as_groups = as_connection.get_all_groups()\\n as_groups_list.extend(get_as_groups)\\n\\n token = get_as_groups.next_token\\n while token is not None:\\n get_as_groups = as_connection.get_all_groups(\\n next_token=token)\\n as_groups_list.extend(get_as_groups)\\n token = get_as_groups.next_token\\n print \\\"Processed {0} AutoScaling Group\\\"\\\\\\n .format(len(as_groups_list))\\n return as_groups_list\",\n \"def instances(self):\\r\\n # It would be more efficient to do this with filters now\\r\\n # but not all services that implement EC2 API support filters.\\r\\n instances = []\\r\\n rs = self.connection.get_all_instances()\\r\\n for reservation in rs:\\r\\n uses_group = [g.name for g in reservation.groups if g.name == self.name]\\r\\n if uses_group:\\r\\n instances.extend(reservation.instances)\\r\\n return instances\",\n \"def get_biases(self):\\n return []\",\n \"def new_deck(cla):\\r\\n\\treturn [cla(i) for i in range(52)]\",\n \"def get_as_instances(as_connection, as_group_name):\\n as_all_instances_list = []\\n as_instances_list = []\\n get_as_instances = as_connection.get_all_autoscaling_instances()\\n as_all_instances_list.extend(get_as_instances)\\n\\n token = get_as_instances.next_token\\n while token is not None:\\n get_as_groups = as_connection.get_all_autoscaling_instances(\\n next_token=token)\\n as_all_instances_list.extend(get_as_groups)\\n token = get_as_groups.next_token\\n\\n for instance in as_all_instances_list:\\n if instance.group_name in as_group_name:\\n as_instances_list.append(instance.instance_id)\\n return as_instances_list\",\n \"def get_shares_banners():\\n try:\\n shares_banners = SharesBanner.objects.all()\\n except SliderBanner.DoesNotExist:\\n shares_banners = None\\n return shares_banners\",\n \"def get_dns_list(self):\\n return self.get_ipv4_dns_list()\",\n \"def availableSquares(self):\\n List2=[]\\n for item in self.all:\\n if item.retrieve()==\\\"\\\":\\n List2.append(item.name())\\n return List2\",\n \"def get_all_candidates(self) -> list:\",\n \"def featurize_shard(shard):\\n X = [] # to save the graph object\\n L = []\\n n_samples = len(shard)\\n for idx in range(n_samples):\\n print(\\\"processing sample %s\\\\n\\\" % str(idx))\\n # iterate each pc in shard\\n P = np.squeeze(np.array(shard[idx]))\\n\\n # do not need a clustering, use original points\\n node_features = P\\n adj_list, adj_matrix = gl.get_adjacency(node_features)\\n Laplacian = gl.compute_laplacian(adj_list, normalized=False)\\n X.append(node_features)\\n L.append(Laplacian)\\n\\n return X, L\",\n \"def collect():\\n datadir = 'data'\\n if 'OUTPUT_DATA_DIR' in os.environ:\\n datadir = os.environ['OUTPUT_DATA_DIR']\\n\\n scraper_dir = os.path.join(os.getcwd(), 'scrapers')\\n scrapers = get_scraper_list(scraper_dir)\\n now = datetime.now()\\n total_deals = []\\n for scr_instance in scrapers:\\n deals = scr_instance.get_deals()\\n\\n # Map a timestamp on each deal\\n for item in deals:\\n item.update({'timestamp': now.strftime('%Y-%m-%d')})\\n\\n print(\\\"\\\\n Collected {0} deals for {1} \\\\n\\\\n\\\".format(len(deals), scr))\\n\\n total_deals += deals\\n\\n filename = '{0}_resultset.json'.format(now.strftime('%Y%m%d_%H%I%S'))\\n\\n fh = open(os.path.join(datadir, filename), 'w+')\\n fh.write(json.dumps(total_deals))\\n fh.close()\",\n \"def get_skeletons_from_mongodb(self):\\n query = {\\\"date\\\":self.date}\\n print \\\"query:\\\", query\\n ret = self._store_client.query(query, skeleton_complete._type) # ret is a list of all queried msgs, returned as tuples. (msg, meta)\\n\\n # for (complete_skel_msg, meta) in ret:\\n # do stuff\\n return ret\",\n \"def districts(self):\\n catalog = getToolByName(self.context, 'portal_catalog')\\n d = [dict(url=district.getURL(), title=district.Title,\\n address=district.Description) for district in\\n catalog({'object_provides': IDistrict.__identifier__,\\n 'path': dict(query='/'.join(self.context.getPhysicalPath()),\\n depth=1), 'sort_on': 'sortable_title'})]\\n print d\\n return d\",\n \"def get_stats(self, epg_dn):\\n # Apic saves up to 95 different objects with statistic information\\n traffic_list = []\\n for i in range(10, -1, -1):\\n traffic = self.moDir.lookupByDn(epg_dn + '/HDl2IngrBytesAg15min-%s' % str(i))\\n if traffic is not None:\\n traffic_list.append(traffic)\\n return traffic_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6366169","0.58527523","0.55230117","0.5514247","0.5457407","0.5414462","0.537656","0.5369209","0.53689307","0.53553814","0.53361785","0.5334375","0.53261983","0.53052175","0.5293422","0.5286213","0.5268966","0.5263969","0.525932","0.5256553","0.5237803","0.52356845","0.5226721","0.5215882","0.52152693","0.5201982","0.5179947","0.51768917","0.51729065","0.51726174","0.51707387","0.5161508","0.5129348","0.5124727","0.5107733","0.51051754","0.5093075","0.50841665","0.50684756","0.5063228","0.5063087","0.50571084","0.5049038","0.50481504","0.5042616","0.5041448","0.50322276","0.5010538","0.50076956","0.5007523","0.5004738","0.5000295","0.49998823","0.49991056","0.49976015","0.49917385","0.49813208","0.49808207","0.49757025","0.4968886","0.4967423","0.4967231","0.49636206","0.49547604","0.49526104","0.4936662","0.4934241","0.49340388","0.49301457","0.49275625","0.49210826","0.49207297","0.49175045","0.49140897","0.49118745","0.4910689","0.49088523","0.4908802","0.49014568","0.49003997","0.48973915","0.48959836","0.48914886","0.4891325","0.48897672","0.4888865","0.48871654","0.48856893","0.48849735","0.48817688","0.4880635","0.48774514","0.48770186","0.48751244","0.48737705","0.48707947","0.4849695","0.48420915","0.48375833","0.483628"],"string":"[\n \"0.6366169\",\n \"0.58527523\",\n \"0.55230117\",\n \"0.5514247\",\n \"0.5457407\",\n \"0.5414462\",\n \"0.537656\",\n \"0.5369209\",\n \"0.53689307\",\n \"0.53553814\",\n \"0.53361785\",\n \"0.5334375\",\n \"0.53261983\",\n \"0.53052175\",\n \"0.5293422\",\n \"0.5286213\",\n \"0.5268966\",\n \"0.5263969\",\n \"0.525932\",\n \"0.5256553\",\n \"0.5237803\",\n \"0.52356845\",\n \"0.5226721\",\n \"0.5215882\",\n \"0.52152693\",\n \"0.5201982\",\n \"0.5179947\",\n \"0.51768917\",\n \"0.51729065\",\n \"0.51726174\",\n \"0.51707387\",\n \"0.5161508\",\n \"0.5129348\",\n \"0.5124727\",\n \"0.5107733\",\n \"0.51051754\",\n \"0.5093075\",\n \"0.50841665\",\n \"0.50684756\",\n \"0.5063228\",\n \"0.5063087\",\n \"0.50571084\",\n \"0.5049038\",\n \"0.50481504\",\n \"0.5042616\",\n \"0.5041448\",\n \"0.50322276\",\n \"0.5010538\",\n \"0.50076956\",\n \"0.5007523\",\n \"0.5004738\",\n \"0.5000295\",\n \"0.49998823\",\n \"0.49991056\",\n \"0.49976015\",\n \"0.49917385\",\n \"0.49813208\",\n \"0.49808207\",\n \"0.49757025\",\n \"0.4968886\",\n \"0.4967423\",\n \"0.4967231\",\n \"0.49636206\",\n \"0.49547604\",\n \"0.49526104\",\n \"0.4936662\",\n \"0.4934241\",\n \"0.49340388\",\n \"0.49301457\",\n \"0.49275625\",\n \"0.49210826\",\n \"0.49207297\",\n \"0.49175045\",\n \"0.49140897\",\n \"0.49118745\",\n \"0.4910689\",\n \"0.49088523\",\n \"0.4908802\",\n \"0.49014568\",\n \"0.49003997\",\n \"0.48973915\",\n \"0.48959836\",\n \"0.48914886\",\n \"0.4891325\",\n \"0.48897672\",\n \"0.4888865\",\n \"0.48871654\",\n \"0.48856893\",\n \"0.48849735\",\n \"0.48817688\",\n \"0.4880635\",\n \"0.48774514\",\n \"0.48770186\",\n \"0.48751244\",\n \"0.48737705\",\n \"0.48707947\",\n \"0.4849695\",\n \"0.48420915\",\n \"0.48375833\",\n \"0.483628\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59305084"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":85187,"cells":{"query":{"kind":"string","value":"Driver method for the spider script."},"document":{"kind":"string","value":"def main_driver(args):\n starttime = time.time()\n\n # Get all the schedd ads\n schedd_ads = get_schedds(args)\n logging.warning(\"&&& There are %d schedds to query.\", len(schedd_ads))\n\n pool = multiprocessing.Pool(processes=args.query_pool_size)\n\n if not args.skip_history:\n htcondor_es.history.process_histories(schedd_ads=schedd_ads,\n starttime=starttime,\n pool=pool,\n args=args)\n\n # Now that we have the fresh history, process the queues themselves.\n if args.process_queue:\n htcondor_es.queues.process_queues(schedd_ads=schedd_ads,\n starttime=starttime,\n pool=pool,\n args=args)\n\n pool.close()\n pool.join()\n\n logging.warning(\"@@@ Total processing time: %.2f mins\", ((time.time()-starttime)/60.))\n\n return 0"},"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 open_spider(self, spider):\n pass","def open_spider(self,Spider):\n pass","def _scrape(self):","def scrape(self):\n pass","def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.crawl(spiderClass)\n\tprocess.start() # the script will block here until the crawling is finished","def __init__(self):\n self.SPIDER = \"spider\"","def __init__(self, spider):\n\n super(SprintBehavior, self).__init__(spider)\n self.remoteContext = spider.remoteController.context","def script(self):","def main():\n\n from scrapy.crawler import CrawlerProcess\n from scrapy.utils.project import get_project_settings\n\n process = CrawlerProcess(get_project_settings())\n process.crawl(NCBIGeoSpider)\n process.start()","def main():\n # get input params\n args = parm_parser.get_args()\n # init log config\n log.init_log('./log/mini_spider')\n if args:\n # read config file spider.conf\n conf_params = parm_parser.set_config_by_file(args.conf)\n # use config set up spider initial params\n spider = SpiderWorker(conf_params)\n # init result_path, make it complete\n spider.set_path()\n # init url queue\n spider.set_url_queue()\n # start to crawl url\n spider.start_crawl_work()\n\n return","def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)","def main():\n # 日志保存到./log/spider.log和./log/spider.log.wf，按天切割，保留7天\n log.init_log(\"./log/spider\")\n spider = SpiderEngine.SpiderEngine()\n try:\n opts, args = getopt.getopt(sys.argv[1:], \"vhc:\")\n except getopt.GetoptError as err:\n logging.error(\"get option error : %s.\" % err)\n return\n for o, a in opts:\n if o == \"-v\":\n version()\n return\n elif o == \"-h\":\n # spider_engine = _SpiderEngine._SpiderEngine()\n # spider_engine.config_tostring()\n # spider_engine.set_config()\n print \"帮助信息：没有帮助^_^\"\n return\n else:\n logging.error(\"unhandled option\")\n print \"unhandled option\"\n return\n spider.start_work()\n return","def __init__(self, url, epRange):\n self.driver = webdriver.PhantomJS()\n self.downloads = OrderedDict() # sort episodes in asending order\n self.pbar = \"\" # Download Progressbar\n self.Main(url, epRange)","def __init__(self, *args, **kwargs):\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider","def process(self):","def process(self):","def process(self):","def run_spider_on_zyte(spider_name):\n print(f'Running spider {spider_name}...')\n data = dict(project=project_id, spider=spider_name)\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\n return response.json()['jobid']","def __init__(self, spider):\n self.connect = pymysql.Connect(\n cursorclass=pymysql.cursors.DictCursor,\n **zaih_scraper.settings.CONNECT_INFO\n )\n\n self.cursor = self.connect.cursor()\n\n self.start_time = datetime.datetime.now()\n self.end_time = datetime.datetime.now()\n self.duration = datetime.timedelta()\n\n # self.logger = logging.getLogger(spider.name)\n self.logger = SetLogger.set_logger(spider.name)\n\n self.table_exist = []","def run(self):\n\t\t\n\t\tpass","def parse(self, response):\n\n\t\t### close spider if exception\n\t\tif 'Bandwidth exceeded' in response.body:\n\t\t\traise CloseSpider('bandwidth_exceeded')\n\n\t\tlog_scrap.debug(u\"\\n>>> NEW PARSING >>>\\n\" )\n\t\tlog_scrap.info(\"--- GenericSpider.parse ...\" )\n\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s\" , response)\n\t\tlog_scrap.info(\"\\n--- GenericSpider.parse /response : \\n%s \\n\" , response.__dict__.keys() )\n\n\t\t# for k, v in response.__dict__.iteritems() :\n\t\t# \tlog_scrap.info(\"\\n--- [k] {} : [v] {} : \".format(k,v))\n\t\t# print response._body\n\t\tstart_url = response.meta[\"start_url\"]\n\t\tlog_scrap.info(\"--- GenericSpider.parse / start_url : %s\", start_url )\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start request with API crawler\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t# if self.spider_config_flat[\"parse_api\"] == True :\n\t\tif self.parse_api == True :\n\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting request on API endpoint... \" )\n\t\t\tjsonresponse = json.loads(response.body_as_unicode())\n\t\t\t# log_scrap.info(\"--- GenericSpider.parse / jsonresponse : \\n%s\", jsonresponse )\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / jsonresponse received...\" )\n\n\t\t\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\n\t\t\t# raw_items_list = jsonresponse[self.item_xpath]\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / raw_items_list[0] : \\n%s\\n...\", pformat(raw_items_list[0]) )\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - API\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\" )\n\n\t\t\t\t# while self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - API - item n°{} >>> \\n\".format(self.item_count) )\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - API\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t# follow_link_raw = raw_data[ self.follow_xpath ]\n\t\t\t\t\t\t\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link_raw),follow_link_raw) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\turl_follow = self.page_url\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\tfollow_is_api = self.follow_is_api\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t# log_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - API\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\turl_next = \"\"\n\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\turl_next = self.api_pagination_root\n\t\t\t\t\telse :\n\t\t\t\t\t\turl_next = self.page_url\n\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\tnext_page = url_next + str(self.page_count)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with pure Scrapy requests\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telif self.spider_config_flat[\"parse_reactive\"] == False :\n\t\t# elif self.parse_reactive == False :\n \n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting requests with Scrapy... \" )\n\t\t\t# self.parse_scrapy(response)\n\n\t\t\t### find items list\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / self.item_xpath : %s\", self.item_xpath )\n\t\t\traw_items_list = response.xpath(self.item_xpath)\n\t\t\tlog_scrap.info(\"--- GenericSpider.parse / len(raw_items_list) : %d \", len(raw_items_list) )\n\n\n\t\t\t### - - - - - - - - - - - ###\n\t\t\t### PARSING PAGE - SCRAPY\n\t\t\t### start parsing page : loop through data items in page in response\n\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\" )\n\n\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\tprint()\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t# print \">>> raw_data : \\n\", raw_data.extract()\n\n\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\n\n\n\t\t\t\t\t\t### - - - - - - - - - - - ###\n\t\t\t\t\t\t### FOLLOW LINK - SCRAPY\n\t\t\t\t\t\t### if need to follow to extract all data\n\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\tfollow_link \t= raw_data.xpath( self.follow_xpath ).extract_first()\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t# log_scrap.info(\" --> follow_link CLEAN : %s \", follow_link )\n\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {} \".format(type(follow_link),follow_link) )\n\n\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\turl \t\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\n\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\n\t\t\t\t\t\t\t\t# log_scrap.warning(u\">>> FOLLOWING LINK --> url : {} / WORKED !!! \".format(url) )\n\n\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\telse :\n\n\t\t\t\t\t\t\tlog_scrap.warning(u\">>> NO FOLLOW LINK ... \" )\n\t\t\t\t\t\t\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.items() : \\n %s\", item.items() )\n\t\t\t\t\t\t\t# log_scrap.info(\">>> GenericSpider.parse - item.keys() : \\n %s\", item.items() )\n\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t# print (\"\\n>>> NEXT ITEM \" + \">>> >>> \"*10, \"\\n\")\n\n\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF ITEMS')\n\n\t\t\t### - - - - - - - - - - ###\n\t\t\t### NEXT PAGE - SCRAPY\n\t\t\t### check if there is a test_limit\n\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t### get and go to next page\n\t\t\t\t\tis_next_page, next_page = self.get_next_page(response, start_url)\n\n\t\t\t\t\tif is_next_page :\n\n\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\turl_next = \"\"\n\t\t\t\t\t\tif self.api_pagination_root != \"\" :\n\t\t\t\t\t\t\turl_next = self.api_pagination_root\n\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE I : %s\", next_page )\n\t\t\t\t\t\tnext_page = self.clean_link(next_page, url_root=url_next)\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider.parse >>> NEXT PAGE II : %s\", next_page )\n\n\t\t\t\t\t\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \".format(self.page_count) )\n\t\t\t\t\t\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\n\n\t\t\t\telse :\n\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\t\t\telse :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t# self.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\n\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\t### start requests with Selenium\n\t\t### - - - - - - - - - - - - - - - - - - - - - - - ###\n\t\telse :\n\t\t\t### initiate selenium browser\n\t\t\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\n\t\t\tlog_scrap.info(\"\\n--- GenericSpider.parse / starting Selenium driver... \" )\n\n\t\t\t# retrieve exec path for chromedriver from settings_scrapy.py\n\t\t\t### GET APP MODE FROM ENV VARS\n\t\t\tapp_mode \t\t\t\t\t\t= os.environ.get('APP_MODE', 'default')\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / APP_MODE : %s\", app_mode)\n\t\t\tchromedriver_path \t= CHROMEDRIVER_PATH_LIST[ app_mode ]\n\t\t\tlog_scrap.debug(u\"--- GenericSpider.parse / chromedriver_path : %s\", chromedriver_path)\n\n\t\t\t### specify executable path to launch webdriver-->\n\t\t\t# cf : where chromedriver was installed when `brew install chromedriver`\n\t\t\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\n\t\t\t# self.driver = webdriver.Firefox()\n\t\t\t# self.driver = webdriver.Chrome()\n\t\t\t# self.driver = webdriver.PhantomJS() ### deprecated\n\n\t\t\t### setup waiting times\n\t\t\t# self.driver.set_page_load_timeout(60)\n\t\t\tself.wait_driver\t= WebDriverWait(self.driver, self.delay_driver)\n\t\t\tself.wait_page \t\t= WebDriverWait(self.driver, self.delay_new_page)\n\t\t\tself.driver.implicitly_wait(self.delay_implicit)\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_driver : %s\", self.delay_driver )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_new_page : %s\", self.delay_new_page )\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / self.delay_implicit : %s\", self.delay_implicit )\n\n\n\t\t\t### start parsing with selenium\n\t\t\tlog_scrap.debug(u\"--- GenericSpider. / response._url : %s\", response._url )\n\t\t\ttry :\n\t\t\t\tself.driver.get(response._url)\n\n\t\t\t\t### try scroll_down if needed in config\n\t\t\t\tif self.spider_config_flat['scroll_down'] : \n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / scroll_down is TRUE ... \" )\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\n%s\", pformat(self.spider_config_flat) )\n\n\t\t\t\t\tscroll_pause_time = self.spider_config_flat[\"scroll_pause_time\"]\n\t\t\t\t\tmax_loops \t\t\t\t= self.spider_config_flat[\"scroll_loops\"]\n\t\t\t\t\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\t\t# scroll_down(self.driver, scroll_pause_time, max_loops)\n\t\t\t\tlog_scrap.info(\"--- GenericSpider. / url '{}' is loaded ... \".format( response._url ))\n\t\t\t\n\t\t\texcept :\n\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\tself.driver.close()\n\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\traise CloseSpider('DRIVER NOT RESPONDING')\n\n\n\t\t\t### clean original xpath from strings\n\t\t\tstrings_to_clean = [\n\t\t\t\t'/@src',\n\t\t\t\t'/@href',\n\t\t\t\t'/text()',\n\t\t\t\t'/@*[name()=\"xlink:href\"]',\n\t\t\t\t'/@datetime'\n\t\t\t]\n\n\t\t\t# while self.there_is_more_items_to_scrap :\n\t\t\twhile self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap )\n\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / while loop continues : %s\", self.there_is_more_items_to_scrap_dict[start_url] )\n\n\t\t\t\ttry :\n\n\t\t\t\t\t### wait / debug page content\n\t\t\t\t\tpage_source_code = self.driver.page_source.encode(\"utf-8\")\n\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / page_source_code : \\n %s \", page_source_code )\n\t\t\t\t\ttime.sleep(self.delay_new_page)\n\n\t\t\t\t\t### start parsing page :\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.item_xpath : %s\", self.item_xpath )\n\t\t\t\t\traw_items_list \t= self.driver.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / raw_items_list length : %s\", len(raw_items_list) )\n\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / raw_items_list[0].text : \\n%s\", raw_items_list[0].text )\n\n\t\t\t\t\t# current_item_index = 0\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### PARSING PAGE - SELENIUM\n\t\t\t\t\t# loop through data items in page in response\n\t\t\t\t\tif len(raw_items_list) != 0 :\n\n\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\n\" )\n\n\t\t\t\t\t\tfor raw_data in raw_items_list :\n\n\t\t\t\t\t\t\tprint()\n\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\" )\n\n\t\t\t\t\t\t\t### add +1 to items count\n\t\t\t\t\t\t\tself.item_count += 1\n\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \".format(self.spider_name, self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - item n°{} \".format(self.item_count) )\n\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \" %(self.spider_name, self.item_count) )\n\n\t\t\t\t\t\t\t### check if can continue depending on item_count\n\t\t\t\t\t\t\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - current start_url : {} >>>\".format(start_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\n\".format(self.item_count, self.page_count) )\n\n\t\t\t\t\t\t\t\t### instantiate Item to fill from datamodel --> cf items.py\n\t\t\t\t\t\t\t\titemclass \t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\n\t\t\t\t\t\t\t\titem \t\t= itemclass()\n\n\t\t\t\t\t\t\t\t### add global info to item : i.e. core fields in dm_core_item_related list\n\t\t\t\t\t\t\t\titem[ 'spider_id' ]\t\t= self.spider_id\n\t\t\t\t\t\t\t\titem[ 'added_by' ]\t\t= self.user_id\n\t\t\t\t\t\t\t\titem[ 'added_at' ]\t\t= time.time()\t\t# timestamp\n\t\t\t\t\t\t\t\titem[ 'link_src' ]\t\t= response._url\n\n\t\t\t\t\t\t\t\titem[ 'page_n' ]\t\t= self.page_count\n\t\t\t\t\t\t\t\titem[ 'item_n' ]\t\t= self.item_count\n\n\t\t\t\t\t\t\t\t### extract data and feed it to the Item instance based on spider_config_flat\n\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t### - - - - - - - - - - ###\n\t\t\t\t\t\t\t\t### FOLLOW LINK - SELENIUM\n\t\t\t\t\t\t\t\t### find follow link to open detailled item view\n\t\t\t\t\t\t\t\tif self.spider_config_flat[\"parse_follow\"] == True :\n\n\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\n\".format(self.item_count, self.page_count) )\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_xpath : %s\", self.follow_xpath )\n\n\t\t\t\t\t\t\t\t\t### follow link with Scrapy\n\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Scrapy ...\" )\n\n\t\t\t\t\t\t\t\t\t\t# log_scrap.debug(u\"--- GenericSpider. / get href of follow_link ...\" )\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link_xpath : %s \", follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link\t\t\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link RAW : %s \", follow_link )\n\n\t\t\t\t\t\t\t\t\t\turl_follow = \"\"\n\t\t\t\t\t\t\t\t\t\tif self.api_follow_root != \"\" :\n\t\t\t\t\t\t\t\t\t\t\t\turl_follow = self.api_follow_root\n\n\t\t\t\t\t\t\t\t\t\t# complete follow link if needed\n\t\t\t\t\t\t\t\t\t\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\" --> follow_link CLEAN ({}) : {}\".format(type(follow_link), follow_link ) )\n\n\t\t\t\t\t\t\t\t\t\t# store follow_link\n\t\t\t\t\t\t\t\t\t\titem[ 'link_data' ]\t= follow_link\n\t\t\t\t\t\t\t\t\t\turl\t\t\t= item['link_data']\n\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOWING LINK --> url : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.warning(u\">>> FOLLOW LINK - NOT WORKING : {} \".format(url) )\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\n\t\t\t\t\t\t\t\t\t### follow link with Selenium\n\t\t\t\t\t\t\t\t\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\n\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / follow link with Selenium ...\" )\n\n\t\t\t\t\t\t\t\t\t\tfollow_link_xpath \t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\n\t\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.follow_link_xpath : %s\", self.follow_link_xpath )\n\t\t\t\t\t\t\t\t\t\tfollow_link \t\t= raw_data.find_element_by_xpath( follow_link_xpath )\n\n\t\t\t\t\t\t\t\t\t\t### open link in new tab ?\n\t\t\t\t\t\t\t\t\t\tfollow_link.click()\n\n\t\t\t\t\t\t\t\t\t\t### get data and save data\n\t\t\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- GenericSpider. / get data and save data ...\" )\n\t\t\t\t\t\t\t\t\t\t\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\n\n\t\t\t\t\t\t\t\t\t\t\t### back to previous page and scrap from where it left\n\t\t\t\t\t\t\t\t\t\t\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\n\t\t\t\t\t\t\t\t\t\t\tself.driver.back()\n\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t### if no follow link\n\t\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t\tyield item\n\n\t\t\t\t\t\t\t\t# log_scrap.info(\" --> item : \\n %s \\n\", pformat(item) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\" --> item ...\" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF LIMIT_ITEMS')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\t\t### - - - - - - - - - - - - ###\n\t\t\t\t\t### NEXT PAGE - SELENIUM\n\t\t\t\t\tif self.test_limit == None or self.page_count < self.test_limit :\n\n\t\t\t\t\t\tif self.there_is_more_items_to_scrap_dict[start_url] :\n\n\t\t\t\t\t\t\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\n\n\t\t\t\t\t\t\t\tprint ()\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_name : '%s' >>>\" %(self.spider_name) )\n\t\t\t\t\t\t\t\tlog_scrap.info(\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\n\".format(self.page_count) )\n\n\t\t\t\t\t\t\t\t### add +1 to parsed pages\n\t\t\t\t\t\t\t\tself.page_count += 1\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - spider_page_url : {} >>>\".format(self.spider_page_url) )\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\">>> NEXT PAGE - current start_url : {} >>>\".format(start_url) )\n\n\t\t\t\t\t\t\t\t### find next page btn in current view\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / self.next_page : %s\", self.next_page )\n\t\t\t\t\t\t\t\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page_xpath : %s\", next_page_xpath )\n\t\t\t\t\t\t\t\t# next_page \t= re.sub(\"|\".join(strings_to_clean), \"\", next_page )\n\n\t\t\t\t\t\t\t\t# try :\n\t\t\t\t\t\t\t\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\n\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page present : %s\", element_present )\n\t\t\t\t\t\t\t\t# self.wait.until(element_present)\n\t\t\t\t\t\t\t\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\n\t\t\t\t\t\t\t\t# next_page \t\t= self.driver.find_element_by_xpath( next_page_xpath )\n\t\t\t\t\t\t\t\tnext_page \t\t= self.driver.find_element(By.XPATH, next_page_xpath )\n\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page : %s\", next_page )\n\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.text : %s\", next_page.text )\n\n\t\t\t\t\t\t\t\t# except TimeoutException:\n\t\t\t\t\t\t\t\t# except :\n\t\t\t\t\t\t\t\t# \tlog_scrap.error(\"--- GenericSpider. / Timed out waiting for page to load\")\n\n\t\t\t\t\t\t\t\t### click next button and wait for ajax calls to complete (post and get)\n\t\t\t\t\t\t\t\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\n\n\t\t\t\t\t\t\t\t# def wait_for(condition_function):\n\t\t\t\t\t\t\t\t# \t\tstart_time = time.time()\n\t\t\t\t\t\t\t\t# \twhile time.time() < start_time + 3:\n\t\t\t\t\t\t\t\t# \t\tif condition_function():\n\t\t\t\t\t\t\t\t# \t\t\treturn True\n\t\t\t\t\t\t\t\t# \t\telse:\n\t\t\t\t\t\t\t\t# \t\t\ttime.sleep(0.1)\n\t\t\t\t\t\t\t\t# \traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\n\n\t\t\t\t\t\t\t\t# def link_has_gone_stale():\n\t\t\t\t\t\t\t\t# \t\ttry:\n\t\t\t\t\t\t\t\t# \t\t# poll the link with an arbitrary call\n\t\t\t\t\t\t\t\t# \t\tnext_page.find_elements_by_xpath(self.item_xpath)\n\t\t\t\t\t\t\t\t# \t\treturn False\n\t\t\t\t\t\t\t\t# \texcept StaleElementReferenceException :\n\t\t\t\t\t\t\t\t# \t\treturn True\n\n\t\t\t\t\t\t\t\tlog_scrap.debug(u\"--- ... ---\")\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / next_page.click() \" )\n\t\t\t\t\t\t\t\t\tnext_page.click()\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\t# log_scrap.info(\"--- GenericSpider. / next_page.send_keys( \\ n )\" )\n\t\t\t\t\t\t\t\t\t# next_page.send_keys(\"\\n\")\n\t\t\t\t\t\t\t\t\t# added this step for compatibility of scrolling to the view\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / ALTERNATIVE next_page.click() \" )\n\t\t\t\t\t\t\t\t\t# self.driver.execute_script(\"return arguments[0].scrollIntoView();\", next_page)\n\t\t\t\t\t\t\t\t\t# next_page.click()\n\t\t\t\t\t\t\t\t\tself.driver.execute_script(\"arguments[0].click();\", next_page)\n\n\t\t\t\t\t\t\t\t### wait after click\n\t\t\t\t\t\t\t\ttry :\n\t\t\t\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider. / wait for ajax to finish... \" )\n\t\t\t\t\t\t\t\t\t# wait_for(link_has_gone_stale)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\n\t\t\t\t\t\t\t\t\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\n\t\t\t\t\t\t\t\t\t# time.sleep(self.delay_implicit)\n\t\t\t\t\t\t\t\t\ttime.sleep(self.delay_new_page)\n\t\t\t\t\t\t\t\texcept :\n\t\t\t\t\t\t\t\t\tlog_scrap.error(\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \" )\n\n\t\t\t\t\t\t\telse :\n\t\t\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\".format(self.page_count) )\n\t\t\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\t\t\traise CloseSpider('OUT OF PAGES TO SCRAP')\n\t\t\t\t\t\t\t\tbreak\n\n\t\t\t\t\telse :\n\t\t\t\t\t\t# self.there_is_more_items_to_scrap = False\n\t\t\t\t\t\tself.there_is_more_items_to_scrap_dict[start_url] = False\n\t\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\n\t\t\t\t\t\tself.driver.close()\n\t\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\t\t# raise CloseSpider('OUT OF TEST_LIMIT')\n\t\t\t\t\t\tbreak\n\n\t\t\t\texcept :\n\t\t\t\t\tlog_scrap.warning(u\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\".format(self.item_count, self.LIMIT_ITEMS) )\n\t\t\t\t\tself.driver.close()\n\t\t\t\t\tlog_scrap.info(\"--- GenericSpider / driver is shut\" )\n\t\t\t\t\traise CloseSpider('NO MORE ITEMS TO SCRAP')\n\t\t\t\t\tbreak","def process(self):\n pass","def spider(given_url):\n \n url_to_crawl = given_url\n\n source_code = requests.get(url_to_crawl)\n plain_text = source_code.text\n soup = BeautifulSoup(plain_text)\n # name = soup.find('h1', {'class': 'pl-header-title'})\n # name = name.string\n # name = str(name)\n # name = name.strip('')\n # fw = open('links of' + name + '.txt', 'w')\n # fw2 = open('names of' + name + '.txt', 'w')\n fw = open('links.txt', 'w')\n fw2 = open('names.txt', 'w')\n for link in soup.findAll('a', {'class': 'pl-video-title-link yt-uix-tile-link yt-uix-sessionlink spf-link '}):\n my_href = 'https://www.youtube.com' + link.get('href')\n title = link.string\n #print(my_href, title)\n fw.write(my_href + '\\n')\n fw2.write(title)\n\n fw.close()\n fw2.close()\n\n \"\"\"Downloading Part\"\"\"\n try:\n os.system(\"youtube-dl --max-quality FORMAT -a links.txt\")\n return\n except:\n print(\"Something went wrong related to downloading\")\n exit(2)","def run(self, **kwargs):","def run_script(self):\n pass","def _genspider(self, module, name, domain, template_name, template_file):\n tvars = {\n 'project_name': settings.get('BOT_NAME'),\n 'ProjectName': string_camelcase(settings.get('BOT_NAME')),\n 'module': module,\n 'name': name,\n 'domain': domain,\n 'classname': '%sSpider' % ''.join([s.capitalize() \\\n for s in module.split('_')])\n }\n\n spiders_module = __import__(settings['NEWSPIDER_MODULE'], {}, {}, [''])\n spiders_dir = abspath(dirname(spiders_module.__file__))\n spider_file = \"%s.py\" % join(spiders_dir, module)\n\n shutil.copyfile(template_file, spider_file)\n render_templatefile(spider_file, **tvars)\n print \"Created spider %r using template %r in module:\" % (name, \\\n template_name)\n print \" %s.%s\" % (spiders_module.__name__, module)","def crawl(self):\n\n # create helper process and setup IPC\n self.socket.listen(1)\n help_out_fd = open(self.helper_outfile, \"w\")\n with subprocess.Popen(\"./crawl_helper.py\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\n self.helper_pid = proc.pid\n try:\n conn, _ = self.socket.accept()\n # create initial params for crawler helper and send them\n new_urls = set()\n setup_params = {\"start_urls\": self.start_urls, \"allowed_domains\": [self.domain],\n \"cookies\": self.cookies, \"user_agent\": self.config[\"user_agent\"]}\n ipc_operations.send_object(conn, setup_params)\n\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\n while True:\n try:\n proc.wait(timeout=0.001)\n break\n except subprocess.TimeoutExpired:\n response = ipc_operations.receive_object(conn)\n if not response: # socket is dead / closed\n break\n new_urls = self.process_response(response)\n ipc_operations.send_object(conn, new_urls)\n except socket.timeout:\n util.printit(\"Unix socket connection to scrapy crawler unexpectedly broke. \" +\n \"Quitting crawling of %s\" % self.base_url, color=util.RED)\n break\n finally:\n # ensure connection is closed and helper process killed in any case\n conn.close()\n proc.kill()\n\n # after the actual crawling, extract all the gathered cookies from Selenium\n if self.config[\"use_selenium\"].lower() == \"true\":\n selenium_cookies = self.driver.get_cookies()\n for cookie in selenium_cookies:\n if not any(cookie[\"name\"] == c[\"name\"] and cookie[\"path\"] == c[\"path\"] and\n cookie[\"domain\"] == c[\"domain\"] for c in self.found_cookies):\n parsed_cookie = {}\n for key in (\"name\", \"path\", \"domain\", \"httpOnly\", \"secure\"):\n parsed_cookie[key] = cookie[key]\n self.found_cookies.append(parsed_cookie)\n\n help_out_fd.close()\n return self.create_results()","def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\n if copy_data:\n self.extend(copy_data)\n return\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\n print(os.getcwd())\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\n # output json file name\n com += '-o %s ' % (file)\n # page\n com += '-a pages=%d ' % (pages)\n # board\n com += '-a board=%s ' % (board)\n\n # title limit\n if title_lim:\n com += '-a title_lim=\"'\n for lim in title_lim:\n com += \"%s,\" % (str(lim))\n com += '\" '\n # not opened by json_file\n if not jsonf:\n # start crawl\n print('Command: ' + com)\n os.system('rm -f {}'.format(file))\n os.system('{}'.format(com))\n # opened by json file\n else:\n file = jsonf\n\n # all data save in self\n self.load_json(file)\n self.com = com\n self.file = file","def run(self): \r\n return","def run(self, parsed):","def run_generic_spider( user_id\t\t\t\t= None,\n\t\t\t\t\t\tspider_id\t\t\t= None,\n\t\t\t\t\t\tdatamodel\t\t\t= None,\n\t\t\t\t\t\trun_spider_config\t= None,\n\t\t\t\t\t\ttest_limit\t\t\t= None\n\t\t\t\t\t\t):\n\n\tprint ()\n\tlog_scrap.info(\"--- run_generic_spider / spider_id : %s \", spider_id )\n\n\t### WARNING !!! --> TEMPORARY SOLUTION\n\t### remove spider folder for spider_id in JOBDIR\n\tlog_scrap.debug(u\"--- run_generic_spider / cwd : %s\", os.getcwd() )\n\ttry :\n\t\tshutil.rmtree( os.getcwd() + \"/\" + JOBDIR_FOLDER + \"/\" + spider_id )\n\texcept:\n\t\tpass\n\tlog_scrap.debug(u\"--- run_generic_spider / removed folder : {}/{}\".format(JOBDIR_FOLDER, spider_id) )\n\n\t# !!! spider is launched from main.py level !!!\n\t# all relative routes referring to this...\n\tlog_scrap.info(\"--- run_generic_spider / os.getcwd() : %s \", os.getcwd() )\n\n\t### flattening run_spider_config : from nested to flat dict\n\tlog_scrap.info(\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\" )\n\tspider_config_flat = flattenSpiderConfig( run_spider_config )\n\n\n\t### settings for crawler\n\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\n\n\t### global settings for scrapy processes (see upper)\n\tlog_scrap.info(\"--- run_generic_spider / BOT_NAME : %s \", settings.get('BOT_NAME') )\n\tlog_scrap.info(\"--- run_generic_spider / USER_AGENT : %s \", settings.get('USER_AGENT') )\n\tlog_scrap.info(\"--- run_generic_spider / ITEM_PIPELINES : %s \", settings.get('ITEM_PIPELINES').__dict__ )\n\n\n\t# specific settings for this scrapy process\n\n\t# settings.set( \"RETRY_TIMES\"\t\t\t\t\t\t, RETRY_TIMES )\n\t# settings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, CONCURRENT_ITEMS )\n\t# settings.set( \"CONCURRENT_REQUESTS\"\t\t\t\t, CONCURRENT_REQUESTS )\n\t# settings.set( \"CONCURRENT_REQUESTS_PER_DOMAIN\"\t, CONCURRENT_REQUESTS_PER_DOMAIN )\n\t# settings.set( \"REDIRECT_MAX_TIMES\"\t\t\t\t, REDIRECT_MAX_TIMES )\n\t# settings.set( \"DOWNLOAD_MAXSIZE\" \t\t\t\t, DOWNLOAD_MAXSIZE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, DEPTH_PRIORITY )\n\t# settings.set( \"SCHEDULER_DISK_QUEUE\"\t\t\t, SCHEDULER_DISK_QUEUE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, SCHEDULER_MEMORY_QUEUE )\n\n\t# settings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t\t, RANDOMIZE_DOWNLOAD_DELAY )\n\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\n\tsettings.set( \"JOBDIR\"\t\t\t\t\t\t\t, JOBDIR_FOLDER + \"/\" + spider_id )\n\n\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\n\n\tsettings.set( \"CURRENT_SPIDER_ID\" \t\t\t, spider_id )\n\tsettings.set( \"RETRY_TIMES\"\t\t\t\t\t\t\t, spider_config_flat[\"RETRY_TIMES\"] )\n\tsettings.set( \"CLOSESPIDER_ITEMCOUNT\"\t\t, spider_config_flat[\"LIMIT_ITEMS\"] )\n\t# settings.set( \"CLOSESPIDER_PAGECOUNT\"\t\t, spider_config_flat[\"LIMIT_PAGES\"] )\n\tsettings.set( \"DOWNLOAD_DELAY\" \t\t\t\t\t, spider_config_flat[\"download_delay\"] )\n\tsettings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, spider_config_flat[\"CONCURRENT_ITEMS\"] )\n\tsettings.set( \"CONCURRENT_REQUESTS\"\t\t\t, spider_config_flat[\"CONCURRENT_REQUESTS\"] )\n\t# settings.set( \"DOWNLOAD_DELAY\" \t\t\t\t, DOWNLOAD_DELAY )\n\n\tsettings.set( \"BOT_NAME\"\t\t\t\t\t\t\t\t\t, spider_config_flat[\"BOT_NAME\"] )\n\tsettings.set( \"USER_AGENT\"\t\t\t\t\t\t\t\t, spider_config_flat[\"USER_AGENT\"] )\n\tsettings.set( \"ROBOTSTXT_OBEY\"\t\t\t\t\t\t, spider_config_flat[\"ROBOTSTXT_OBEY\"] )\n\tsettings.set( \"AUTOTHROTTLE_ENABLED\"\t\t\t, spider_config_flat[\"AUTOTHROTTLE_ENABLED\"] )\n\tsettings.set( \"HTTPCACHE_ENABLED\"\t\t\t\t\t, spider_config_flat[\"HTTPCACHE_ENABLED\"] )\n\tsettings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t, spider_config_flat[\"RANDOMIZE_DOWNLOAD_DELAY\"] )\n\n\t### initiating crawler process\n\tlog_scrap.info(\"--- run_generic_spider / instanciate process ...\" \t )\n\tprocess = CrawlerRunner( settings = settings )\n\n\t### adding CrawlerRunner as deferred\n\tdef f(q):\n\t\ttry:\n\t\t\t### send/create custom spider from run_spider_config\n\t\t\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\n\n\t\t\tdeferred = process.crawl( \tGenericSpider,\n\t\t\t\t\t\t\t\t\t\t\tuser_id\t\t\t\t\t\t\t= user_id,\n\t\t\t\t\t\t\t\t\t\t\tdatamodel \t\t\t\t\t= datamodel ,\n\t\t\t\t\t\t\t\t\t\t\tspider_id \t\t\t\t\t= spider_id ,\n\t\t\t\t\t\t\t\t\t\t\tspider_config_flat\t= spider_config_flat,\n\t\t\t\t\t\t\t\t\t\t\ttest_limit\t\t\t\t\t= test_limit\n\t\t\t\t\t\t\t\t\t)\n\t\t\tdeferred.addBoth(lambda _: reactor.stop())\n\t\t\treactor.run()\n\t\t\tq.put(None)\n\t\texcept Exception as e:\n\t\t\tq.put(e)\n\n\t### putting task in queue and start\n\tq = Queue()\n\tp = Process(target=f, args=(q,))\n\tp.start()\n\tresult = q.get()\n\tp.join()\n\n\tif result is not None:\n\t\traise result\n\n\n\n\tprint (\"\\n\\n{}\\n\".format(\"> > > \"*20))","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def run(self):","def scrap_site(link):\n pass # Scrapy or BeautifulSoup","def from_crawler(cls, crawler, *args, **kwargs):\n\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\n crawler, *args, **kwargs)\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\n return spider","def scrape_main() -> None:\n\n logger.info(\"Starting scrape\")\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\n links = run_scrape(\n url=search_info['url'],\n seasons_regex=search_info['seasons'],\n episodes_regex=search_info['episodes']\n )\n if links:\n logger.debug(\"Writing urls to file\")\n with open('urls.txt', 'w') as f:\n for link in links:\n f.write(link + '\\n')\n else:\n logger.warning(\"No links available\")","def genspider(ctx, name, domain):\n spider_filename = _gen_spider(name, domain)\n print('Created {0}'.format(spider_filename))\n\n test_filename = _gen_tests(name, domain)\n print('Created {0}'.format(test_filename))","def executor(self):","def runCrawler(crawlerid):\n sclogic.runCrawler(crawlerid)","def run(self):\r\n pass","def _run(self):\n raise NotImplementedError","def _run(self):\n raise NotImplementedError","def run_spiders():\n hour_limit = 3600 # in seconds\n\n settings = get_project_settings()\n\n # Uncomment the following block of code if you want to test the manager on\n # the \"onepagetest\" to make sure the manager is working.\n \"\"\"\n settings[\"HTTPCACHE_ENABLED\"] = 1\n settings[\"HTTPCACHE_EXPIRATION_SECS\"] = 0\n settings[\"HTTPCACHE_STORAGE\"] = \"scrapy.extensions.httpcache.FilesystemCacheStorage\"\n settings[\"HTTPCACHE_IGNORE_MISSING\"] = 1\n settings[\"HTTPCACHE_DIR\"] = \"onepagetest\"\n \"\"\"\n\n runner = CrawlerRunner(settings)\n begin_time = datetime.now()\n\n d = runner.crawl(\"sb_spider\")\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\n reactor.run()","def execute(self):","def execute(self):","def execute(self):","def execute(self):","def setup( self ):","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def run(self):\n pass","def main():\n download_insert_title_basics()\n download_insert_title_principals()\n download_insert_name_basics()\n download_insert_title_ratings()\n scrap_keywords()\n create_and_insert_soup()\n return","def setUp(self):\n self.myfuncdesc = \"casper.demo.module.a_function_to_wrap\"\n self.mycloth = \"casper.demo.module.clothing\"\n self.mypipedesc = \"casper.demo.pipeline.xml\"\n self.myclothingdesc = \"casper.demo.clothing_pipeline.xml\"\n self.mypipexmldesc = \"casper.demo.xml_pipeline.xml\"\n self.mypyramiddesc = \"casper.demo.pyramid_pipeline.xml\"\n self.myswitchdesc = \"casper.demo.switch_pipeline.xml\"\n self.myiterativedesc = \"casper.demo.iterative_pipeline.xml\"\n self.myfile = os.path.abspath(__file__)\n self.mydir = os.path.dirname(self.myfile)","def run(self):\n \n pass","def run(self, dom):\n\n pass","def __init__(self, *args, **kwargs):\n super(TurntableCrawler, self).__init__(*args, **kwargs)\n\n parts = self.var(\"name\").split(\"_\")\n\n # Add the job var once job names on disk match job code names in shotgun\n self.setVar('assetName', parts[1], True)\n self.setVar('step', parts[2], True)\n self.setVar('variant', parts[3], True)\n self.setVar('pass', parts[4], True)\n self.setVar('renderName', '{}-{}-{}'.format(\n self.var('assetName'),\n self.var('variant'),\n self.var('pass')\n ),\n True\n )","def setup_script(self, *args, **kwargs):\n pass","def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\n allow_clean_url_='no', time_out_=60, work_path_='./',\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\"\"):\n self.__urls = Crawler.__read_file(urls_file_)\n self.__file_spider = file_spider_\n self.__target_format = target_format_\n self.__allow_clean_url = allow_clean_url_\n self.__one_bite = one_bite_\n self.__white_list_path = white_list_path_\n self.__white_list = []\n\n # loads white list in beginning in case an argument was passed for it\n if self.__file_spider == 'yes' and self.__white_list_path != '':\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\n\n # link titles that should be ignored during recursions\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\n\n self.__time_out = time_out_\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\n self.__recursion_max_depth = max_recursion_depth_\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\n\n logging.info('''Crawler Has been Initialized With The Below Configurations:\n-------------------------------------------------------------------\n-urls: %s\n-file_spider: %s\n-target_format: %s\n-ignored_links_file: %s\n-allow_clean_url: %s\n-time_out: %s\n-work_path: %s\n-max_recursion_depth: %s\n-one_bite: %s\n-white_list_path: %s\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\n self.__allow_clean_url, self.__time_out, self.__work_path,\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)","def __init__(self,**kwargs):\r\n self.__dict__ = dict(list(kwargs.items()) + list(self.__dict__.items()))\r\n self.driver = kwargs.get('driver', None)\r\n self.scraper_url = self.state_storage_get_prop('scraper_url') #kwargs.get('scraper_url', None)\r\n self.scraper_url = self.reformat_scraper_url()\r\n self.retry_count = kwargs.get('retry_count', HitParadeBot.DEFAULT_RETRY)\r\n self.command = kwargs.get('command', None)\r\n self.open_url = self.state_storage_get_prop('data_selectors').get('open_url', True) #kwargs.get('data_selectors', {}).get('open_url', True)\r\n self.cache_manager = kwargs.get('cache_manager', None)\r\n parser_kwargs = {'driver' : self.driver}\r\n self.parser_kwargs = kwargs\r\n try:\r\n self.default_parser = kwargs.get('default_parser', 'BeautifulSoupParser')\r\n if self.default_parser is None:\r\n self.default_parser = self.cache_manager.cache_output_component_func(kwargs.get('default_parser', 'BeautifulSoupParser'), **kwargs)\r\n except:\r\n print('exception making parser')\r\n traceback.print_exc()\r\n self.use_once = kwargs.get('use_once', False)\r\n self.use_until_failure = kwargs.get('use_until_failure', False)\r\n self.web_driver = kwargs.get('web_driver', None)\r\n self.force_refresh = kwargs.get('force_refresh', False)\r\n self.get_external_ip_addressesss = kwargs.get('get_external_ip_adressesss', None)","def run_crawl(self, args):\n\n # Crawler process declaration\n process = CrawlerProcess({\n 'USER_AGENT': 'David Avs Crawler',\n 'FEED_FORMAT': 'json',\n 'FEED_URI': 'stdout:',\n 'LOG_ENABLED': args.verbose,\n })\n kwargs = dict(\n start_urls=[args.url],\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\n )\n\n # Run crawling\n old_stdout = sys.stdout\n sys.stdout = args.file\n try:\n process.crawl(DavidAvsSpider, **kwargs)\n process.start()\n finally:\n sys.stdout = old_stdout","def boot():\n\t\tcreate_project_url_dir(Spider.project_name)\n\t\tcreate_url_data(Spider.project_name, Spider.base_url)\n\t\tSpider.queue = file_to_set(Spider.queue_file)\n\t\tSpider.crawled = file_to_set(Spider.crawled_file)","def test_get_site_scans(self):\n pass","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def run(self):\n raise NotImplementedError","def createSpiderFile(self):\n\t\temancmd = \"proc2d \"\n\t\tif not os.path.isfile(self.stack['file']):\n\t\t\tapDisplay.printError(\"stackfile does not exist: \"+self.stack['file'])\n\t\temancmd += self.stack['file']+\" \"\n\n\t\tspiderstack = os.path.join(self.params['rundir'], \"start.spi\")\n\t\tapFile.removeFile(spiderstack, warn=True)\n\t\temancmd += spiderstack+\" \"\n\n\t\temancmd += \"apix=\"+str(self.stack['apix'])+\" \"\n\t\tif self.params['lowpass'] > 0:\n\t\t\temancmd += \"lp=\"+str(self.params['lowpass'])+\" \"\n\t\tif self.params['highpass'] > 0:\n\t\t\temancmd += \"hp=\"+str(self.params['highpass'])+\" \"\n\t\tif self.params['bin'] > 1:\n\t\t\tclipboxsize = self.boxsize*self.params['bin']\n\t\t\temancmd += \"shrink=\"+str(self.params['bin'])+\" \"\n\t\t\temancmd += \"clip=\"+str(clipboxsize)+\",\"+str(clipboxsize)+\" \"\n\t\temancmd += \"last=\"+str(self.params['numpart']-1)+\" \"\n\t\temancmd += \"spiderswap edgenorm\"\n\t\tstarttime = time.time()\n\t\tapDisplay.printColor(\"Running spider stack conversion this can take a while\", \"cyan\")\n\t\tapEMAN.executeEmanCmd(emancmd, verbose=True)\n\t\tapDisplay.printColor(\"finished eman in \"+apDisplay.timeString(time.time()-starttime), \"cyan\")\n\t\treturn spiderstack","def setup_method(self):\n\n # Load in test data as pandas dataframe\n # Test urls are duplicated twice.\n\n self.urls = pd.read_csv('tests/test_urls.csv')\n\n # Note that self.urls is a dataframe so we must specify the appropriate\n # column: `url`\n\n self.urlsclass = govukurls(self.urls.url)","def __init__(self):\n self.site = pywikibot.Site(u'commons', u'commons')\n self.generator = self.getGenerator()","def wrapper(self):\n parser = Gerber(ignore_unknown=False)\n self.design = parser.parse(path.join(DIR, filename))\n test_method(self)","def __init__(self, script=None, **kwargs):\n super().__init__()\n\n # The splash lua script. Provide a custom lua script to fit your use case.\n if script:\n self.LUA_SOURCE = script\n else:\n self.LUA_SOURCE = get_data(\n 'transistor',\n 'scrapers/scripts/basic_splash.lua').decode('utf-8')\n\n # after calling super().__init__(), call self.start_http_session()\n\n # ------------------ kwargs ---------------- #\n # Set these as needed in your subclass with keywords or hardcoded.\n self.baseurl = kwargs.pop('baseurl', None)\n self.searchurl = kwargs.pop('searchurl', None)\n self.crawlera_user = kwargs.pop('crawlera_user', None)\n self.name = kwargs.pop('name', None)\n self.referrer = kwargs.pop('referrer', None)\n self.user_agent = kwargs.pop('user_agent',\n \"Mozilla/5.0 (Windows NT 10.0; Win64; x64) \"\n \"AppleWebKit/537.36 (KHTML, like Gecko) \"\n \"Chrome/73.0.3683.86 Safari/537.36\")\n self.max_retries = kwargs.pop('max_retries', 5)\n self.http_session_timeout = kwargs.pop('http_session_timeout', (3.05, 10.05))\n self.splash_args = kwargs.pop('splash_args', None)\n self.splash_wait = kwargs.pop('splash_wait', 3.0)\n self.js_source = kwargs.pop('js_source', None)\n\n # ----- kwargs only used for testing setup ----- #\n self._test_true = kwargs.get('_test_true', False)\n self._test_page_text = kwargs.get('_test_page_text', None)\n self._test_status_code = kwargs.get('_test_status_code', None)\n self._test_url = kwargs.get('_test_url', None)\n self._test_soup_config = kwargs.get('_test_soup_config', None)\n # ----- end kwargs for testing setup ----- #\n\n # ------ flags for internal use --------- #\n # For example, if a public method on your scraper returns\n # None undesirably, switch the self._result flag to False.\n # Then, you can just delete scrape results if flagged False.\n self._result = True\n # ------- /end internal use flags -------- #\n\n # Whether we already have a valid HTTP session with the remote server\n self.http_session_valid = False\n\n # ssl._create_default_https_context = ssl._create_unverified_context\n self._crawlera_ca = get_data('transistor',\n 'scrapers/certs/crawlera-ca.crt').decode('utf-8')\n\n ssl.create_default_context(cadata=self._crawlera_ca)\n\n self.browser = SplashBrowser(\n soup_config={'features': 'lxml'},\n requests_adapters={'http://': HTTPAdapter(max_retries=self.max_retries)})\n\n self.cookies = dict_from_cookiejar(self.browser.session.cookies)\n\n # set the splash basic authorization\n self.auth = basic_auth_header(\n username=os.environ.get('SPLASH_USERNAME', 'user'),\n password=os.environ.get('SPLASH_PASSWORD', 'userpass'))\n self.browser.session.headers.update({'Authorization': self.auth})","def crawl(spider: str, book_id: int):\n proc = CrawlerProcess(get_project_settings())\n\n proc.crawl(spider, book_id=book_id)\n\n proc.start()","def main():\n proxy = get_random_proxy()\n html = crawl(target_url)\n company_all_url = html.xpath('//*[@id=\"quotesearch\"]/ul/li/a/@href')\n code=['none']*len(company_all_url)\n for i in range(len(company_all_url)):\n s = str(str(company_all_url[i]))\n code[i]=s[(len(s) - 13):(len(s) - 5)]\n save_to_neo4j(code,0,len(code))","def __init__(self, base_url, start_urls, config, helper_outfile, verbose):\n\n # setup class variables\n self.base_url = base_url\n self.config = config\n self.helper_outfile = helper_outfile\n self.verbose = verbose\n self.found_urls = set()\n self.crawled_urls = {}\n self.crawled_paths = {}\n self.param_infos = {}\n self.helper_pid = None\n self.found_cookies = []\n self.comments = {}\n self.redirects = {}\n self.driver = None\n\n # figure out domain\n parsed_url = urllib.parse.urlparse(base_url)\n self.domain = parsed_url.hostname\n self.port = parsed_url.port\n if not self.port:\n self.port = 80 if parsed_url.scheme == \"http\" else 443\n self.protocol_prefix = \"%s://\" % parsed_url.scheme\n\n # compile exclude path regexes from config\n self.exclude_paths = []\n if self.config.get(\"exclude_paths\", \"\"):\n exclude_paths_str = util.parse_as_csv(self.config.get(\"exclude_paths\", \"\"))\n for path_str in exclude_paths_str:\n self.exclude_paths.append(re.compile(path_str))\n\n # parse cookies from config\n self.cookies = {}\n for key_val_pair in self.config[\"cookie_str\"].split(\";\"):\n if not key_val_pair:\n continue\n if \"=\" not in key_val_pair:\n self.cookies[key_val_pair.strip()] = \"\"\n else:\n key, val = key_val_pair.strip().split(\"=\")\n self.cookies[key.strip()] = val.strip()\n\n # setup start urls\n self.start_urls = set([base_url])\n for url in start_urls:\n # skip paths that are excluded from crawling\n if self.exclude_paths and url.count(\"/\") > 2:\n check_str = \"/\" + \"/\".join(url.split(\"/\")[3:])\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\n continue\n self.start_urls.add(url)\n self.start_urls = list(self.start_urls)\n\n # create unix socket for IPC with crawler helper\n if os.path.exists(UNIX_SOCK_ADDR):\n os.remove(UNIX_SOCK_ADDR)\n self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)\n self.socket.bind(UNIX_SOCK_ADDR)\n\n # setup selenium if it is configured to be used\n if config[\"use_selenium\"].lower() == \"true\":\n import logging\n logging.getLogger(\"seleniumwire\").setLevel(logging.ERROR)\n from seleniumwire import webdriver\n from selenium.webdriver.chrome.options import Options\n chrome_options = Options()\n chrome_options.add_argument(\"--headless\")\n chrome_options.add_argument(\"--user-agent=%s\" % self.config[\"user_agent\"])\n\n # on Linux running Selenium as root requires '--no-sandbox' option\n if os.geteuid() == 0 and sys.platform.startswith(\"linux\"):\n chrome_options.add_argument(\"--no-sandbox\")\n self.driver = webdriver.Chrome(options=chrome_options)\n\n # disallow downloads via Selenium (see https://stackoverflow.com/a/47366981)\n self.driver.command_executor._commands[\"send_command\"] = (\"POST\", \"/session/$sessionId/chromium/send_command\")\n params = {\"cmd\": \"Page.setDownloadBehavior\", \"params\": {\"behavior\": \"disallow\", \"downloadPath\": \"\"}}\n command_result = self.driver.execute(\"send_command\", params)\n\n # add cookies\n self.driver.get(self.base_url) # initial request required to add cookies\n self.driver.delete_all_cookies()\n for key, val in self.cookies.items():\n self.driver.add_cookie({\"name\": key, \"value\": val, \"domain\": self.domain})","def __call__(self):\r\n self.init_data = td.import_data(self.__module__)\r\n self.page1() # GET navigation (requests 101-153)\r\n\r\n grinder.sleep(20)\r\n self.page2() # GET case (requests 201-252)\r\n\r\n grinder.sleep(20)\r\n self.page3() # GET view (requests 301-365)\r\n\r\n grinder.sleep(20)\r\n self.page4() # POST view (requests 401-452)\r"],"string":"[\n \"def open_spider(self, spider):\\n pass\",\n \"def open_spider(self,Spider):\\n pass\",\n \"def _scrape(self):\",\n \"def scrape(self):\\n pass\",\n \"def runSpider(spiderClass):\\n\\n\\tprocess = CrawlerProcess({\\n\\t\\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\\n\\t})\\n\\n\\tprocess.crawl(spiderClass)\\n\\tprocess.start() # the script will block here until the crawling is finished\",\n \"def __init__(self):\\n self.SPIDER = \\\"spider\\\"\",\n \"def __init__(self, spider):\\n\\n super(SprintBehavior, self).__init__(spider)\\n self.remoteContext = spider.remoteController.context\",\n \"def script(self):\",\n \"def main():\\n\\n from scrapy.crawler import CrawlerProcess\\n from scrapy.utils.project import get_project_settings\\n\\n process = CrawlerProcess(get_project_settings())\\n process.crawl(NCBIGeoSpider)\\n process.start()\",\n \"def main():\\n # get input params\\n args = parm_parser.get_args()\\n # init log config\\n log.init_log('./log/mini_spider')\\n if args:\\n # read config file spider.conf\\n conf_params = parm_parser.set_config_by_file(args.conf)\\n # use config set up spider initial params\\n spider = SpiderWorker(conf_params)\\n # init result_path, make it complete\\n spider.set_path()\\n # init url queue\\n spider.set_url_queue()\\n # start to crawl url\\n spider.start_crawl_work()\\n\\n return\",\n \"def runSpider(spider, searchterm = None, fullink = None, spiderbotid = -1):\\n sclogic.runSpider(spider, searchterm, fullink, spiderbotid)\",\n \"def main():\\n # 日志保存到./log/spider.log和./log/spider.log.wf，按天切割，保留7天\\n log.init_log(\\\"./log/spider\\\")\\n spider = SpiderEngine.SpiderEngine()\\n try:\\n opts, args = getopt.getopt(sys.argv[1:], \\\"vhc:\\\")\\n except getopt.GetoptError as err:\\n logging.error(\\\"get option error : %s.\\\" % err)\\n return\\n for o, a in opts:\\n if o == \\\"-v\\\":\\n version()\\n return\\n elif o == \\\"-h\\\":\\n # spider_engine = _SpiderEngine._SpiderEngine()\\n # spider_engine.config_tostring()\\n # spider_engine.set_config()\\n print \\\"帮助信息：没有帮助^_^\\\"\\n return\\n else:\\n logging.error(\\\"unhandled option\\\")\\n print \\\"unhandled option\\\"\\n return\\n spider.start_work()\\n return\",\n \"def __init__(self, url, epRange):\\n self.driver = webdriver.PhantomJS()\\n self.downloads = OrderedDict() # sort episodes in asending order\\n self.pbar = \\\"\\\" # Download Progressbar\\n self.Main(url, epRange)\",\n \"def __init__(self, *args, **kwargs):\\n super(AlibabaCompanySpider, self).__init__(*args, **kwargs)\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(autos_detran_terceiros_sp_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\",\n \"def process(self):\",\n \"def process(self):\",\n \"def process(self):\",\n \"def run_spider_on_zyte(spider_name):\\n print(f'Running spider {spider_name}...')\\n data = dict(project=project_id, spider=spider_name)\\n response = requests.post('https://app.scrapinghub.com/api/run.json', data=data, auth=(api_key, ''))\\n return response.json()['jobid']\",\n \"def __init__(self, spider):\\n self.connect = pymysql.Connect(\\n cursorclass=pymysql.cursors.DictCursor,\\n **zaih_scraper.settings.CONNECT_INFO\\n )\\n\\n self.cursor = self.connect.cursor()\\n\\n self.start_time = datetime.datetime.now()\\n self.end_time = datetime.datetime.now()\\n self.duration = datetime.timedelta()\\n\\n # self.logger = logging.getLogger(spider.name)\\n self.logger = SetLogger.set_logger(spider.name)\\n\\n self.table_exist = []\",\n \"def run(self):\\n\\t\\t\\n\\t\\tpass\",\n \"def parse(self, response):\\n\\n\\t\\t### close spider if exception\\n\\t\\tif 'Bandwidth exceeded' in response.body:\\n\\t\\t\\traise CloseSpider('bandwidth_exceeded')\\n\\n\\t\\tlog_scrap.debug(u\\\"\\\\n>>> NEW PARSING >>>\\\\n\\\" )\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse ...\\\" )\\n\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s\\\" , response)\\n\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse /response : \\\\n%s \\\\n\\\" , response.__dict__.keys() )\\n\\n\\t\\t# for k, v in response.__dict__.iteritems() :\\n\\t\\t# \\tlog_scrap.info(\\\"\\\\n--- [k] {} : [v] {} : \\\".format(k,v))\\n\\t\\t# print response._body\\n\\t\\tstart_url = response.meta[\\\"start_url\\\"]\\n\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / start_url : %s\\\", start_url )\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start request with API crawler\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t# if self.spider_config_flat[\\\"parse_api\\\"] == True :\\n\\t\\tif self.parse_api == True :\\n\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting request on API endpoint... \\\" )\\n\\t\\t\\tjsonresponse = json.loads(response.body_as_unicode())\\n\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider.parse / jsonresponse : \\\\n%s\\\", jsonresponse )\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / jsonresponse received...\\\" )\\n\\n\\t\\t\\traw_items_list = get_dictvalue_from_xpath(jsonresponse, self.item_xpath)\\n\\t\\t\\t# raw_items_list = jsonresponse[self.item_xpath]\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / raw_items_list[0] : \\\\n%s\\\\n...\\\", pformat(raw_items_list[0]) )\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - API\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH API ...\\\" )\\n\\n\\t\\t\\t\\t# while self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - API - item n°{} >>> \\\\n\\\".format(self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_api_rest=True, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - API\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - API - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t# follow_link_raw = raw_data[ self.follow_xpath ]\\n\\t\\t\\t\\t\\t\\t\\tfollow_link_raw = get_dictvalue_from_xpath(raw_data, self.follow_xpath)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link_raw),follow_link_raw) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.page_url\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link_raw, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_is_api = self.follow_is_api\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url, 'item_n' : self.item_count , 'parse_api' : follow_is_api })\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - API\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (API) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\turl_next = self.page_url\\n\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\tnext_page = url_next + str(self.page_count)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} \\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} \\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with pure Scrapy requests\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telif self.spider_config_flat[\\\"parse_reactive\\\"] == False :\\n\\t\\t# elif self.parse_reactive == False :\\n \\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting requests with Scrapy... \\\" )\\n\\t\\t\\t# self.parse_scrapy(response)\\n\\n\\t\\t\\t### find items list\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\traw_items_list = response.xpath(self.item_xpath)\\n\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse / len(raw_items_list) : %d \\\", len(raw_items_list) )\\n\\n\\n\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t### PARSING PAGE - SCRAPY\\n\\t\\t\\t### start parsing page : loop through data items in page in response\\n\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SCRAPY ...\\\" )\\n\\n\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Scrapy - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t# print \\\">>> raw_data : \\\\n\\\", raw_data.extract()\\n\\n\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, item_n=self.item_count)\\n\\n\\n\\t\\t\\t\\t\\t\\t### - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SCRAPY\\n\\t\\t\\t\\t\\t\\t### if need to follow to extract all data\\n\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SCRAPY - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\tfollow_link \\t= raw_data.xpath( self.follow_xpath ).extract_first()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> follow_link CLEAN : %s \\\", follow_link )\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {} \\\".format(type(follow_link),follow_link) )\\n\\n\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\turl \\t\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# yield Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url } )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={ 'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False} )\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} / WORKED !!! \\\".format(url) )\\n\\n\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\telse :\\n\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> NO FOLLOW LINK ... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t### item completion is finished - yield and so spark pipeline for item (store in db for instance)\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.items() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\">>> GenericSpider.parse - item.keys() : \\\\n %s\\\", item.items() )\\n\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t# print (\\\"\\\\n>>> NEXT ITEM \\\" + \\\">>> >>> \\\"*10, \\\"\\\\n\\\")\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {}\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF ITEMS')\\n\\n\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t### NEXT PAGE - SCRAPY\\n\\t\\t\\t### check if there is a test_limit\\n\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse (Scrapy) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t### get and go to next page\\n\\t\\t\\t\\t\\tis_next_page, next_page = self.get_next_page(response, start_url)\\n\\n\\t\\t\\t\\t\\tif is_next_page :\\n\\n\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\turl_next = \\\"\\\"\\n\\t\\t\\t\\t\\t\\tif self.api_pagination_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\turl_next = self.api_pagination_root\\n\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE I : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\tnext_page = self.clean_link(next_page, url_root=url_next)\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider.parse >>> NEXT PAGE II : %s\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\tyield response.follow(next_page, callback=self.parse, meta={'start_url': start_url} )\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE PAGE TO SCRAP - pages count : {} \\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('NO MORE PAGE TO SCRAP')\\n\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\t\\t\\telse :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\n\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\t### start requests with Selenium\\n\\t\\t### - - - - - - - - - - - - - - - - - - - - - - - ###\\n\\t\\telse :\\n\\t\\t\\t### initiate selenium browser\\n\\t\\t\\t### cf : https://github.com/voliveirajr/seleniumcrawler/blob/master/seleniumcrawler/spiders/seleniumcrawler_spider.py\\n\\t\\t\\tlog_scrap.info(\\\"\\\\n--- GenericSpider.parse / starting Selenium driver... \\\" )\\n\\n\\t\\t\\t# retrieve exec path for chromedriver from settings_scrapy.py\\n\\t\\t\\t### GET APP MODE FROM ENV VARS\\n\\t\\t\\tapp_mode \\t\\t\\t\\t\\t\\t= os.environ.get('APP_MODE', 'default')\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / APP_MODE : %s\\\", app_mode)\\n\\t\\t\\tchromedriver_path \\t= CHROMEDRIVER_PATH_LIST[ app_mode ]\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider.parse / chromedriver_path : %s\\\", chromedriver_path)\\n\\n\\t\\t\\t### specify executable path to launch webdriver-->\\n\\t\\t\\t# cf : where chromedriver was installed when `brew install chromedriver`\\n\\t\\t\\tself.driver = webdriver.Chrome(executable_path=chromedriver_path, chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Chrome(chrome_options=options_selenium)\\n\\t\\t\\t# self.driver = webdriver.Firefox()\\n\\t\\t\\t# self.driver = webdriver.Chrome()\\n\\t\\t\\t# self.driver = webdriver.PhantomJS() ### deprecated\\n\\n\\t\\t\\t### setup waiting times\\n\\t\\t\\t# self.driver.set_page_load_timeout(60)\\n\\t\\t\\tself.wait_driver\\t= WebDriverWait(self.driver, self.delay_driver)\\n\\t\\t\\tself.wait_page \\t\\t= WebDriverWait(self.driver, self.delay_new_page)\\n\\t\\t\\tself.driver.implicitly_wait(self.delay_implicit)\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_driver : %s\\\", self.delay_driver )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_new_page : %s\\\", self.delay_new_page )\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / self.delay_implicit : %s\\\", self.delay_implicit )\\n\\n\\n\\t\\t\\t### start parsing with selenium\\n\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / response._url : %s\\\", response._url )\\n\\t\\t\\ttry :\\n\\t\\t\\t\\tself.driver.get(response._url)\\n\\n\\t\\t\\t\\t### try scroll_down if needed in config\\n\\t\\t\\t\\tif self.spider_config_flat['scroll_down'] : \\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / scroll_down is TRUE ... \\\" )\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericsSpider. / scroll_down - self.spider_config_flat : \\\\n%s\\\", pformat(self.spider_config_flat) )\\n\\n\\t\\t\\t\\t\\tscroll_pause_time = self.spider_config_flat[\\\"scroll_pause_time\\\"]\\n\\t\\t\\t\\t\\tmax_loops \\t\\t\\t\\t= self.spider_config_flat[\\\"scroll_loops\\\"]\\n\\t\\t\\t\\t\\tself.driver = scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\t\\t# scroll_down(self.driver, scroll_pause_time, max_loops)\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / url '{}' is loaded ... \\\".format( response._url ))\\n\\t\\t\\t\\n\\t\\t\\texcept :\\n\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\traise CloseSpider('DRIVER NOT RESPONDING')\\n\\n\\n\\t\\t\\t### clean original xpath from strings\\n\\t\\t\\tstrings_to_clean = [\\n\\t\\t\\t\\t'/@src',\\n\\t\\t\\t\\t'/@href',\\n\\t\\t\\t\\t'/text()',\\n\\t\\t\\t\\t'/@*[name()=\\\"xlink:href\\\"]',\\n\\t\\t\\t\\t'/@datetime'\\n\\t\\t\\t]\\n\\n\\t\\t\\t# while self.there_is_more_items_to_scrap :\\n\\t\\t\\twhile self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap )\\n\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / while loop continues : %s\\\", self.there_is_more_items_to_scrap_dict[start_url] )\\n\\n\\t\\t\\t\\ttry :\\n\\n\\t\\t\\t\\t\\t### wait / debug page content\\n\\t\\t\\t\\t\\tpage_source_code = self.driver.page_source.encode(\\\"utf-8\\\")\\n\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / page_source_code : \\\\n %s \\\", page_source_code )\\n\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\n\\t\\t\\t\\t\\t### start parsing page :\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.item_xpath : %s\\\", self.item_xpath )\\n\\t\\t\\t\\t\\traw_items_list \\t= self.driver.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / raw_items_list length : %s\\\", len(raw_items_list) )\\n\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / raw_items_list[0].text : \\\\n%s\\\", raw_items_list[0].text )\\n\\n\\t\\t\\t\\t\\t# current_item_index = 0\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### PARSING PAGE - SELENIUM\\n\\t\\t\\t\\t\\t# loop through data items in page in response\\n\\t\\t\\t\\t\\tif len(raw_items_list) != 0 :\\n\\n\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / START PARSING WITH SELENIUM ...\\\\n\\\" )\\n\\n\\t\\t\\t\\t\\t\\tfor raw_data in raw_items_list :\\n\\n\\t\\t\\t\\t\\t\\t\\tprint()\\n\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / START LOOPING raw_items_list WITH SELENIUM ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t### add +1 to items count\\n\\t\\t\\t\\t\\t\\t\\tself.item_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} - there_is_more_items_to_scrap_dict[start_url] : {} \\\".format(str(self.spider_name), self.item_count, self.there_is_more_items_to_scrap_dict[start_url]) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : {} - item n°{} \\\".format(self.spider_name, self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - item n°{} \\\".format(self.item_count) )\\n\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / VARIABLES - spider_name : '%s' - item n°%s \\\" %(self.spider_name, self.item_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t### check if can continue depending on item_count\\n\\t\\t\\t\\t\\t\\t\\tif self.settings_limit_items == 0 or self.item_count <= self.settings_limit_items :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - current start_url : {} >>>\\\".format(start_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEW ITEM - Selenium - item n°{} / page n°{} >>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### instantiate Item to fill from datamodel --> cf items.py\\n\\t\\t\\t\\t\\t\\t\\t\\titemclass \\t= create_item_class( 'GenericItemClass', fields_list = self.dm_item_related )\\n\\t\\t\\t\\t\\t\\t\\t\\titem \\t\\t= itemclass()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add global info to item : i.e. core fields in dm_core_item_related list\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'spider_id' ]\\t\\t= self.spider_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_by' ]\\t\\t= self.user_id\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'added_at' ]\\t\\t= time.time()\\t\\t# timestamp\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_src' ]\\t\\t= response._url\\n\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'page_n' ]\\t\\t= self.page_count\\n\\t\\t\\t\\t\\t\\t\\t\\titem[ 'item_n' ]\\t\\t= self.item_count\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### extract data and feed it to the Item instance based on spider_config_flat\\n\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t\\t\\t\\t### FOLLOW LINK - SELENIUM\\n\\t\\t\\t\\t\\t\\t\\t\\t### find follow link to open detailled item view\\n\\t\\t\\t\\t\\t\\t\\t\\tif self.spider_config_flat[\\\"parse_follow\\\"] == True :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> FOLLOW LINK - SELENIUM - item n°{} / page n°{} >>>>>> \\\\n\\\".format(self.item_count, self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_xpath : %s\\\", self.follow_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Scrapy\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Scrapy ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.debug(u\\\"--- GenericSpider. / get href of follow_link ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link_xpath : %s \\\", follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link\\t\\t\\t= raw_data.find_element_by_xpath( follow_link_xpath ).get_attribute('href')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link RAW : %s \\\", follow_link )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = \\\"\\\"\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif self.api_follow_root != \\\"\\\" :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl_follow = self.api_follow_root\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# complete follow link if needed\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link = self.clean_link(follow_link, url_root=url_follow)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --> follow_link CLEAN ({}) : {}\\\".format(type(follow_link), follow_link ) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# store follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem[ 'link_data' ]\\t= follow_link\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\turl\\t\\t\\t= item['link_data']\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOWING LINK --> url : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield scrapy.Request(url, callback=self.parse_detailed_page, meta={'item': item, 'start_url' : start_url , 'item_n' : self.item_count , 'parse_api' : False})\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\">>> FOLLOW LINK - NOT WORKING : {} \\\".format(url) )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### follow link with Selenium\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t### FIND A WEBSITE TEST FOR REACTIVE DETAILLED PAGES\\n\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / follow link with Selenium ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link_xpath \\t= clean_xpath_for_reactive(self.follow_xpath, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.follow_link_xpath : %s\\\", self.follow_link_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link \\t\\t= raw_data.find_element_by_xpath( follow_link_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### open link in new tab ?\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfollow_link.click()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### get data and save data\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- GenericSpider. / get data and save data ...\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\titem = self.fill_item_from_results_page(raw_data, item, is_reactive=True, strings_to_clean=strings_to_clean, item_n=self.item_count )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### back to previous page and scrap from where it left\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t### cf : https://selenium-python.readthedocs.io/navigating.html#navigation-history-and-location\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.back()\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### if no follow link\\n\\t\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tyield item\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\" --> item : \\\\n %s \\\\n\\\", pformat(item) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\" --> item ...\\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF LIMIT_ITEMS - items count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF LIMIT_ITEMS')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF ITEMS - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\t### - - - - - - - - - - - - ###\\n\\t\\t\\t\\t\\t### NEXT PAGE - SELENIUM\\n\\t\\t\\t\\t\\tif self.test_limit == None or self.page_count < self.test_limit :\\n\\n\\t\\t\\t\\t\\t\\tif self.there_is_more_items_to_scrap_dict[start_url] :\\n\\n\\t\\t\\t\\t\\t\\t\\tif self.page_count < self.settings_limit_pages or self.settings_limit_pages == 0 :\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tprint ()\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_name : '%s' >>>\\\" %(self.spider_name) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\" --- GenericSpider.parse (Selenium) >>> PAGE n°{} DONE -> NEXT PAGE >>> \\\\n\\\".format(self.page_count) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### add +1 to parsed pages\\n\\t\\t\\t\\t\\t\\t\\t\\tself.page_count += 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - spider_page_url : {} >>>\\\".format(self.spider_page_url) )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\">>> NEXT PAGE - current start_url : {} >>>\\\".format(start_url) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### find next page btn in current view\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / self.next_page : %s\\\", self.next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page_xpath = clean_xpath_for_reactive(self.next_page, strings_to_clean)\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page_xpath : %s\\\", next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t= re.sub(\\\"|\\\".join(strings_to_clean), \\\"\\\", next_page )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# try :\\n\\t\\t\\t\\t\\t\\t\\t\\t# element_present = EC.presence_of_element_located((By.XPATH, next_page_xpath ))\\n\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page present : %s\\\", element_present )\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.wait.until(element_present)\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page = self.wait.until( EC.element_to_be_clickable(element_present) )\\n\\t\\t\\t\\t\\t\\t\\t\\t# next_page \\t\\t= self.driver.find_element_by_xpath( next_page_xpath )\\n\\t\\t\\t\\t\\t\\t\\t\\tnext_page \\t\\t= self.driver.find_element(By.XPATH, next_page_xpath )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page : %s\\\", next_page )\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.text : %s\\\", next_page.text )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# except TimeoutException:\\n\\t\\t\\t\\t\\t\\t\\t\\t# except :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\tlog_scrap.error(\\\"--- GenericSpider. / Timed out waiting for page to load\\\")\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### click next button and wait for ajax calls to complete (post and get)\\n\\t\\t\\t\\t\\t\\t\\t\\t### cf : http://www.obeythetestinggoat.com/how-to-get-selenium-to-wait-for-page-load-after-a-click.html\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def wait_for(condition_function):\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tstart_time = time.time()\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\twhile time.time() < start_time + 3:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tif condition_function():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\treturn True\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t\\ttime.sleep(0.1)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\traise Exception ('Timeout waiting for {}'.format(condition_function.__name__) )\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t# def link_has_gone_stale():\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\ttry:\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\t# poll the link with an arbitrary call\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\tnext_page.find_elements_by_xpath(self.item_xpath)\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn False\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\texcept StaleElementReferenceException :\\n\\t\\t\\t\\t\\t\\t\\t\\t# \\t\\treturn True\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.debug(u\\\"--- ... ---\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnext_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# log_scrap.info(\\\"--- GenericSpider. / next_page.send_keys( \\\\ n )\\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.send_keys(\\\"\\\\n\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# added this step for compatibility of scrolling to the view\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / ALTERNATIVE next_page.click() \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# self.driver.execute_script(\\\"return arguments[0].scrollIntoView();\\\", next_page)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# next_page.click()\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.driver.execute_script(\\\"arguments[0].click();\\\", next_page)\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t### wait after click\\n\\t\\t\\t\\t\\t\\t\\t\\ttry :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider. / wait for ajax to finish... \\\" )\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# wait_for(link_has_gone_stale)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return jQuery.active') == 0)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.wait_page.until(lambda driver: self.driver.execute_script('return document.readyState') == 'complete')\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t# time.sleep(self.delay_implicit)\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ttime.sleep(self.delay_new_page)\\n\\t\\t\\t\\t\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.error(\\\"--- GenericSpider. / !!! FAIL / wait for ajax to finish... \\\" )\\n\\n\\t\\t\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF PAGES TO SCRAP - page n°{} / except -> break\\\".format(self.page_count) )\\n\\t\\t\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\t\\t\\traise CloseSpider('OUT OF PAGES TO SCRAP')\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\t\\t# self.there_is_more_items_to_scrap = False\\n\\t\\t\\t\\t\\t\\tself.there_is_more_items_to_scrap_dict[start_url] = False\\n\\t\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / OUT OF TEST_LIMIT - page n°{} - limit : {} - test_limit : {} / except -> break\\\".format(self.page_count, self.settings_limit_pages, self.test_limit) )\\n\\t\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\t\\t# raise CloseSpider('OUT OF TEST_LIMIT')\\n\\t\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\texcept :\\n\\t\\t\\t\\t\\tlog_scrap.warning(u\\\"--- GenericSpider. / NO MORE ITEMS TO SCRAP - item_count : {} - LIMIT_ITEMS : {} / except -> break\\\".format(self.item_count, self.LIMIT_ITEMS) )\\n\\t\\t\\t\\t\\tself.driver.close()\\n\\t\\t\\t\\t\\tlog_scrap.info(\\\"--- GenericSpider / driver is shut\\\" )\\n\\t\\t\\t\\t\\traise CloseSpider('NO MORE ITEMS TO SCRAP')\\n\\t\\t\\t\\t\\tbreak\",\n \"def process(self):\\n pass\",\n \"def spider(given_url):\\n \\n url_to_crawl = given_url\\n\\n source_code = requests.get(url_to_crawl)\\n plain_text = source_code.text\\n soup = BeautifulSoup(plain_text)\\n # name = soup.find('h1', {'class': 'pl-header-title'})\\n # name = name.string\\n # name = str(name)\\n # name = name.strip('')\\n # fw = open('links of' + name + '.txt', 'w')\\n # fw2 = open('names of' + name + '.txt', 'w')\\n fw = open('links.txt', 'w')\\n fw2 = open('names.txt', 'w')\\n for link in soup.findAll('a', {'class': 'pl-video-title-link yt-uix-tile-link yt-uix-sessionlink spf-link '}):\\n my_href = 'https://www.youtube.com' + link.get('href')\\n title = link.string\\n #print(my_href, title)\\n fw.write(my_href + '\\\\n')\\n fw2.write(title)\\n\\n fw.close()\\n fw2.close()\\n\\n \\\"\\\"\\\"Downloading Part\\\"\\\"\\\"\\n try:\\n os.system(\\\"youtube-dl --max-quality FORMAT -a links.txt\\\")\\n return\\n except:\\n print(\\\"Something went wrong related to downloading\\\")\\n exit(2)\",\n \"def run(self, **kwargs):\",\n \"def run_script(self):\\n pass\",\n \"def _genspider(self, module, name, domain, template_name, template_file):\\n tvars = {\\n 'project_name': settings.get('BOT_NAME'),\\n 'ProjectName': string_camelcase(settings.get('BOT_NAME')),\\n 'module': module,\\n 'name': name,\\n 'domain': domain,\\n 'classname': '%sSpider' % ''.join([s.capitalize() \\\\\\n for s in module.split('_')])\\n }\\n\\n spiders_module = __import__(settings['NEWSPIDER_MODULE'], {}, {}, [''])\\n spiders_dir = abspath(dirname(spiders_module.__file__))\\n spider_file = \\\"%s.py\\\" % join(spiders_dir, module)\\n\\n shutil.copyfile(template_file, spider_file)\\n render_templatefile(spider_file, **tvars)\\n print \\\"Created spider %r using template %r in module:\\\" % (name, \\\\\\n template_name)\\n print \\\" %s.%s\\\" % (spiders_module.__name__, module)\",\n \"def crawl(self):\\n\\n # create helper process and setup IPC\\n self.socket.listen(1)\\n help_out_fd = open(self.helper_outfile, \\\"w\\\")\\n with subprocess.Popen(\\\"./crawl_helper.py\\\", stdout=help_out_fd, stderr=subprocess.STDOUT) as proc:\\n self.helper_pid = proc.pid\\n try:\\n conn, _ = self.socket.accept()\\n # create initial params for crawler helper and send them\\n new_urls = set()\\n setup_params = {\\\"start_urls\\\": self.start_urls, \\\"allowed_domains\\\": [self.domain],\\n \\\"cookies\\\": self.cookies, \\\"user_agent\\\": self.config[\\\"user_agent\\\"]}\\n ipc_operations.send_object(conn, setup_params)\\n\\n # loop: receive a response object, then send new URLs to crawl. Catch & handle problems.\\n while True:\\n try:\\n proc.wait(timeout=0.001)\\n break\\n except subprocess.TimeoutExpired:\\n response = ipc_operations.receive_object(conn)\\n if not response: # socket is dead / closed\\n break\\n new_urls = self.process_response(response)\\n ipc_operations.send_object(conn, new_urls)\\n except socket.timeout:\\n util.printit(\\\"Unix socket connection to scrapy crawler unexpectedly broke. \\\" +\\n \\\"Quitting crawling of %s\\\" % self.base_url, color=util.RED)\\n break\\n finally:\\n # ensure connection is closed and helper process killed in any case\\n conn.close()\\n proc.kill()\\n\\n # after the actual crawling, extract all the gathered cookies from Selenium\\n if self.config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n selenium_cookies = self.driver.get_cookies()\\n for cookie in selenium_cookies:\\n if not any(cookie[\\\"name\\\"] == c[\\\"name\\\"] and cookie[\\\"path\\\"] == c[\\\"path\\\"] and\\n cookie[\\\"domain\\\"] == c[\\\"domain\\\"] for c in self.found_cookies):\\n parsed_cookie = {}\\n for key in (\\\"name\\\", \\\"path\\\", \\\"domain\\\", \\\"httpOnly\\\", \\\"secure\\\"):\\n parsed_cookie[key] = cookie[key]\\n self.found_cookies.append(parsed_cookie)\\n\\n help_out_fd.close()\\n return self.create_results()\",\n \"def __init__(self, board='Gossiping', pages=1, file='tmp.json', title_lim=[], jsonf=None, copy_data=[], simple_mode=True):\\n if copy_data:\\n self.extend(copy_data)\\n return\\n os.chdir(os.path.split(os.path.realpath(__file__))[0])\\n print(os.getcwd())\\n com = 'scrapy crawl ptt ' if not simple_mode else 'scrapy crawl ptt_url '\\n # output json file name\\n com += '-o %s ' % (file)\\n # page\\n com += '-a pages=%d ' % (pages)\\n # board\\n com += '-a board=%s ' % (board)\\n\\n # title limit\\n if title_lim:\\n com += '-a title_lim=\\\"'\\n for lim in title_lim:\\n com += \\\"%s,\\\" % (str(lim))\\n com += '\\\" '\\n # not opened by json_file\\n if not jsonf:\\n # start crawl\\n print('Command: ' + com)\\n os.system('rm -f {}'.format(file))\\n os.system('{}'.format(com))\\n # opened by json file\\n else:\\n file = jsonf\\n\\n # all data save in self\\n self.load_json(file)\\n self.com = com\\n self.file = file\",\n \"def run(self): \\r\\n return\",\n \"def run(self, parsed):\",\n \"def run_generic_spider( user_id\\t\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tspider_id\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tdatamodel\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\trun_spider_config\\t= None,\\n\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t= None\\n\\t\\t\\t\\t\\t\\t):\\n\\n\\tprint ()\\n\\tlog_scrap.info(\\\"--- run_generic_spider / spider_id : %s \\\", spider_id )\\n\\n\\t### WARNING !!! --> TEMPORARY SOLUTION\\n\\t### remove spider folder for spider_id in JOBDIR\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / cwd : %s\\\", os.getcwd() )\\n\\ttry :\\n\\t\\tshutil.rmtree( os.getcwd() + \\\"/\\\" + JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\texcept:\\n\\t\\tpass\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / removed folder : {}/{}\\\".format(JOBDIR_FOLDER, spider_id) )\\n\\n\\t# !!! spider is launched from main.py level !!!\\n\\t# all relative routes referring to this...\\n\\tlog_scrap.info(\\\"--- run_generic_spider / os.getcwd() : %s \\\", os.getcwd() )\\n\\n\\t### flattening run_spider_config : from nested to flat dict\\n\\tlog_scrap.info(\\\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\\\" )\\n\\tspider_config_flat = flattenSpiderConfig( run_spider_config )\\n\\n\\n\\t### settings for crawler\\n\\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\\n\\n\\t### global settings for scrapy processes (see upper)\\n\\tlog_scrap.info(\\\"--- run_generic_spider / BOT_NAME : %s \\\", settings.get('BOT_NAME') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / USER_AGENT : %s \\\", settings.get('USER_AGENT') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / ITEM_PIPELINES : %s \\\", settings.get('ITEM_PIPELINES').__dict__ )\\n\\n\\n\\t# specific settings for this scrapy process\\n\\n\\t# settings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t, RETRY_TIMES )\\n\\t# settings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, CONCURRENT_ITEMS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t\\t, CONCURRENT_REQUESTS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS_PER_DOMAIN\\\"\\t, CONCURRENT_REQUESTS_PER_DOMAIN )\\n\\t# settings.set( \\\"REDIRECT_MAX_TIMES\\\"\\t\\t\\t\\t, REDIRECT_MAX_TIMES )\\n\\t# settings.set( \\\"DOWNLOAD_MAXSIZE\\\" \\t\\t\\t\\t, DOWNLOAD_MAXSIZE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, DEPTH_PRIORITY )\\n\\t# settings.set( \\\"SCHEDULER_DISK_QUEUE\\\"\\t\\t\\t, SCHEDULER_DISK_QUEUE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, SCHEDULER_MEMORY_QUEUE )\\n\\n\\t# settings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t\\t, RANDOMIZE_DOWNLOAD_DELAY )\\n\\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\\n\\tsettings.set( \\\"JOBDIR\\\"\\t\\t\\t\\t\\t\\t\\t, JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\n\\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\\n\\n\\tsettings.set( \\\"CURRENT_SPIDER_ID\\\" \\t\\t\\t, spider_id )\\n\\tsettings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"RETRY_TIMES\\\"] )\\n\\tsettings.set( \\\"CLOSESPIDER_ITEMCOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_ITEMS\\\"] )\\n\\t# settings.set( \\\"CLOSESPIDER_PAGECOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_PAGES\\\"] )\\n\\tsettings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t\\t, spider_config_flat[\\\"download_delay\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_ITEMS\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_REQUESTS\\\"] )\\n\\t# settings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t, DOWNLOAD_DELAY )\\n\\n\\tsettings.set( \\\"BOT_NAME\\\"\\t\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"BOT_NAME\\\"] )\\n\\tsettings.set( \\\"USER_AGENT\\\"\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"USER_AGENT\\\"] )\\n\\tsettings.set( \\\"ROBOTSTXT_OBEY\\\"\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"ROBOTSTXT_OBEY\\\"] )\\n\\tsettings.set( \\\"AUTOTHROTTLE_ENABLED\\\"\\t\\t\\t, spider_config_flat[\\\"AUTOTHROTTLE_ENABLED\\\"] )\\n\\tsettings.set( \\\"HTTPCACHE_ENABLED\\\"\\t\\t\\t\\t\\t, spider_config_flat[\\\"HTTPCACHE_ENABLED\\\"] )\\n\\tsettings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t, spider_config_flat[\\\"RANDOMIZE_DOWNLOAD_DELAY\\\"] )\\n\\n\\t### initiating crawler process\\n\\tlog_scrap.info(\\\"--- run_generic_spider / instanciate process ...\\\" \\t )\\n\\tprocess = CrawlerRunner( settings = settings )\\n\\n\\t### adding CrawlerRunner as deferred\\n\\tdef f(q):\\n\\t\\ttry:\\n\\t\\t\\t### send/create custom spider from run_spider_config\\n\\t\\t\\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\\n\\n\\t\\t\\tdeferred = process.crawl( \\tGenericSpider,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tuser_id\\t\\t\\t\\t\\t\\t\\t= user_id,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdatamodel \\t\\t\\t\\t\\t= datamodel ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_id \\t\\t\\t\\t\\t= spider_id ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_config_flat\\t= spider_config_flat,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t\\t\\t= test_limit\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t)\\n\\t\\t\\tdeferred.addBoth(lambda _: reactor.stop())\\n\\t\\t\\treactor.run()\\n\\t\\t\\tq.put(None)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tq.put(e)\\n\\n\\t### putting task in queue and start\\n\\tq = Queue()\\n\\tp = Process(target=f, args=(q,))\\n\\tp.start()\\n\\tresult = q.get()\\n\\tp.join()\\n\\n\\tif result is not None:\\n\\t\\traise result\\n\\n\\n\\n\\tprint (\\\"\\\\n\\\\n{}\\\\n\\\".format(\\\"> > > \\\"*20))\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def run(self):\",\n \"def scrap_site(link):\\n pass # Scrapy or BeautifulSoup\",\n \"def from_crawler(cls, crawler, *args, **kwargs):\\n\\n spider = super(telecom_vivo_movel_spider, cls).from_crawler(\\n crawler, *args, **kwargs)\\n crawler.signals.connect(spider.get_final_result, signals.spider_idle)\\n return spider\",\n \"def scrape_main() -> None:\\n\\n logger.info(\\\"Starting scrape\\\")\\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\\n links = run_scrape(\\n url=search_info['url'],\\n seasons_regex=search_info['seasons'],\\n episodes_regex=search_info['episodes']\\n )\\n if links:\\n logger.debug(\\\"Writing urls to file\\\")\\n with open('urls.txt', 'w') as f:\\n for link in links:\\n f.write(link + '\\\\n')\\n else:\\n logger.warning(\\\"No links available\\\")\",\n \"def genspider(ctx, name, domain):\\n spider_filename = _gen_spider(name, domain)\\n print('Created {0}'.format(spider_filename))\\n\\n test_filename = _gen_tests(name, domain)\\n print('Created {0}'.format(test_filename))\",\n \"def executor(self):\",\n \"def runCrawler(crawlerid):\\n sclogic.runCrawler(crawlerid)\",\n \"def run(self):\\r\\n pass\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def _run(self):\\n raise NotImplementedError\",\n \"def run_spiders():\\n hour_limit = 3600 # in seconds\\n\\n settings = get_project_settings()\\n\\n # Uncomment the following block of code if you want to test the manager on\\n # the \\\"onepagetest\\\" to make sure the manager is working.\\n \\\"\\\"\\\"\\n settings[\\\"HTTPCACHE_ENABLED\\\"] = 1\\n settings[\\\"HTTPCACHE_EXPIRATION_SECS\\\"] = 0\\n settings[\\\"HTTPCACHE_STORAGE\\\"] = \\\"scrapy.extensions.httpcache.FilesystemCacheStorage\\\"\\n settings[\\\"HTTPCACHE_IGNORE_MISSING\\\"] = 1\\n settings[\\\"HTTPCACHE_DIR\\\"] = \\\"onepagetest\\\"\\n \\\"\\\"\\\"\\n\\n runner = CrawlerRunner(settings)\\n begin_time = datetime.now()\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\\n reactor.run()\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def setup( self ):\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def run(self):\\n pass\",\n \"def main():\\n download_insert_title_basics()\\n download_insert_title_principals()\\n download_insert_name_basics()\\n download_insert_title_ratings()\\n scrap_keywords()\\n create_and_insert_soup()\\n return\",\n \"def setUp(self):\\n self.myfuncdesc = \\\"casper.demo.module.a_function_to_wrap\\\"\\n self.mycloth = \\\"casper.demo.module.clothing\\\"\\n self.mypipedesc = \\\"casper.demo.pipeline.xml\\\"\\n self.myclothingdesc = \\\"casper.demo.clothing_pipeline.xml\\\"\\n self.mypipexmldesc = \\\"casper.demo.xml_pipeline.xml\\\"\\n self.mypyramiddesc = \\\"casper.demo.pyramid_pipeline.xml\\\"\\n self.myswitchdesc = \\\"casper.demo.switch_pipeline.xml\\\"\\n self.myiterativedesc = \\\"casper.demo.iterative_pipeline.xml\\\"\\n self.myfile = os.path.abspath(__file__)\\n self.mydir = os.path.dirname(self.myfile)\",\n \"def run(self):\\n \\n pass\",\n \"def run(self, dom):\\n\\n pass\",\n \"def __init__(self, *args, **kwargs):\\n super(TurntableCrawler, self).__init__(*args, **kwargs)\\n\\n parts = self.var(\\\"name\\\").split(\\\"_\\\")\\n\\n # Add the job var once job names on disk match job code names in shotgun\\n self.setVar('assetName', parts[1], True)\\n self.setVar('step', parts[2], True)\\n self.setVar('variant', parts[3], True)\\n self.setVar('pass', parts[4], True)\\n self.setVar('renderName', '{}-{}-{}'.format(\\n self.var('assetName'),\\n self.var('variant'),\\n self.var('pass')\\n ),\\n True\\n )\",\n \"def setup_script(self, *args, **kwargs):\\n pass\",\n \"def __init__(self, urls_file_, file_spider_='no', target_format_='', ignored_links_file_='',\\n allow_clean_url_='no', time_out_=60, work_path_='./',\\n max_recursion_depth_=0, one_bite_='no', white_list_path_=\\\"\\\"):\\n self.__urls = Crawler.__read_file(urls_file_)\\n self.__file_spider = file_spider_\\n self.__target_format = target_format_\\n self.__allow_clean_url = allow_clean_url_\\n self.__one_bite = one_bite_\\n self.__white_list_path = white_list_path_\\n self.__white_list = []\\n\\n # loads white list in beginning in case an argument was passed for it\\n if self.__file_spider == 'yes' and self.__white_list_path != '':\\n self.__white_list = Crawler.__read_white_list(self.__white_list_path)\\n\\n # link titles that should be ignored during recursions\\n self.__ignored_links = Crawler.__read_file(ignored_links_file_)\\n\\n self.__time_out = time_out_\\n self.__work_path = os.path.join(work_path_.rstrip('/')+'/', 'DATA')\\n self.__recursion_max_depth = max_recursion_depth_\\n self.__extensions = ['txt', 'html', 'csv', 'tsv', 'tar', 'raw']\\n\\n logging.info('''Crawler Has been Initialized With The Below Configurations:\\n-------------------------------------------------------------------\\n-urls: %s\\n-file_spider: %s\\n-target_format: %s\\n-ignored_links_file: %s\\n-allow_clean_url: %s\\n-time_out: %s\\n-work_path: %s\\n-max_recursion_depth: %s\\n-one_bite: %s\\n-white_list_path: %s\\n''', self.__urls, self.__file_spider, self.__target_format, self.__ignored_links,\\n self.__allow_clean_url, self.__time_out, self.__work_path,\\n self.__recursion_max_depth, self.__one_bite, self.__white_list_path)\",\n \"def __init__(self,**kwargs):\\r\\n self.__dict__ = dict(list(kwargs.items()) + list(self.__dict__.items()))\\r\\n self.driver = kwargs.get('driver', None)\\r\\n self.scraper_url = self.state_storage_get_prop('scraper_url') #kwargs.get('scraper_url', None)\\r\\n self.scraper_url = self.reformat_scraper_url()\\r\\n self.retry_count = kwargs.get('retry_count', HitParadeBot.DEFAULT_RETRY)\\r\\n self.command = kwargs.get('command', None)\\r\\n self.open_url = self.state_storage_get_prop('data_selectors').get('open_url', True) #kwargs.get('data_selectors', {}).get('open_url', True)\\r\\n self.cache_manager = kwargs.get('cache_manager', None)\\r\\n parser_kwargs = {'driver' : self.driver}\\r\\n self.parser_kwargs = kwargs\\r\\n try:\\r\\n self.default_parser = kwargs.get('default_parser', 'BeautifulSoupParser')\\r\\n if self.default_parser is None:\\r\\n self.default_parser = self.cache_manager.cache_output_component_func(kwargs.get('default_parser', 'BeautifulSoupParser'), **kwargs)\\r\\n except:\\r\\n print('exception making parser')\\r\\n traceback.print_exc()\\r\\n self.use_once = kwargs.get('use_once', False)\\r\\n self.use_until_failure = kwargs.get('use_until_failure', False)\\r\\n self.web_driver = kwargs.get('web_driver', None)\\r\\n self.force_refresh = kwargs.get('force_refresh', False)\\r\\n self.get_external_ip_addressesss = kwargs.get('get_external_ip_adressesss', None)\",\n \"def run_crawl(self, args):\\n\\n # Crawler process declaration\\n process = CrawlerProcess({\\n 'USER_AGENT': 'David Avs Crawler',\\n 'FEED_FORMAT': 'json',\\n 'FEED_URI': 'stdout:',\\n 'LOG_ENABLED': args.verbose,\\n })\\n kwargs = dict(\\n start_urls=[args.url],\\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\\n )\\n\\n # Run crawling\\n old_stdout = sys.stdout\\n sys.stdout = args.file\\n try:\\n process.crawl(DavidAvsSpider, **kwargs)\\n process.start()\\n finally:\\n sys.stdout = old_stdout\",\n \"def boot():\\n\\t\\tcreate_project_url_dir(Spider.project_name)\\n\\t\\tcreate_url_data(Spider.project_name, Spider.base_url)\\n\\t\\tSpider.queue = file_to_set(Spider.queue_file)\\n\\t\\tSpider.crawled = file_to_set(Spider.crawled_file)\",\n \"def test_get_site_scans(self):\\n pass\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def run(self):\\n raise NotImplementedError\",\n \"def createSpiderFile(self):\\n\\t\\temancmd = \\\"proc2d \\\"\\n\\t\\tif not os.path.isfile(self.stack['file']):\\n\\t\\t\\tapDisplay.printError(\\\"stackfile does not exist: \\\"+self.stack['file'])\\n\\t\\temancmd += self.stack['file']+\\\" \\\"\\n\\n\\t\\tspiderstack = os.path.join(self.params['rundir'], \\\"start.spi\\\")\\n\\t\\tapFile.removeFile(spiderstack, warn=True)\\n\\t\\temancmd += spiderstack+\\\" \\\"\\n\\n\\t\\temancmd += \\\"apix=\\\"+str(self.stack['apix'])+\\\" \\\"\\n\\t\\tif self.params['lowpass'] > 0:\\n\\t\\t\\temancmd += \\\"lp=\\\"+str(self.params['lowpass'])+\\\" \\\"\\n\\t\\tif self.params['highpass'] > 0:\\n\\t\\t\\temancmd += \\\"hp=\\\"+str(self.params['highpass'])+\\\" \\\"\\n\\t\\tif self.params['bin'] > 1:\\n\\t\\t\\tclipboxsize = self.boxsize*self.params['bin']\\n\\t\\t\\temancmd += \\\"shrink=\\\"+str(self.params['bin'])+\\\" \\\"\\n\\t\\t\\temancmd += \\\"clip=\\\"+str(clipboxsize)+\\\",\\\"+str(clipboxsize)+\\\" \\\"\\n\\t\\temancmd += \\\"last=\\\"+str(self.params['numpart']-1)+\\\" \\\"\\n\\t\\temancmd += \\\"spiderswap edgenorm\\\"\\n\\t\\tstarttime = time.time()\\n\\t\\tapDisplay.printColor(\\\"Running spider stack conversion this can take a while\\\", \\\"cyan\\\")\\n\\t\\tapEMAN.executeEmanCmd(emancmd, verbose=True)\\n\\t\\tapDisplay.printColor(\\\"finished eman in \\\"+apDisplay.timeString(time.time()-starttime), \\\"cyan\\\")\\n\\t\\treturn spiderstack\",\n \"def setup_method(self):\\n\\n # Load in test data as pandas dataframe\\n # Test urls are duplicated twice.\\n\\n self.urls = pd.read_csv('tests/test_urls.csv')\\n\\n # Note that self.urls is a dataframe so we must specify the appropriate\\n # column: `url`\\n\\n self.urlsclass = govukurls(self.urls.url)\",\n \"def __init__(self):\\n self.site = pywikibot.Site(u'commons', u'commons')\\n self.generator = self.getGenerator()\",\n \"def wrapper(self):\\n parser = Gerber(ignore_unknown=False)\\n self.design = parser.parse(path.join(DIR, filename))\\n test_method(self)\",\n \"def __init__(self, script=None, **kwargs):\\n super().__init__()\\n\\n # The splash lua script. Provide a custom lua script to fit your use case.\\n if script:\\n self.LUA_SOURCE = script\\n else:\\n self.LUA_SOURCE = get_data(\\n 'transistor',\\n 'scrapers/scripts/basic_splash.lua').decode('utf-8')\\n\\n # after calling super().__init__(), call self.start_http_session()\\n\\n # ------------------ kwargs ---------------- #\\n # Set these as needed in your subclass with keywords or hardcoded.\\n self.baseurl = kwargs.pop('baseurl', None)\\n self.searchurl = kwargs.pop('searchurl', None)\\n self.crawlera_user = kwargs.pop('crawlera_user', None)\\n self.name = kwargs.pop('name', None)\\n self.referrer = kwargs.pop('referrer', None)\\n self.user_agent = kwargs.pop('user_agent',\\n \\\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) \\\"\\n \\\"AppleWebKit/537.36 (KHTML, like Gecko) \\\"\\n \\\"Chrome/73.0.3683.86 Safari/537.36\\\")\\n self.max_retries = kwargs.pop('max_retries', 5)\\n self.http_session_timeout = kwargs.pop('http_session_timeout', (3.05, 10.05))\\n self.splash_args = kwargs.pop('splash_args', None)\\n self.splash_wait = kwargs.pop('splash_wait', 3.0)\\n self.js_source = kwargs.pop('js_source', None)\\n\\n # ----- kwargs only used for testing setup ----- #\\n self._test_true = kwargs.get('_test_true', False)\\n self._test_page_text = kwargs.get('_test_page_text', None)\\n self._test_status_code = kwargs.get('_test_status_code', None)\\n self._test_url = kwargs.get('_test_url', None)\\n self._test_soup_config = kwargs.get('_test_soup_config', None)\\n # ----- end kwargs for testing setup ----- #\\n\\n # ------ flags for internal use --------- #\\n # For example, if a public method on your scraper returns\\n # None undesirably, switch the self._result flag to False.\\n # Then, you can just delete scrape results if flagged False.\\n self._result = True\\n # ------- /end internal use flags -------- #\\n\\n # Whether we already have a valid HTTP session with the remote server\\n self.http_session_valid = False\\n\\n # ssl._create_default_https_context = ssl._create_unverified_context\\n self._crawlera_ca = get_data('transistor',\\n 'scrapers/certs/crawlera-ca.crt').decode('utf-8')\\n\\n ssl.create_default_context(cadata=self._crawlera_ca)\\n\\n self.browser = SplashBrowser(\\n soup_config={'features': 'lxml'},\\n requests_adapters={'http://': HTTPAdapter(max_retries=self.max_retries)})\\n\\n self.cookies = dict_from_cookiejar(self.browser.session.cookies)\\n\\n # set the splash basic authorization\\n self.auth = basic_auth_header(\\n username=os.environ.get('SPLASH_USERNAME', 'user'),\\n password=os.environ.get('SPLASH_PASSWORD', 'userpass'))\\n self.browser.session.headers.update({'Authorization': self.auth})\",\n \"def crawl(spider: str, book_id: int):\\n proc = CrawlerProcess(get_project_settings())\\n\\n proc.crawl(spider, book_id=book_id)\\n\\n proc.start()\",\n \"def main():\\n proxy = get_random_proxy()\\n html = crawl(target_url)\\n company_all_url = html.xpath('//*[@id=\\\"quotesearch\\\"]/ul/li/a/@href')\\n code=['none']*len(company_all_url)\\n for i in range(len(company_all_url)):\\n s = str(str(company_all_url[i]))\\n code[i]=s[(len(s) - 13):(len(s) - 5)]\\n save_to_neo4j(code,0,len(code))\",\n \"def __init__(self, base_url, start_urls, config, helper_outfile, verbose):\\n\\n # setup class variables\\n self.base_url = base_url\\n self.config = config\\n self.helper_outfile = helper_outfile\\n self.verbose = verbose\\n self.found_urls = set()\\n self.crawled_urls = {}\\n self.crawled_paths = {}\\n self.param_infos = {}\\n self.helper_pid = None\\n self.found_cookies = []\\n self.comments = {}\\n self.redirects = {}\\n self.driver = None\\n\\n # figure out domain\\n parsed_url = urllib.parse.urlparse(base_url)\\n self.domain = parsed_url.hostname\\n self.port = parsed_url.port\\n if not self.port:\\n self.port = 80 if parsed_url.scheme == \\\"http\\\" else 443\\n self.protocol_prefix = \\\"%s://\\\" % parsed_url.scheme\\n\\n # compile exclude path regexes from config\\n self.exclude_paths = []\\n if self.config.get(\\\"exclude_paths\\\", \\\"\\\"):\\n exclude_paths_str = util.parse_as_csv(self.config.get(\\\"exclude_paths\\\", \\\"\\\"))\\n for path_str in exclude_paths_str:\\n self.exclude_paths.append(re.compile(path_str))\\n\\n # parse cookies from config\\n self.cookies = {}\\n for key_val_pair in self.config[\\\"cookie_str\\\"].split(\\\";\\\"):\\n if not key_val_pair:\\n continue\\n if \\\"=\\\" not in key_val_pair:\\n self.cookies[key_val_pair.strip()] = \\\"\\\"\\n else:\\n key, val = key_val_pair.strip().split(\\\"=\\\")\\n self.cookies[key.strip()] = val.strip()\\n\\n # setup start urls\\n self.start_urls = set([base_url])\\n for url in start_urls:\\n # skip paths that are excluded from crawling\\n if self.exclude_paths and url.count(\\\"/\\\") > 2:\\n check_str = \\\"/\\\" + \\\"/\\\".join(url.split(\\\"/\\\")[3:])\\n if any(re_path.match(check_str) for re_path in self.exclude_paths):\\n continue\\n self.start_urls.add(url)\\n self.start_urls = list(self.start_urls)\\n\\n # create unix socket for IPC with crawler helper\\n if os.path.exists(UNIX_SOCK_ADDR):\\n os.remove(UNIX_SOCK_ADDR)\\n self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)\\n self.socket.bind(UNIX_SOCK_ADDR)\\n\\n # setup selenium if it is configured to be used\\n if config[\\\"use_selenium\\\"].lower() == \\\"true\\\":\\n import logging\\n logging.getLogger(\\\"seleniumwire\\\").setLevel(logging.ERROR)\\n from seleniumwire import webdriver\\n from selenium.webdriver.chrome.options import Options\\n chrome_options = Options()\\n chrome_options.add_argument(\\\"--headless\\\")\\n chrome_options.add_argument(\\\"--user-agent=%s\\\" % self.config[\\\"user_agent\\\"])\\n\\n # on Linux running Selenium as root requires '--no-sandbox' option\\n if os.geteuid() == 0 and sys.platform.startswith(\\\"linux\\\"):\\n chrome_options.add_argument(\\\"--no-sandbox\\\")\\n self.driver = webdriver.Chrome(options=chrome_options)\\n\\n # disallow downloads via Selenium (see https://stackoverflow.com/a/47366981)\\n self.driver.command_executor._commands[\\\"send_command\\\"] = (\\\"POST\\\", \\\"/session/$sessionId/chromium/send_command\\\")\\n params = {\\\"cmd\\\": \\\"Page.setDownloadBehavior\\\", \\\"params\\\": {\\\"behavior\\\": \\\"disallow\\\", \\\"downloadPath\\\": \\\"\\\"}}\\n command_result = self.driver.execute(\\\"send_command\\\", params)\\n\\n # add cookies\\n self.driver.get(self.base_url) # initial request required to add cookies\\n self.driver.delete_all_cookies()\\n for key, val in self.cookies.items():\\n self.driver.add_cookie({\\\"name\\\": key, \\\"value\\\": val, \\\"domain\\\": self.domain})\",\n \"def __call__(self):\\r\\n self.init_data = td.import_data(self.__module__)\\r\\n self.page1() # GET navigation (requests 101-153)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page2() # GET case (requests 201-252)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page3() # GET view (requests 301-365)\\r\\n\\r\\n grinder.sleep(20)\\r\\n self.page4() # POST view (requests 401-452)\\r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69789076","0.6779831","0.6693511","0.6653942","0.6546695","0.6390095","0.62781423","0.6225595","0.61060053","0.60984313","0.59596026","0.59464854","0.5914226","0.5914064","0.5889635","0.5883018","0.5883018","0.5883018","0.58060247","0.5801764","0.5786768","0.5786765","0.57857835","0.57800335","0.5752843","0.5747418","0.57371014","0.5727239","0.5724929","0.57152176","0.56875694","0.5678607","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.5658643","0.56575084","0.56558466","0.56318533","0.56008726","0.55863565","0.5578021","0.5577482","0.55747896","0.55747896","0.5570914","0.55692935","0.55692935","0.55692935","0.55692935","0.55643785","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5563338","0.5562597","0.55567753","0.55562633","0.5555392","0.5545581","0.5544439","0.5544103","0.55382025","0.55040205","0.5491952","0.5481473","0.5458264","0.5458264","0.5458264","0.5458264","0.5458264","0.5458264","0.5458264","0.5458264","0.5458264","0.545742","0.54544014","0.5447859","0.5445858","0.54393816","0.5437315","0.541612","0.5414823","0.54081535"],"string":"[\n \"0.69789076\",\n \"0.6779831\",\n \"0.6693511\",\n \"0.6653942\",\n \"0.6546695\",\n \"0.6390095\",\n \"0.62781423\",\n \"0.6225595\",\n \"0.61060053\",\n \"0.60984313\",\n \"0.59596026\",\n \"0.59464854\",\n \"0.5914226\",\n \"0.5914064\",\n \"0.5889635\",\n \"0.5883018\",\n \"0.5883018\",\n \"0.5883018\",\n \"0.58060247\",\n \"0.5801764\",\n \"0.5786768\",\n \"0.5786765\",\n \"0.57857835\",\n \"0.57800335\",\n \"0.5752843\",\n \"0.5747418\",\n \"0.57371014\",\n \"0.5727239\",\n \"0.5724929\",\n \"0.57152176\",\n \"0.56875694\",\n \"0.5678607\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.5658643\",\n \"0.56575084\",\n \"0.56558466\",\n \"0.56318533\",\n \"0.56008726\",\n \"0.55863565\",\n \"0.5578021\",\n \"0.5577482\",\n \"0.55747896\",\n \"0.55747896\",\n \"0.5570914\",\n \"0.55692935\",\n \"0.55692935\",\n \"0.55692935\",\n \"0.55692935\",\n \"0.55643785\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5563338\",\n \"0.5562597\",\n \"0.55567753\",\n \"0.55562633\",\n \"0.5555392\",\n \"0.5545581\",\n \"0.5544439\",\n \"0.5544103\",\n \"0.55382025\",\n \"0.55040205\",\n \"0.5491952\",\n \"0.5481473\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.5458264\",\n \"0.545742\",\n \"0.54544014\",\n \"0.5447859\",\n \"0.5445858\",\n \"0.54393816\",\n \"0.5437315\",\n \"0.541612\",\n \"0.5414823\",\n \"0.54081535\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85188,"cells":{"query":{"kind":"string","value":"Main method for the spider_cms script. Parses arguments and invokes main_driver"},"document":{"kind":"string","value":"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--process_queue\", action='store_true',\n dest=\"process_queue\",\n help=\"Process also schedd queue (Running/Idle/Pending jobs)\")\n parser.add_argument(\"--feed_es\", action='store_true',\n dest=\"feed_es\",\n help=\"Feed to Elasticsearch\")\n parser.add_argument(\"--feed_es_for_queues\", action='store_true',\n dest=\"feed_es_for_queues\",\n help=\"Feed queue data also to Elasticsearch\")\n parser.add_argument(\"--feed_amq\", action='store_true',\n dest=\"feed_amq\",\n help=\"Feed to CERN AMQ\")\n\n parser.add_argument(\"--schedd_filter\", default='',\n type=str, dest=\"schedd_filter\",\n help=(\"Comma separated list of schedd names to process \"\n \"[default is to process all]\"))\n parser.add_argument(\"--skip_history\", action='store_true',\n dest=\"skip_history\",\n help=\"Skip processing the history. (Only do queues.)\")\n parser.add_argument(\"--read_only\", action='store_true',\n dest=\"read_only\",\n help=\"Only read the info, don't submit it.\")\n parser.add_argument(\"--dry_run\", action='store_true',\n dest=\"dry_run\",\n help=(\"Don't even read info, just pretend to. (Still \"\n \"query the collector for the schedd's though.)\"))\n parser.add_argument(\"--keep_full_queue_data\", action='store_true',\n dest=\"keep_full_queue_data\",\n help=\"Drop all but some fields for running jobs.\")\n parser.add_argument(\"--amq_bunch_size\", default=5000,\n type=int, dest=\"amq_bunch_size\",\n help=(\"Send docs to AMQ in bunches of this number \"\n \"[default: %(default)d]\"))\n parser.add_argument(\"--es_bunch_size\", default=250,\n type=int, dest=\"es_bunch_size\",\n help=(\"Send docs to ES in bunches of this number \"\n \"[default: %(default)d]\"))\n parser.add_argument(\"--query_queue_batch_size\", default=50,\n type=int, dest=\"query_queue_batch_size\",\n help=(\"Send docs to listener in batches of this number \"\n \"[default: %(default)d]\"))\n parser.add_argument(\"--upload_pool_size\", default=8,\n type=int, dest=\"upload_pool_size\",\n help=(\"Number of parallel processes for uploading \"\n \"[default: %(default)d]\"))\n parser.add_argument(\"--query_pool_size\", default=8,\n type=int, dest=\"query_pool_size\",\n help=(\"Number of parallel processes for querying \"\n \"[default: %(default)d]\"))\n\n parser.add_argument(\"--es_hostname\", default='es-cms.cern.ch',\n type=str, dest=\"es_hostname\",\n help=\"Hostname of the elasticsearch instance to be used \"\n \"[default: %(default)s]\")\n parser.add_argument(\"--es_port\", default=9203,\n type=int, dest=\"es_port\",\n help=\"Port of the elasticsearch instance to be used \"\n \"[default: %(default)d]\")\n parser.add_argument(\"--es_index_template\", default='cms',\n type=str, dest=\"es_index_template\",\n help=(\"Trunk of index pattern. \"\n \"Needs to start with 'cms' \"\n \"[default: %(default)s]\"))\n parser.add_argument(\"--log_dir\", default='log/',\n type=str, dest=\"log_dir\",\n help=\"Directory for logging information [default: %(default)s]\")\n parser.add_argument(\"--log_level\", default='WARNING',\n type=str, dest=\"log_level\",\n help=\"Log level (CRITICAL/ERROR/WARNING/INFO/DEBUG) \"\n \"[default: %(default)s]\")\n parser.add_argument(\"--email_alerts\", default=[], action='append',\n dest=\"email_alerts\",\n help=\"Email addresses for alerts [default: none]\")\n\n args = parser.parse_args()\n set_up_logging(args)\n\n # --dry_run implies read_only\n args.read_only = args.read_only or args.dry_run\n\n main_driver(args)"},"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 main():\n\n from scrapy.crawler import CrawlerProcess\n from scrapy.utils.project import get_project_settings\n\n process = CrawlerProcess(get_project_settings())\n process.crawl(NCBIGeoSpider)\n process.start()","def main():\n # get input params\n args = parm_parser.get_args()\n # init log config\n log.init_log('./log/mini_spider')\n if args:\n # read config file spider.conf\n conf_params = parm_parser.set_config_by_file(args.conf)\n # use config set up spider initial params\n spider = SpiderWorker(conf_params)\n # init result_path, make it complete\n spider.set_path()\n # init url queue\n spider.set_url_queue()\n # start to crawl url\n spider.start_crawl_work()\n\n return","def main():\n\n # add custom commandline args (if we dont have any we can pass None instead of parser to do_main_commandline_startup()).\n import argparse\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-t\", \"--querytests\", help=\"run some test queries\", action=\"store_true\", default=False)\n\n # Create a site manager and ask it to instantiate a site of the class we specify, and handle some generic commandline options\n # it returns parsed commandline args so we can look for any custom ones\n (args, sitemanager) = MewloSiteManager.do_main_commandline_startup(MewloSite_Test1, parser)\n\n # on successful creation, we can parse and do some stuff\n if (sitemanager != None):\n # sitemanager was created and early commandline processing done\n # now we have some custom commandline arg proessing we might want to do\n if (sitemanager.is_readytoserve()):\n # this stuff only is entertained if sitemanager says all green lights\n if (args.querytests):\n # simulate some simple simulated query requests\n print \"Running query tests.\"\n print sitemanager.test_submit_path('/')\n print sitemanager.test_submit_path('/help/about')\n print sitemanager.test_submit_path('/page/mystery')\n print sitemanager.test_submit_path('/test/hello/name/jesse/age/44')\n\n # now any late generic commandline stuff (including serving the website)\n sitemanager.do_main_commandline_late()","def main():\n # 日志保存到./log/spider.log和./log/spider.log.wf，按天切割，保留7天\n log.init_log(\"./log/spider\")\n spider = SpiderEngine.SpiderEngine()\n try:\n opts, args = getopt.getopt(sys.argv[1:], \"vhc:\")\n except getopt.GetoptError as err:\n logging.error(\"get option error : %s.\" % err)\n return\n for o, a in opts:\n if o == \"-v\":\n version()\n return\n elif o == \"-h\":\n # spider_engine = _SpiderEngine._SpiderEngine()\n # spider_engine.config_tostring()\n # spider_engine.set_config()\n print \"帮助信息：没有帮助^_^\"\n return\n else:\n logging.error(\"unhandled option\")\n print \"unhandled option\"\n return\n spider.start_work()\n return","def main():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"layout_path\", help=\"relative path to the directory \"\n \"containing .rst files with site content and jinja \"\n \"templates that define the site structure\")\n parser.add_argument(\"output_path\", help=\"relative path to the output \"\n \"directory\")\n arguments = parser.parse_args()\n\n generate_site(arguments.layout_path, arguments.output_path)","def main():\n driver = Driver()\n driver.start()","def main():\n download_insert_title_basics()\n download_insert_title_principals()\n download_insert_name_basics()\n download_insert_title_ratings()\n scrap_keywords()\n create_and_insert_soup()\n return","def main(args):\n parser = create_parser()\n\n if not args:\n parser.print_usage()\n sys.exit(1)\n\n parsed_args = parser.parse_args(args)\n scrape_url(parsed_args.url)","def main(args):\r\n logger.info(\"Starting site generation...\")\r\n logger.info(args)\r\n logger.info(\"Opening syllabus.yml...\")\r\n\r\n## PUT THIS BACK LATER!!!!!####\r\n\r\n with open(\"/home/tofts/git/upskilling/data/syllabus.yml\", \"r\") as syllabus_file:\r\n syllabus = yaml.safe_load(syllabus_file)\r\n\r\n logger.info(\"Found the following modules:\")\r\n for module in syllabus['modules']:\r\n logger.info(f\"...{syllabus['modules'][module]['name']}\")\r\n\r\n logger.info(\"Opening squad.yml...\")\r\n with open(\"/home/tofts/git/upskilling/data/squad.yml\", \"r\") as squad_file:\r\n squad = yaml.safe_load(squad_file)\r\n\r\n for member in squad['members']:\r\n logger.info(f\"Found member {member.upper()}\")\r\n logger.info(f\"...{squad['members'][member]}\")\r\n\r\n logger.info(\"Processing index.html template...\")\r\n with open(\"/home/tofts/git/upskilling/templates/index.html\") as index_template_file:\r\n index_template = index_template_file.read()\r\n\r\n index_template = module_list(index_template, syllabus, squad)\r\n index_template = task_list(index_template, syllabus, squad)\r\n index_template = member_progress_list(index_template, syllabus, squad)\r\n\r\n logger.info(\"Writing completed template out...\")\r\n with open(\"/home/tofts/git/upskilling/docs/index.html\", \"w\") as index_output_file:\r\n index_output_file.write(index_template)\r\n\r\n logger.info(\"Generating member pages...\")\r\n with open(\"/home/tofts/git/upskilling/templates/member-page.html\", \"r\") as member_template_file:\r\n member_page_template = member_template_file.read()\r\n generate_member_pages(member_page_template, syllabus, squad)\r\n\r\n logger.info(\"Generating task detail pages...\")\r\n with open(\"/home/tofts/git/upskilling/templates/task-details.html\", \"r\") as task_details_file:\r\n task_details_template = task_details_file.read()\r\n generate_task_details_pages(task_details_template, syllabus, squad)\r\n\r\n logger.info(\"Generating downloads...\")\r\n generate_downloads(syllabus, squad)","def main():\n parser = argparse.ArgumentParser(description=\"\"\"Tester for YT Data API and different inputs\"\"\")\n parser.add_argument('-a', '--analytics', help='Performs a basic analytics lookup for the user\\'s channel entered')\n parser.add_argument('-c', '--comments', help='Performs a lookup of comments for the video id entered')\n args = parser.parse_args()\n\n if args.analytics:\n analytics = args.analytics\n analyt(analytics)\n\n if args.comments:\n comments = args.comments\n get_comments(comments)","def main():\n args = parseCommandLineArguments()\n\n\n chemkin1 = args.chemkin1[0]\n speciesDict1 = args.speciesDict1[0]\n if args.thermo1: \n thermo1 = args.thermo1[0]\n else:\n thermo1 = None\n chemkin2 = args.chemkin2[0]\n speciesDict2 = args.speciesDict2[0]\n if args.thermo2: \n thermo2 = args.thermo2[0]\n else:\n thermo2 = None\n\n kwargs = {\n 'web': args.web,\n 'wd': os.getcwd()\n }\n\n execute(chemkin1, speciesDict1, thermo1, chemkin2, speciesDict2, thermo2, **kwargs)","def main():\n logger.info(\"Running main function...\")\n args = get_args()\n # rose suite default location\n if args.suite_dir:\n default_suite = args.suite_dir\n rose_config_template = os.path.join(default_suite, \"rose-suite.conf\")\n\n # get command line arguments\n recipe_files = args.recipe_files\n config_file = args.config_file\n main_dir = args.main_dir\n log_level = args.log_level\n\n # setup rose suite\n run_rose = _setup_work(rose_config_template, recipe_files,\n config_file, main_dir, default_suite, log_level)\n\n # submit to cylc\n if not args.no_submit:\n _run_suite(run_rose)","def main(self, **kwargs) -> None:\n ...","def main(call_args):\n\n args = parse_args(call_args)\n init_logging(args.loglevel)\n\n _log.info(\"'scrape-jobs' called with args: %s\", args)\n runner.run_with_config_file(args.site, args.config_file)","def main():\n parg = argparse.ArgumentParser(\n description=\"Crawl a website and check for broken links.\",\n epilog=\"A broken links report will be output to stdout, so you may like to redirect this to a file.\",\n )\n parg.add_argument(\n \"URL\", help=\"The URL of the website to crawl, e.g. https://example.com\"\n )\n parg.add_argument(\"--config\", \"-c\", help=\"Path to a configuration file\")\n args = parg.parse_args()\n\n # If a configuration file path was provided, ensure we can find it\n if args.config and not path.exists(args.config):\n print(f\"Can't find {args.config} as config file.\")\n sys.exit(1)\n\n # Ensure we have a valid URL to crawl\n url = args.URL\n check_url = parse.urlparse(url)\n if check_url.scheme == \"\" or check_url.netloc == \"\":\n print(\"Please provide a valid URL with scheme, e.g. https://example.com\")\n sys.exit(1)\n\n # Configure and run Hydra\n first_url = {\"parent\": url, \"url\": url}\n config_file = \"\" # Uses default settings if no configuration file provided\n if args.config:\n config_file = args.config\n config = Config(config_file)\n check = Checker(url, config)\n check.TO_PROCESS.put(first_url)\n check.run()\n print(check.make_report())\n\n if check.broken and not check.config.graceful_exit:\n sys.exit(1)","def main():\n if len(sys.argv) >= 2:\n crawler = EmailCrawler(sys.argv[1])\n if len(sys.argv) >= 3 and sys.argv[2].isdigit():\n crawler.num_pages_limit = int(sys.argv[2])\n\n print(\"Beginning crawl with a limit of \" + str(crawler.num_pages_limit) + \" pages...\\n\")\n crawler.find()\n crawler.print_emails()\n else:\n print(\"Error: Please enter a domain to search on and an optional page limit (default=50).\")\n print(\"Example: `python find_email_addresses.py jana.com 30`\")\n sys.exit(1)","def Main(base_dir, page_set_filenames):\n runner = PageTestRunner()\n sys.exit(runner.Run(base_dir, page_set_filenames))","def main():\n args = parse_args()\n process_args(args)","def main():\r\n if len(sys.argv) == 1:\r\n wizard_mode()\r\n else:\r\n web_site_mode()","def main():\n from clize import run\n\n run(\n cases, webserver,\n description=DESCRIPTION, footnotes=FOOTNOTES)","def Main(parsed_args):\n logging.basicConfig(\n format='[[%(filename)s %(funcName)s]] - %(message)s',\n level=(logging.ERROR if os.environ.get('CI') else logging.INFO))\n EnsureNodeJsIsInstalled()\n CheckPrereqs()\n InstallNodeDependencies()\n SetupOutDir(out_dir='dist')\n GenValidatorProtoascii(out_dir='dist')\n GenValidatorPb2Py(out_dir='dist')\n GenValidatorProtoGeneratedJs(out_dir='dist')\n GenValidatorGeneratedJs(out_dir='dist')\n CompileValidatorMinified(out_dir='dist')\n RunSmokeTest(out_dir='dist')\n RunIndexTest()\n CompileValidatorTestMinified(out_dir='dist')\n CompileHtmlparserTestMinified(out_dir='dist')\n CompileParseCssTestMinified(out_dir='dist')\n CompileParseUrlTestMinified(out_dir='dist')\n CompileAmp4AdsParseCssTestMinified(out_dir='dist')\n CompileKeyframesParseCssTestMinified(out_dir='dist')\n CompileParseSrcsetTestMinified(out_dir='dist')\n GenerateTestRunner(out_dir='dist')\n RunTests(update_tests=parsed_args.update_tests, out_dir='dist')","def _runner(self, classpath, main, jvm_options, args):","def main(*args):\n options = {}\n # Process global arguments to determine desired site\n local_args = pywikibot.handle_args(args)\n\n # This factory is responsible for processing command line arguments\n # that are also used by other scripts and that determine on which pages to work on.\n genFactory = pagegenerators.GeneratorFactory()\n\n for arg in local_args:\n\n # Catch the pagegenerators options\n if genFactory.handleArg(arg):\n continue # nothing to do here\n\n # Now pick up your own options\n arg, sep, value = arg.partition(':')\n option = arg[1:]\n if option in ('summary', 'page'):\n if not value:\n pywikibot.input('Please enter a value for ' + arg)\n options[option] = value\n # take the remaining options as booleans.\n # You will get a hint if they aren't pre-definded in your bot class\n else:\n options[option] = True\n\n\n\n # The preloading option is responsible for downloading multiple pages from the wiki simultaneously.\n gen = genFactory.getCombinedGenerator(preload=True)\n if gen:\n # pass generator and private options to the bot\n bot = CopyLinksBot(gen, **options)\n bot.run() # guess what it does\n return True\n else:\n pywikibot.bot.suggest_help(missing_generator=True)\n return False","def main():\n parser = optparse.OptionParser(usage='%prog [options]', version=\"0.0.1\")\n parser.add_option('--settings', \\\n help='Python path to settings module. If this isn\\'t provided, the DJANGO_SETTINGS_MODULE enviroment variable will be used.')\n\n parser.add_option('-v', '--verbose', action='store_true', dest='verbose', \\\n default=False, help='Verbose output.')\n options = parser.parse_args()[0]\n if options.settings:\n os.environ[\"DJANGO_SETTINGS_MODULE\"] = options.settings\n else:\n os.environ[\"DJANGO_SETTINGS_MODULE\"] = \"settings\"\n\n probe_all()","def main():\r\n args = getargs()\r\n dir_name = args.dir_name\r\n url = args.url\r\n fetch_junit(dir_name, url)","def main(*arguments):\n\n args = parse_args(arguments)\n\n if args.test_suite is not None:\n test_suite = report_manager.load_test_suite_conf(args.test_suite)\n for i, test in enumerate(test_suite):\n args = parse_args(test)\n process_args_and_run(args, test_suite_iter=i)\n else:\n process_args_and_run(args)","def main(aArgs, aTransmitToTaskHandler):\n\n global TASK_HANDLER_HOST\n global TASK_HANDLER_PORT\n\n # if the option --printList is passed, only generate the file\n # reftestList.txt\n if hasattr(aArgs, \"printList\"):\n printReftestList()\n exit(0)\n\n # if the option --printNotes is passed, only generate the\n # testsuiteNotes html page.\n if hasattr(aArgs, \"printNotes\"):\n printNotes()\n exit(0)\n\n # if the option --printListOfTests is passed, only generate a ListOfTests\n # from a file containing test URIs\n if hasattr(aArgs, \"printListOfTests\"):\n if not aArgs.printListOfTests:\n print(\"No input file!\", file=sys.stderr)\n exit(0)\n printListOfTests(aArgs.printListOfTests)\n exit(0)\n\n # create the date directory\n now = datetime.utcnow();\n directory = MATHJAX_WEB_PATH + \"results/\"\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # create the subdirectory\n if aArgs.output and re.match(\"^([0-9]|[a-z]|[A-Z]|-|/){1,50}/$\",\n aArgs.output):\n directory += aArgs.output\n else:\n directory += now.strftime(\"%Y-%m-%d/%H-%M-%S/\")\n\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # execute testing instances for all the config files\n configFileList = aArgs.config.split(\",\")\n\n for configFile in configFileList:\n\n configFile = configFile\n\n if (not os.path.isfile(configFile)):\n print(\"Warning: config file \" + configFile + \" not found!\",\n file=sys.stderr)\n continue\n\n # Load configuration file\n config = ConfigParser.ConfigParser()\n config.readfp(open(configFile))\n\n # framework section\n section = \"framework\"\n useGrid = getBooleanOption(config, section, \"useGrid\")\n host = config.get(section, \"host\")\n # host == \"default\" is handled below\n port = config.getint(section, \"port\")\n if (port == -1):\n port = SELENIUM_SERVER_PORT\n mathJaxPath = config.get(section, \"mathJaxPath\")\n if (mathJaxPath == \"default\"):\n mathJaxPath = DEFAULT_MATHJAX_PATH\n mathJaxTestPath = config.get(section, \"mathJaxTestPath\")\n if (mathJaxTestPath == \"default\"):\n mathJaxTestPath = MATHJAX_TEST_LOCAL_URI + \"testsuite/\"\n timeOut = config.getint(section, \"timeOut\")\n if (timeOut == -1):\n timeOut = DEFAULT_TIMEOUT\n timeOut = timeOut * 1000 # convert in ms\n useWebDriver = getBooleanOption(config, section, \"useWebDriver\")\n fullScreenMode = getBooleanOption(config, section, \"fullScreenMode\")\n formatOutput = getBooleanOption(config, section, \"formatOutput\")\n compressOutput = getBooleanOption(config, section, \"compressOutput\")\n\n # platform section\n section = \"platform\"\n operatingSystem = config.get(section, \"operatingSystem\")\n if (operatingSystem == \"default\"):\n operatingSystem = OS_LIST[0]\n if (host == \"default\"):\n host = HOST_LIST[HOST_LIST_OS.index(OS_LIST.index(operatingSystem))]\n browserList = config.get(section, \"browser\").split()\n browserVersionList = config.get(section, \"browserVersion\").split()\n browserModeList = config.get(section, \"browserMode\").split()\n browserPath = config.get(section, \"browserPath\")\n fontList = config.get(section, \"font\").split()\n outputJaxList = config.get(section, \"outputJax\").split()\n \n # testsuite section\n section = \"testsuite\"\n runSlowTests = getBooleanOption(config, section, \"runSlowTests\")\n runSkipTests = getBooleanOption(config, section, \"runSkipTests\")\n listOfTests = config.get(section, \"listOfTests\")\n startID = config.get(section, \"startID\")\n if (startID == \"default\"):\n startID = \"\"\n \n # When more than one browser is specified, browserPath is ignored.\n if (len(browserList) > 1 and browserPath != \"default\"):\n print(\"Warning: browserPath ignored\", file=sys.stderr)\n browserPath = \"default\"\n\n for browser in browserList:\n\n if (browser == \"default\"):\n browser = BROWSER_LIST[0]\n\n for font in fontList:\n\n if (font == \"default\"):\n font = FONT_LIST[0]\n\n for outputJax in outputJaxList:\n\n if (outputJax == \"default\"):\n outputJax = OUTPUT_JAX_LIST[0]\n\n for browserVersion in browserVersionList:\n\n # browserModeList is only relevant for MSIE\n if not(browser == \"MSIE\"):\n browserModeList2 = [\"default\"]\n else:\n browserModeList2 = browserModeList\n \n for browserMode in browserModeList2:\n \n # Create a Selenium instance\n selenium = \\\n seleniumMathJax.seleniumMathJax(useWebDriver,\n useGrid,\n host,\n port,\n mathJaxPath,\n mathJaxTestPath,\n operatingSystem,\n browser,\n browserVersion,\n browserMode,\n browserPath,\n font,\n outputJax,\n timeOut,\n fullScreenMode)\n \n if aTransmitToTaskHandler:\n taskHandler = [TASK_HANDLER_HOST,\n TASK_HANDLER_PORT,\n str(os.getpid())]\n else:\n taskHandler = None\n\n # Create the test suite\n suite = reftest.reftestSuite(taskHandler,\n runSlowTests,\n runSkipTests,\n listOfTests,\n startID)\n # use the specified file name\n if hasattr(aArgs, \"filename\"):\n filename = aArgs.filename\n else:\n filename = getOutputFileName(directory,\n selenium,\n suite)\n runTestingInstance(directory, selenium, suite,\n formatOutput, compressOutput,\n filename)\n # end browserMode\n # end browserVersion\n #end outputJax\n # end for font\n # end browser","def main():\n\n # Chdir into script directory so to properly resolve relative paths in configuration\n os.chdir(os.path.dirname(os.path.realpath(__file__)) + \"/\")\n\n # Disable proxy as we access localhost, both to avoid overhead and issues with proxy misconfiguration\n os.environ['NO_PROXY'] = '*'\n\n # Stop any GraphDB server that we previously started and is possibly still around due to script interruption/crash\n shell(f\"{cmd_graphdb} stopall\")\n\n # Generate synthetic traces, both for populating the repositories and for the {sf, sp, pf, pp} tests\n prepare_traces()\n \n # Generate central repositories (if needed)\n for size, approach in itertools.product(sizes, approaches):\n prepare_repository(size, approach)\n \n # Run experiments (if needed)\n for size, approach in itertools.product(sizes, approaches):\n run_experiments(size, approach)","def main():\n parser = argparse.ArgumentParser(description='Creates a Mist site within your organization')\n parser.add_argument('config', metavar='config_file', type=argparse.FileType(\n 'r'), help='file containing all the configuration information')\n args = parser.parse_args()\n configs = json.load(args.config)\n\n claim_ap(configs)","def run_main():\n main(sys.argv)","def main(argv):\n\n output_filename = ''\n input_filename = ''\n langCode = 'en'\n language = False\n\n # add support for default (en) language\n language = gettext.translation(\n 'webperf-core', localedir='locales', languages=[langCode])\n language.install()\n _ = language.gettext\n\n try:\n opts, args = getopt.getopt(\n argv, \"hi:o:\", [\"help\", \"input=\", \"output=\"])\n except getopt.GetoptError:\n print(main.__doc__)\n sys.exit(2)\n\n if (opts.__len__() == 0):\n print(main.__doc__)\n sys.exit(2)\n\n for opt, arg in opts:\n if opt in ('-h', '--help'): # help\n print(main.__doc__)\n sys.exit(2)\n elif opt in (\"-i\", \"--input\"): # input file path\n input_filename = arg\n\n file_ending = \"\"\n file_long_ending = \"\"\n if (len(input_filename) > 4):\n file_ending = input_filename[-4:].lower()\n if (len(input_filename) > 7):\n file_long_ending = input_filename[-7:].lower()\n\n if file_long_ending == \".sqlite\":\n from engines.sqlite import read_sites, add_site, delete_site\n elif (file_ending == \".csv\"):\n from engines.csv import read_sites, add_site, delete_site\n elif (file_ending == \".xml\"): # https://example.com/sitemap.xml\n from engines.sitemap import read_sites, add_site, delete_site\n else:\n from engines.json import read_tests, read_sites, add_site, delete_site\n pass\n elif opt in (\"-o\", \"--output\"): # output file path\n output_filename = arg\n pass\n\n tests = read_tests(input_filename, 0, -1)\n generated_date = False\n co2s = list()\n\n for test in tests:\n if not generated_date:\n generated_date = datetime.fromisoformat(\n test[FIELD_INDEX_DATE]).strftime('%Y-%m-%d')\n\n str_data = test[FIELD_INDEX_DATA].replace('\\'', '\"')\n data = json.loads(str_data)\n print(str_data)\n co2s.append(data['co2'])\n\n if not generated_date:\n generated_date = datetime.today().strftime('%Y-%m-%d')\n\n output_content = \"# This array was last generated with carbon-rating.py on {0}\\n\".format(\n generated_date)\n output_content += \"def get_generated_date():\\n\"\n output_content += \"\\treturn '{0}'\\n\".format(\n generated_date)\n output_content += \"\\n\"\n output_content += \"def get_percentiles():\\n\"\n output_content += \"\\treturn [\\n\"\n\n co2s_sorted = sorted(co2s)\n\n intervals = list()\n\n index = 1\n while (index <= 100):\n percentile = getPercentile(co2s_sorted, index)\n intervals.append(percentile)\n position = index - 1\n if index < 100:\n if position % 10 == 0 and position != 0:\n output_content += \"\\t\\t# {0} percentile\\n\".format(position)\n\n output_content += \"\\t\\t{0},\\n\".format(percentile)\n else:\n output_content += \"\\t\\t{0}\\n\".format(percentile)\n index += 1\n\n output_content += \"\\t]\"\n\n print(output_content)\n if (len(output_filename) > 0):\n write(output_filename, output_content)","def main():\r\n args = getargs()\r\n testng_file = args.testng_file\r\n url = args.url\r\n fetch_testng(testng_file, url)","def main(args):","def main(args):","def main(*args):\n local_args = pywikibot.handle_args(args)\n\n # This factory is responsible for processing command line arguments\n # that are also used by other scripts and that determine on which pages\n # to work on.\n gen_factory = pagegenerators.GeneratorFactory()\n # The program to pipe stuff through\n filters = []\n options = {}\n\n # Parse command line arguments\n for arg in local_args:\n option, sep, value = arg.partition(':')\n if option == '-filter':\n filters.append(value)\n elif option == '-always':\n options['always'] = True\n else:\n # check if a standard argument like\n # -start:XYZ or -ref:Asdf was given.\n gen_factory.handleArg(arg)\n\n options['filters'] = filters\n\n gen = gen_factory.getCombinedGenerator(preload=True)\n if gen:\n # The preloading generator is responsible for downloading multiple\n # pages from the wiki simultaneously.\n bot = PiperBot(gen, **options)\n bot.run()\n return True\n else:\n pywikibot.bot.suggest_help(missing_generator=True)\n return False","def main(self):\n self.parse_option()\n self.set_option()\n\n r = Bootscripts()\n reactor.listenTCP(8009, server.Site(r))\n reactor.run()","def main(ctx, qa_dir, no_editor, report_dir, vcs, debug, main_branch):\n __main_imp__(ctx, qa_dir, no_editor, report_dir, vcs, debug, main_branch)","def main(arguments):\n auth = (arguments['username'], arguments['token'])\n data_collector = DataCollector(arguments['repo name'],\n arguments['start date'],\n arguments['end date'], auth,\n arguments['all'], arguments['page'])\n data_collector.collect_signals()","def main() -> None:\r\n # pylint: disable=W0601\r\n global ARGS, BROWSERS\r\n BROWSERS = {'chrome': Chrome, 'firefox': Firefox, 'ie': Ie,\r\n 'safari': Safari, 'opera': Opera, 'edge': Edge}\r\n # pylint: disable=C0103\r\n PARSER = argparse.ArgumentParser()\r\n PARSER.add_argument('-m', '--modules', help='Which modules to test. One or more of '\r\n '[%(choices)s]. Default is all.', nargs='+', type=str,\r\n choices=MODULES.keys(), metavar='', default=list(MODULES.keys()))\r\n PARSER.add_argument('-l', '--locales', help='Which locales to test. One or more of '\r\n '[%(choices)s]. Default is all.', nargs='+', type=str,\r\n choices=LANGS.keys(), metavar='', default=list(LANGS.keys()))\r\n PARSER.add_argument('-b', '--browsers', help='Which browser to use. One or more of '\r\n '[%(choices)s]. Default is %(default)s', nargs='+', default=['chrome'],\r\n choices=BROWSERS.keys(), metavar='')\r\n PARSER.add_argument('-w', '--wait', help='Wait this many seconds before deciding an element is '\r\n 'missing. Default is %(default)s', default=[20], type=int, nargs=1)\r\n ARGS = PARSER.parse_args()\r\n parseargs()\r\n os.makedirs(SCREENSHOT_DIR, exist_ok=True)\r\n\r\n try:\r\n full_languages_modules_run(modfilter=ARGS.modules,\r\n langfilter=ARGS.locales, brows=ARGS.browsers)\r\n except Exception: # Too general is the point, it's a Final Action. pylint: disable=W0703\r\n with open(RESULTS_FILE, mode='a', encoding='UTF-8') as log:\r\n log.write('\\n\"Well, something went wrong. A manual exit, hopefully:\"\\n\\n' + tidy_error())\r\n raise","def main(args):\n\n if 'log' in args and args['log'] is not None:\n logging.basicConfig(level=LOGGING_LEVELS.get(args['log'].lower(), logging.NOTSET))\n\n test_structure = read_test_file(args['test'])\n tests = build_testsets(args['url'], test_structure)\n\n # Override configs from command line if config set\n for t in tests:\n if 'print_bodies' in args and args['print_bodies'] is not None:\n t.config.print_bodies = safe_to_bool(args['print_bodies'])\n\n if 'interactive' in args and args['interactive'] is not None:\n t.config.interactive = safe_to_bool(args['interactive'])\n\n # Execute all testsets\n failures = execute_testsets(tests)\n\n sys.exit(failures)","def run_crawl(self, args):\n\n # Crawler process declaration\n process = CrawlerProcess({\n 'USER_AGENT': 'David Avs Crawler',\n 'FEED_FORMAT': 'json',\n 'FEED_URI': 'stdout:',\n 'LOG_ENABLED': args.verbose,\n })\n kwargs = dict(\n start_urls=[args.url],\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\n )\n\n # Run crawling\n old_stdout = sys.stdout\n sys.stdout = args.file\n try:\n process.crawl(DavidAvsSpider, **kwargs)\n process.start()\n finally:\n sys.stdout = old_stdout","def main():\n # Step1: generate htmls\n csv_data_path= \"./frontend/html_template_data/dataset.csv\"\n html_template_path = \"./frontend/html_template_data/template.html\"\n html_save_path = \"./frontend/html_files/\"\n\n generate_htmls(csv_data_path, html_template_path, html_save_path)\n\n # Step2: push htmls to Github\n # push htmls to Github Pages, currently manual.","def _main():\n import argparse\n parser = argparse.ArgumentParser(description=__doc__)\n group = parser.add_mutually_exclusive_group(required=True)\n group.add_argument('--author', help='download works by this author')\n parser.add_argument('-v', '--verbose', action='count', default=0,\n help='increase logging verbosity')\n args = parser.parse_args()\n logging.basicConfig(level=logging.WARNING - 10 * args.verbose)\n\n download_texts(author=args.author)","def scrape_main() -> None:\n\n logger.info(\"Starting scrape\")\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\n links = run_scrape(\n url=search_info['url'],\n seasons_regex=search_info['seasons'],\n episodes_regex=search_info['episodes']\n )\n if links:\n logger.debug(\"Writing urls to file\")\n with open('urls.txt', 'w') as f:\n for link in links:\n f.write(link + '\\n')\n else:\n logger.warning(\"No links available\")","def main(*args, **kwargs):\n src_mgr = SourceDriverManager()\n fs_mgr = FileSystemManager()","def main():\n configuration = {'resource-folder': 'resources',\n 'build-folder': 'build',\n 'log-folder': 'logfiles',\n 'use-preloaded': False,\n 'addi-metrics': 'addi-metrics.json',\n 'jenkins': {'dependency-filename': 'dependencies.txt',\n 'server': 'http://is.dbc.dk',\n 'repository-project': 'opensearch-3rd-party-dependencies'},\n 'log-zip-file':'logs.zip'}\n configuration.update(cli())\n setup_logger(configuration['verbose'])\n run_performance_test(configuration)","def main():\n\n parser = argparse.ArgumentParser(description='Newsgroup post classifier')\n parser.add_argument('--data_dir',\n type=str,\n help=\"Data directory\")\n\n args = parser.parse_args()\n data_dir = args.data_dir\n\n example(data_dir=data_dir)","def main(state=None, overwrite=False):\n \n # Initialize process\n process = initialize_process()\n\n if overwrite:\n # TODO: delete all (and only) files to be regenerated\n pass\n\n # Add a spider instance for each state to be run\n if state:\n add_state_to_process(state, process=process)\n else:\n for s in list(CONFIG.keys()):\n add_state_to_process(s, process=process)\n\n # Run scrape\n process.start()","def test(self, cmdline):\n\n if tm.UPDATE_BEFORE_TEST:\n print \"Updating directory of source ...\"\n mu.update_dir(tm.SOURCE_DIR)\n\n args = mu.get_second_arg(cmdline).strip().split()\n if len(args) == 0:\n print \"Invalid command, test [sourcename] ([maxThread] ([pageLimit]))\"\n return\n elif len(args) == 1:\n self.sourcename, = args\n self.max_thread = '5'\n self.page_limit = '2'\n elif len(args) == 2:\n self.sourcename, self.max_thread = args\n self.page_limit = '2'\n elif len(args) == 3:\n self.sourcename, self.max_thread, self.page_limit = args\n\n print \"Searching directory of %s ...\" % self.sourcename\n self.sourcedir = mu.search_for_source(self.sourcename)\n if not self.sourcedir:\n print \"Directory of %s doesn't exist.\\n\" % self.sourcename\n return\n\n self.sourcetype = self.get_source_type()\n if self.sourcetype == 'blog':\n process = BlogProcess(self.sourcename, self.sourcedir)\n config_files = ('%s.xq' % self.sourcename, 'config.xml', 'globalConfig.xml', 'subSourceConfig.xml')\n elif self.sourcetype == 'forum':\n process = ForumProcess(self.sourcename, self.sourcedir, string.atoi(self.max_thread), self.page_limit)\n config_files = ('%s-url.xq' % self.sourcename, '%s-thread.xq' % self.sourcename, 'finished.xml', 'webForumConfiguration.xml')\n self.test_source(process, self.sourcedir, config_files)","def main():\n\n parser = argparse.ArgumentParser('Download all data into a folder')\n parser.add_argument('--homepage_url', help='url for adap-kdb homepage', required=True)\n parser.add_argument('--msp_path', help='path for msv file', required=True)\n parser.add_argument('--user_name', help='username for login', required=True)\n parser.add_argument('--user_password', help='user password fpr login', required=True)\n args = parser.parse_args()\n\n homepage_url = args.homepage_url\n msp_path = args.msp_path\n user_name = args.user_name\n user_password = args.user_password\n\n individual_search_test(homepage_url, msp_path, user_name, user_password)","def main() -> None:\n parser = argparse.ArgumentParser()\n parser.add_argument('-c', '--configfile',\n default=os.path.join(os.getcwd(), 'downloader.toml'),\n help=\"Configuration file to load settings from (default: %(default)s).\")\n parser.add_argument('-n', '--name',\n default=platform.node(),\n help=\"Host-specific name of the downloader (default: %(default)s).\")\n parser.add_argument('-p', '--print-config',\n action=\"store_true\", default=False,\n help=\"Print the configuration and exit.\")\n args = parser.parse_args()\n\n conf = Config.from_configfile(args.name, args.configfile)\n\n if args.print_config:\n print(conf)\n sys.exit(0)\n\n logging.basicConfig(format='%(levelname)-7s %(asctime)s %(message)s',\n level=logging.INFO, datefmt=\"%Y-%m-%d %H:%M:%S\")\n\n run(conf)","def main(args=sys.argv):\n try:\n # Set up logging.\n logging.basicConfig(level=logging.WARN)\n work_dir = args[1]\n assert os.path.exists(work_dir), \"First argument to lsf_runner.py must be a directory that exists\"\n do_work_on_compute_node(work_dir)\n except Exception as exc:\n # Dump encoded data that we will try to fetch using mechanize\n print(exc)\n raise","def main(args=None):","def main(args=None):","def cmd_runner():\n parser = argparse.ArgumentParser(description=\"Get news from extracted sources\")\n parser.add_argument('-s', '--source', help=\"Name of the news source. Available options are: {}\"\n .format(', '.join(\n available_rss_feed_sources_user_prompt\n )\n ))\n parser.add_argument('-t', '--top', help=\"Count of news items to show from top order. Default: 10\")\n parser.add_argument('-v', '--version', action='version', version='%(prog)s {version}'.format(version=__version__))\n\n args = parser.parse_args()\n \n rss_feed_top_count = RSS_FEED_TOP_COUNT\n if args.top:\n if not args.top.isnumeric():\n raise argparse.ArgumentTypeError('Provide a positive integer for --top argument')\n \n else:\n rss_feed_top_count = int(args.top)\n\n if args.source:\n source_name = args.source.lower()\n print('Source argument found, validating...')\n time.sleep(1)\n source_name_is_valid = source_name in available_rss_feed_sources\n \n if not source_name_is_valid:\n print(\n 'Invalid input {0} for source. Available sources are {1} '\n .format(source_name, ', '.join(available_rss_feed_sources_user_prompt)))\n sys.exit()\n \n \n rss_feed_details = {\n 'rss_feed_url': '',\n 'top': rss_feed_top_count,\n 'source': source_name\n }\n rss_feed_url = rss_data_main._get_rss_feed_url_by_source(source_name)\n if not rss_feed_url:\n raise ValueError('RSS url not found for source {}'.format(source_name))\n \n rss_feed_details['rss_feed_url'] = rss_feed_url\n\n \n rss_feed_details['top'] = rss_feed_top_count\n \n print('Getting news...\\n\\n')\n time.sleep(1)\n \n feed_data = rss_feed_main._get(rss_feed_details)\n feed_viewer(feed_data)\n else:\n print('--source argument not provided, getting data for all available sources...')\n rss_feed_details_list = []\n for source_name in available_rss_feed_sources:\n rss_feed_details = {\n 'rss_feed_url': '',\n 'source': source_name,\n 'top': rss_feed_top_count\n }\n rss_feed_url = rss_data_main._get_rss_feed_url_by_source(source_name)\n if not rss_feed_url:\n raise ValueError('RSS url not found for source {}'.format(source_name))\n \n rss_feed_details['rss_feed_url'] = rss_feed_url\n rss_feed_details_list.append(rss_feed_details)\n \n with Pool(AVIALABLE_CPU_COUNT) as p:\n feed_data_list = p.map(rss_feed_main._get, rss_feed_details_list) \n # put list of lists in a single list\n feed_data_flattened_list = []\n for feed_data in feed_data_list:\n feed_data_flattened_list.extend(feed_data) \n\n feed_viewer(feed_data_flattened_list)","def main(args):\n options = parse_cmd_parameters_(args)\n execute_(options)","def main(self):\n try:\n self.parse_args()\n self.run()\n return 0\n except AnalysisBackendError as e:\n L.error(e)\n return 1","def main_driver(args):\n starttime = time.time()\n\n # Get all the schedd ads\n schedd_ads = get_schedds(args)\n logging.warning(\"&&& There are %d schedds to query.\", len(schedd_ads))\n\n pool = multiprocessing.Pool(processes=args.query_pool_size)\n\n if not args.skip_history:\n htcondor_es.history.process_histories(schedd_ads=schedd_ads,\n starttime=starttime,\n pool=pool,\n args=args)\n\n # Now that we have the fresh history, process the queues themselves.\n if args.process_queue:\n htcondor_es.queues.process_queues(schedd_ads=schedd_ads,\n starttime=starttime,\n pool=pool,\n args=args)\n\n pool.close()\n pool.join()\n\n logging.warning(\"@@@ Total processing time: %.2f mins\", ((time.time()-starttime)/60.))\n\n return 0","def __main() :\n launchTests()","def main():\n with open(\"page_data.yaml\", 'r') as inputstr:\n config_data = yaml.safe_load(inputstr)\n ointf = OutputInterface('template.txt')\n table_data = get_song_artist_matches()\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\n title = 'Song Titles and Band Name Overlap'\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\n 'Date', 'Song']\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\n ointf.inject(XTRAEDIT)\n ointf.output()","def main(argv=sys.argv):\n log = _setup_logging()\n log.info(\"Starting {f} version {v} dataset manipulator\".format(\n f=__file__, v=__VERSION__))\n parser = get_parser()\n args = parser.parse_args()\n if args.debug:\n log.setLevel(logging.DEBUG)\n return args.func(args)\n #return main_runner_default(argv[1:], get_parser(), log)","def main(dummy_args=None):\n ap = argparse.ArgumentParser(\n description='Import test results to HP Quality Center.')\n\n # console or gui\n ap.add_argument('--console', '-c', action='store_true')\n\n # console options\n ap.add_argument('--url', '-u', help='the quality center url')\n ap.add_argument('--domain', '-d', help='the quality center domain')\n ap.add_argument('--project', '-p', help='the quality center project')\n ap.add_argument('--username', '-U', help='the quality center username')\n ap.add_argument('--password', '-P', help='the quality center password')\n ap.add_argument('--source', '-r', help='the path to the test results file')\n ap.add_argument('--destination', '-D',\n help=('the path to where the results will be uploaded to '\n 'in quality center'))\n ap.add_argument('--attach_report', '-a',\n help=('flag to zip and attach the test results folder to '\n 'the folder specified in the source argument'))\n ap.set_defaults(func=_handle_command)\n\n ap.parse_args().func(ap.parse_args())","def main():\n tester = Tester()\n # parse args, load configuration and create all required objects.\n tester.setup_experiment()\n # GO!\n tester.run_experiment()","def run_spiders():\n hour_limit = 3600 # in seconds\n\n settings = get_project_settings()\n\n # Uncomment the following block of code if you want to test the manager on\n # the \"onepagetest\" to make sure the manager is working.\n \"\"\"\n settings[\"HTTPCACHE_ENABLED\"] = 1\n settings[\"HTTPCACHE_EXPIRATION_SECS\"] = 0\n settings[\"HTTPCACHE_STORAGE\"] = \"scrapy.extensions.httpcache.FilesystemCacheStorage\"\n settings[\"HTTPCACHE_IGNORE_MISSING\"] = 1\n settings[\"HTTPCACHE_DIR\"] = \"onepagetest\"\n \"\"\"\n\n runner = CrawlerRunner(settings)\n begin_time = datetime.now()\n\n d = runner.crawl(\"sb_spider\")\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\n reactor.run()","def main():\n opt = parse_opts()\n run(opt)","def main():\n opt = parse_opts()\n run(opt)","def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.crawl(spiderClass)\n\tprocess.start() # the script will block here until the crawling is finished","def main(*args):\n commandline_arguments = list()\n template_title = u'Deux colonnes'\n\n # Process global args and prepare generator args parser\n local_args = pywikibot.handle_args(args)\n gen = pg.GeneratorFactory()\n\n param_debug = False\n param_first = None\n \n for arg in local_args:\n if arg == '-d':\n param_debug = True\n elif arg.startswith('-b'):\n param_first = arg[3:]\n else:\n commandline_arguments.append(arg)\n\n if not template_title:\n pywikibot.error('Please specify either -template or -transcludes argument')\n return\n\n if len(commandline_arguments) % 2:\n raise ValueError # or something.\n \n fields = dict()\n for i in range(0, len(commandline_arguments), 2): \n fields[commandline_arguments[i]] = commandline_arguments[i + 1]\n\n generator = gen.getCombinedGenerator()\n if not generator:\n gen.handleArg(u'-transcludes:' + template_title)\n generator = gen.getCombinedGenerator()\n\n bot = HarvestRobot(generator, template_title, fields, param_first, param_debug)\n bot.run()","def run_generic_spider( user_id\t\t\t\t= None,\n\t\t\t\t\t\tspider_id\t\t\t= None,\n\t\t\t\t\t\tdatamodel\t\t\t= None,\n\t\t\t\t\t\trun_spider_config\t= None,\n\t\t\t\t\t\ttest_limit\t\t\t= None\n\t\t\t\t\t\t):\n\n\tprint ()\n\tlog_scrap.info(\"--- run_generic_spider / spider_id : %s \", spider_id )\n\n\t### WARNING !!! --> TEMPORARY SOLUTION\n\t### remove spider folder for spider_id in JOBDIR\n\tlog_scrap.debug(u\"--- run_generic_spider / cwd : %s\", os.getcwd() )\n\ttry :\n\t\tshutil.rmtree( os.getcwd() + \"/\" + JOBDIR_FOLDER + \"/\" + spider_id )\n\texcept:\n\t\tpass\n\tlog_scrap.debug(u\"--- run_generic_spider / removed folder : {}/{}\".format(JOBDIR_FOLDER, spider_id) )\n\n\t# !!! spider is launched from main.py level !!!\n\t# all relative routes referring to this...\n\tlog_scrap.info(\"--- run_generic_spider / os.getcwd() : %s \", os.getcwd() )\n\n\t### flattening run_spider_config : from nested to flat dict\n\tlog_scrap.info(\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\" )\n\tspider_config_flat = flattenSpiderConfig( run_spider_config )\n\n\n\t### settings for crawler\n\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\n\n\t### global settings for scrapy processes (see upper)\n\tlog_scrap.info(\"--- run_generic_spider / BOT_NAME : %s \", settings.get('BOT_NAME') )\n\tlog_scrap.info(\"--- run_generic_spider / USER_AGENT : %s \", settings.get('USER_AGENT') )\n\tlog_scrap.info(\"--- run_generic_spider / ITEM_PIPELINES : %s \", settings.get('ITEM_PIPELINES').__dict__ )\n\n\n\t# specific settings for this scrapy process\n\n\t# settings.set( \"RETRY_TIMES\"\t\t\t\t\t\t, RETRY_TIMES )\n\t# settings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, CONCURRENT_ITEMS )\n\t# settings.set( \"CONCURRENT_REQUESTS\"\t\t\t\t, CONCURRENT_REQUESTS )\n\t# settings.set( \"CONCURRENT_REQUESTS_PER_DOMAIN\"\t, CONCURRENT_REQUESTS_PER_DOMAIN )\n\t# settings.set( \"REDIRECT_MAX_TIMES\"\t\t\t\t, REDIRECT_MAX_TIMES )\n\t# settings.set( \"DOWNLOAD_MAXSIZE\" \t\t\t\t, DOWNLOAD_MAXSIZE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, DEPTH_PRIORITY )\n\t# settings.set( \"SCHEDULER_DISK_QUEUE\"\t\t\t, SCHEDULER_DISK_QUEUE )\n\t# settings.set( \"DEPTH_PRIORITY\"\t\t\t\t\t, SCHEDULER_MEMORY_QUEUE )\n\n\t# settings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t\t, RANDOMIZE_DOWNLOAD_DELAY )\n\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\n\tsettings.set( \"JOBDIR\"\t\t\t\t\t\t\t, JOBDIR_FOLDER + \"/\" + spider_id )\n\n\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\n\n\tsettings.set( \"CURRENT_SPIDER_ID\" \t\t\t, spider_id )\n\tsettings.set( \"RETRY_TIMES\"\t\t\t\t\t\t\t, spider_config_flat[\"RETRY_TIMES\"] )\n\tsettings.set( \"CLOSESPIDER_ITEMCOUNT\"\t\t, spider_config_flat[\"LIMIT_ITEMS\"] )\n\t# settings.set( \"CLOSESPIDER_PAGECOUNT\"\t\t, spider_config_flat[\"LIMIT_PAGES\"] )\n\tsettings.set( \"DOWNLOAD_DELAY\" \t\t\t\t\t, spider_config_flat[\"download_delay\"] )\n\tsettings.set( \"CONCURRENT_ITEMS\"\t\t\t\t, spider_config_flat[\"CONCURRENT_ITEMS\"] )\n\tsettings.set( \"CONCURRENT_REQUESTS\"\t\t\t, spider_config_flat[\"CONCURRENT_REQUESTS\"] )\n\t# settings.set( \"DOWNLOAD_DELAY\" \t\t\t\t, DOWNLOAD_DELAY )\n\n\tsettings.set( \"BOT_NAME\"\t\t\t\t\t\t\t\t\t, spider_config_flat[\"BOT_NAME\"] )\n\tsettings.set( \"USER_AGENT\"\t\t\t\t\t\t\t\t, spider_config_flat[\"USER_AGENT\"] )\n\tsettings.set( \"ROBOTSTXT_OBEY\"\t\t\t\t\t\t, spider_config_flat[\"ROBOTSTXT_OBEY\"] )\n\tsettings.set( \"AUTOTHROTTLE_ENABLED\"\t\t\t, spider_config_flat[\"AUTOTHROTTLE_ENABLED\"] )\n\tsettings.set( \"HTTPCACHE_ENABLED\"\t\t\t\t\t, spider_config_flat[\"HTTPCACHE_ENABLED\"] )\n\tsettings.set( \"RANDOMIZE_DOWNLOAD_DELAY\"\t, spider_config_flat[\"RANDOMIZE_DOWNLOAD_DELAY\"] )\n\n\t### initiating crawler process\n\tlog_scrap.info(\"--- run_generic_spider / instanciate process ...\" \t )\n\tprocess = CrawlerRunner( settings = settings )\n\n\t### adding CrawlerRunner as deferred\n\tdef f(q):\n\t\ttry:\n\t\t\t### send/create custom spider from run_spider_config\n\t\t\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\n\n\t\t\tdeferred = process.crawl( \tGenericSpider,\n\t\t\t\t\t\t\t\t\t\t\tuser_id\t\t\t\t\t\t\t= user_id,\n\t\t\t\t\t\t\t\t\t\t\tdatamodel \t\t\t\t\t= datamodel ,\n\t\t\t\t\t\t\t\t\t\t\tspider_id \t\t\t\t\t= spider_id ,\n\t\t\t\t\t\t\t\t\t\t\tspider_config_flat\t= spider_config_flat,\n\t\t\t\t\t\t\t\t\t\t\ttest_limit\t\t\t\t\t= test_limit\n\t\t\t\t\t\t\t\t\t)\n\t\t\tdeferred.addBoth(lambda _: reactor.stop())\n\t\t\treactor.run()\n\t\t\tq.put(None)\n\t\texcept Exception as e:\n\t\t\tq.put(e)\n\n\t### putting task in queue and start\n\tq = Queue()\n\tp = Process(target=f, args=(q,))\n\tp.start()\n\tresult = q.get()\n\tp.join()\n\n\tif result is not None:\n\t\traise result\n\n\n\n\tprint (\"\\n\\n{}\\n\".format(\"> > > \"*20))","def main() -> None:\n\n download_data_tools.initial_message()\n\n # S&P 500 companies, initial year and time step\n stocks: List[str] = download_data_tools.get_stocks(['all'])\n dates: List[str] = ['1992-01', '2012-12']\n time_step: str = '1d'\n\n # Basic folders\n download_data_tools.start_folders()\n\n # Run analysis\n # Download data\n portfolio_download_data(stocks, dates, time_step)\n\n print('Ay vamos!!!')","def main():\n if len(sys.argv) > 1:\n CFS3Site().help()\n else:\n print(sceptre_handler(dict()))","def main(self, params):\n pass","def test_script(self) -> None:\n main()","def main(args):\n parser = create_parser()\n\n if not args:\n parser.print_usage()\n sys.exit(1)\n\n parsed_args = parser.parse_args(args)\n\n urls = scrape_urls(parsed_args.webpage)\n emails = scrape_emails(parsed_args.webpage)\n phones = scrape_phones(parsed_args.webpage)\n\n if urls:\n print(\"\\nURLS:\\n\\n\", '\\n'.join(urls))\n else:\n print(\"\\nURLS:\\n\\nNone\")\n\n if emails:\n print(\"\\nEMAILS:\\n\\n\", '\\n'.join(emails))\n else:\n print(\"\\nEMAILS:\\n\\nNone\")\n\n if phones:\n print(\"\\nPHONE NUMBERS:\\n\\n\", '\\n'.join(phones))\n else:\n print(\"\\nPHONE NUMBERS:\\n\\nNone\")","def main(*args):\n gen = None\n xmlFilename = None\n HTTPignore = []\n\n if isinstance(memento_client, ImportError):\n warn('memento_client not imported: %s' % memento_client, ImportWarning)\n\n # Process global args and prepare generator args parser\n local_args = pywikibot.handle_args(args)\n genFactory = pagegenerators.GeneratorFactory()\n\n for arg in local_args:\n if arg == '-talk':\n config.report_dead_links_on_talk = True\n elif arg == '-notalk':\n config.report_dead_links_on_talk = False\n elif arg == '-repeat':\n gen = RepeatPageGenerator()\n elif arg.startswith('-ignore:'):\n HTTPignore.append(int(arg[8:]))\n elif arg.startswith('-day:'):\n config.weblink_dead_days = int(arg[5:])\n elif arg.startswith('-xmlstart'):\n if len(arg) == 9:\n xmlStart = pywikibot.input(\n u'Please enter the dumped article to start with:')\n else:\n xmlStart = arg[10:]\n elif arg.startswith('-xml'):\n if len(arg) == 4:\n xmlFilename = i18n.input('pywikibot-enter-xml-filename')\n else:\n xmlFilename = arg[5:]\n else:\n genFactory.handleArg(arg)\n\n if xmlFilename:\n try:\n xmlStart\n except NameError:\n xmlStart = None\n gen = XmlDumpPageGenerator(xmlFilename, xmlStart,\n genFactory.namespaces)\n\n if not gen:\n gen = genFactory.getCombinedGenerator()\n if gen:\n if not genFactory.nopreload:\n # fetch at least 240 pages simultaneously from the wiki, but more\n # if a high thread number is set.\n pageNumber = max(30, config.max_external_links * 2)\n pywikibot.output(\"Fetch %i pages.\" % pageNumber)\n gen = pagegenerators.PreloadingGenerator(gen, groupsize=pageNumber)\n gen = pagegenerators.RedirectFilterPageGenerator(gen)\n bot = WeblinkCheckerRobot(gen, HTTPignore, config.weblink_dead_days)\n try:\n bot.run()\n finally:\n waitTime = 0\n # Don't wait longer than 30 seconds for threads to finish.\n while countLinkCheckThreads() > 0 and waitTime < 30:\n try:\n pywikibot.output(u\"Waiting for remaining %i threads to \"\n u\"finish, please wait...\"\n % countLinkCheckThreads())\n # wait 1 second\n time.sleep(1)\n waitTime += 1\n except KeyboardInterrupt:\n pywikibot.output(u'Interrupted.')\n break\n if countLinkCheckThreads() > 0:\n pywikibot.output(u'Remaining %i threads will be killed.'\n % countLinkCheckThreads())\n # Threads will die automatically because they are daemonic.\n if bot.history.reportThread:\n bot.history.reportThread.shutdown()\n # wait until the report thread is shut down; the user can\n # interrupt it by pressing CTRL-C.\n try:\n while bot.history.reportThread.isAlive():\n time.sleep(0.1)\n except KeyboardInterrupt:\n pywikibot.output(u'Report thread interrupted.')\n bot.history.reportThread.kill()\n pywikibot.output(u'Saving history...')\n bot.history.save()\n return True\n else:\n pywikibot.bot.suggest_help(missing_generator=True)\n return False","def main():\n \n usage = \"\"\"usage: %prog [target]\nTargets :\n\tall\t\tCompile all projects in csunplugged directory\n\tindex\t\tCreate the index page\n\tdirectory\tCompile single project in csunplugged directory\n \"\"\"\n parser = optparse.OptionParser(usage)\n \n (options, args) = parser.parse_args()\n if not (len(args) == 1) :\n parser.error('incorrect number of arguments')\n \n if args[0]=='all' :\n build_all()\n \n elif args[0]=='index' :\n make_index_page()\n \n else :\n jsFile = args[0] + '.js'\n jsFilePath = os.path.join(csunpluggedPath, args[0], jsFile)\n if not os.path.exists(jsFilePath) :\n print 'Can not found ' + jsFilePath+'\\n' \n else :\n \tbuild(args[0])","def main():\n\n browser = initialize()\n process_directory(browser, \"data\")\n browser.close()","def main():\n test_network_connection()\n parser()","def main():\r\n\tlang = get_arguments()\r\n\twiki_analyzer(lang)","def run_main():\n\n #Check for sold bikes\n checkSold(auto=True) #Change Auto to True to prevent user input\n\n #Find all available URLs split by Make & Model - Find Make\n print(\"Getting Makes...\")\n makes = getMakes()\n \n #Find all Models for each Make\n print(\"Getting Models...\")\n models = []\n for make in tqdm(makes, desc=\"Makes\"):\n models += getModels(make)\n\n\n #Find all URLs for each Model - Scrape bikes on each model\n errlog = \"\"\n print(\"Scraping Bikes...\")\n for model in tqdm(models, desc=\"Models\"):\n #Get urls for each model\n urlsTemp = getURLs(model)\n\n #Remove duplicates\n urlsTemp = removeDups(urlsTemp)\n\n #Remove listings already found\n urlsTemp = newURLs(\"motorcycles\", urlsTemp)\n\n #Get model description\n try:\n modelDesc = model.split(\"/\")[2].replace(\"model-\", \"\")\n except:\n modelDesc = \"Listings\"\n\n #Find motorbike details on all urls for this model\n #Split by model to prevent large datasets changing during code runtime\n for url in tqdm(urlsTemp, desc=modelDesc, leave=False):\n temp = Motorcycle(url)\n if not temp.na:\n temp.dbInsert()\n else:\n errlog += url + \"|\"\n \n #Finish\n if not errlog:\n print(\"Errors Found: \", errlog)\n if not printlog:\n print(printlog)\n \n print(\"Done!\")","def main(self, options):\n raise NotImplementedError","def main():\n settings.configure(\n INSTALLED_APPS=(\n 'rtl_django_tools',\n 'django.contrib.sites',\n 'django.contrib.auth',\n 'django.contrib.contenttypes',\n 'django.contrib.sessions',\n 'django_nose',\n 'registration',\n ),\n TEST_RUNNER = 'django_nose.NoseTestSuiteRunner',\n DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3',\n 'NAME': '/tmp/registration.db',\n 'USER': '',\n 'PASSWORD': '',\n 'HOST': '',\n 'PORT': ''}},\n NOSE_ARGS=['--with-xunit', '-s'],\n ROOT_URLCONF=None,\n TEMPLATE_DIRS = (\n os.path.join(THIS_DIR, 'templates'),\n ),\n FIXTURES_DIR=(\n os.path.join(THIS_DIR, 'fixtures'),\n ),\n SITE_ID=1,\n )\n\n call_command('test', 'registration')","def main(args=None):\n\n args, _ = root_parser.parse_known_args(args=args)\n import_path = ENTRY_POINTS[args.test]\n module = import_module(import_path)\n main_fnc = getattr(module, \"main\")\n _check_main(main_fnc)\n if args.dry:\n return\n main_fnc()","def main():\n #print( \"main() entered...\" )\n initialize()\n getCmdOptions()\n printVersionInfo()\n\n rc = doWork()\n\n cleanUp()\n sys.exit(rc)","def main():\n setup(**setup_params)","def main(args=None):\n args = args or sys.argv[1:]\n parser = parse_options()\n common.main_cli(experiment_parse_and_run, parser, args)","def run(self):\n\n #Load old cache\n if '-r' not in sys.argv:\n old_db = SiteDB([], 'upwork')\n old_db.load()\n\n #Set it to current DBs old cache\n self.db.pred = old_db.cache\n\n #Generate crawler object\n \n crawler = self.generate_crawler()\n\n #Generate DB for latest scan\n if '-full' not in sys.argv:\n self.db = crawler.crawl()\n else:\n _ = crawler.crawl()\n\n if '-r' not in sys.argv:\n #Get deleted info\n _ = self.db.compare(old_db)\n\n targets = ['https://community.upwork.com/t5/Announcements/bd-p/news', \\\n 'https://community.upwork.com/t5/Freelancers/bd-p/freelancers', \\\n 'https://community.upwork.com/t5/Clients/bd-p/clients', \\\n 'https://community.upwork.com/t5/Agencies/bd-p/Agencies']\n target = None\n for tar in targets:\n if tar in sys.argv:\n target = tar\n\n #Write result\n #self.db.write(target_name=target)","def main():\n\n args = parse_arguments(sys.argv[1:])\n configure_logging(args.debug)\n\n if(args.subcommand):\n logging.debug(\"Executing sub-command \" + args.subcommand)\n\n if(args.subcommand == \"build\"):\n build(args)\n elif(args.subcommand == \"init\"):\n init(args)\n elif(args.subcommand == \"new\"):\n init_new_entry(args, args.buildpage)\n\n logging.debug(\"Done. Exiting.\")","def run():\n\n call_args = sys.argv[1:]\n main(call_args)","def main(*args):\n options = {}\n local_args = pywikibot.handle_args(args)\n site = pywikibot.Site()\n site.login()\n gen_factory = GeneratorFactory(site)\n for arg in local_args:\n if gen_factory.handleArg(arg):\n continue\n arg, _, value = arg.partition(':')\n arg = arg[1:]\n if arg == 'config':\n if not value:\n value = pywikibot.input(\n 'Please enter a value for {}'.format(arg), default=None\n )\n options[arg] = value\n else:\n options[arg] = True\n gen = gen_factory.getCombinedGenerator(preload=True)\n if 'config' not in options:\n pywikibot.bot.suggest_help(missing_parameters=['config'])\n return False\n config = get_json_from_page(pywikibot.Page(site, options.pop('config')))\n if validate_config(config):\n options.update(config)\n else:\n pywikibot.error('Invalid config.')\n return False\n MagicLinksReplacer(gen, site=site, **options).run()\n return True","def main():\n\n # Parse arguments using `optparse'\n (opts, _) = parse_arguments(sys.argv[1:])\n\n # Initialize burnin\n (testsuites, failfast) = \\\n common.initialize(opts, TSUITES_NAMES, STALE_TSUITES_NAMES)\n testsuites = string_to_class(testsuites)\n\n # Run burnin\n # The return value denotes the success status\n return common.run_burnin(testsuites, failfast=failfast)","def main():\n parser = ArgumentParser(description=\"pre-process nexus templates\")\n parser.add_argument(\n \"nexus_templates\",\n nargs=\"+\",\n help=\"Nexus template files to process\",\n )\n args = parser.parse_args()\n\n for template_file in args.nexus_templates:\n preprocess_template(template_file)","def main():\n\tcli = Cli()\n\tcli.run()","def main():\n feed_url = ( len(sys.argv) > 2 ) and sys.argv[2] or FEED_URL\n\n f = AmazonAdFeed(feed_url)\n f.STATE_FN = 'link_amazon_ads_state'\n \n if len(sys.argv) > 1 and sys.argv[1] == 'rss':\n print f.scrape_rss()\n else:\n print f.scrape_atom()","def main():\n # Initialization\n args = init_args()\n config = init_config(args.config_file)\n logger = init_logging(location=config['main']['log_location'],\n level=parse_log_level(config['main']['log_level']))\n\n logger.info(\"DeltaSherlock Version %s\", VERSION)\n logger.debug(\"Logger initialized: %s yielded %s with level %i\",\n config['main']['log_location'], str(logger),\n logger.getEffectiveLevel())\n logger.debug(\"Command line arguments loaded: %s\", str(args))\n logger.debug(\"Config file loaded: %s yielded %s\",\n args.config_file, str(config))\n\n if args.daemon:\n # Exceute the central loop\n interval = config['daemon'].getint('interval')\n logger.debug(\"Entering daemon mode loop with interval %i\", interval)\n else:\n # Perform one check, then exit\n logger.debug(\"Daemon mode disabled. Running once then exiting\")","def parse_arguments(args):\n\n parent_parser = argparse.ArgumentParser(add_help=False)\n parent_parser.add_argument('--debug', '-d', action='count', default=0)\n parent_parser.add_argument('--version', '-v', action='version',\n version='%(prog)s {version}'.format(version=version.__version__))\n\n main_parser = argparse.ArgumentParser(parents=[parent_parser],\n description='The lightweight static website generator')\n\n subparsers = main_parser.add_subparsers(help=\"sub-command to be executed\",\n dest=\"subcommand\")\n subparsers.required = True\n\n parser_build = subparsers.add_parser('build', parents=[parent_parser],\n help=\"Build static site from local directory to the directory specified in config.yml\")\n\n parser_build.add_argument('--build-src', '-s', dest=\"src\", type=str, default=\"\",\n help='directory to load source')\n\n parser_build.add_argument('--build-dst', '-ds', dest=\"dest\", type=str,\n default=paths.DEFAULT_BUILDDIR,\n help='build and install website in passed directory')\n\n parser_build.add_argument('--no-clean', '-nc', dest=\"noclean\",\n default=False, action='store_true',\n help='do not clean build directory before installation')\n\n parser_build.add_argument('--config-file', '-cf', dest=\"configfile\",\n default=paths.CFG_FILE, type=str,\n help='use a non default config file')\n\n parser_build.add_argument('--auto-baseurl', dest=\"autobaseurl\",\n default=False, action='store_true',\n help='override baseurl and set it to build destination (useful for local builds)')\n\n parser_init = subparsers.add_parser('init', parents=[parent_parser],\n help=\"Initialize a new, clean website in current directory.\")\n\n parser_init.add_argument('--dir', dest=\"dir\", type=str,\n default=paths.DEFAULT_INITDIR,\n help='Initialize website in passed directory')\n\n parser_new = subparsers.add_parser('new', parents=[parent_parser],\n help=\"Initialize a fresh, new post file (--page for a page).\")\n\n parser_new.add_argument('--build-src', '-s', dest=\"src\", type=str, default=\"\",\n help='juliet source directory where to initialize post/page')\n\n parser_new.add_argument('--file-name', '-f', dest=\"file_name\", nargs='?',\n default=None, help='file name for new post/page')\n\n parser_new.add_argument('--page', dest=\"buildpage\", default=False, action='store_true',\n help='build a new page (instead of a new post)')\n\n parser_new.add_argument('header_content', default=[],\n nargs=argparse.REMAINDER, help='header content of the new post/page')\n\n return main_parser.parse_args(args)","def main():\n logging.basicConfig(\n level=logging.DEBUG, format=\"%(levelname)s: %(message)s\")\n root.add_command(all_)\n root.add_command(build)\n root.add_command(cleanup)\n root.add_command(clitest)\n root.add_command(run)\n root.add_command(push)\n root.add_command(unittest)\n root.add_command(list_images)\n root.add_command(list_stages)\n root()","def setup(args=None):\n\n # Setup API server\n api = ParadropAPIServer(reactor)\n api.putChild('internal', Base(apiinternal, allowNone=True))\n site = Site(api, timeout=None)\n\n # Development mode\n if(args and args.development):\n thePort = settings.PDFCD_PORT + 10000\n out.info('Using DEVELOPMENT variables')\n # Disable sending the error traceback to the client\n site.displayTracebacks = True\n elif(args and args.unittest):\n thePort = settings.PDFCD_PORT + 20000\n out.info('Running under unittest mode')\n site.displayTracebacks = True\n else:\n thePort = settings.PDFCD_PORT\n site.displayTracebacks = False\n initializeSystem()\n\n # Setup the port we listen on\n reactor.listenTCP(thePort, site)\n\n # Never return from here\n reactor.run()","def main():\n grid_tester_cpu = GridTesterCPU()\n\n # parse args, load configuration and create all required objects.\n grid_tester_cpu.setup_grid_experiment()\n\n # GO!\n grid_tester_cpu.run_grid_experiment()","def main():\n args = parse_args()\n\n make_session = bootstrap(\n 'sqlite:///{}'.format(DB_NAME),\n )\n session = make_session()\n\n for vase in session.query(Vase).order_by(Vase.produced_start):\n for query_str in make_searches(vase):\n pass","def main():\n run_test_all()"],"string":"[\n \"def main():\\n\\n from scrapy.crawler import CrawlerProcess\\n from scrapy.utils.project import get_project_settings\\n\\n process = CrawlerProcess(get_project_settings())\\n process.crawl(NCBIGeoSpider)\\n process.start()\",\n \"def main():\\n # get input params\\n args = parm_parser.get_args()\\n # init log config\\n log.init_log('./log/mini_spider')\\n if args:\\n # read config file spider.conf\\n conf_params = parm_parser.set_config_by_file(args.conf)\\n # use config set up spider initial params\\n spider = SpiderWorker(conf_params)\\n # init result_path, make it complete\\n spider.set_path()\\n # init url queue\\n spider.set_url_queue()\\n # start to crawl url\\n spider.start_crawl_work()\\n\\n return\",\n \"def main():\\n\\n # add custom commandline args (if we dont have any we can pass None instead of parser to do_main_commandline_startup()).\\n import argparse\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-t\\\", \\\"--querytests\\\", help=\\\"run some test queries\\\", action=\\\"store_true\\\", default=False)\\n\\n # Create a site manager and ask it to instantiate a site of the class we specify, and handle some generic commandline options\\n # it returns parsed commandline args so we can look for any custom ones\\n (args, sitemanager) = MewloSiteManager.do_main_commandline_startup(MewloSite_Test1, parser)\\n\\n # on successful creation, we can parse and do some stuff\\n if (sitemanager != None):\\n # sitemanager was created and early commandline processing done\\n # now we have some custom commandline arg proessing we might want to do\\n if (sitemanager.is_readytoserve()):\\n # this stuff only is entertained if sitemanager says all green lights\\n if (args.querytests):\\n # simulate some simple simulated query requests\\n print \\\"Running query tests.\\\"\\n print sitemanager.test_submit_path('/')\\n print sitemanager.test_submit_path('/help/about')\\n print sitemanager.test_submit_path('/page/mystery')\\n print sitemanager.test_submit_path('/test/hello/name/jesse/age/44')\\n\\n # now any late generic commandline stuff (including serving the website)\\n sitemanager.do_main_commandline_late()\",\n \"def main():\\n # 日志保存到./log/spider.log和./log/spider.log.wf，按天切割，保留7天\\n log.init_log(\\\"./log/spider\\\")\\n spider = SpiderEngine.SpiderEngine()\\n try:\\n opts, args = getopt.getopt(sys.argv[1:], \\\"vhc:\\\")\\n except getopt.GetoptError as err:\\n logging.error(\\\"get option error : %s.\\\" % err)\\n return\\n for o, a in opts:\\n if o == \\\"-v\\\":\\n version()\\n return\\n elif o == \\\"-h\\\":\\n # spider_engine = _SpiderEngine._SpiderEngine()\\n # spider_engine.config_tostring()\\n # spider_engine.set_config()\\n print \\\"帮助信息：没有帮助^_^\\\"\\n return\\n else:\\n logging.error(\\\"unhandled option\\\")\\n print \\\"unhandled option\\\"\\n return\\n spider.start_work()\\n return\",\n \"def main():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"layout_path\\\", help=\\\"relative path to the directory \\\"\\n \\\"containing .rst files with site content and jinja \\\"\\n \\\"templates that define the site structure\\\")\\n parser.add_argument(\\\"output_path\\\", help=\\\"relative path to the output \\\"\\n \\\"directory\\\")\\n arguments = parser.parse_args()\\n\\n generate_site(arguments.layout_path, arguments.output_path)\",\n \"def main():\\n driver = Driver()\\n driver.start()\",\n \"def main():\\n download_insert_title_basics()\\n download_insert_title_principals()\\n download_insert_name_basics()\\n download_insert_title_ratings()\\n scrap_keywords()\\n create_and_insert_soup()\\n return\",\n \"def main(args):\\n parser = create_parser()\\n\\n if not args:\\n parser.print_usage()\\n sys.exit(1)\\n\\n parsed_args = parser.parse_args(args)\\n scrape_url(parsed_args.url)\",\n \"def main(args):\\r\\n logger.info(\\\"Starting site generation...\\\")\\r\\n logger.info(args)\\r\\n logger.info(\\\"Opening syllabus.yml...\\\")\\r\\n\\r\\n## PUT THIS BACK LATER!!!!!####\\r\\n\\r\\n with open(\\\"/home/tofts/git/upskilling/data/syllabus.yml\\\", \\\"r\\\") as syllabus_file:\\r\\n syllabus = yaml.safe_load(syllabus_file)\\r\\n\\r\\n logger.info(\\\"Found the following modules:\\\")\\r\\n for module in syllabus['modules']:\\r\\n logger.info(f\\\"...{syllabus['modules'][module]['name']}\\\")\\r\\n\\r\\n logger.info(\\\"Opening squad.yml...\\\")\\r\\n with open(\\\"/home/tofts/git/upskilling/data/squad.yml\\\", \\\"r\\\") as squad_file:\\r\\n squad = yaml.safe_load(squad_file)\\r\\n\\r\\n for member in squad['members']:\\r\\n logger.info(f\\\"Found member {member.upper()}\\\")\\r\\n logger.info(f\\\"...{squad['members'][member]}\\\")\\r\\n\\r\\n logger.info(\\\"Processing index.html template...\\\")\\r\\n with open(\\\"/home/tofts/git/upskilling/templates/index.html\\\") as index_template_file:\\r\\n index_template = index_template_file.read()\\r\\n\\r\\n index_template = module_list(index_template, syllabus, squad)\\r\\n index_template = task_list(index_template, syllabus, squad)\\r\\n index_template = member_progress_list(index_template, syllabus, squad)\\r\\n\\r\\n logger.info(\\\"Writing completed template out...\\\")\\r\\n with open(\\\"/home/tofts/git/upskilling/docs/index.html\\\", \\\"w\\\") as index_output_file:\\r\\n index_output_file.write(index_template)\\r\\n\\r\\n logger.info(\\\"Generating member pages...\\\")\\r\\n with open(\\\"/home/tofts/git/upskilling/templates/member-page.html\\\", \\\"r\\\") as member_template_file:\\r\\n member_page_template = member_template_file.read()\\r\\n generate_member_pages(member_page_template, syllabus, squad)\\r\\n\\r\\n logger.info(\\\"Generating task detail pages...\\\")\\r\\n with open(\\\"/home/tofts/git/upskilling/templates/task-details.html\\\", \\\"r\\\") as task_details_file:\\r\\n task_details_template = task_details_file.read()\\r\\n generate_task_details_pages(task_details_template, syllabus, squad)\\r\\n\\r\\n logger.info(\\\"Generating downloads...\\\")\\r\\n generate_downloads(syllabus, squad)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\"Tester for YT Data API and different inputs\\\"\\\"\\\")\\n parser.add_argument('-a', '--analytics', help='Performs a basic analytics lookup for the user\\\\'s channel entered')\\n parser.add_argument('-c', '--comments', help='Performs a lookup of comments for the video id entered')\\n args = parser.parse_args()\\n\\n if args.analytics:\\n analytics = args.analytics\\n analyt(analytics)\\n\\n if args.comments:\\n comments = args.comments\\n get_comments(comments)\",\n \"def main():\\n args = parseCommandLineArguments()\\n\\n\\n chemkin1 = args.chemkin1[0]\\n speciesDict1 = args.speciesDict1[0]\\n if args.thermo1: \\n thermo1 = args.thermo1[0]\\n else:\\n thermo1 = None\\n chemkin2 = args.chemkin2[0]\\n speciesDict2 = args.speciesDict2[0]\\n if args.thermo2: \\n thermo2 = args.thermo2[0]\\n else:\\n thermo2 = None\\n\\n kwargs = {\\n 'web': args.web,\\n 'wd': os.getcwd()\\n }\\n\\n execute(chemkin1, speciesDict1, thermo1, chemkin2, speciesDict2, thermo2, **kwargs)\",\n \"def main():\\n logger.info(\\\"Running main function...\\\")\\n args = get_args()\\n # rose suite default location\\n if args.suite_dir:\\n default_suite = args.suite_dir\\n rose_config_template = os.path.join(default_suite, \\\"rose-suite.conf\\\")\\n\\n # get command line arguments\\n recipe_files = args.recipe_files\\n config_file = args.config_file\\n main_dir = args.main_dir\\n log_level = args.log_level\\n\\n # setup rose suite\\n run_rose = _setup_work(rose_config_template, recipe_files,\\n config_file, main_dir, default_suite, log_level)\\n\\n # submit to cylc\\n if not args.no_submit:\\n _run_suite(run_rose)\",\n \"def main(self, **kwargs) -> None:\\n ...\",\n \"def main(call_args):\\n\\n args = parse_args(call_args)\\n init_logging(args.loglevel)\\n\\n _log.info(\\\"'scrape-jobs' called with args: %s\\\", args)\\n runner.run_with_config_file(args.site, args.config_file)\",\n \"def main():\\n parg = argparse.ArgumentParser(\\n description=\\\"Crawl a website and check for broken links.\\\",\\n epilog=\\\"A broken links report will be output to stdout, so you may like to redirect this to a file.\\\",\\n )\\n parg.add_argument(\\n \\\"URL\\\", help=\\\"The URL of the website to crawl, e.g. https://example.com\\\"\\n )\\n parg.add_argument(\\\"--config\\\", \\\"-c\\\", help=\\\"Path to a configuration file\\\")\\n args = parg.parse_args()\\n\\n # If a configuration file path was provided, ensure we can find it\\n if args.config and not path.exists(args.config):\\n print(f\\\"Can't find {args.config} as config file.\\\")\\n sys.exit(1)\\n\\n # Ensure we have a valid URL to crawl\\n url = args.URL\\n check_url = parse.urlparse(url)\\n if check_url.scheme == \\\"\\\" or check_url.netloc == \\\"\\\":\\n print(\\\"Please provide a valid URL with scheme, e.g. https://example.com\\\")\\n sys.exit(1)\\n\\n # Configure and run Hydra\\n first_url = {\\\"parent\\\": url, \\\"url\\\": url}\\n config_file = \\\"\\\" # Uses default settings if no configuration file provided\\n if args.config:\\n config_file = args.config\\n config = Config(config_file)\\n check = Checker(url, config)\\n check.TO_PROCESS.put(first_url)\\n check.run()\\n print(check.make_report())\\n\\n if check.broken and not check.config.graceful_exit:\\n sys.exit(1)\",\n \"def main():\\n if len(sys.argv) >= 2:\\n crawler = EmailCrawler(sys.argv[1])\\n if len(sys.argv) >= 3 and sys.argv[2].isdigit():\\n crawler.num_pages_limit = int(sys.argv[2])\\n\\n print(\\\"Beginning crawl with a limit of \\\" + str(crawler.num_pages_limit) + \\\" pages...\\\\n\\\")\\n crawler.find()\\n crawler.print_emails()\\n else:\\n print(\\\"Error: Please enter a domain to search on and an optional page limit (default=50).\\\")\\n print(\\\"Example: `python find_email_addresses.py jana.com 30`\\\")\\n sys.exit(1)\",\n \"def Main(base_dir, page_set_filenames):\\n runner = PageTestRunner()\\n sys.exit(runner.Run(base_dir, page_set_filenames))\",\n \"def main():\\n args = parse_args()\\n process_args(args)\",\n \"def main():\\r\\n if len(sys.argv) == 1:\\r\\n wizard_mode()\\r\\n else:\\r\\n web_site_mode()\",\n \"def main():\\n from clize import run\\n\\n run(\\n cases, webserver,\\n description=DESCRIPTION, footnotes=FOOTNOTES)\",\n \"def Main(parsed_args):\\n logging.basicConfig(\\n format='[[%(filename)s %(funcName)s]] - %(message)s',\\n level=(logging.ERROR if os.environ.get('CI') else logging.INFO))\\n EnsureNodeJsIsInstalled()\\n CheckPrereqs()\\n InstallNodeDependencies()\\n SetupOutDir(out_dir='dist')\\n GenValidatorProtoascii(out_dir='dist')\\n GenValidatorPb2Py(out_dir='dist')\\n GenValidatorProtoGeneratedJs(out_dir='dist')\\n GenValidatorGeneratedJs(out_dir='dist')\\n CompileValidatorMinified(out_dir='dist')\\n RunSmokeTest(out_dir='dist')\\n RunIndexTest()\\n CompileValidatorTestMinified(out_dir='dist')\\n CompileHtmlparserTestMinified(out_dir='dist')\\n CompileParseCssTestMinified(out_dir='dist')\\n CompileParseUrlTestMinified(out_dir='dist')\\n CompileAmp4AdsParseCssTestMinified(out_dir='dist')\\n CompileKeyframesParseCssTestMinified(out_dir='dist')\\n CompileParseSrcsetTestMinified(out_dir='dist')\\n GenerateTestRunner(out_dir='dist')\\n RunTests(update_tests=parsed_args.update_tests, out_dir='dist')\",\n \"def _runner(self, classpath, main, jvm_options, args):\",\n \"def main(*args):\\n options = {}\\n # Process global arguments to determine desired site\\n local_args = pywikibot.handle_args(args)\\n\\n # This factory is responsible for processing command line arguments\\n # that are also used by other scripts and that determine on which pages to work on.\\n genFactory = pagegenerators.GeneratorFactory()\\n\\n for arg in local_args:\\n\\n # Catch the pagegenerators options\\n if genFactory.handleArg(arg):\\n continue # nothing to do here\\n\\n # Now pick up your own options\\n arg, sep, value = arg.partition(':')\\n option = arg[1:]\\n if option in ('summary', 'page'):\\n if not value:\\n pywikibot.input('Please enter a value for ' + arg)\\n options[option] = value\\n # take the remaining options as booleans.\\n # You will get a hint if they aren't pre-definded in your bot class\\n else:\\n options[option] = True\\n\\n\\n\\n # The preloading option is responsible for downloading multiple pages from the wiki simultaneously.\\n gen = genFactory.getCombinedGenerator(preload=True)\\n if gen:\\n # pass generator and private options to the bot\\n bot = CopyLinksBot(gen, **options)\\n bot.run() # guess what it does\\n return True\\n else:\\n pywikibot.bot.suggest_help(missing_generator=True)\\n return False\",\n \"def main():\\n parser = optparse.OptionParser(usage='%prog [options]', version=\\\"0.0.1\\\")\\n parser.add_option('--settings', \\\\\\n help='Python path to settings module. If this isn\\\\'t provided, the DJANGO_SETTINGS_MODULE enviroment variable will be used.')\\n\\n parser.add_option('-v', '--verbose', action='store_true', dest='verbose', \\\\\\n default=False, help='Verbose output.')\\n options = parser.parse_args()[0]\\n if options.settings:\\n os.environ[\\\"DJANGO_SETTINGS_MODULE\\\"] = options.settings\\n else:\\n os.environ[\\\"DJANGO_SETTINGS_MODULE\\\"] = \\\"settings\\\"\\n\\n probe_all()\",\n \"def main():\\r\\n args = getargs()\\r\\n dir_name = args.dir_name\\r\\n url = args.url\\r\\n fetch_junit(dir_name, url)\",\n \"def main(*arguments):\\n\\n args = parse_args(arguments)\\n\\n if args.test_suite is not None:\\n test_suite = report_manager.load_test_suite_conf(args.test_suite)\\n for i, test in enumerate(test_suite):\\n args = parse_args(test)\\n process_args_and_run(args, test_suite_iter=i)\\n else:\\n process_args_and_run(args)\",\n \"def main(aArgs, aTransmitToTaskHandler):\\n\\n global TASK_HANDLER_HOST\\n global TASK_HANDLER_PORT\\n\\n # if the option --printList is passed, only generate the file\\n # reftestList.txt\\n if hasattr(aArgs, \\\"printList\\\"):\\n printReftestList()\\n exit(0)\\n\\n # if the option --printNotes is passed, only generate the\\n # testsuiteNotes html page.\\n if hasattr(aArgs, \\\"printNotes\\\"):\\n printNotes()\\n exit(0)\\n\\n # if the option --printListOfTests is passed, only generate a ListOfTests\\n # from a file containing test URIs\\n if hasattr(aArgs, \\\"printListOfTests\\\"):\\n if not aArgs.printListOfTests:\\n print(\\\"No input file!\\\", file=sys.stderr)\\n exit(0)\\n printListOfTests(aArgs.printListOfTests)\\n exit(0)\\n\\n # create the date directory\\n now = datetime.utcnow();\\n directory = MATHJAX_WEB_PATH + \\\"results/\\\"\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # create the subdirectory\\n if aArgs.output and re.match(\\\"^([0-9]|[a-z]|[A-Z]|-|/){1,50}/$\\\",\\n aArgs.output):\\n directory += aArgs.output\\n else:\\n directory += now.strftime(\\\"%Y-%m-%d/%H-%M-%S/\\\")\\n\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # execute testing instances for all the config files\\n configFileList = aArgs.config.split(\\\",\\\")\\n\\n for configFile in configFileList:\\n\\n configFile = configFile\\n\\n if (not os.path.isfile(configFile)):\\n print(\\\"Warning: config file \\\" + configFile + \\\" not found!\\\",\\n file=sys.stderr)\\n continue\\n\\n # Load configuration file\\n config = ConfigParser.ConfigParser()\\n config.readfp(open(configFile))\\n\\n # framework section\\n section = \\\"framework\\\"\\n useGrid = getBooleanOption(config, section, \\\"useGrid\\\")\\n host = config.get(section, \\\"host\\\")\\n # host == \\\"default\\\" is handled below\\n port = config.getint(section, \\\"port\\\")\\n if (port == -1):\\n port = SELENIUM_SERVER_PORT\\n mathJaxPath = config.get(section, \\\"mathJaxPath\\\")\\n if (mathJaxPath == \\\"default\\\"):\\n mathJaxPath = DEFAULT_MATHJAX_PATH\\n mathJaxTestPath = config.get(section, \\\"mathJaxTestPath\\\")\\n if (mathJaxTestPath == \\\"default\\\"):\\n mathJaxTestPath = MATHJAX_TEST_LOCAL_URI + \\\"testsuite/\\\"\\n timeOut = config.getint(section, \\\"timeOut\\\")\\n if (timeOut == -1):\\n timeOut = DEFAULT_TIMEOUT\\n timeOut = timeOut * 1000 # convert in ms\\n useWebDriver = getBooleanOption(config, section, \\\"useWebDriver\\\")\\n fullScreenMode = getBooleanOption(config, section, \\\"fullScreenMode\\\")\\n formatOutput = getBooleanOption(config, section, \\\"formatOutput\\\")\\n compressOutput = getBooleanOption(config, section, \\\"compressOutput\\\")\\n\\n # platform section\\n section = \\\"platform\\\"\\n operatingSystem = config.get(section, \\\"operatingSystem\\\")\\n if (operatingSystem == \\\"default\\\"):\\n operatingSystem = OS_LIST[0]\\n if (host == \\\"default\\\"):\\n host = HOST_LIST[HOST_LIST_OS.index(OS_LIST.index(operatingSystem))]\\n browserList = config.get(section, \\\"browser\\\").split()\\n browserVersionList = config.get(section, \\\"browserVersion\\\").split()\\n browserModeList = config.get(section, \\\"browserMode\\\").split()\\n browserPath = config.get(section, \\\"browserPath\\\")\\n fontList = config.get(section, \\\"font\\\").split()\\n outputJaxList = config.get(section, \\\"outputJax\\\").split()\\n \\n # testsuite section\\n section = \\\"testsuite\\\"\\n runSlowTests = getBooleanOption(config, section, \\\"runSlowTests\\\")\\n runSkipTests = getBooleanOption(config, section, \\\"runSkipTests\\\")\\n listOfTests = config.get(section, \\\"listOfTests\\\")\\n startID = config.get(section, \\\"startID\\\")\\n if (startID == \\\"default\\\"):\\n startID = \\\"\\\"\\n \\n # When more than one browser is specified, browserPath is ignored.\\n if (len(browserList) > 1 and browserPath != \\\"default\\\"):\\n print(\\\"Warning: browserPath ignored\\\", file=sys.stderr)\\n browserPath = \\\"default\\\"\\n\\n for browser in browserList:\\n\\n if (browser == \\\"default\\\"):\\n browser = BROWSER_LIST[0]\\n\\n for font in fontList:\\n\\n if (font == \\\"default\\\"):\\n font = FONT_LIST[0]\\n\\n for outputJax in outputJaxList:\\n\\n if (outputJax == \\\"default\\\"):\\n outputJax = OUTPUT_JAX_LIST[0]\\n\\n for browserVersion in browserVersionList:\\n\\n # browserModeList is only relevant for MSIE\\n if not(browser == \\\"MSIE\\\"):\\n browserModeList2 = [\\\"default\\\"]\\n else:\\n browserModeList2 = browserModeList\\n \\n for browserMode in browserModeList2:\\n \\n # Create a Selenium instance\\n selenium = \\\\\\n seleniumMathJax.seleniumMathJax(useWebDriver,\\n useGrid,\\n host,\\n port,\\n mathJaxPath,\\n mathJaxTestPath,\\n operatingSystem,\\n browser,\\n browserVersion,\\n browserMode,\\n browserPath,\\n font,\\n outputJax,\\n timeOut,\\n fullScreenMode)\\n \\n if aTransmitToTaskHandler:\\n taskHandler = [TASK_HANDLER_HOST,\\n TASK_HANDLER_PORT,\\n str(os.getpid())]\\n else:\\n taskHandler = None\\n\\n # Create the test suite\\n suite = reftest.reftestSuite(taskHandler,\\n runSlowTests,\\n runSkipTests,\\n listOfTests,\\n startID)\\n # use the specified file name\\n if hasattr(aArgs, \\\"filename\\\"):\\n filename = aArgs.filename\\n else:\\n filename = getOutputFileName(directory,\\n selenium,\\n suite)\\n runTestingInstance(directory, selenium, suite,\\n formatOutput, compressOutput,\\n filename)\\n # end browserMode\\n # end browserVersion\\n #end outputJax\\n # end for font\\n # end browser\",\n \"def main():\\n\\n # Chdir into script directory so to properly resolve relative paths in configuration\\n os.chdir(os.path.dirname(os.path.realpath(__file__)) + \\\"/\\\")\\n\\n # Disable proxy as we access localhost, both to avoid overhead and issues with proxy misconfiguration\\n os.environ['NO_PROXY'] = '*'\\n\\n # Stop any GraphDB server that we previously started and is possibly still around due to script interruption/crash\\n shell(f\\\"{cmd_graphdb} stopall\\\")\\n\\n # Generate synthetic traces, both for populating the repositories and for the {sf, sp, pf, pp} tests\\n prepare_traces()\\n \\n # Generate central repositories (if needed)\\n for size, approach in itertools.product(sizes, approaches):\\n prepare_repository(size, approach)\\n \\n # Run experiments (if needed)\\n for size, approach in itertools.product(sizes, approaches):\\n run_experiments(size, approach)\",\n \"def main():\\n parser = argparse.ArgumentParser(description='Creates a Mist site within your organization')\\n parser.add_argument('config', metavar='config_file', type=argparse.FileType(\\n 'r'), help='file containing all the configuration information')\\n args = parser.parse_args()\\n configs = json.load(args.config)\\n\\n claim_ap(configs)\",\n \"def run_main():\\n main(sys.argv)\",\n \"def main(argv):\\n\\n output_filename = ''\\n input_filename = ''\\n langCode = 'en'\\n language = False\\n\\n # add support for default (en) language\\n language = gettext.translation(\\n 'webperf-core', localedir='locales', languages=[langCode])\\n language.install()\\n _ = language.gettext\\n\\n try:\\n opts, args = getopt.getopt(\\n argv, \\\"hi:o:\\\", [\\\"help\\\", \\\"input=\\\", \\\"output=\\\"])\\n except getopt.GetoptError:\\n print(main.__doc__)\\n sys.exit(2)\\n\\n if (opts.__len__() == 0):\\n print(main.__doc__)\\n sys.exit(2)\\n\\n for opt, arg in opts:\\n if opt in ('-h', '--help'): # help\\n print(main.__doc__)\\n sys.exit(2)\\n elif opt in (\\\"-i\\\", \\\"--input\\\"): # input file path\\n input_filename = arg\\n\\n file_ending = \\\"\\\"\\n file_long_ending = \\\"\\\"\\n if (len(input_filename) > 4):\\n file_ending = input_filename[-4:].lower()\\n if (len(input_filename) > 7):\\n file_long_ending = input_filename[-7:].lower()\\n\\n if file_long_ending == \\\".sqlite\\\":\\n from engines.sqlite import read_sites, add_site, delete_site\\n elif (file_ending == \\\".csv\\\"):\\n from engines.csv import read_sites, add_site, delete_site\\n elif (file_ending == \\\".xml\\\"): # https://example.com/sitemap.xml\\n from engines.sitemap import read_sites, add_site, delete_site\\n else:\\n from engines.json import read_tests, read_sites, add_site, delete_site\\n pass\\n elif opt in (\\\"-o\\\", \\\"--output\\\"): # output file path\\n output_filename = arg\\n pass\\n\\n tests = read_tests(input_filename, 0, -1)\\n generated_date = False\\n co2s = list()\\n\\n for test in tests:\\n if not generated_date:\\n generated_date = datetime.fromisoformat(\\n test[FIELD_INDEX_DATE]).strftime('%Y-%m-%d')\\n\\n str_data = test[FIELD_INDEX_DATA].replace('\\\\'', '\\\"')\\n data = json.loads(str_data)\\n print(str_data)\\n co2s.append(data['co2'])\\n\\n if not generated_date:\\n generated_date = datetime.today().strftime('%Y-%m-%d')\\n\\n output_content = \\\"# This array was last generated with carbon-rating.py on {0}\\\\n\\\".format(\\n generated_date)\\n output_content += \\\"def get_generated_date():\\\\n\\\"\\n output_content += \\\"\\\\treturn '{0}'\\\\n\\\".format(\\n generated_date)\\n output_content += \\\"\\\\n\\\"\\n output_content += \\\"def get_percentiles():\\\\n\\\"\\n output_content += \\\"\\\\treturn [\\\\n\\\"\\n\\n co2s_sorted = sorted(co2s)\\n\\n intervals = list()\\n\\n index = 1\\n while (index <= 100):\\n percentile = getPercentile(co2s_sorted, index)\\n intervals.append(percentile)\\n position = index - 1\\n if index < 100:\\n if position % 10 == 0 and position != 0:\\n output_content += \\\"\\\\t\\\\t# {0} percentile\\\\n\\\".format(position)\\n\\n output_content += \\\"\\\\t\\\\t{0},\\\\n\\\".format(percentile)\\n else:\\n output_content += \\\"\\\\t\\\\t{0}\\\\n\\\".format(percentile)\\n index += 1\\n\\n output_content += \\\"\\\\t]\\\"\\n\\n print(output_content)\\n if (len(output_filename) > 0):\\n write(output_filename, output_content)\",\n \"def main():\\r\\n args = getargs()\\r\\n testng_file = args.testng_file\\r\\n url = args.url\\r\\n fetch_testng(testng_file, url)\",\n \"def main(args):\",\n \"def main(args):\",\n \"def main(*args):\\n local_args = pywikibot.handle_args(args)\\n\\n # This factory is responsible for processing command line arguments\\n # that are also used by other scripts and that determine on which pages\\n # to work on.\\n gen_factory = pagegenerators.GeneratorFactory()\\n # The program to pipe stuff through\\n filters = []\\n options = {}\\n\\n # Parse command line arguments\\n for arg in local_args:\\n option, sep, value = arg.partition(':')\\n if option == '-filter':\\n filters.append(value)\\n elif option == '-always':\\n options['always'] = True\\n else:\\n # check if a standard argument like\\n # -start:XYZ or -ref:Asdf was given.\\n gen_factory.handleArg(arg)\\n\\n options['filters'] = filters\\n\\n gen = gen_factory.getCombinedGenerator(preload=True)\\n if gen:\\n # The preloading generator is responsible for downloading multiple\\n # pages from the wiki simultaneously.\\n bot = PiperBot(gen, **options)\\n bot.run()\\n return True\\n else:\\n pywikibot.bot.suggest_help(missing_generator=True)\\n return False\",\n \"def main(self):\\n self.parse_option()\\n self.set_option()\\n\\n r = Bootscripts()\\n reactor.listenTCP(8009, server.Site(r))\\n reactor.run()\",\n \"def main(ctx, qa_dir, no_editor, report_dir, vcs, debug, main_branch):\\n __main_imp__(ctx, qa_dir, no_editor, report_dir, vcs, debug, main_branch)\",\n \"def main(arguments):\\n auth = (arguments['username'], arguments['token'])\\n data_collector = DataCollector(arguments['repo name'],\\n arguments['start date'],\\n arguments['end date'], auth,\\n arguments['all'], arguments['page'])\\n data_collector.collect_signals()\",\n \"def main() -> None:\\r\\n # pylint: disable=W0601\\r\\n global ARGS, BROWSERS\\r\\n BROWSERS = {'chrome': Chrome, 'firefox': Firefox, 'ie': Ie,\\r\\n 'safari': Safari, 'opera': Opera, 'edge': Edge}\\r\\n # pylint: disable=C0103\\r\\n PARSER = argparse.ArgumentParser()\\r\\n PARSER.add_argument('-m', '--modules', help='Which modules to test. One or more of '\\r\\n '[%(choices)s]. Default is all.', nargs='+', type=str,\\r\\n choices=MODULES.keys(), metavar='', default=list(MODULES.keys()))\\r\\n PARSER.add_argument('-l', '--locales', help='Which locales to test. One or more of '\\r\\n '[%(choices)s]. Default is all.', nargs='+', type=str,\\r\\n choices=LANGS.keys(), metavar='', default=list(LANGS.keys()))\\r\\n PARSER.add_argument('-b', '--browsers', help='Which browser to use. One or more of '\\r\\n '[%(choices)s]. Default is %(default)s', nargs='+', default=['chrome'],\\r\\n choices=BROWSERS.keys(), metavar='')\\r\\n PARSER.add_argument('-w', '--wait', help='Wait this many seconds before deciding an element is '\\r\\n 'missing. Default is %(default)s', default=[20], type=int, nargs=1)\\r\\n ARGS = PARSER.parse_args()\\r\\n parseargs()\\r\\n os.makedirs(SCREENSHOT_DIR, exist_ok=True)\\r\\n\\r\\n try:\\r\\n full_languages_modules_run(modfilter=ARGS.modules,\\r\\n langfilter=ARGS.locales, brows=ARGS.browsers)\\r\\n except Exception: # Too general is the point, it's a Final Action. pylint: disable=W0703\\r\\n with open(RESULTS_FILE, mode='a', encoding='UTF-8') as log:\\r\\n log.write('\\\\n\\\"Well, something went wrong. A manual exit, hopefully:\\\"\\\\n\\\\n' + tidy_error())\\r\\n raise\",\n \"def main(args):\\n\\n if 'log' in args and args['log'] is not None:\\n logging.basicConfig(level=LOGGING_LEVELS.get(args['log'].lower(), logging.NOTSET))\\n\\n test_structure = read_test_file(args['test'])\\n tests = build_testsets(args['url'], test_structure)\\n\\n # Override configs from command line if config set\\n for t in tests:\\n if 'print_bodies' in args and args['print_bodies'] is not None:\\n t.config.print_bodies = safe_to_bool(args['print_bodies'])\\n\\n if 'interactive' in args and args['interactive'] is not None:\\n t.config.interactive = safe_to_bool(args['interactive'])\\n\\n # Execute all testsets\\n failures = execute_testsets(tests)\\n\\n sys.exit(failures)\",\n \"def run_crawl(self, args):\\n\\n # Crawler process declaration\\n process = CrawlerProcess({\\n 'USER_AGENT': 'David Avs Crawler',\\n 'FEED_FORMAT': 'json',\\n 'FEED_URI': 'stdout:',\\n 'LOG_ENABLED': args.verbose,\\n })\\n kwargs = dict(\\n start_urls=[args.url],\\n allowed_domains=[urlparse.urlparse(args.url).netloc.lower()],\\n )\\n\\n # Run crawling\\n old_stdout = sys.stdout\\n sys.stdout = args.file\\n try:\\n process.crawl(DavidAvsSpider, **kwargs)\\n process.start()\\n finally:\\n sys.stdout = old_stdout\",\n \"def main():\\n # Step1: generate htmls\\n csv_data_path= \\\"./frontend/html_template_data/dataset.csv\\\"\\n html_template_path = \\\"./frontend/html_template_data/template.html\\\"\\n html_save_path = \\\"./frontend/html_files/\\\"\\n\\n generate_htmls(csv_data_path, html_template_path, html_save_path)\\n\\n # Step2: push htmls to Github\\n # push htmls to Github Pages, currently manual.\",\n \"def _main():\\n import argparse\\n parser = argparse.ArgumentParser(description=__doc__)\\n group = parser.add_mutually_exclusive_group(required=True)\\n group.add_argument('--author', help='download works by this author')\\n parser.add_argument('-v', '--verbose', action='count', default=0,\\n help='increase logging verbosity')\\n args = parser.parse_args()\\n logging.basicConfig(level=logging.WARNING - 10 * args.verbose)\\n\\n download_texts(author=args.author)\",\n \"def scrape_main() -> None:\\n\\n logger.info(\\\"Starting scrape\\\")\\n search_info = construct_scrape_regex_patterns(grab_scrape_info())\\n links = run_scrape(\\n url=search_info['url'],\\n seasons_regex=search_info['seasons'],\\n episodes_regex=search_info['episodes']\\n )\\n if links:\\n logger.debug(\\\"Writing urls to file\\\")\\n with open('urls.txt', 'w') as f:\\n for link in links:\\n f.write(link + '\\\\n')\\n else:\\n logger.warning(\\\"No links available\\\")\",\n \"def main(*args, **kwargs):\\n src_mgr = SourceDriverManager()\\n fs_mgr = FileSystemManager()\",\n \"def main():\\n configuration = {'resource-folder': 'resources',\\n 'build-folder': 'build',\\n 'log-folder': 'logfiles',\\n 'use-preloaded': False,\\n 'addi-metrics': 'addi-metrics.json',\\n 'jenkins': {'dependency-filename': 'dependencies.txt',\\n 'server': 'http://is.dbc.dk',\\n 'repository-project': 'opensearch-3rd-party-dependencies'},\\n 'log-zip-file':'logs.zip'}\\n configuration.update(cli())\\n setup_logger(configuration['verbose'])\\n run_performance_test(configuration)\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description='Newsgroup post classifier')\\n parser.add_argument('--data_dir',\\n type=str,\\n help=\\\"Data directory\\\")\\n\\n args = parser.parse_args()\\n data_dir = args.data_dir\\n\\n example(data_dir=data_dir)\",\n \"def main(state=None, overwrite=False):\\n \\n # Initialize process\\n process = initialize_process()\\n\\n if overwrite:\\n # TODO: delete all (and only) files to be regenerated\\n pass\\n\\n # Add a spider instance for each state to be run\\n if state:\\n add_state_to_process(state, process=process)\\n else:\\n for s in list(CONFIG.keys()):\\n add_state_to_process(s, process=process)\\n\\n # Run scrape\\n process.start()\",\n \"def test(self, cmdline):\\n\\n if tm.UPDATE_BEFORE_TEST:\\n print \\\"Updating directory of source ...\\\"\\n mu.update_dir(tm.SOURCE_DIR)\\n\\n args = mu.get_second_arg(cmdline).strip().split()\\n if len(args) == 0:\\n print \\\"Invalid command, test [sourcename] ([maxThread] ([pageLimit]))\\\"\\n return\\n elif len(args) == 1:\\n self.sourcename, = args\\n self.max_thread = '5'\\n self.page_limit = '2'\\n elif len(args) == 2:\\n self.sourcename, self.max_thread = args\\n self.page_limit = '2'\\n elif len(args) == 3:\\n self.sourcename, self.max_thread, self.page_limit = args\\n\\n print \\\"Searching directory of %s ...\\\" % self.sourcename\\n self.sourcedir = mu.search_for_source(self.sourcename)\\n if not self.sourcedir:\\n print \\\"Directory of %s doesn't exist.\\\\n\\\" % self.sourcename\\n return\\n\\n self.sourcetype = self.get_source_type()\\n if self.sourcetype == 'blog':\\n process = BlogProcess(self.sourcename, self.sourcedir)\\n config_files = ('%s.xq' % self.sourcename, 'config.xml', 'globalConfig.xml', 'subSourceConfig.xml')\\n elif self.sourcetype == 'forum':\\n process = ForumProcess(self.sourcename, self.sourcedir, string.atoi(self.max_thread), self.page_limit)\\n config_files = ('%s-url.xq' % self.sourcename, '%s-thread.xq' % self.sourcename, 'finished.xml', 'webForumConfiguration.xml')\\n self.test_source(process, self.sourcedir, config_files)\",\n \"def main():\\n\\n parser = argparse.ArgumentParser('Download all data into a folder')\\n parser.add_argument('--homepage_url', help='url for adap-kdb homepage', required=True)\\n parser.add_argument('--msp_path', help='path for msv file', required=True)\\n parser.add_argument('--user_name', help='username for login', required=True)\\n parser.add_argument('--user_password', help='user password fpr login', required=True)\\n args = parser.parse_args()\\n\\n homepage_url = args.homepage_url\\n msp_path = args.msp_path\\n user_name = args.user_name\\n user_password = args.user_password\\n\\n individual_search_test(homepage_url, msp_path, user_name, user_password)\",\n \"def main() -> None:\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-c', '--configfile',\\n default=os.path.join(os.getcwd(), 'downloader.toml'),\\n help=\\\"Configuration file to load settings from (default: %(default)s).\\\")\\n parser.add_argument('-n', '--name',\\n default=platform.node(),\\n help=\\\"Host-specific name of the downloader (default: %(default)s).\\\")\\n parser.add_argument('-p', '--print-config',\\n action=\\\"store_true\\\", default=False,\\n help=\\\"Print the configuration and exit.\\\")\\n args = parser.parse_args()\\n\\n conf = Config.from_configfile(args.name, args.configfile)\\n\\n if args.print_config:\\n print(conf)\\n sys.exit(0)\\n\\n logging.basicConfig(format='%(levelname)-7s %(asctime)s %(message)s',\\n level=logging.INFO, datefmt=\\\"%Y-%m-%d %H:%M:%S\\\")\\n\\n run(conf)\",\n \"def main(args=sys.argv):\\n try:\\n # Set up logging.\\n logging.basicConfig(level=logging.WARN)\\n work_dir = args[1]\\n assert os.path.exists(work_dir), \\\"First argument to lsf_runner.py must be a directory that exists\\\"\\n do_work_on_compute_node(work_dir)\\n except Exception as exc:\\n # Dump encoded data that we will try to fetch using mechanize\\n print(exc)\\n raise\",\n \"def main(args=None):\",\n \"def main(args=None):\",\n \"def cmd_runner():\\n parser = argparse.ArgumentParser(description=\\\"Get news from extracted sources\\\")\\n parser.add_argument('-s', '--source', help=\\\"Name of the news source. Available options are: {}\\\"\\n .format(', '.join(\\n available_rss_feed_sources_user_prompt\\n )\\n ))\\n parser.add_argument('-t', '--top', help=\\\"Count of news items to show from top order. Default: 10\\\")\\n parser.add_argument('-v', '--version', action='version', version='%(prog)s {version}'.format(version=__version__))\\n\\n args = parser.parse_args()\\n \\n rss_feed_top_count = RSS_FEED_TOP_COUNT\\n if args.top:\\n if not args.top.isnumeric():\\n raise argparse.ArgumentTypeError('Provide a positive integer for --top argument')\\n \\n else:\\n rss_feed_top_count = int(args.top)\\n\\n if args.source:\\n source_name = args.source.lower()\\n print('Source argument found, validating...')\\n time.sleep(1)\\n source_name_is_valid = source_name in available_rss_feed_sources\\n \\n if not source_name_is_valid:\\n print(\\n 'Invalid input {0} for source. Available sources are {1} '\\n .format(source_name, ', '.join(available_rss_feed_sources_user_prompt)))\\n sys.exit()\\n \\n \\n rss_feed_details = {\\n 'rss_feed_url': '',\\n 'top': rss_feed_top_count,\\n 'source': source_name\\n }\\n rss_feed_url = rss_data_main._get_rss_feed_url_by_source(source_name)\\n if not rss_feed_url:\\n raise ValueError('RSS url not found for source {}'.format(source_name))\\n \\n rss_feed_details['rss_feed_url'] = rss_feed_url\\n\\n \\n rss_feed_details['top'] = rss_feed_top_count\\n \\n print('Getting news...\\\\n\\\\n')\\n time.sleep(1)\\n \\n feed_data = rss_feed_main._get(rss_feed_details)\\n feed_viewer(feed_data)\\n else:\\n print('--source argument not provided, getting data for all available sources...')\\n rss_feed_details_list = []\\n for source_name in available_rss_feed_sources:\\n rss_feed_details = {\\n 'rss_feed_url': '',\\n 'source': source_name,\\n 'top': rss_feed_top_count\\n }\\n rss_feed_url = rss_data_main._get_rss_feed_url_by_source(source_name)\\n if not rss_feed_url:\\n raise ValueError('RSS url not found for source {}'.format(source_name))\\n \\n rss_feed_details['rss_feed_url'] = rss_feed_url\\n rss_feed_details_list.append(rss_feed_details)\\n \\n with Pool(AVIALABLE_CPU_COUNT) as p:\\n feed_data_list = p.map(rss_feed_main._get, rss_feed_details_list) \\n # put list of lists in a single list\\n feed_data_flattened_list = []\\n for feed_data in feed_data_list:\\n feed_data_flattened_list.extend(feed_data) \\n\\n feed_viewer(feed_data_flattened_list)\",\n \"def main(args):\\n options = parse_cmd_parameters_(args)\\n execute_(options)\",\n \"def main(self):\\n try:\\n self.parse_args()\\n self.run()\\n return 0\\n except AnalysisBackendError as e:\\n L.error(e)\\n return 1\",\n \"def main_driver(args):\\n starttime = time.time()\\n\\n # Get all the schedd ads\\n schedd_ads = get_schedds(args)\\n logging.warning(\\\"&&& There are %d schedds to query.\\\", len(schedd_ads))\\n\\n pool = multiprocessing.Pool(processes=args.query_pool_size)\\n\\n if not args.skip_history:\\n htcondor_es.history.process_histories(schedd_ads=schedd_ads,\\n starttime=starttime,\\n pool=pool,\\n args=args)\\n\\n # Now that we have the fresh history, process the queues themselves.\\n if args.process_queue:\\n htcondor_es.queues.process_queues(schedd_ads=schedd_ads,\\n starttime=starttime,\\n pool=pool,\\n args=args)\\n\\n pool.close()\\n pool.join()\\n\\n logging.warning(\\\"@@@ Total processing time: %.2f mins\\\", ((time.time()-starttime)/60.))\\n\\n return 0\",\n \"def __main() :\\n launchTests()\",\n \"def main():\\n with open(\\\"page_data.yaml\\\", 'r') as inputstr:\\n config_data = yaml.safe_load(inputstr)\\n ointf = OutputInterface('template.txt')\\n table_data = get_song_artist_matches()\\n ofilen = config_data['directory'] + os.sep + 'common_songs.html'\\n title = 'Song Titles and Band Name Overlap'\\n header = ['No.', 'Artist', 'Peak', 'Date', 'Song/Artist', 'Peak',\\n 'Date', 'Song']\\n ointf.build_page(ofilen, title, header, fmt_table(table_data))\\n ointf.inject(XTRAEDIT)\\n ointf.output()\",\n \"def main(argv=sys.argv):\\n log = _setup_logging()\\n log.info(\\\"Starting {f} version {v} dataset manipulator\\\".format(\\n f=__file__, v=__VERSION__))\\n parser = get_parser()\\n args = parser.parse_args()\\n if args.debug:\\n log.setLevel(logging.DEBUG)\\n return args.func(args)\\n #return main_runner_default(argv[1:], get_parser(), log)\",\n \"def main(dummy_args=None):\\n ap = argparse.ArgumentParser(\\n description='Import test results to HP Quality Center.')\\n\\n # console or gui\\n ap.add_argument('--console', '-c', action='store_true')\\n\\n # console options\\n ap.add_argument('--url', '-u', help='the quality center url')\\n ap.add_argument('--domain', '-d', help='the quality center domain')\\n ap.add_argument('--project', '-p', help='the quality center project')\\n ap.add_argument('--username', '-U', help='the quality center username')\\n ap.add_argument('--password', '-P', help='the quality center password')\\n ap.add_argument('--source', '-r', help='the path to the test results file')\\n ap.add_argument('--destination', '-D',\\n help=('the path to where the results will be uploaded to '\\n 'in quality center'))\\n ap.add_argument('--attach_report', '-a',\\n help=('flag to zip and attach the test results folder to '\\n 'the folder specified in the source argument'))\\n ap.set_defaults(func=_handle_command)\\n\\n ap.parse_args().func(ap.parse_args())\",\n \"def main():\\n tester = Tester()\\n # parse args, load configuration and create all required objects.\\n tester.setup_experiment()\\n # GO!\\n tester.run_experiment()\",\n \"def run_spiders():\\n hour_limit = 3600 # in seconds\\n\\n settings = get_project_settings()\\n\\n # Uncomment the following block of code if you want to test the manager on\\n # the \\\"onepagetest\\\" to make sure the manager is working.\\n \\\"\\\"\\\"\\n settings[\\\"HTTPCACHE_ENABLED\\\"] = 1\\n settings[\\\"HTTPCACHE_EXPIRATION_SECS\\\"] = 0\\n settings[\\\"HTTPCACHE_STORAGE\\\"] = \\\"scrapy.extensions.httpcache.FilesystemCacheStorage\\\"\\n settings[\\\"HTTPCACHE_IGNORE_MISSING\\\"] = 1\\n settings[\\\"HTTPCACHE_DIR\\\"] = \\\"onepagetest\\\"\\n \\\"\\\"\\\"\\n\\n runner = CrawlerRunner(settings)\\n begin_time = datetime.now()\\n\\n d = runner.crawl(\\\"sb_spider\\\")\\n d.addBoth(lambda _: continue_crawl(d, runner, begin_time, hour_limit))\\n reactor.run()\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def main():\\n opt = parse_opts()\\n run(opt)\",\n \"def runSpider(spiderClass):\\n\\n\\tprocess = CrawlerProcess({\\n\\t\\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\\n\\t})\\n\\n\\tprocess.crawl(spiderClass)\\n\\tprocess.start() # the script will block here until the crawling is finished\",\n \"def main(*args):\\n commandline_arguments = list()\\n template_title = u'Deux colonnes'\\n\\n # Process global args and prepare generator args parser\\n local_args = pywikibot.handle_args(args)\\n gen = pg.GeneratorFactory()\\n\\n param_debug = False\\n param_first = None\\n \\n for arg in local_args:\\n if arg == '-d':\\n param_debug = True\\n elif arg.startswith('-b'):\\n param_first = arg[3:]\\n else:\\n commandline_arguments.append(arg)\\n\\n if not template_title:\\n pywikibot.error('Please specify either -template or -transcludes argument')\\n return\\n\\n if len(commandline_arguments) % 2:\\n raise ValueError # or something.\\n \\n fields = dict()\\n for i in range(0, len(commandline_arguments), 2): \\n fields[commandline_arguments[i]] = commandline_arguments[i + 1]\\n\\n generator = gen.getCombinedGenerator()\\n if not generator:\\n gen.handleArg(u'-transcludes:' + template_title)\\n generator = gen.getCombinedGenerator()\\n\\n bot = HarvestRobot(generator, template_title, fields, param_first, param_debug)\\n bot.run()\",\n \"def run_generic_spider( user_id\\t\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tspider_id\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\tdatamodel\\t\\t\\t= None,\\n\\t\\t\\t\\t\\t\\trun_spider_config\\t= None,\\n\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t= None\\n\\t\\t\\t\\t\\t\\t):\\n\\n\\tprint ()\\n\\tlog_scrap.info(\\\"--- run_generic_spider / spider_id : %s \\\", spider_id )\\n\\n\\t### WARNING !!! --> TEMPORARY SOLUTION\\n\\t### remove spider folder for spider_id in JOBDIR\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / cwd : %s\\\", os.getcwd() )\\n\\ttry :\\n\\t\\tshutil.rmtree( os.getcwd() + \\\"/\\\" + JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\texcept:\\n\\t\\tpass\\n\\tlog_scrap.debug(u\\\"--- run_generic_spider / removed folder : {}/{}\\\".format(JOBDIR_FOLDER, spider_id) )\\n\\n\\t# !!! spider is launched from main.py level !!!\\n\\t# all relative routes referring to this...\\n\\tlog_scrap.info(\\\"--- run_generic_spider / os.getcwd() : %s \\\", os.getcwd() )\\n\\n\\t### flattening run_spider_config : from nested to flat dict\\n\\tlog_scrap.info(\\\"--- run_generic_spider / 'flattenSpiderConfig()' on 'run_spider_config' --> 'spider_config_flat' ...\\\" )\\n\\tspider_config_flat = flattenSpiderConfig( run_spider_config )\\n\\n\\n\\t### settings for crawler\\n\\t# cf : https://hackernoon.com/how-to-crawl-the-web-politely-with-scrapy-15fbe489573d\\n\\n\\t### global settings for scrapy processes (see upper)\\n\\tlog_scrap.info(\\\"--- run_generic_spider / BOT_NAME : %s \\\", settings.get('BOT_NAME') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / USER_AGENT : %s \\\", settings.get('USER_AGENT') )\\n\\tlog_scrap.info(\\\"--- run_generic_spider / ITEM_PIPELINES : %s \\\", settings.get('ITEM_PIPELINES').__dict__ )\\n\\n\\n\\t# specific settings for this scrapy process\\n\\n\\t# settings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t, RETRY_TIMES )\\n\\t# settings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, CONCURRENT_ITEMS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t\\t, CONCURRENT_REQUESTS )\\n\\t# settings.set( \\\"CONCURRENT_REQUESTS_PER_DOMAIN\\\"\\t, CONCURRENT_REQUESTS_PER_DOMAIN )\\n\\t# settings.set( \\\"REDIRECT_MAX_TIMES\\\"\\t\\t\\t\\t, REDIRECT_MAX_TIMES )\\n\\t# settings.set( \\\"DOWNLOAD_MAXSIZE\\\" \\t\\t\\t\\t, DOWNLOAD_MAXSIZE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, DEPTH_PRIORITY )\\n\\t# settings.set( \\\"SCHEDULER_DISK_QUEUE\\\"\\t\\t\\t, SCHEDULER_DISK_QUEUE )\\n\\t# settings.set( \\\"DEPTH_PRIORITY\\\"\\t\\t\\t\\t\\t, SCHEDULER_MEMORY_QUEUE )\\n\\n\\t# settings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t\\t, RANDOMIZE_DOWNLOAD_DELAY )\\n\\t# cf : https://doc.scrapy.org/en/latest/topics/jobs.html#job-directory\\n\\tsettings.set( \\\"JOBDIR\\\"\\t\\t\\t\\t\\t\\t\\t, JOBDIR_FOLDER + \\\"/\\\" + spider_id )\\n\\n\\t## https://scrapy.readthedocs.io/en/0.12/topics/extensions.html#module-scrapy.contrib.closespider\\n\\n\\tsettings.set( \\\"CURRENT_SPIDER_ID\\\" \\t\\t\\t, spider_id )\\n\\tsettings.set( \\\"RETRY_TIMES\\\"\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"RETRY_TIMES\\\"] )\\n\\tsettings.set( \\\"CLOSESPIDER_ITEMCOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_ITEMS\\\"] )\\n\\t# settings.set( \\\"CLOSESPIDER_PAGECOUNT\\\"\\t\\t, spider_config_flat[\\\"LIMIT_PAGES\\\"] )\\n\\tsettings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t\\t, spider_config_flat[\\\"download_delay\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_ITEMS\\\"\\t\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_ITEMS\\\"] )\\n\\tsettings.set( \\\"CONCURRENT_REQUESTS\\\"\\t\\t\\t, spider_config_flat[\\\"CONCURRENT_REQUESTS\\\"] )\\n\\t# settings.set( \\\"DOWNLOAD_DELAY\\\" \\t\\t\\t\\t, DOWNLOAD_DELAY )\\n\\n\\tsettings.set( \\\"BOT_NAME\\\"\\t\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"BOT_NAME\\\"] )\\n\\tsettings.set( \\\"USER_AGENT\\\"\\t\\t\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"USER_AGENT\\\"] )\\n\\tsettings.set( \\\"ROBOTSTXT_OBEY\\\"\\t\\t\\t\\t\\t\\t, spider_config_flat[\\\"ROBOTSTXT_OBEY\\\"] )\\n\\tsettings.set( \\\"AUTOTHROTTLE_ENABLED\\\"\\t\\t\\t, spider_config_flat[\\\"AUTOTHROTTLE_ENABLED\\\"] )\\n\\tsettings.set( \\\"HTTPCACHE_ENABLED\\\"\\t\\t\\t\\t\\t, spider_config_flat[\\\"HTTPCACHE_ENABLED\\\"] )\\n\\tsettings.set( \\\"RANDOMIZE_DOWNLOAD_DELAY\\\"\\t, spider_config_flat[\\\"RANDOMIZE_DOWNLOAD_DELAY\\\"] )\\n\\n\\t### initiating crawler process\\n\\tlog_scrap.info(\\\"--- run_generic_spider / instanciate process ...\\\" \\t )\\n\\tprocess = CrawlerRunner( settings = settings )\\n\\n\\t### adding CrawlerRunner as deferred\\n\\tdef f(q):\\n\\t\\ttry:\\n\\t\\t\\t### send/create custom spider from run_spider_config\\n\\t\\t\\t### cf : https://stackoverflow.com/questions/35662146/dynamic-spider-generation-with-scrapy-subclass-init-error\\n\\n\\t\\t\\tdeferred = process.crawl( \\tGenericSpider,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tuser_id\\t\\t\\t\\t\\t\\t\\t= user_id,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdatamodel \\t\\t\\t\\t\\t= datamodel ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_id \\t\\t\\t\\t\\t= spider_id ,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tspider_config_flat\\t= spider_config_flat,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\ttest_limit\\t\\t\\t\\t\\t= test_limit\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t)\\n\\t\\t\\tdeferred.addBoth(lambda _: reactor.stop())\\n\\t\\t\\treactor.run()\\n\\t\\t\\tq.put(None)\\n\\t\\texcept Exception as e:\\n\\t\\t\\tq.put(e)\\n\\n\\t### putting task in queue and start\\n\\tq = Queue()\\n\\tp = Process(target=f, args=(q,))\\n\\tp.start()\\n\\tresult = q.get()\\n\\tp.join()\\n\\n\\tif result is not None:\\n\\t\\traise result\\n\\n\\n\\n\\tprint (\\\"\\\\n\\\\n{}\\\\n\\\".format(\\\"> > > \\\"*20))\",\n \"def main() -> None:\\n\\n download_data_tools.initial_message()\\n\\n # S&P 500 companies, initial year and time step\\n stocks: List[str] = download_data_tools.get_stocks(['all'])\\n dates: List[str] = ['1992-01', '2012-12']\\n time_step: str = '1d'\\n\\n # Basic folders\\n download_data_tools.start_folders()\\n\\n # Run analysis\\n # Download data\\n portfolio_download_data(stocks, dates, time_step)\\n\\n print('Ay vamos!!!')\",\n \"def main():\\n if len(sys.argv) > 1:\\n CFS3Site().help()\\n else:\\n print(sceptre_handler(dict()))\",\n \"def main(self, params):\\n pass\",\n \"def test_script(self) -> None:\\n main()\",\n \"def main(args):\\n parser = create_parser()\\n\\n if not args:\\n parser.print_usage()\\n sys.exit(1)\\n\\n parsed_args = parser.parse_args(args)\\n\\n urls = scrape_urls(parsed_args.webpage)\\n emails = scrape_emails(parsed_args.webpage)\\n phones = scrape_phones(parsed_args.webpage)\\n\\n if urls:\\n print(\\\"\\\\nURLS:\\\\n\\\\n\\\", '\\\\n'.join(urls))\\n else:\\n print(\\\"\\\\nURLS:\\\\n\\\\nNone\\\")\\n\\n if emails:\\n print(\\\"\\\\nEMAILS:\\\\n\\\\n\\\", '\\\\n'.join(emails))\\n else:\\n print(\\\"\\\\nEMAILS:\\\\n\\\\nNone\\\")\\n\\n if phones:\\n print(\\\"\\\\nPHONE NUMBERS:\\\\n\\\\n\\\", '\\\\n'.join(phones))\\n else:\\n print(\\\"\\\\nPHONE NUMBERS:\\\\n\\\\nNone\\\")\",\n \"def main(*args):\\n gen = None\\n xmlFilename = None\\n HTTPignore = []\\n\\n if isinstance(memento_client, ImportError):\\n warn('memento_client not imported: %s' % memento_client, ImportWarning)\\n\\n # Process global args and prepare generator args parser\\n local_args = pywikibot.handle_args(args)\\n genFactory = pagegenerators.GeneratorFactory()\\n\\n for arg in local_args:\\n if arg == '-talk':\\n config.report_dead_links_on_talk = True\\n elif arg == '-notalk':\\n config.report_dead_links_on_talk = False\\n elif arg == '-repeat':\\n gen = RepeatPageGenerator()\\n elif arg.startswith('-ignore:'):\\n HTTPignore.append(int(arg[8:]))\\n elif arg.startswith('-day:'):\\n config.weblink_dead_days = int(arg[5:])\\n elif arg.startswith('-xmlstart'):\\n if len(arg) == 9:\\n xmlStart = pywikibot.input(\\n u'Please enter the dumped article to start with:')\\n else:\\n xmlStart = arg[10:]\\n elif arg.startswith('-xml'):\\n if len(arg) == 4:\\n xmlFilename = i18n.input('pywikibot-enter-xml-filename')\\n else:\\n xmlFilename = arg[5:]\\n else:\\n genFactory.handleArg(arg)\\n\\n if xmlFilename:\\n try:\\n xmlStart\\n except NameError:\\n xmlStart = None\\n gen = XmlDumpPageGenerator(xmlFilename, xmlStart,\\n genFactory.namespaces)\\n\\n if not gen:\\n gen = genFactory.getCombinedGenerator()\\n if gen:\\n if not genFactory.nopreload:\\n # fetch at least 240 pages simultaneously from the wiki, but more\\n # if a high thread number is set.\\n pageNumber = max(30, config.max_external_links * 2)\\n pywikibot.output(\\\"Fetch %i pages.\\\" % pageNumber)\\n gen = pagegenerators.PreloadingGenerator(gen, groupsize=pageNumber)\\n gen = pagegenerators.RedirectFilterPageGenerator(gen)\\n bot = WeblinkCheckerRobot(gen, HTTPignore, config.weblink_dead_days)\\n try:\\n bot.run()\\n finally:\\n waitTime = 0\\n # Don't wait longer than 30 seconds for threads to finish.\\n while countLinkCheckThreads() > 0 and waitTime < 30:\\n try:\\n pywikibot.output(u\\\"Waiting for remaining %i threads to \\\"\\n u\\\"finish, please wait...\\\"\\n % countLinkCheckThreads())\\n # wait 1 second\\n time.sleep(1)\\n waitTime += 1\\n except KeyboardInterrupt:\\n pywikibot.output(u'Interrupted.')\\n break\\n if countLinkCheckThreads() > 0:\\n pywikibot.output(u'Remaining %i threads will be killed.'\\n % countLinkCheckThreads())\\n # Threads will die automatically because they are daemonic.\\n if bot.history.reportThread:\\n bot.history.reportThread.shutdown()\\n # wait until the report thread is shut down; the user can\\n # interrupt it by pressing CTRL-C.\\n try:\\n while bot.history.reportThread.isAlive():\\n time.sleep(0.1)\\n except KeyboardInterrupt:\\n pywikibot.output(u'Report thread interrupted.')\\n bot.history.reportThread.kill()\\n pywikibot.output(u'Saving history...')\\n bot.history.save()\\n return True\\n else:\\n pywikibot.bot.suggest_help(missing_generator=True)\\n return False\",\n \"def main():\\n \\n usage = \\\"\\\"\\\"usage: %prog [target]\\nTargets :\\n\\tall\\t\\tCompile all projects in csunplugged directory\\n\\tindex\\t\\tCreate the index page\\n\\tdirectory\\tCompile single project in csunplugged directory\\n \\\"\\\"\\\"\\n parser = optparse.OptionParser(usage)\\n \\n (options, args) = parser.parse_args()\\n if not (len(args) == 1) :\\n parser.error('incorrect number of arguments')\\n \\n if args[0]=='all' :\\n build_all()\\n \\n elif args[0]=='index' :\\n make_index_page()\\n \\n else :\\n jsFile = args[0] + '.js'\\n jsFilePath = os.path.join(csunpluggedPath, args[0], jsFile)\\n if not os.path.exists(jsFilePath) :\\n print 'Can not found ' + jsFilePath+'\\\\n' \\n else :\\n \\tbuild(args[0])\",\n \"def main():\\n\\n browser = initialize()\\n process_directory(browser, \\\"data\\\")\\n browser.close()\",\n \"def main():\\n test_network_connection()\\n parser()\",\n \"def main():\\r\\n\\tlang = get_arguments()\\r\\n\\twiki_analyzer(lang)\",\n \"def run_main():\\n\\n #Check for sold bikes\\n checkSold(auto=True) #Change Auto to True to prevent user input\\n\\n #Find all available URLs split by Make & Model - Find Make\\n print(\\\"Getting Makes...\\\")\\n makes = getMakes()\\n \\n #Find all Models for each Make\\n print(\\\"Getting Models...\\\")\\n models = []\\n for make in tqdm(makes, desc=\\\"Makes\\\"):\\n models += getModels(make)\\n\\n\\n #Find all URLs for each Model - Scrape bikes on each model\\n errlog = \\\"\\\"\\n print(\\\"Scraping Bikes...\\\")\\n for model in tqdm(models, desc=\\\"Models\\\"):\\n #Get urls for each model\\n urlsTemp = getURLs(model)\\n\\n #Remove duplicates\\n urlsTemp = removeDups(urlsTemp)\\n\\n #Remove listings already found\\n urlsTemp = newURLs(\\\"motorcycles\\\", urlsTemp)\\n\\n #Get model description\\n try:\\n modelDesc = model.split(\\\"/\\\")[2].replace(\\\"model-\\\", \\\"\\\")\\n except:\\n modelDesc = \\\"Listings\\\"\\n\\n #Find motorbike details on all urls for this model\\n #Split by model to prevent large datasets changing during code runtime\\n for url in tqdm(urlsTemp, desc=modelDesc, leave=False):\\n temp = Motorcycle(url)\\n if not temp.na:\\n temp.dbInsert()\\n else:\\n errlog += url + \\\"|\\\"\\n \\n #Finish\\n if not errlog:\\n print(\\\"Errors Found: \\\", errlog)\\n if not printlog:\\n print(printlog)\\n \\n print(\\\"Done!\\\")\",\n \"def main(self, options):\\n raise NotImplementedError\",\n \"def main():\\n settings.configure(\\n INSTALLED_APPS=(\\n 'rtl_django_tools',\\n 'django.contrib.sites',\\n 'django.contrib.auth',\\n 'django.contrib.contenttypes',\\n 'django.contrib.sessions',\\n 'django_nose',\\n 'registration',\\n ),\\n TEST_RUNNER = 'django_nose.NoseTestSuiteRunner',\\n DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3',\\n 'NAME': '/tmp/registration.db',\\n 'USER': '',\\n 'PASSWORD': '',\\n 'HOST': '',\\n 'PORT': ''}},\\n NOSE_ARGS=['--with-xunit', '-s'],\\n ROOT_URLCONF=None,\\n TEMPLATE_DIRS = (\\n os.path.join(THIS_DIR, 'templates'),\\n ),\\n FIXTURES_DIR=(\\n os.path.join(THIS_DIR, 'fixtures'),\\n ),\\n SITE_ID=1,\\n )\\n\\n call_command('test', 'registration')\",\n \"def main(args=None):\\n\\n args, _ = root_parser.parse_known_args(args=args)\\n import_path = ENTRY_POINTS[args.test]\\n module = import_module(import_path)\\n main_fnc = getattr(module, \\\"main\\\")\\n _check_main(main_fnc)\\n if args.dry:\\n return\\n main_fnc()\",\n \"def main():\\n #print( \\\"main() entered...\\\" )\\n initialize()\\n getCmdOptions()\\n printVersionInfo()\\n\\n rc = doWork()\\n\\n cleanUp()\\n sys.exit(rc)\",\n \"def main():\\n setup(**setup_params)\",\n \"def main(args=None):\\n args = args or sys.argv[1:]\\n parser = parse_options()\\n common.main_cli(experiment_parse_and_run, parser, args)\",\n \"def run(self):\\n\\n #Load old cache\\n if '-r' not in sys.argv:\\n old_db = SiteDB([], 'upwork')\\n old_db.load()\\n\\n #Set it to current DBs old cache\\n self.db.pred = old_db.cache\\n\\n #Generate crawler object\\n \\n crawler = self.generate_crawler()\\n\\n #Generate DB for latest scan\\n if '-full' not in sys.argv:\\n self.db = crawler.crawl()\\n else:\\n _ = crawler.crawl()\\n\\n if '-r' not in sys.argv:\\n #Get deleted info\\n _ = self.db.compare(old_db)\\n\\n targets = ['https://community.upwork.com/t5/Announcements/bd-p/news', \\\\\\n 'https://community.upwork.com/t5/Freelancers/bd-p/freelancers', \\\\\\n 'https://community.upwork.com/t5/Clients/bd-p/clients', \\\\\\n 'https://community.upwork.com/t5/Agencies/bd-p/Agencies']\\n target = None\\n for tar in targets:\\n if tar in sys.argv:\\n target = tar\\n\\n #Write result\\n #self.db.write(target_name=target)\",\n \"def main():\\n\\n args = parse_arguments(sys.argv[1:])\\n configure_logging(args.debug)\\n\\n if(args.subcommand):\\n logging.debug(\\\"Executing sub-command \\\" + args.subcommand)\\n\\n if(args.subcommand == \\\"build\\\"):\\n build(args)\\n elif(args.subcommand == \\\"init\\\"):\\n init(args)\\n elif(args.subcommand == \\\"new\\\"):\\n init_new_entry(args, args.buildpage)\\n\\n logging.debug(\\\"Done. Exiting.\\\")\",\n \"def run():\\n\\n call_args = sys.argv[1:]\\n main(call_args)\",\n \"def main(*args):\\n options = {}\\n local_args = pywikibot.handle_args(args)\\n site = pywikibot.Site()\\n site.login()\\n gen_factory = GeneratorFactory(site)\\n for arg in local_args:\\n if gen_factory.handleArg(arg):\\n continue\\n arg, _, value = arg.partition(':')\\n arg = arg[1:]\\n if arg == 'config':\\n if not value:\\n value = pywikibot.input(\\n 'Please enter a value for {}'.format(arg), default=None\\n )\\n options[arg] = value\\n else:\\n options[arg] = True\\n gen = gen_factory.getCombinedGenerator(preload=True)\\n if 'config' not in options:\\n pywikibot.bot.suggest_help(missing_parameters=['config'])\\n return False\\n config = get_json_from_page(pywikibot.Page(site, options.pop('config')))\\n if validate_config(config):\\n options.update(config)\\n else:\\n pywikibot.error('Invalid config.')\\n return False\\n MagicLinksReplacer(gen, site=site, **options).run()\\n return True\",\n \"def main():\\n\\n # Parse arguments using `optparse'\\n (opts, _) = parse_arguments(sys.argv[1:])\\n\\n # Initialize burnin\\n (testsuites, failfast) = \\\\\\n common.initialize(opts, TSUITES_NAMES, STALE_TSUITES_NAMES)\\n testsuites = string_to_class(testsuites)\\n\\n # Run burnin\\n # The return value denotes the success status\\n return common.run_burnin(testsuites, failfast=failfast)\",\n \"def main():\\n parser = ArgumentParser(description=\\\"pre-process nexus templates\\\")\\n parser.add_argument(\\n \\\"nexus_templates\\\",\\n nargs=\\\"+\\\",\\n help=\\\"Nexus template files to process\\\",\\n )\\n args = parser.parse_args()\\n\\n for template_file in args.nexus_templates:\\n preprocess_template(template_file)\",\n \"def main():\\n\\tcli = Cli()\\n\\tcli.run()\",\n \"def main():\\n feed_url = ( len(sys.argv) > 2 ) and sys.argv[2] or FEED_URL\\n\\n f = AmazonAdFeed(feed_url)\\n f.STATE_FN = 'link_amazon_ads_state'\\n \\n if len(sys.argv) > 1 and sys.argv[1] == 'rss':\\n print f.scrape_rss()\\n else:\\n print f.scrape_atom()\",\n \"def main():\\n # Initialization\\n args = init_args()\\n config = init_config(args.config_file)\\n logger = init_logging(location=config['main']['log_location'],\\n level=parse_log_level(config['main']['log_level']))\\n\\n logger.info(\\\"DeltaSherlock Version %s\\\", VERSION)\\n logger.debug(\\\"Logger initialized: %s yielded %s with level %i\\\",\\n config['main']['log_location'], str(logger),\\n logger.getEffectiveLevel())\\n logger.debug(\\\"Command line arguments loaded: %s\\\", str(args))\\n logger.debug(\\\"Config file loaded: %s yielded %s\\\",\\n args.config_file, str(config))\\n\\n if args.daemon:\\n # Exceute the central loop\\n interval = config['daemon'].getint('interval')\\n logger.debug(\\\"Entering daemon mode loop with interval %i\\\", interval)\\n else:\\n # Perform one check, then exit\\n logger.debug(\\\"Daemon mode disabled. Running once then exiting\\\")\",\n \"def parse_arguments(args):\\n\\n parent_parser = argparse.ArgumentParser(add_help=False)\\n parent_parser.add_argument('--debug', '-d', action='count', default=0)\\n parent_parser.add_argument('--version', '-v', action='version',\\n version='%(prog)s {version}'.format(version=version.__version__))\\n\\n main_parser = argparse.ArgumentParser(parents=[parent_parser],\\n description='The lightweight static website generator')\\n\\n subparsers = main_parser.add_subparsers(help=\\\"sub-command to be executed\\\",\\n dest=\\\"subcommand\\\")\\n subparsers.required = True\\n\\n parser_build = subparsers.add_parser('build', parents=[parent_parser],\\n help=\\\"Build static site from local directory to the directory specified in config.yml\\\")\\n\\n parser_build.add_argument('--build-src', '-s', dest=\\\"src\\\", type=str, default=\\\"\\\",\\n help='directory to load source')\\n\\n parser_build.add_argument('--build-dst', '-ds', dest=\\\"dest\\\", type=str,\\n default=paths.DEFAULT_BUILDDIR,\\n help='build and install website in passed directory')\\n\\n parser_build.add_argument('--no-clean', '-nc', dest=\\\"noclean\\\",\\n default=False, action='store_true',\\n help='do not clean build directory before installation')\\n\\n parser_build.add_argument('--config-file', '-cf', dest=\\\"configfile\\\",\\n default=paths.CFG_FILE, type=str,\\n help='use a non default config file')\\n\\n parser_build.add_argument('--auto-baseurl', dest=\\\"autobaseurl\\\",\\n default=False, action='store_true',\\n help='override baseurl and set it to build destination (useful for local builds)')\\n\\n parser_init = subparsers.add_parser('init', parents=[parent_parser],\\n help=\\\"Initialize a new, clean website in current directory.\\\")\\n\\n parser_init.add_argument('--dir', dest=\\\"dir\\\", type=str,\\n default=paths.DEFAULT_INITDIR,\\n help='Initialize website in passed directory')\\n\\n parser_new = subparsers.add_parser('new', parents=[parent_parser],\\n help=\\\"Initialize a fresh, new post file (--page for a page).\\\")\\n\\n parser_new.add_argument('--build-src', '-s', dest=\\\"src\\\", type=str, default=\\\"\\\",\\n help='juliet source directory where to initialize post/page')\\n\\n parser_new.add_argument('--file-name', '-f', dest=\\\"file_name\\\", nargs='?',\\n default=None, help='file name for new post/page')\\n\\n parser_new.add_argument('--page', dest=\\\"buildpage\\\", default=False, action='store_true',\\n help='build a new page (instead of a new post)')\\n\\n parser_new.add_argument('header_content', default=[],\\n nargs=argparse.REMAINDER, help='header content of the new post/page')\\n\\n return main_parser.parse_args(args)\",\n \"def main():\\n logging.basicConfig(\\n level=logging.DEBUG, format=\\\"%(levelname)s: %(message)s\\\")\\n root.add_command(all_)\\n root.add_command(build)\\n root.add_command(cleanup)\\n root.add_command(clitest)\\n root.add_command(run)\\n root.add_command(push)\\n root.add_command(unittest)\\n root.add_command(list_images)\\n root.add_command(list_stages)\\n root()\",\n \"def setup(args=None):\\n\\n # Setup API server\\n api = ParadropAPIServer(reactor)\\n api.putChild('internal', Base(apiinternal, allowNone=True))\\n site = Site(api, timeout=None)\\n\\n # Development mode\\n if(args and args.development):\\n thePort = settings.PDFCD_PORT + 10000\\n out.info('Using DEVELOPMENT variables')\\n # Disable sending the error traceback to the client\\n site.displayTracebacks = True\\n elif(args and args.unittest):\\n thePort = settings.PDFCD_PORT + 20000\\n out.info('Running under unittest mode')\\n site.displayTracebacks = True\\n else:\\n thePort = settings.PDFCD_PORT\\n site.displayTracebacks = False\\n initializeSystem()\\n\\n # Setup the port we listen on\\n reactor.listenTCP(thePort, site)\\n\\n # Never return from here\\n reactor.run()\",\n \"def main():\\n grid_tester_cpu = GridTesterCPU()\\n\\n # parse args, load configuration and create all required objects.\\n grid_tester_cpu.setup_grid_experiment()\\n\\n # GO!\\n grid_tester_cpu.run_grid_experiment()\",\n \"def main():\\n args = parse_args()\\n\\n make_session = bootstrap(\\n 'sqlite:///{}'.format(DB_NAME),\\n )\\n session = make_session()\\n\\n for vase in session.query(Vase).order_by(Vase.produced_start):\\n for query_str in make_searches(vase):\\n pass\",\n \"def main():\\n run_test_all()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70166576","0.69471085","0.6813321","0.66161793","0.6571456","0.63922524","0.6328098","0.63057745","0.62522024","0.6190267","0.6187147","0.61624885","0.6162456","0.6151359","0.6139654","0.6124047","0.6120733","0.6099212","0.6035318","0.60084355","0.5996641","0.59817743","0.5963839","0.5962803","0.596178","0.59547764","0.59191805","0.59070307","0.5904539","0.59036225","0.5900063","0.5886124","0.58653927","0.58653927","0.5853289","0.5839178","0.58274317","0.5825567","0.5825184","0.5822074","0.5819334","0.5817451","0.5813425","0.5812994","0.58079666","0.58041966","0.5803616","0.57822376","0.5781859","0.5779766","0.57784945","0.5765172","0.57603765","0.57603765","0.5757183","0.57438236","0.57311034","0.57213914","0.57158995","0.57080686","0.5708062","0.57074124","0.5706722","0.5706033","0.57007694","0.57007694","0.56921554","0.56837624","0.5677966","0.5664493","0.5663105","0.56547105","0.5654342","0.56500304","0.56495124","0.5647341","0.5625909","0.56251127","0.56246936","0.5622069","0.5614545","0.5607988","0.56070006","0.5603626","0.5598714","0.5594609","0.55697113","0.55643296","0.5561282","0.5550747","0.5532561","0.55318564","0.5527101","0.55238426","0.5522382","0.5515942","0.5513232","0.55105376","0.55072016","0.550709","0.55064684"],"string":"[\n \"0.70166576\",\n \"0.69471085\",\n \"0.6813321\",\n \"0.66161793\",\n \"0.6571456\",\n \"0.63922524\",\n \"0.6328098\",\n \"0.63057745\",\n \"0.62522024\",\n \"0.6190267\",\n \"0.6187147\",\n \"0.61624885\",\n \"0.6162456\",\n \"0.6151359\",\n \"0.6139654\",\n \"0.6124047\",\n \"0.6120733\",\n \"0.6099212\",\n \"0.6035318\",\n \"0.60084355\",\n \"0.5996641\",\n \"0.59817743\",\n \"0.5963839\",\n \"0.5962803\",\n \"0.596178\",\n \"0.59547764\",\n \"0.59191805\",\n \"0.59070307\",\n \"0.5904539\",\n \"0.59036225\",\n \"0.5900063\",\n \"0.5886124\",\n \"0.58653927\",\n \"0.58653927\",\n \"0.5853289\",\n \"0.5839178\",\n \"0.58274317\",\n \"0.5825567\",\n \"0.5825184\",\n \"0.5822074\",\n \"0.5819334\",\n \"0.5817451\",\n \"0.5813425\",\n \"0.5812994\",\n \"0.58079666\",\n \"0.58041966\",\n \"0.5803616\",\n \"0.57822376\",\n \"0.5781859\",\n \"0.5779766\",\n \"0.57784945\",\n \"0.5765172\",\n \"0.57603765\",\n \"0.57603765\",\n \"0.5757183\",\n \"0.57438236\",\n \"0.57311034\",\n \"0.57213914\",\n \"0.57158995\",\n \"0.57080686\",\n \"0.5708062\",\n \"0.57074124\",\n \"0.5706722\",\n \"0.5706033\",\n \"0.57007694\",\n \"0.57007694\",\n \"0.56921554\",\n \"0.56837624\",\n \"0.5677966\",\n \"0.5664493\",\n \"0.5663105\",\n \"0.56547105\",\n \"0.5654342\",\n \"0.56500304\",\n \"0.56495124\",\n \"0.5647341\",\n \"0.5625909\",\n \"0.56251127\",\n \"0.56246936\",\n \"0.5622069\",\n \"0.5614545\",\n \"0.5607988\",\n \"0.56070006\",\n \"0.5603626\",\n \"0.5598714\",\n \"0.5594609\",\n \"0.55697113\",\n \"0.55643296\",\n \"0.5561282\",\n \"0.5550747\",\n \"0.5532561\",\n \"0.55318564\",\n \"0.5527101\",\n \"0.55238426\",\n \"0.5522382\",\n \"0.5515942\",\n \"0.5513232\",\n \"0.55105376\",\n \"0.55072016\",\n \"0.550709\",\n \"0.55064684\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85189,"cells":{"query":{"kind":"string","value":"Prepare inputs for GTN, topo input and feat input together."},"document":{"kind":"string","value":"def gen_input(args, datareader, bkd_gids):\n As = {}\n Xs = {}\n for gid in bkd_gids:\n if gid not in As: As[gid] = torch.tensor(datareader.data['adj_list'][gid], dtype=torch.float)\n if gid not in Xs: Xs[gid] = torch.tensor(datareader.data['features'][gid], dtype=torch.float)\n Ainputs = {}\n Xinputs = {}\n \n if args.gtn_input_type == '1hop':\n for gid in bkd_gids:\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n elif args.gtn_input_type == '2hop':\n for gid in bkd_gids:\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\n torch.tensor(0.0, requires_grad=True))\n As[gid].fill_diagonal_(0.0)\n \n for gid in bkd_gids:\n if gid not in Ainputs: Ainputs[gid] = As[gid].clone().detach()\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n \n elif args.gtn_input_type == '1hop_degree': \n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\n \n for i in range(len(bkd_gids)):\n gid = bkd_gids[i]\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n \n elif args.gtn_input_type == '2hop_degree':\n for gid in bkd_gids:\n As[gid] = torch.add(As[gid], torch.mm(As[gid], As[gid]))\n As[gid] = torch.where(As[gid]>0, torch.tensor(1.0, requires_grad=True),\n torch.tensor(0.0, requires_grad=True))\n As[gid].fill_diagonal_(0.0)\n \n rowsums = [torch.add(torch.sum(As[gid], dim=1), 1e-6) for gid in bkd_gids]\n re_Ds = [torch.diag(torch.pow(rowsum, -1)) for rowsum in rowsums]\n \n for i in range(len(bkd_gids)):\n gid = bkd_gids[i]\n if gid not in Ainputs: Ainputs[gid] = torch.mm(re_Ds[i], As[gid])\n if gid not in Xinputs: Xinputs[gid] = torch.mm(Ainputs[gid], Xs[gid])\n \n else: raise NotImplementedError('not support other types of aggregated inputs')\n\n # pad each input into maxi possible size (N, N) / (N, F)\n NodeMax = int(datareader.data['n_node_max'])\n FeatDim = np.array(datareader.data['features'][0]).shape[1]\n for gid in Ainputs.keys():\n a_input = Ainputs[gid]\n x_input = Xinputs[gid]\n \n add_dim = NodeMax - a_input.shape[0]\n Ainputs[gid] = np.pad(a_input, ((0, add_dim), (0, add_dim))).tolist()\n Xinputs[gid] = np.pad(x_input, ((0, add_dim), (0, 0))).tolist()\n Ainputs[gid] = torch.tensor(Ainputs[gid])\n Xinputs[gid] = torch.tensor(Xinputs[gid])\n\n return Ainputs, Xinputs"},"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 construct_inputs(\n cls,\n training_data: Dict[str, SupervisedDataset],\n task_feature: int,\n rank: Optional[int] = None,\n **kwargs: Any,\n ) -> Dict[str, Any]:\n inputs = super().construct_inputs(\n training_data=training_data, task_feature=task_feature, rank=rank, **kwargs\n )\n inputs.pop(\"task_covar_prior\")\n if \"train_Yvar\" not in inputs:\n inputs[\"train_Yvar\"] = None\n return inputs","def preprocess(self, first_inputs,second_inputs,third_inputs):\r\n pass","def _prep_inputs(self):\n if self.x is not None:\n self.x = np.array(self.x)\n\n if self.y is not None:\n self.y = np.array(self.y)\n\n if self.z is not None:\n for k in self.z.keys():\n self.z[k] = np.array(self.z[k])","def prepare_data_inputs(self, process, inputs, domain, **kwargs):\n temp_process = process.copy()\n\n domains = {}\n\n if domain is not None:\n domains[domain.name] = domain\n\n temp_process.domain = domain\n\n if not isinstance(inputs, (list, tuple)):\n inputs = [inputs, ]\n\n temp_process.inputs.extend(inputs)\n\n if 'gridder' in kwargs:\n temp_process.gridder = kwargs.pop('gridder')\n\n temp_process.add_parameters(**kwargs)\n\n processes, variables = temp_process.collect_input_processes()\n\n # Collect all the domains from nested processes\n for item in list(processes.values()):\n if item.domain is not None and item.domain.name not in domains:\n domains[item.domain.name] = item.domain\n\n variable = json.dumps([x.to_dict() for x in list(variables.values())])\n\n domain = json.dumps([x.to_dict() for x in list(domains.values())])\n\n operation = json.dumps([x.to_dict() for x in list(processes.values())])\n\n return variable, domain, operation","def prepare_infer_input(insts, bos_idx, eos_idx, src_pad_idx, n_head):\n src_word, src_pos, src_slf_attn_bias, src_max_len = pad_batch_data(\n [inst[0] + [eos_idx] for inst in insts],\n src_pad_idx,\n n_head,\n is_target=False)\n trg_src_attn_bias = np.tile(src_slf_attn_bias[:, :, ::src_max_len, :],\n [1, 1, 1, 1]).astype(\"float32\")\n src_word = src_word.reshape(-1, src_max_len)\n src_pos = src_pos.reshape(-1, src_max_len)\n\n data_inputs = [src_word, src_pos, src_slf_attn_bias, trg_src_attn_bias]\n return data_inputs","def process_inputs(self, inputs):","def processInputs(self):","def setup(self):\n\n for name, infos in Rt.geom_dict.items():\n if name in Rt.optim_var_dict:\n self.add_input(name, val=infos[1][0])","def prepare_inputs(self, **inputs):\n true_inputs = {'imain_loc' : self.get_input_tensor(0, 'loc'),\n 'imain_prec' : self.get_input_tensor(0, 'prec'),\n 'ids_prec' : self.get_input_tensor(1, 'prec'),\n 'ids_A' : self.get_input_tensor(1, 'A'),\n 'iprior_scale' : self.get_input_tensor(2, 'scale')}\n \n if inputs:\n print(\"\\t\\tUpdating defaults,\", self.name, \"with\", list(inputs.keys()))\n true_inputs.update(inputs)\n return true_inputs","def _prepare_data(self):\n #TODO hardcoded values need to change\n print_info(\"Preprocessing the train data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"train\"),\n self.TRAIN_OUT_PATH)\n\n print_info(\"Preprocessing the test data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"test\"),\n self.TEST_OUT_PATH)\n\n print_info(\"Preprocessing the validation data...\")\n self._place_dataset(os.path.join(self._hparams[\"temp-data\"], \"val\"),\n self.VAL_OUT_PATH)","def _prepare_input_for_export(args, kwargs):\n args, kwargs = _prepare_input_for_pytorch(args, kwargs)\n if not kwargs and len(args) > 0 and isinstance(args[-1], dict):\n onnx_inputs = args + ({},)\n elif kwargs:\n onnx_inputs = args + (kwargs,)\n else:\n onnx_inputs = args\n return onnx_inputs","def prepare_train_input(insts, bos_idx, eos_idx, src_pad_idx, trg_pad_idx,\n n_head):\n src_word, src_pos, src_slf_attn_bias, src_max_len = pad_batch_data(\n [inst[0] + [eos_idx] for inst in insts],\n src_pad_idx,\n n_head,\n is_target=False)\n src_word = src_word.reshape(-1, src_max_len)\n src_pos = src_pos.reshape(-1, src_max_len)\n trg_word, trg_pos, trg_slf_attn_bias, trg_max_len = pad_batch_data(\n [[bos_idx] + inst[1] for inst in insts],\n trg_pad_idx,\n n_head,\n is_target=True)\n trg_word = trg_word.reshape(-1, trg_max_len)\n trg_pos = trg_pos.reshape(-1, trg_max_len)\n\n trg_src_attn_bias = np.tile(src_slf_attn_bias[:, :, ::src_max_len, :],\n [1, 1, trg_max_len, 1]).astype(\"float32\")\n\n lbl_word, lbl_weight, num_token = pad_batch_data(\n [inst[1] + [eos_idx] for inst in insts],\n trg_pad_idx,\n n_head,\n is_target=False,\n is_label=True,\n return_attn_bias=False,\n return_max_len=False,\n return_num_token=True)\n lbl_word = lbl_word.reshape(-1, 1)\n lbl_weight = lbl_weight.reshape(-1, 1)\n\n data_inputs = [\n src_word, src_pos, src_slf_attn_bias, trg_word, trg_pos,\n trg_slf_attn_bias, trg_src_attn_bias, lbl_word, lbl_weight\n ]\n\n return data_inputs","def _buildInput (self):\n\n\t\tindata = self.config['input']\n\t\tif not isinstance (indata, dict):\n\t\t\tindata = ','.join(utils.alwaysList (indata))\t\t\t\n\t\t\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\n\t\t\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\n\t\t\t\n\t\t# expand to one key-channel pairs\n\t\tfor inkeys, invals in indata.iteritems():\n\t\t\tkeys = utils.split(inkeys, ',')\n\t\t\tif callable (invals):\n\t\t\t\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\n\t\t\t\tvals = vals.split()\n\t\t\telif isinstance (invals, basestring): # only for files: \"/a/b/*.txt, /a/c/*.txt\"\n\t\t\t\tvals = utils.split(invals, ',')\n\t\t\telif isinstance (invals, channel):\n\t\t\t\tvals = invals.split()\n\t\t\telif isinstance (invals, list):\n\t\t\t\tvals = channel.create(invals).split()\n\t\t\telse:\n\t\t\t\traise ValueError (\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\" % self._name())\n\t\t\t\n\t\t\twidth = len (vals)\n\t\t\tif len (keys) > width:\n\t\t\t\traise ValueError ('%s: Not enough data for input variables.\\nVarialbes: %s\\nData: %s' % (self._name(), keys, vals))\n\t\t\t\n\t\t\tfor i, key in enumerate(keys):\n\t\t\t\tintype = key.split(':')[-1]\n\t\t\t\tthekey = key.split(':')[0]\n\t\t\t\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\n\n\t\t\t\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\n\t\t\t\t\tintype = proc.IN_VARTYPE[0]\n\t\t\t\t\n\t\t\t\tif intype in proc.IN_FILESTYPE:\n\t\t\t\t\tfor x, v in enumerate(val):\n\t\t\t\t\t\tif isinstance (v, basestring):\n\t\t\t\t\t\t\tval[x] = channel.fromPath (v).toList()\n\t\t\t\t\n\t\t\t\tif self.length == 0: \n\t\t\t\t\tself.props['length'] = len (val)\n\t\t\t\tif self.length != len (val):\n\t\t\t\t\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\n\t\t\t\tself.props['indata'][thekey] = {\n\t\t\t\t\t'type': intype,\n\t\t\t\t\t'data': val\n\t\t\t\t}\n\t\t\tself.props['jobs'] = [None] * self.length","def extract_features(self, inputs):\n pass","def input_setup(config):\n # Load data path, if is_train False, get test data\n data = load_data(config.is_train, config.test_img)\n \n # Make sub_input and sub_label, if is_train false more return nx, ny\n if config.is_train:\n \tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_train(data, config)\n else:\n\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_test(data, config)\n\n\n # Make list to numpy array. With this transform\n arrinput = np.asarray(sub_input_sequence) # [?, 41, 41, 3]\n arrlabel = np.asarray(sub_label_sequence) # [?, 41, 41, 3]\n make_data_hf(arrinput, arrlabel, config)\n\n return nx, ny","def build_inputs(self):\n if self.mode == \"encode\":\n # Word embeddings are fed from an external vocabulary which has possibly\n # been expanded (see vocabulary_expansion.py).\n encode_ids1 = None\n encode_ids2 = None\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask1\")\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask2\")\n label = None\n\n elif self.mode == \"test\":\n encode_ids1 = None\n encode_ids2 = None\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask1\")\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\"encode_mask2\")\n label = None\n \n else:\n # Prefetch serialized tf.Example protos.\n input_queue = input_ops.prefetch_input_data(\n self.reader,\n self.config.input_file_pattern,\n shuffle=self.config.shuffle_input_data,\n capacity=self.config.input_queue_capacity,\n num_reader_threads=self.config.num_input_reader_threads)\n\n # Deserialize a batch.\n serialized = input_queue.dequeue_many(self.config.batch_size)\n s1, s2, label = input_ops.parse_example_batch(\n serialized)\n\n encode_ids1 = s1.ids\n encode_ids2 = s2.ids\n\n encode_mask1 = s1.mask\n encode_mask2 = s2.mask\n \n\n\n self.encode_ids1 = encode_ids1\n self.encode_ids2 = encode_ids2\n\n self.encode_mask1 = encode_mask1\n self.encode_mask2 = encode_mask2\n\n self.label = label","def setup_layers(self, params):\n\n #\n # Input layer\n #\n\n # Input and encoding layers\n layer_stack = [\n tf.placeholder(\n tf.int32,\n name=\"input\",\n shape=[None, params.in_size]\n )\n ]\n\n in_layer = layer_stack[0]\n\n good_chars = getattr(params, 'good_chars', tops.TextProcessor.DEFAULT_CHARS)\n character_depth = len(good_chars) + 2\n\n layer_stack.append(\n self.make_onehot_encode_layer(\n layer_stack[-1],\n character_depth\n )\n )\n\n # Add conv layers\n for idx, num_nodes in enumerate(params.conv_nodes):\n layer_stack.append(\n self.make_conv_layer(\n layer_stack[-1],\n num_nodes,\n 'conv_{}'.format(idx),\n params.conv_params\n )\n )\n\n # Flatten convolutional layers\n layer_stack.append(\n tf.contrib.layers.flatten(\n layer_stack[-1]\n )\n )\n\n # Add dense layers\n for idx, num_nodes in enumerate(params.dense_nodes):\n layer_stack.append(\n self.make_dense_layer(\n layer_stack[-1],\n num_nodes,\n 'dense_{}'.format(idx),\n params.dense_params\n )\n )\n\n # Output layer is broken into two pieces. The pre/post the application\n # of the activation function. That's because the loss functions\n # for cross-entropy rely on the pre-activation scores in preact\n\n preact_out_layer, out_layer = self.make_dense_output_layer(\n layer_stack[-1],\n params.out_size,\n params.output_params\n )\n\n target_layer = tf.placeholder(\n \"float\",\n name=\"target\",\n shape=[None, params.out_size]\n )\n\n if params.output_params.activation in ['sigmoid']:\n loss = tops.loss_sigmoid_ce(preact_out_layer, target_layer)\n else:\n loss = tops.loss_softmax_ce(preact_out_layer, target_layer)\n\n return in_layer, out_layer, target_layer, loss","def _process_task_inputs(self):\n _input = self._task.input\n log.debug('Input parsing for %s and node %s from container', self._task.project_id, self._task.internal_id)\n log.debug(_input)\n\n input_ports = dict()\n for port in _input:\n log.debug(port)\n self._process_task_input(port, input_ports)\n\n log.debug('DUMPING json')\n #dump json file\n if input_ports:\n file_name = os.path.join(self._executor.in_dir, 'input.json')\n with open(file_name, 'w') as f:\n json.dump(input_ports, f)\n\n log.debug('DUMPING DONE')","def prepare_data(self):\n data = self._get_dataset(self.hparams.dataset_path)\n label_encoder = data[\"label_encoder\"]\n del data[\"label_encoder\"]\n\n click.secho(\"Building inputs and labels.\", fg=\"yellow\")\n datasets = {\n \"train\": defaultdict(list),\n \"valid\": defaultdict(list),\n \"test\": defaultdict(list),\n }\n for dataset_name, dataset in data.items():\n for sample in dataset:\n instance = self.build_input(\n self.tokenizer, sample[\"text\"], label_encoder, sample[\"label\"]\n )\n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n\n click.secho(\"Padding inputs and building tensors.\", fg=\"yellow\")\n tensor_datasets = {\"train\": [], \"valid\": [], \"test\": []}\n for dataset_name, dataset in datasets.items():\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\n for input_name in MODEL_INPUTS:\n if input_name == \"labels\":\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\n else:\n tensor = torch.tensor(dataset[input_name])\n tensor_datasets[dataset_name].append(tensor)\n\n self.train_dataset = TensorDataset(*tensor_datasets[\"train\"])\n self.valid_dataset = TensorDataset(*tensor_datasets[\"valid\"])\n self.test_dataset = TensorDataset(*tensor_datasets[\"test\"])\n click.secho(\n \"Train dataset (Batch, Candidates, Seq length): {}\".format(\n self.train_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Valid dataset (Batch, Candidates, Seq length): {}\".format(\n self.valid_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )\n click.secho(\n \"Test dataset (Batch, Candidates, Seq length): {}\".format(\n self.test_dataset.tensors[0].shape\n ),\n fg=\"yellow\",\n )","def _prepare_input(\n self, data: Union[Dict[str, torch.Tensor], torch.Tensor, np.ndarray]\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n\n # convert ot dict\n if isinstance(data, torch.Tensor):\n p4 = data\n data = dict()\n data[\"p4\"] = p4\n elif isinstance(data, np.ndarray):\n p4 = torch.from_numpy(data)\n data = dict()\n data[\"p4\"] = p4\n\n node_ps = data[\"p4\"].to(device=self.device, dtype=self.dtype) * self.scale\n if self.jet_features:\n jet_p = torch.sum(node_ps, dim=-2).unsqueeze(-2)\n node_ps = torch.cat((node_ps, jet_p), dim=-2)\n\n scalars = normsq4(node_ps).abs().sqrt().unsqueeze(-1)\n if self.jet_features:\n jet_mass = (\n normsq4(torch.sum(node_ps, dim=-2))\n .unsqueeze(-1)\n .unsqueeze(-1)\n .repeat(1, self.num_input_particles, 1)\n )\n scalars = torch.cat((scalars, jet_mass), dim=-1)\n\n # Calculate node masks and edge masks\n if \"labels\" in data:\n node_mask = data[\"labels\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n elif \"masks\" in data:\n node_mask = data[\"masks\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n elif \"mask\" in data:\n node_mask = data[\"mask\"].to(device=self.device)\n node_mask = node_mask.to(torch.uint8)\n else:\n node_mask = data[\"p4\"][..., 0] != 0\n node_mask = node_mask.to(device=self.device, dtype=torch.uint8)\n if self.jet_features:\n jet_mask = torch.ones_like(node_mask[..., 0:1])\n jet_mask = jet_mask.to(device=self.device, dtype=torch.uint8)\n node_mask = torch.cat((node_mask, jet_mask), dim=-1)\n edge_mask = node_mask.unsqueeze(1) * node_mask.unsqueeze(2)\n\n if \"scalars\" in data.keys():\n # (0,0) representation\n scalars = torch.cat(\n [scalars, data[\"scalars\"].to(device=self.device, dtype=self.dtype)],\n dim=-1,\n )\n\n return scalars, node_ps, node_mask, edge_mask","def _prepare_input_for_onnx(\n args, kwargs, remained_onnx_input_idx: Optional[Sequence[int]], flatten: bool\n):\n onnx_inputs = _prepare_input_for_export(args, kwargs)\n if flatten:\n onnx_inputs, _ = torch.jit._flatten(onnx_inputs)\n elif onnx_inputs and onnx_inputs[-1] == {}:\n # Handle empty kwargs (normally removed by flatten).\n onnx_inputs = onnx_inputs[:-1]\n if remained_onnx_input_idx is not None:\n return [onnx_inputs[i] for i in remained_onnx_input_idx]\n else:\n return onnx_inputs","def _prepare_forward_inputs(\n device: torch.device,\n input_dtype: Optional[torch.dtype],\n *args: Any,\n **kwargs: Any,\n) -> Tuple[Any, Any]:\n # TODO: Do not use the side stream for tensor copies for now; investigate\n # the perf with/without it.\n # TODO: For mixed precision, move the inputs to the compute device and cast\n # to reduced-precision in a single `to()` call.\n args_tuple, kwargs_tuple = _to_kwargs(args, kwargs, device.index, False)\n args = args_tuple[0]\n kwargs = kwargs_tuple[0]\n if input_dtype is not None:\n args, kwargs = _cast_fp_inputs_to_dtype(input_dtype, *args, **kwargs)\n return args, kwargs","def _transform_inputs(self) -> None:\n self.inputs = None if self.inputs == {} else self.inputs","def generate_input_data(self):\n for socket_name, c in self.__taskobject.inputs.items():\n if c['optional']:\n self.__inputs[socket_name] = {'data': None, 'enable': False}\n else:\n self.__inputs[socket_name] = {'data': None, 'enable': True}","def __init__(self, latent_space, input_features):\r\n\r\n self._latent_space = latent_space\r\n self._input_cells = input_features\r\n\r\n self._encoder = None\r\n self._decoder = None\r\n self._autoencoder = None\r\n self._configure_network()","def prepareData(self, *data):\n arguments = 8\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\n self.model, self.annotations, self.args) = tuple(data[:arguments])\n \n self.width = self.args.beam_width\n self.mathType = self.args.mathType\n self.io_files = {\n 'input': self.args.intermediate_input_files,\n 'output': self.args.intermediate_output_files\n }\n self.repeat_width = self.args.repeat_width\n self.cons_count = self.args.cons_count\n self.posterior_processors = self.args.posterior_processors \n\n self.positionGenerator = \\\n list(AlignmentBeamGenerator(self.alignment, self.width))\n \n for i in range(len(self.model.states)):\n self.model.states[i].computeHints(self)\n\n return data[arguments:]","def prepare_inputs(data, queries, tokenizer):\n # Prepare inputs\n table = pd.DataFrame.from_dict(data)\n inputs = tokenizer(table=table, queries=queries,truncation=True, padding=True,return_tensors=\"pt\").to(device)\n\n # Return things\n return table, inputs","def _populate_input_data_transfer_fields(self):\r\n # Valid fields for the Route Stops input are described here:\r\n # https://pro.arcgis.com/en/pro-app/latest/arcpy/network-analyst/route-input-data-types.htm\r\n # Do not transfer RouteName or Sequence as these are explicitly controlled by this tool. Do not transfer\r\n # LocationType because we want all inputs to be Stops. Waypoints don't make sense for this analysis.\r\n int_types = [\"Integer\", \"SmallInteger\"]\r\n numerical_types = [\"Double\", \"Single\"] + int_types\r\n rt_stops_input_fields = {\r\n \"Name\": [\"String\"],\r\n \"AdditionalTime\": numerical_types,\r\n \"AdditionalDistance\": numerical_types,\r\n \"AdditionalCost\": numerical_types,\r\n \"TimeWindowStart\": [\"Date\"],\r\n \"TimeWindowEnd\": [\"Date\"],\r\n \"CurbApproach\": int_types,\r\n \"Bearing\": numerical_types,\r\n \"BearingTol\": numerical_types,\r\n \"NavLatency\": numerical_types,\r\n \"SourceID\": int_types,\r\n \"SourceOID\": int_types,\r\n \"PosAlong\": numerical_types,\r\n \"SideOfEdge\": int_types\r\n }\r\n # Preserve origin and destination input fields that match names and types\r\n origin_transfer_fields = [\r\n f.name for f in arcpy.ListFields(self.origins) if f.name in rt_stops_input_fields and\r\n f.type in rt_stops_input_fields[f.name]]\r\n self.rt_inputs[\"origin_transfer_fields\"] = origin_transfer_fields\r\n if origin_transfer_fields:\r\n LOGGER.info((\r\n \"Supported fields in the input Origins table that will be used in the analysis: \"\r\n f\"{origin_transfer_fields}\"\r\n ))\r\n destination_transfer_fields = [\r\n f.name for f in arcpy.ListFields(self.destinations) if f.name in rt_stops_input_fields and\r\n f.type in rt_stops_input_fields[f.name]]\r\n self.rt_inputs[\"destination_transfer_fields\"] = destination_transfer_fields\r\n if destination_transfer_fields:\r\n LOGGER.info((\r\n \"Supported fields in the input Destinations table that will be used in the analysis: \"\r\n f\"{destination_transfer_fields}\"\r\n ))","def set_inputs(\n self,\n train_X: Tensor,\n train_Y: Tensor,\n train_Yvar: Optional[Tensor],\n task_feature: int,\n task_rank: Optional[int] = None,\n ):\n super().set_inputs(train_X, train_Y, train_Yvar)\n # obtain a list of task indicies\n all_tasks = train_X[:, task_feature].unique().to(dtype=torch.long).tolist()\n self.task_feature = task_feature\n self.num_tasks = len(all_tasks)\n self.task_rank = task_rank or 1\n # assume there is one column for task feature\n self.ard_num_dims = self.train_X.shape[-1] - 1","def feed_inputs(self):\n feed_dict = collections.defaultdict(list)\n for i in range(self._pipe.batch_size):\n data = self.example_to_data(self._buffer.get())\n for k, v in data.items():\n feed_dict[k].append(v)\n for k, v in self.features.items():\n self._pipe.feed_input(self.features[k], feed_dict[k])","def inputs_init():\n input_user = tf.keras.Input((1, ))\n input_item = tf.keras.Input((1, ))\n input_rating = tf.keras.Input((1, ))\n return input_user, input_item, input_rating","def _train_input_fn():\n\t\tprint('\\n\\nRunning _train_input_fn\\n\\n')\n\t\tfeatures_placeholder = {\n\t\t\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), features['query_unigrams'][0].shape[0])),\n\t\t\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), features['doc_unigrams'][0][0].shape[0]))\n\t\t\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), len(features['query_unigrams'][0]))),\n\t\t\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), len(features['doc_unigrams'][0][0])))\n\t\t\t#k: tf.placeholder(tf.string, get_shape(v)) for k, v in six.iteritems(features)\n\t\t\tk: tf.placeholder(v.dtype, v.shape) for k, v in six.iteritems(features)\n\t\t\t#k: tf.sparse.placeholder(tf.string, [len(v)] + v[0].shape.as_list(), name=k) for k, v in six.iteritems(features)\n\t\t\t#k: tf.placeholder(tf.string, (len(v), len(v[0]), len(v[0][0]))) for k, v in six.iteritems(features)\n\t\t}\n\t\tlabels_placeholder = tf.placeholder(labels.dtype, labels.shape, name='label')\n\t\tdataset = tf.data.Dataset.from_tensor_slices((features_placeholder,\n\t\t\t\t\t\t\t\t\t\t\t\t\tlabels_placeholder))\n\t\t#dataset = dataset.shuffle(1000).repeat().batch(batch_size)\n\t\tdataset = dataset.shuffle(batch_size*10).repeat().batch(batch_size)\n\t\titerator = dataset.make_initializable_iterator()\n\t\tfeed_dict = {labels_placeholder: labels}\n\t\tfeed_dict.update(\n\t\t\t\t{features_placeholder[k]: features[k] for k in features_placeholder})\n\n\t\tprint('feed_dict')\n\t\tfor k,v in six.iteritems(feed_dict):\n\t\t\tprint(k.shape)\n\t\t#\tprint(v.shape)\n\t\trun_options = tf.RunOptions(report_tensor_allocations_upon_oom = True)\n\t\titerator_initializer_hook.iterator_initializer_fn = (\n\t\t\t\tlambda sess: sess.run(iterator.initializer, feed_dict=feed_dict, options=run_options))\n\t\treturn iterator.get_next()","def __init__(self, n_latent_features=1024, reduced_size=64, input_type='default', use_masks=False, **kwargs):\n super(AutoEncoderFeatureTransformer, self).__init__()\n self.device = get_device()\n self.use_masks = use_masks\n\n # Tunable parameters\n self.n_latent_features = n_latent_features\n self.reduced_size = reduced_size\n self.input_type = input_type\n\n self.logger = logging.getLogger(AutoEncoderFeatureTransformer.__name__)\n\n self._construct_model()","def prepare(self):\n\n inp = self.config.get('predict.input', 'X:0')\n out = self.config.get('predict.output', 'output:0')\n\n # set input placeholder\n self.input = self.graph.get_tensor_by_name(inp)\n\n # set output operation\n if isinstance(out, str) or isinstance(out, unicode):\n self.output = {out: self.graph.get_tensor_by_name(out)}\n self.output_alone = True\n elif isinstance(out, list):\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\n self.output_alone = False\n else:\n raise LoaderException('incorrect predict.output type')","def _RegisterInputs(self):\n args = []\n for source in ['FcA', 'FcB']:\n gps_type = self._gps_type_per_source[source]\n if gps_type == 'Septentrio':\n args += [\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.x'),\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.y'),\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.z'),\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.mode'),\n self._Arg('SeptentrioSolution', source,\n 'pvt_cartesian.timestamp.tow'),\n ]\n elif gps_type == 'NovAtel':\n args += [\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_x'),\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_y'),\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_z'),\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_type'),\n self._Arg('NovAtelSolution', source, 'best_xyz.timestamp.tow'),\n ]\n else:\n assert False\n return args","def _prepare_for_submission(self, tempfolder, inputdict):\n input_validator = self._get_input_validator(inputdict=inputdict)\n local_input_folder = input_validator(\n name='local_input_folder', valid_types=FolderData, required=False\n )\n remote_input_folder = input_validator(\n name='remote_input_folder', valid_types=RemoteData, required=False\n )\n\n parameters = input_validator(\n name='parameters', valid_types=ParameterData\n )\n param_dict = self._get_validated_parameters_dict(parameters)\n\n projections = input_validator(\n name='projections',\n valid_types=(OrbitalData, List),\n required=False\n )\n kpoints = input_validator(name='kpoints', valid_types=KpointsData)\n kpoint_path = input_validator(\n name='kpoint_path', valid_types=ParameterData, required=False\n )\n structure = input_validator(\n name='structure', valid_types=StructureData\n )\n\n settings = input_validator(\n name='settings', valid_types=ParameterData, required=False\n )\n if settings is None:\n settings_dict = {}\n else:\n settings_dict_raw = settings.get_dict()\n settings_dict = {\n key.lower(): val\n for key, val in settings_dict_raw.items()\n }\n if len(settings_dict_raw) != len(settings_dict):\n raise InputValidationError(\n 'Input settings contain duplicate keys.'\n )\n pp_setup = settings_dict.pop('postproc_setup', False)\n if pp_setup:\n param_dict.update({'postproc_setup': True})\n\n if local_input_folder is None and remote_input_folder is None and pp_setup is False:\n raise InputValidationError(\n 'Either local_input_folder or remote_input_folder must be set.'\n )\n\n code = input_validator(name='code', valid_types=Code)\n\n ############################################################\n # End basic check on inputs\n ############################################################\n random_projections = settings_dict.pop('random_projections', False)\n\n write_win(\n filename=tempfolder.get_abs_path(self._INPUT_FILE),\n parameters=param_dict,\n structure=structure,\n kpoints=kpoints,\n kpoint_path=kpoint_path,\n projections=projections,\n random_projections=random_projections,\n )\n\n if remote_input_folder is not None:\n remote_input_folder_uuid = remote_input_folder.get_computer().uuid\n remote_input_folder_path = remote_input_folder.get_remote_path()\n\n t_dest = get_authinfo(\n computer=remote_input_folder.get_computer(),\n aiidauser=remote_input_folder.get_user()\n ).get_transport()\n with t_dest:\n remote_folder_content = t_dest.listdir(\n path=remote_input_folder_path\n )\n\n if local_input_folder is not None:\n local_folder_content = local_input_folder.get_folder_list()\n if pp_setup:\n required_files = []\n else:\n required_files = [\n self._SEEDNAME + suffix for suffix in ['.mmn', '.amn']\n ]\n optional_files = [\n self._SEEDNAME + suffix for suffix in ['.eig', '.chk', '.spn']\n ]\n input_files = required_files + optional_files\n wavefunctions_files = ['UNK*']\n\n def files_finder(file_list, exact_patterns, glob_patterns):\n result = [f for f in exact_patterns if (f in file_list)]\n import fnmatch\n for glob_p in glob_patterns:\n result += fnmatch.filter(file_list, glob_p)\n return result\n\n # Local FolderData has precedence over RemoteData\n if local_input_folder is not None:\n found_in_local = files_finder(\n local_folder_content, input_files, wavefunctions_files\n )\n else:\n found_in_local = []\n if remote_input_folder is not None:\n found_in_remote = files_finder(\n remote_folder_content, input_files, wavefunctions_files\n )\n found_in_remote = [\n f for f in found_in_remote if f not in found_in_local\n ]\n else:\n found_in_remote = []\n\n not_found = [\n f for f in required_files\n if f not in found_in_remote + found_in_local\n ]\n if len(not_found) != 0:\n raise InputValidationError(\n \"{} necessary input files were not found: {} \".format(\n len(not_found), ', '.join(str(nf) for nf in not_found)\n )\n )\n\n remote_copy_list = []\n remote_symlink_list = []\n local_copy_list = []\n #Here we enforce that everything except checkpoints are symlinked\n #because in W90 you never modify input files on the run\n ALWAYS_COPY_FILES = [self._CHK_FILE]\n for f in found_in_remote:\n file_info = (\n remote_input_folder_uuid,\n os.path.join(remote_input_folder_path, f), os.path.basename(f)\n )\n if f in ALWAYS_COPY_FILES:\n remote_copy_list.append(file_info)\n else:\n remote_symlink_list.append(file_info)\n for f in found_in_local:\n local_copy_list.append(\n (local_input_folder.get_abs_path(f), os.path.basename(f))\n )\n\n # Add any custom copy/sym links\n remote_symlink_list += settings_dict.pop(\n \"additional_remote_symlink_list\", []\n )\n remote_copy_list += settings_dict.pop(\n \"additional_remote_copy_list\", []\n )\n local_copy_list += settings_dict.pop(\"additional_local_copy_list\", [])\n\n #######################################################################\n\n calcinfo = CalcInfo()\n calcinfo.uuid = self.uuid\n calcinfo.local_copy_list = local_copy_list\n calcinfo.remote_copy_list = remote_copy_list\n calcinfo.remote_symlink_list = remote_symlink_list\n\n codeinfo = CodeInfo()\n codeinfo.code_uuid = code.uuid\n #codeinfo.withmpi = True # Current version of W90 can be run in parallel\n codeinfo.cmdline_params = [self._INPUT_FILE]\n\n calcinfo.codes_info = [codeinfo]\n calcinfo.codes_run_mode = code_run_modes.SERIAL\n\n # Retrieve files\n calcinfo.retrieve_list = []\n calcinfo.retrieve_list.append(self._OUTPUT_FILE)\n calcinfo.retrieve_list.append(self._ERROR_FILE)\n if pp_setup:\n calcinfo.retrieve_list.append(self._NNKP_FILE)\n calcinfo.retrieve_singlefile_list = [\n ('output_nnkp', 'singlefile', self._NNKP_FILE)\n ]\n\n calcinfo.retrieve_list += [\n '{}_band.dat'.format(self._SEEDNAME),\n '{}_band.kpt'.format(self._SEEDNAME)\n ]\n\n if settings_dict.pop('retrieve_hoppings', False):\n calcinfo.retrieve_list += [\n '{}_wsvec.dat'.format(self._SEEDNAME),\n '{}_hr.dat'.format(self._SEEDNAME),\n '{}_centres.xyz'.format(self._SEEDNAME),\n ]\n\n # Retrieves bands automatically, if they are calculated\n\n calcinfo.retrieve_list += settings_dict.pop(\n \"additional_retrieve_list\", []\n )\n\n # pop input keys not used here\n settings_dict.pop('seedname', None)\n if settings_dict:\n raise InputValidationError(\n \"The following keys in settings are unrecognized: {}\".format(\n settings_dict.keys()\n )\n )\n\n return calcinfo","def preprocessing_fn(inputs):\n outputs = {}\n for key in _DENSE_FLOAT_FEATURE_KEYS:\n # Preserve this feature as a dense float, setting nan's to the mean.\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\n _fill_in_missing(inputs[key]))\n\n for key in _VOCAB_FEATURE_KEYS:\n # Build a vocabulary for this feature.\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\n _fill_in_missing(inputs[key]),\n top_k=_VOCAB_SIZE,\n num_oov_buckets=_OOV_SIZE)\n\n for key in _BUCKET_FEATURE_KEYS:\n outputs[_transformed_name(key)] = tft.bucketize(\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\n always_return_num_quantiles=False)\n\n for key in _CATEGORICAL_FEATURE_KEYS:\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\n\n # Was this passenger a big tipper?\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\n tips = _fill_in_missing(inputs[_LABEL_KEY])\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\n tf.is_nan(taxi_fare),\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\n # Test if the tip was > 20% of the fare.\n tf.cast(\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\n\n return outputs","def _setup_vasp_inputs(self):\n\n # Set the kpoints (kpoints)\n if 'kpoints' in self.inputs:\n self.ctx.inputs.kpoints = self.inputs.kpoints\n elif 'kpoints_spacing' in self.inputs:\n kpoints = orm.KpointsData()\n kpoints.set_cell_from_structure(self.ctx.inputs.initial_structure)\n kpoints.set_kpoints_mesh_from_density(self.inputs.kpoints_spacing.value * np.pi * 2)\n self.ctx.inputs.kpoints = kpoints\n elif 'kpoints_spacing_vasp' in self.inputs:\n kpoints = orm.KpointsData()\n kpoints.set_cell_from_structure(self.ctx.inputs.initial_structure)\n kpoints.set_kpoints_mesh_from_density(self.inputs.kpoints_spacing.value)\n self.ctx.inputs.kpoints = kpoints\n else:\n raise InputValidationError(\"Must supply either 'kpoints' or 'kpoints_spacing' or 'kpoints_spacing_vasp\")\n\n # Set settings\n\n unsupported_parameters = dict(VTST_ADDITIONAL_TAGS)\n if 'settings' in self.inputs:\n self.ctx.inputs.settings = self.inputs.settings\n # Also check if the user supplied additional tags that is not in the supported file.\n try:\n unsupported_parameters = self.ctx.inputs.settings.unsupported_parameters\n except AttributeError:\n pass\n\n # Perform inputs massage to accommodate generalization in higher lying workchains\n # and set parameters.\n try:\n parameters_massager = ParametersMassage(self.inputs.parameters, unsupported_parameters)\n except Exception as exception: # pylint: disable=broad-except\n return self.exit_codes.ERROR_IN_PARAMETER_MASSAGER.format(exception=exception) # pylint: disable=no-member\n try:\n # Only set if they exists\n # Set any INCAR tags\n self.ctx.inputs.parameters = parameters_massager.parameters.incar\n # Set any dynamics input (currently only for selective dynamics, e.g. custom write to POSCAR)\n self.ctx.inputs.dynamics = parameters_massager.parameters.dynamics\n # Here we could set additional override flags, but those are not relevant for this VASP plugin\n except AttributeError:\n pass\n\n # Setup LDAU keys\n if 'ldau_mapping' in self.inputs:\n ldau_settings = self.inputs.ldau_mapping.get_dict()\n ldau_keys = get_ldau_keys(self.ctx.inputs.initial_structure, **ldau_settings)\n # Directly update the raw inputs passed to VaspCalculation\n self.ctx.inputs.parameters.update(ldau_keys)\n\n # Set settings\n if 'settings' in self.inputs:\n self.ctx.inputs.settings = self.inputs.settings\n\n # Set options\n # Options is very special, not storable and should be\n # wrapped in the metadata dictionary, which is also not storable\n # and should contain an entry for options\n if 'options' in self.inputs:\n options = {}\n options.update(self.inputs.options)\n self.ctx.inputs.metadata = {}\n self.ctx.inputs.metadata['options'] = options\n # Override the parser name if it is supplied by the user.\n parser_name = self.ctx.inputs.metadata['options'].get('parser_name')\n if parser_name:\n self.ctx.inputs.metadata['options']['parser_name'] = parser_name\n # Also make sure we specify the entry point for the\n # Set MPI to True, unless the user specifies otherwise\n withmpi = self.ctx.inputs.metadata['options'].get('withmpi', True)\n self.ctx.inputs.metadata['options']['withmpi'] = withmpi\n else:\n raise InputValidationError('`options` not supplied')\n\n # Utilise default input/output selections\n self.ctx.inputs.metadata['options']['input_filename'] = 'INCAR'\n\n # Set the CalcJobNode to have the same label as the WorkChain\n self.ctx.inputs.metadata['label'] = self.inputs.metadata.get('label', '')\n self.report(self.ctx.inputs.metadata)\n\n # Verify and set potentials (potcar)\n if not self.inputs.potential_family.value:\n self.report( # pylint: disable=not-callable\n 'An empty string for the potential family name was detected.'\n )\n return self.exit_codes.ERROR_NO_POTENTIAL_FAMILY_NAME # pylint: disable=no-member\n try:\n self.ctx.inputs.potential = get_data_class('vasp.potcar').get_potcars_from_structure(\n structure=self.inputs.initial_structure,\n family_name=self.inputs.potential_family.value,\n mapping=self.inputs.potential_mapping.get_dict()\n )\n except ValueError as err:\n return compose_exit_code(self.exit_codes.ERROR_POTENTIAL_VALUE_ERROR.status, str(err)) # pylint: disable=no-member\n except NotExistent as err:\n return compose_exit_code(self.exit_codes.ERROR_POTENTIAL_DO_NOT_EXIST.status, str(err)) # pylint: disable=no-member\n\n self.ctx.verbose = bool(self.inputs.get('verbose', self._verbose))\n\n return None","def preprocessing_fn(inputs):\n outputs = {}\n\n for key in ONE_HOT_FEATURES.keys():\n dim = ONE_HOT_FEATURES[key]\n int_value = tft.compute_and_apply_vocabulary(\n fill_in_missing(inputs[key]), top_k=dim + 1\n )\n outputs[transformed_name(key)] = convert_num_to_one_hot(\n int_value, num_labels=dim + 1\n )\n\n for key, bucket_count in BUCKET_FEATURES.items():\n temp_feature = tft.bucketize(\n convert_zip_code(fill_in_missing(inputs[key])),\n bucket_count,\n )\n outputs[transformed_name(key)] = convert_num_to_one_hot(\n temp_feature, num_labels=bucket_count + 1\n )\n\n for key in TEXT_FEATURES.keys():\n outputs[transformed_name(key)] = fill_in_missing(inputs[key])\n\n outputs[transformed_name(LABEL_KEY)] = fill_in_missing(inputs[LABEL_KEY])\n\n return outputs","def preprocess(args, g, features):\n # g = dgl.to_homogeneous(g)\n with torch.no_grad():\n g.edata[\"weight\"] = calc_weight(g)\n g.ndata[\"feat_0\"] = features\n for hop in range(1, args['n_hops'] + 1):\n g.update_all(fn.u_mul_e(f\"feat_{hop - 1}\", \"weight\", \"msg\"),\n fn.sum(\"msg\", f\"feat_{hop}\"))\n hop_feat_list = []\n for hop in range(args['n_hops'] + 1):\n hop_feat_list.append(g.ndata.pop(f\"feat_{hop}\"))\n return hop_feat_list","def build_input(self):\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\n return n_input, t_input, n_target, t_target, keep_prob","def prepare_inputs(example):\n return example['input_ids'], example['label_ids']","def prepare_inputs(example):\n return example['input_ids'], example['label_ids']","def prepare_wf(self,wf,stk):\n for lst in stk:\n for op_tag in lst:\n op = wf.get_data_from_uri(op_tag)\n for inpname,il in op.input_locator.items():\n if il.tp not in [opmod.runtime_type,opmod.workflow_item]:\n # runtime inputs should be set directly, without using il.val.\n # this is because il.val gets serialized in wf.wf_setup_dict().\n # workflow_item inputs should be set later, during execution.\n # the no_input case ends up setting the input to None\n #op.inputs[inpname] = self.locate_input(il)\n wf.set_op_item(op_tag,'inputs.'+inpname,self.locate_input(il))","def _synth_input(self, path, files):\n features = np.empty((0, 15))\n for i in range(len(files)):\n train_set = np.load(f'{path}coords/{files[i]}.npy')\n train_set = train_set.reshape((train_set.shape[0], -1))\n features = np.concatenate((features, train_set), axis=0)\n self.input_ = F.normalize(torch.tensor(np.array(features), dtype=torch.float32))","def train_input(config, params):\n \"\"\"\n rawimages: Nb x hf x wf x 3, tf.float32, in [0,1]\n rawlabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\n rawmetadata: Python dictionary with matadata (e.g. image shape, dtype)\n proimages: Nb x hf x wf x 3, tf.float32, in [0,1]\n prolabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\n \"\"\"\n # runconfig = config.runconfig\n # # otherconfig includes: train_preprocess, mappings\n # otherconfig = config.otherconfig\n # hparams = params\n\n # reading, mapping labels to problem from otherconfig['lids2cids'],\n # batching, preprocessing with otherconfig['train_preprocess'], output\n\n # no obvious use of prodata metadata for now\n with tf.variable_scope('input_pipeline'):\n values = None\n for num_dataset in range(len(params.tfrecords_list)): # , params.camvid_tfrecords_path]:\n if values is None:\n values = train_input_per_data(config, params, num_dataset)\n values = list(values) + [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\n else:\n _values = list(train_input_per_data(config, params, num_dataset)) + \\\n [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\n values = [tf.concat((value1, value2), 0) for value1, value2 in zip(values, _values)]\n\n features = {'rawimages': values[1],\n 'proimages': values[3],\n 'rawimagespaths': values[0][0],\n 'rawlabelspaths': values[0][1]}\n labels = {'rawlabels': values[2],\n 'prolabels': values[4],\n 'domainlabels': values[5]}\n return features, labels","def _preprocess_data(\n self, data_batch: Dict[str, Any]) -> Tuple[tf.Tensor, tf.Tensor]:\n # Get input data, with shape [batch_size, dim_h, dim_w, dim_c].\n input_data = data_batch['sdf_map']\n\n gt_data = input_data\n\n return input_data, gt_data","def get_inputs(self,force_gen=False,comp_gridness_score=False,comp_tuning_index=True):\n #print self.paramMap\n \n \n self.inputs=SpatialInputs(sl.map_merge(self.paramMap,{'n':self.n_e}),\n force_gen=force_gen,\n comp_gridness_score=comp_gridness_score,\n comp_tuning_index=comp_tuning_index) \n \n \n self.inputs_flat=self.inputs.inputs_flat\n \n self.h_e=self.inputs_flat.T \n self.h_i=np.zeros((self.N_i,self.NX))\n self.h=np.vstack([self.h_e,self.h_i])\n \n self.gp=gl.GridProps(self.n_e,self.grid_T,self.grid_angle)","def train_input_args():\n # Create Parse using ArgumentParser\n parser = argparse.ArgumentParser()\n parser.add_argument('data_dir', type = str, help = 'Path to the data directory') \n parser.add_argument('--lr', type = float, default = 0.001, help = 'Learning rate (0.001)') \n parser.add_argument('--model', type = str, default = 'vgg16', help = 'TorchVision VGG model used: vgg19 or (vgg16)') \n parser.add_argument('--hidden', type = int, default = 4096, help = 'Number of hidden units (4096)') \n parser.add_argument('--epochs', type = int, default = 8, help = 'Number of training epochs (8)') \n parser.add_argument('--gpu', type = bool, default = True, help = '(True) = GPU enabled, False = GPU disabled') \n parser.add_argument('--chk', type = str, default = 'checkpoint', help = 'Checkpoint folder name') \n return parser.parse_args()","def forward(self, inputs):\n features, coords = inputs\n voxel_features, voxel_coords = self.voxelization(features, coords)\n voxel_features = self.voxel_layers(voxel_features)\n voxel_features = trilinear_devoxelize(voxel_features, voxel_coords,\n self.resolution, self.training)\n fused_features = voxel_features + self.point_features(features)\n return fused_features, coords","def train_input(config, params):\n\n def _grouping(rim, rla, pim, pla, imp, lap):\n # group dataset elements as required by estimator\n features = {\n 'rawimages': rim,\n 'proimages': pim,\n 'rawimagespaths': imp,\n 'rawlabelspaths': lap,\n }\n labels = {\n 'rawlabels': rla,\n 'prolabels': pla,\n }\n\n # next line for distributed debugging\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\n if params.distribute:\n del features['rawimagespaths']\n del features['rawlabelspaths']\n\n return (features, labels)\n\n with tf.variable_scope('input_pipeline'):\n dataset = prebatch_dataset(config, params)\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\n dataset = postbatch_dataset(dataset, config, params)\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\n dataset = dataset.prefetch(None)\n\n return dataset","def _prepare_input_for_pytorch(args, kwargs):\n if isinstance(args, (torch.Tensor, dict)):\n args = (args,)\n # In-place operators will update input tensor data as well.\n # Thus inputs are replicated before every forward call.\n args = copy.deepcopy(args)\n if kwargs:\n kwargs = copy.deepcopy(kwargs)\n else:\n kwargs = {}\n return args, kwargs","def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \n \n depth = len(token_mapping)\n one_hot_tokens = []\n for sentence in tokens:\n one_hot_sentence = []\n for i, token in enumerate(sentence):\n if token != token_mapping['#UNK#']:\n one_hot_sentence.append(one_hot_encode(token, depth))\n else:\n if i <= 2:\n context_tokens = sentence[:i] + sentence[i+1:i+3]\n else:\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\n one_hot_sentence.append(context_mean)\n one_hot_tokens.append(one_hot_sentence)\n \n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\n return vec_tokens","def _preprocess_inputs(self, train_x_dict):\n\n numpy_arrays = []\n for key, value in train_x_dict.items():\n numpy_arrays.append(value)\n logger.info(\"Appending feature of shape {}\".format(value.shape))\n\n # Currently train_x will have dimensions [features; samples; timesteps; symbols]\n train_x = np.stack(numpy_arrays, axis=0)\n train_x = self.reorder_input_dimensions(train_x)\n\n # Expand dataset if requested\n if self._tensorflow_flags.predict_single_shares:\n train_x = self.expand_input_data(train_x)\n\n train_x = self.verify_x_data(train_x)\n\n return train_x.astype(np.float32) # FIXME: set float32 in data transform, conditional on config file","def processing_inputs(data, mk_cols_list, link_cols_list, cross_cols_list, WIDE_COLS, arrival=True):\n print('*-'*40, processing_inputs)\n if arrival:\n mk_cols_list = mk_cols_list + ['lk_arrival_0_percent', 'lk_arrival_1_percent','lk_arrival_2_percent', 'lk_arrival_3_percent', 'lk_arrival_4_percent']\n mk_cols_list = mk_cols_list + ['zsl_link_arrival_status_mean','zsl_link_arrival_status_nunique','zsl_link_arrival_status0','zsl_link_arrival_status1','zsl_link_arrival_status2','zsl_link_arrival_status3']\n if 'lk_arrival_0_percent' in mk_cols_list:\n print('The lk_arrival_0_percent in the mk_cols_list')\n #print('*-' * 40, 'EXIT')\n #sys.exit(0)\n print('111'*40, 'HAVE FEATURES OF ARRIVAL')\n else:\n print('222'*40, 'HAVENOT FEATURES OF ARRIVAL')\n if 'ata' in mk_cols_list:\n print('The ata in the mk_cols_list')\n print('*-' * 40, 'EXIT')\n sys.exit(0)\n if 'ata' in link_cols_list:\n print('The ata in the link_cols_list')\n if 'ata' in cross_cols_list:\n print('The ata in the cross_cols_list')\n if 'ata' in WIDE_COLS:\n print('The ata in the WIDE_COLS')\n print('*-' * 40, 'EXIT')\n sys.exit(0)\n data_link_inputs = preprocess_inputs(data, cols=link_cols_list)\n data.drop(columns=link_cols_list, axis=1, inplace=True)\n gc.collect()\n print('drop the link_cols_list')\n # print(data_link_inputs[:, :, :1])\n # data['cross_id'] = data['cross_id'].str.replace('nan','0')\n data_cross_inputs = preprocess_inputs(data, cols=cross_cols_list)\n data.drop(columns=cross_cols_list, axis=1, inplace=True)\n gc.collect()\n print('drop the cross_cols_list')\n\n data_deep_input = data[mk_cols_list]\n data_wide_input = data[WIDE_COLS].values\n data_inputs_slice = data['slice_id'].values\n data_labels = data['ata']\n if arrival:\n arrival_col = ['lk_arrival_0_percent', 'lk_arrival_1_percent',\n 'lk_arrival_2_percent', 'lk_arrival_3_percent', 'lk_arrival_4_percent']\n data_arrival = data[arrival_col]\n print('*-'*40, 'data_arrival', data_arrival.shape)\n return data_link_inputs, data_cross_inputs, data_deep_input, data_wide_input, data_inputs_slice, data_labels, data_arrival\n else:\n return data_link_inputs, data_cross_inputs, data_deep_input, data_wide_input, data_inputs_slice, data_labels","def reconstruct_input_ext(self, model_in):","def preprocess_model_inputs(self, data_batch):\n\n unique_ids, input_ids, input_mask, segment_ids, start_positions, \\\n end_positions, cls_index, p_mask, is_impossible = data_batch\n\n x = {\n \"input_ids\": input_ids,\n \"attention_mask\": input_mask,\n \"token_type_ids\": segment_ids,\n \"cls_index\": cls_index,\n \"p_mask\": p_mask\n }\n\n y = {\n \"unique_ids\": unique_ids,\n \"start_positions\": start_positions,\n \"end_positions\": end_positions,\n \"is_impossible\": is_impossible,\n }\n\n return x, y","def _TransformInputs(self, _):\n raise NotImplementedError()","def transform(self, inputs: list, stage: str) -> datapack.DataPack:","def _create_placeholders(self, n_features, n_classes):\n\n self.input_data = tf.placeholder(\"float\", [None, n_features], name='x-input')\n self.input_labels = tf.placeholder(\"float\", [None, n_classes], name='y-input')","def initialize_inputs(self) -> None:\n self.inputs.lifts_per_truck_day = self.operations.lifts_per_truck_day()\n self.inputs.avg_tonnes_per_m3 = self.operations.avg_tonnes_per_m3()\n self.inputs.revenue_per_m3 = (\n self.income_statement.revenue.operating_revenue\n * self.inputs.allocation_to_collection_unit\n / self.operations.productivity.total_m3_collected\n )\n self.inputs.num_customers = self.operations.productivity.num_customers","def _init_inputs(self, in_channels, in_index, input_transform):\n if input_transform is not None:\n assert input_transform in ['resize_concat', 'multiple_select']\n self.input_transform = input_transform\n self.in_index = in_index\n if input_transform is not None:\n assert isinstance(in_channels, (list, tuple))\n assert isinstance(in_index, (list, tuple))\n assert len(in_channels) == len(in_index)\n if input_transform == 'resize_concat':\n self.in_channels = sum(in_channels)\n else:\n self.in_channels = in_channels\n else:\n assert isinstance(in_channels, int)\n assert isinstance(in_index, int)\n self.in_channels = in_channels","def _init_inputs(self, in_channels, in_index, input_transform):\n if input_transform is not None:\n assert input_transform in ['resize_concat', 'multiple_select']\n self.input_transform = input_transform\n self.in_index = in_index\n if input_transform is not None:\n assert isinstance(in_channels, (list, tuple))\n assert isinstance(in_index, (list, tuple))\n assert len(in_channels) == len(in_index)\n if input_transform == 'resize_concat':\n self.in_channels = sum(in_channels)\n else:\n self.in_channels = in_channels\n else:\n assert isinstance(in_channels, int)\n assert isinstance(in_index, int)\n self.in_channels = in_channels","def _init_inputs(self, in_channels, in_index, input_transform):\n if input_transform is not None:\n assert input_transform in ['resize_concat', 'multiple_select']\n self.input_transform = input_transform\n self.in_index = in_index\n if input_transform is not None:\n assert isinstance(in_channels, (list, tuple))\n assert isinstance(in_index, (list, tuple))\n assert len(in_channels) == len(in_index)\n if input_transform == 'resize_concat':\n self.in_channels = sum(in_channels)\n else:\n self.in_channels = in_channels\n else:\n assert isinstance(in_channels, int)\n assert isinstance(in_index, int)\n self.in_channels = in_channels","def prepare_args():\n parser = argparse.ArgumentParser(description='Args for training')\n \"\"\"Optional arguments for pre-split train/test files\n parser.add_argument('--train_file', type=str, default='data/train.npy')\n parser.add_argument('--test_file', type=str, default='data/test.npy')\n parser.add_argument('--label_file',\n type=str,\n default='data/train_labels.npy')\n \"\"\"\n parser.add_argument('--dataset_file', type=str, default='data/dev.npy')\n parser.add_argument('--label_file',\n type=str,\n default='data/dev_labels.npy')\n parser.add_argument('--context', type=int, default=1)\n parser.add_argument('--batch_size', type=int, default=8)\n parser.add_argument('--optimizer', type=str, default='SGD')\n parser.add_argument('--model_name', type=str, default='SimpleNet')\n parser.add_argument('--lr', type=float, default=3e-4)\n parser.add_argument('--wd', type=float, default=0)\n parser.add_argument('--num_epochs', type=int, default=1000)\n parser.add_argument('--shuffle', action='store_true')\n args_to_ret = parser.parse_args()\n return args_to_ret","def input_fn():\n problem_count, batches = len(hparams.problems), []\n with tf.name_scope(\"input_reader\"):\n for n in xrange(problem_count):\n if fixed_problem is not None and n != fixed_problem:\n continue\n problem_instance = hparams.problem_instances[n]\n p_hparams = hparams.problems[n]\n with tf.name_scope(\"problem_%d\" % n):\n with tf.device(\"/cpu:0\"): # Input reading on CPU\n capacity = (\n p_hparams.max_expected_batch_size_per_shard * num_datashards)\n feature_map = data_reader.input_pipeline(\n problem_instance, data_file_patterns and data_file_patterns[n],\n capacity, mode, hparams,\n data_reader.hparams_to_batching_scheme(\n hparams,\n shard_multiplier=num_datashards,\n drop_long_sequences=(mode == tf.contrib.learn.ModeKeys.TRAIN\n or hparams.eval_drop_long_sequences),\n length_multiplier=(p_hparams.batch_size_multiplier)))\n\n # Reverse inputs and targets features if the problem was reversed.\n if problem_instance is not None:\n problem_instance.maybe_reverse_features(feature_map)\n problem_instance.maybe_copy_features(feature_map)\n else:\n if p_hparams.was_reversed:\n inputs = feature_map[\"inputs\"]\n targets = feature_map[\"targets\"]\n feature_map[\"inputs\"] = targets\n feature_map[\"targets\"] = inputs\n # Use the inputs as the targets if the problem is a copy problem.\n if p_hparams.was_copy:\n feature_map[\"targets\"] = feature_map[\"inputs\"]\n\n # Ensure inputs and targets are proper rank.\n while len(feature_map[\"inputs\"].get_shape()) != 4:\n feature_map[\"inputs\"] = tf.expand_dims(feature_map[\"inputs\"], axis=-1)\n while len(feature_map[\"targets\"].get_shape()) != 4:\n feature_map[\"targets\"] = tf.expand_dims(\n feature_map[\"targets\"], axis=-1)\n\n batches.append((feature_map[\"inputs\"], feature_map[\"targets\"],\n tf.constant(n), tf.constant(p_hparams.input_space_id),\n tf.constant(p_hparams.target_space_id)))\n\n # We choose which problem to process.\n loss_moving_avgs = [] # Need loss moving averages for that.\n for n in xrange(problem_count):\n with tf.variable_scope(\"losses_avg\"):\n loss_moving_avgs.append(\n tf.get_variable(\n \"problem_%d/total_loss\" % n, initializer=100.0,\n trainable=False))\n if fixed_problem is None:\n if (hparams.problem_choice == \"uniform\" or\n mode != tf.contrib.learn.ModeKeys.TRAIN):\n problem_choice = tf.random_uniform(\n [], maxval=problem_count, dtype=tf.int32)\n elif hparams.problem_choice == \"adaptive\":\n loss_moving_avgs = tf.stack(loss_moving_avgs)\n problem_choice = tf.multinomial(\n tf.reshape(loss_moving_avgs, [1, -1]), 1)\n problem_choice = tf.to_int32(tf.squeeze(problem_choice))\n elif hparams.problem_choice == \"distributed\":\n assert worker_replicas >= problem_count\n assert worker_replicas % problem_count == 0\n problem_choice = tf.to_int32(worker_id % problem_count)\n else:\n raise ValueError(\n \"Value of hparams.problem_choice is %s and must be \"\n \"one of [uniform, adaptive, distributed]\" % hparams.problem_choice)\n\n # Inputs and targets conditional on problem_choice.\n rand_inputs, rand_target, choice, inp_id, tgt_id = cond_on_index(\n lambda n: batches[n], problem_choice, 0, problem_count - 1)\n else:\n problem_choice = tf.constant(fixed_problem)\n # Take the only constructed batch, which is the fixed_problem.\n rand_inputs, rand_target, choice, inp_id, tgt_id = batches[0]\n\n # Set shapes so the ranks are clear.\n rand_inputs.set_shape([None, None, None, None])\n rand_target.set_shape([None, None, None, None])\n choice.set_shape([])\n inp_id.set_shape([])\n tgt_id.set_shape([])\n # Forced shape obfuscation is necessary for inference.\n if mode == tf.contrib.learn.ModeKeys.INFER:\n rand_inputs._shape = tf.TensorShape([None, None, None, None]) # pylint: disable=protected-access\n rand_target._shape = tf.TensorShape([None, None, None, None]) # pylint: disable=protected-access\n\n # Final feature map.\n rand_feature_map = {\n \"inputs\": rand_inputs,\n \"problem_choice\": choice,\n \"input_space_id\": inp_id,\n \"target_space_id\": tgt_id\n }\n if mode == tf.contrib.learn.ModeKeys.INFER:\n rand_feature_map[\"infer_targets\"] = rand_target\n rand_target = None\n # This is because of a bug in the tf.contrib.learn Estimator that\n # short-circuits prediction if it doesn't see a QueueRunner.\n # DummyQueueRunner implements the minimal expected interface but does\n # nothing.\n # TODO(rsepassi): Remove once we move to core Estimator.\n tf.add_to_collection(tf.GraphKeys.QUEUE_RUNNERS, DummyQueueRunner())\n return rand_feature_map, rand_target","def _preprocess_input(self, dataset):\n masker = self.masker or dataset.masker\n\n mask_img = masker.mask_img or masker.labels_img\n if isinstance(mask_img, str):\n mask_img = nib.load(mask_img)\n\n # Ensure that protected values are not included among _required_inputs\n assert \"aggressive_mask\" not in self._required_inputs.keys(), \"This is a protected name.\"\n\n if \"aggressive_mask\" in self.inputs_.keys():\n LGR.warning(\"Removing existing 'aggressive_mask' from Estimator.\")\n self.inputs_.pop(\"aggressive_mask\")\n\n # A dictionary to collect masked image data, to be further reduced by the aggressive mask.\n temp_image_inputs = {}\n\n for name, (type_, _) in self._required_inputs.items():\n if type_ == \"image\":\n # If no resampling is requested, check if resampling is required\n if not self.resample:\n check_imgs = {img: nib.load(img) for img in self.inputs_[name]}\n _check_same_fov(**check_imgs, reference_masker=mask_img, raise_error=True)\n imgs = list(check_imgs.values())\n else:\n # resampling will only occur if shape/affines are different\n # making this harmless if all img shapes/affines are the same as the reference\n imgs = [\n resample_to_img(nib.load(img), mask_img, **self._resample_kwargs)\n for img in self.inputs_[name]\n ]\n\n # input to NiFtiLabelsMasker must be 4d\n img4d = concat_imgs(imgs, ensure_ndim=4)\n\n # Mask required input images using either the dataset's mask or the estimator's.\n temp_arr = masker.transform(img4d)\n\n # An intermediate step to mask out bad voxels.\n # Can be dropped once PyMARE is able to handle masked arrays or missing data.\n nonzero_voxels_bool = np.all(temp_arr != 0, axis=0)\n nonnan_voxels_bool = np.all(~np.isnan(temp_arr), axis=0)\n good_voxels_bool = np.logical_and(nonzero_voxels_bool, nonnan_voxels_bool)\n\n data = masker.transform(img4d)\n\n temp_image_inputs[name] = data\n if \"aggressive_mask\" not in self.inputs_.keys():\n self.inputs_[\"aggressive_mask\"] = good_voxels_bool\n else:\n # Remove any voxels that are bad in any image-based inputs\n self.inputs_[\"aggressive_mask\"] = np.logical_or(\n self.inputs_[\"aggressive_mask\"],\n good_voxels_bool,\n )\n\n # Further reduce image-based inputs to remove \"bad\" voxels\n # (voxels with zeros or NaNs in any studies)\n if \"aggressive_mask\" in self.inputs_.keys():\n n_bad_voxels = (\n self.inputs_[\"aggressive_mask\"].size - self.inputs_[\"aggressive_mask\"].sum()\n )\n if n_bad_voxels:\n LGR.warning(\n f\"Masking out {n_bad_voxels} additional voxels. \"\n \"The updated masker is available in the Estimator.masker attribute.\"\n )\n\n for name, raw_masked_data in temp_image_inputs.items():\n self.inputs_[name] = raw_masked_data[:, self.inputs_[\"aggressive_mask\"]]","def genInput(tasksInfo, results, origLocation, destLocation, typeGray, samplSize = 0.10):\n print '\\nbegin of genInput\\n'\n # Training / aplication\n treina = True\n verdade = False\n\n # Sampling pixels from image\n sampl = True\n if sampl == True:\n buildSampl = True\n else:\n buildSampl = False\n\n # Write data to file\n if treina:\n outInput = open('trainInput.dat', 'w')\n #~ outInput1par = open('trainInput1par.dat', 'w')\n outOutput = open('trainOutput.dat', 'w')\n outTasks = open('trainTasks.dat', 'w')\n #~ outOutputClass = open('trainOutputClass.dat', 'w')\n selecOut = open('selected.dat', 'w')\n else:\n outInput = open('aplicInput.dat', 'w')\n outTasks = open('aplicTasks.dat', 'w')\n #~ outInput1par = open('aplicInput1par.dat', 'w')\n if verdade:\n outOutput = open('verdadeOutput.dat', 'w')\n #~ outOutputClass = open('verdadeOutputClass.dat', 'w')\n\n #Setting info on temporary directory for images\n numberImages = 12\n tmpImg = []\n for i in range(numberImages):\n tmpImg.append(destLocation+\"tmpImg_n\"+str(i+1).zfill(2)+\"/\")\n\n imgFile = []\n imgFile.append('2011352')\n imgFile.append('2011353')\n imgFile.append('2011355')\n imgFile.append('2011357')\n imgFile.append('2011358')\n imgFile.append('2011359')\n imgFile.append('2011360')\n imgFile.append('2011361')\n imgFile.append('2011362')\n imgFile.append('2011363')\n imgFile.append('2011364')\n imgFile.append('2011365')\n\n #If we need to skip line\n finishLine = True\n #Getting number of tasks\n numberTasks = len(tasksInfo)\n print 'number of tasks: ', numberTasks\n for task in range(numberTasks):\n #Geting the selected day for each task\n taskId = tasksInfo[task]['taskId']\n for img in range(numberImages):\n imgName = tmpImg[img] + str(taskId) + '.tif'\n #Openning image (and testing)\n if os.path.exists(imgName) is False:\n print 'INPUT -> Task miss: ' + str(taskId) + ' Image: ' + str(img) + ' Name: ' + imgName\n finishLine = False\n continue\n print 'INPUT -> Task: ' + str(taskId) + ' Image: ' + str(img)\n fileSat = gdal.Open(imgName, GA_ReadOnly)\n if fileSat is None:\n print 'Could not open ' + imgName\n sys.exit(1)\n # Read band values from image\n rows = fileSat.RasterYSize\n cols = fileSat.RasterXSize\n R_band_sat = fileSat.GetRasterBand(1)\n G_band_sat = fileSat.GetRasterBand(2)\n B_band_sat = fileSat.GetRasterBand(3)\n R_data_sat = R_band_sat.ReadAsArray(0, 0, cols, rows)\n G_data_sat = G_band_sat.ReadAsArray(0, 0, cols, rows)\n B_data_sat = B_band_sat.ReadAsArray(0, 0, cols, rows)\n #Closing image\n fileSat = None\n\n #If we are sampling the image, then we'll pick our samples\n print 'sampl: ', sampl\n print 'buildSampl: ', buildSampl\n if ((sampl == True) and (buildSampl == True)):\n universe = []\n samplList = []\n random.seed(8225)\n for i in range(rows):\n for j in range(cols):\n universe.append([i,j])\n sizeUniverse = len(universe)\n samplSizeInt = int(samplSize * sizeUniverse)\n print 'Sampling mode activated.'\n print 'Using ', samplSizeInt, ' out of ', sizeUniverse, ' pixels.'\n for i in range(samplSizeInt):\n samplList.append(universe.pop(random.randint(0,len(universe)-1)))\n buildSampl = False\n\n sumValueGray = 0.0\n if (sampl == False):\n #Working with the values\n for i in range(rows):\n for j in range(cols):\n #~ valueString = str(float(R_data_sat[i,j])/255.0)+' '+str(float(G_data_sat[i,j])/255.0)+' '+str(float(B_data_sat[i,j])/255.0)\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\n sumValueGray = sumValueGray + valueGray\n valueString = str(taskId)+' '+str(valueGray)\n #~ outInput.write(\"%s \"%valueString)\n sumValueString = str(taskId)+' '+str(sumValueGray/(rows*cols))\n #~ outInput1par.write(\"%s \"%sumValueString)\n outInput.write(\"%s \"%sumValueString)\n else:\n #Working with the sampled values\n for idx in range(samplSizeInt):\n i = samplList[idx][0]\n j = samplList[idx][1]\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\n sumValueGray = sumValueGray + valueGray\n valueString = str(valueGray)\n #~ outInput.write(\"%s \"%valueString)\n sumValueString = str(sumValueGray/samplSizeInt)\n #~ outInput1par.write(\"%s \"%sumValueString)\n outInput.write(\"%s \"%sumValueString)\n\n #If we did not had a problem with missing task\n if finishLine == True:\n #Closing the line of the file\n outInput.write(\"\\n\")\n #~ outInput1par.write(\"\\n\")\n outTasks.write(str(taskId)+\"\\n\")\n else:\n finishLine = True\n\n #If we are training (or we know the truth), then we also generate the truth\n if treina or verdade:\n selecName = '/home/eduardo/ForestWatchers/ann2besttile/results/tmpMosaic_n0/' + str(taskId) + '.tif'\n #Openning image (and testing)\n if os.path.exists(selecName) is False:\n print 'OUTPUT -> Task miss: ' + str(taskId)\n continue\n #~ fileSelec = gdal.Open(selecName, GA_ReadOnly)\n #~ if fileSelec is None:\n #~ print 'Could not open ' + selecName\n #~ sys.exit(1)\n #~ # Read band values from image\n #~ rows = fileSelec.RasterYSize\n #~ cols = fileSelec.RasterXSize\n #~ R_band_selec = fileSelec.GetRasterBand(1)\n #~ G_band_selec = fileSelec.GetRasterBand(2)\n #~ B_band_selec = fileSelec.GetRasterBand(3)\n #~ R_data_selec = R_band_selec.ReadAsArray(0, 0, cols, rows)\n #~ G_data_selec = G_band_selec.ReadAsArray(0, 0, cols, rows)\n #~ B_data_selec = B_band_selec.ReadAsArray(0, 0, cols, rows)\n #~ #Closing image\n #~ fileSelec = None\n#~ \n #~ if (sampl == False):\n #~ #Working with the values\n #~ for i in range(rows):\n #~ for j in range(cols):\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\n #~ valueString = str(valueGray)\n #~ outOutput.write(\"%s \"%valueString)\n #~ else:\n #~ #Working with the values\n #~ for idx in range(samplSizeInt):\n #~ i = samplList[idx][0]\n #~ j = samplList[idx][1]\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\n #~ valueString = str(valueGray)\n #~ outOutput.write(\"%s \"%valueString)\n#~ \n #~ #Closing line of the file\n #~ outOutput.write(\"\\n\")\n\n selectedTile = results[task].index(max(results[task]))\n if selectedTile == 0:\n selectedName = str(taskId) + ' 2011352'\n selectedFile = '1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 1:\n selectedName = str(taskId) + ' 2011353'\n selectedFile = '0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 2:\n selectedName = str(taskId) + ' 2011355'\n selectedFile = '0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 3:\n selectedName = str(taskId) + ' 2011357'\n selectedFile = '0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 4:\n selectedName = str(taskId) + ' 2011358'\n selectedFile = '0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 5:\n selectedName = str(taskId) + ' 2011359'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 6:\n selectedName = str(taskId) + ' 2011360'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 7:\n selectedName = str(taskId) + ' 2011361'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0'\n elif selectedTile == 8:\n selectedName = str(taskId) + ' 2011362'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0'\n elif selectedTile == 9:\n selectedName = str(taskId) + ' 2011363'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0'\n elif selectedTile == 10:\n selectedName = str(taskId) + ' 2011364'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0'\n elif selectedTile == 11:\n selectedName = str(taskId) + ' 2011365'\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0'\n #~ outOutputClass.write(\"%s\\n\"%selectedFile)\n outOutput.write(\"%s\\n\"%selectedFile)\n selecOut.write(\"%s\\n\"%selectedName)\n\n # Close files\n outInput.close()\n outTasks.close()\n #~ outInput1par.close()\n if treina or verdade:\n outOutput.close()\n #~ outOutputClass.close()\n selecOut.close()\n\n statusGenInput = 0\n print '\\nend of genInput\\n'\n return statusGenInput","def input_fn():\n bos_id = tf.constant(BOS_ID, tf.int32)\n eos_id = tf.constant(EOS_ID, tf.int32)\n\n # For training, we want a lot of parallel reading and shuffling.\n # For eval, we want no shuffling and parallel reading doesn't matter.\n d = tf.data.TFRecordDataset(input_files)\n if is_training:\n d = d.repeat()\n d = d.shuffle(buffer_size=100)\n\n d = d.map(lambda record: _decode_record(record, name_to_features))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\n tf.concat([tgt_ids, [eos_id]], 0),\n label))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n src_ids[:FLAGS.max_sequence_length],\n tgt_ids[:FLAGS.max_sequence_length],\n label\n ))\n\n d = d.map(lambda src_ids, tgt_ids, label: (\n tf.concat([src_ids, tgt_ids], 0),\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\n label\n ))\n\n d = d.map(lambda input_ids, segment_ids, label_ids: (\n input_ids,\n segment_ids,\n tf.ones_like(input_ids),\n label_ids\n ))\n\n def batching_func(x):\n return x.padded_batch(\n batch_size,\n # The entry is the source line rows;\n # this has unknown-length vectors. The last entry is\n # the source row size; this is a scalar.\n padded_shapes=(\n tf.TensorShape([None]), # src\n tf.TensorShape([None]), # tgt\n tf.TensorShape([None]),\n tf.TensorShape([])), # src_len\n # Pad the source sequences with eos tokens.\n # (Though notice we don't generally need to do this since\n # later on we will be masking out calculations past the true sequence.\n padding_values=(\n PAD_ID, # src\n PAD_ID,\n PAD_ID,\n 0)) # src_len -- unused\n\n batched_dataset = batching_func(d)\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\n {\n \"input_ids\": input_ids,\n \"segment_ids\": segment_ids,\n \"input_mask\": input_mask,\n \"label_ids\": label\n\n })\n\n return features","def prepare_test_inputs(input_dir):\n # Prepare input parameters\n parameters = Dict(dict={})\n # example structure: bcc Fe\n structure = StructureData(cell=[[1.42002584, 1.42002584, 1.42002584],\n [1.42002584, -1.42002584, -1.42002584],\n [-1.42002584, 1.42002584, -1.42002584]])\n structure.append_atom(position=[0, 0, 0], symbols='Fe')\n # create jij couplings input from csv export\n jijs_expanded = np.load(os.path.join(input_dir, 'Jij_expanded.npy'))\n jij_data = ArrayData()\n jij_data.set_array('Jij_expanded', jijs_expanded)\n\n # set up calculation\n inputs = {\n 'parameters': parameters,\n 'jij_data': jij_data,\n 'structure': structure,\n 'metadata': {\n 'description': 'Test job submission with the aiida_spirit plugin',\n },\n }\n\n return inputs","def _parse_inputs(self, skip=None):\n if skip is None:\n skip = []\n skip += ['stim_files', 'labels', 'models']\n\n if self.inputs.no_bucket:\n skip += ['out_file']\n\n return super(Decon, self)._parse_inputs(skip=skip)","def __init__(self, dataset_name, split, *args, data_dir=None, **kwargs):\n super(TfdsInput, self).__init__(*args, **kwargs)\n self.dataset_name = dataset_name\n self.split = split\n self.data_dir = data_dir","def extract_features(self, preprocessed_inputs, init_extraction=False):\n if init_extraction:\n preprocessed_inputs.get_shape().assert_has_rank(4)\n shape_assert = tf.Assert(\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\n ['image size must at least be 33 in both height and width.'])\n with tf.control_dependencies([shape_assert]):\n with slim.arg_scope(self._conv_hyperparams):\n with tf.variable_scope('MobilenetV1',\n reuse=self._reuse_weights) as scope:\n _, image_features = mobilenet_v1.mobilenet_v1_base(\n preprocessed_inputs,\n final_endpoint='Conv2d_13_pointwise',\n min_depth=self._min_depth,\n depth_multiplier=self._depth_multiplier,\n scope=scope)\n feature_head = image_features['Conv2d_13_pointwise']\n feature_head = slim.conv2d(\n feature_head,\n 512, [3,3],\n stride=1,\n padding='SAME',\n scope='Conv2d_Append_1x1_256'\n )\n feature_head = tf.nn.avg_pool(feature_head, strides=[1,1,1,1], ksize=[1,4,4,1],\n padding='VALID', )\n return feature_head\n else:\n preprocessed_inputs.get_shape().assert_has_rank(4)\n shape_assert = tf.Assert(\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\n ['image size must at least be 33 in both height and width.'])\n\n\n bottomup_features_names = [ 'Conv2d_11_pointwise', 'Conv2d_13_pointwise']\n num_appended_layers = 0\n #appended_channel_num = [512, 256, 256, 256]\n appended_channel_num = [512]\n\n with tf.control_dependencies([shape_assert]):\n with slim.arg_scope(self._conv_hyperparams):\n with tf.variable_scope('MobilenetV1',\n reuse=self._reuse_weights) as scope:\n _, image_features = mobilenet_v1.mobilenet_v1_base(\n preprocessed_inputs,\n final_endpoint='Conv2d_13_pointwise',\n min_depth=self._min_depth,\n depth_multiplier=self._depth_multiplier,\n scope=scope)\n\n topdown_features = self._topdown_feature_maps(\n image_features,\n bottomup_features_names=bottomup_features_names,\n num_appended_layers = num_appended_layers,\n appended_channel_num = appended_channel_num)\n return topdown_features.values()","def get_input_args():\n \n parser = argparse.ArgumentParser()\n \n # command line parameter for dataset path\n parser.add_argument('data_directory', action='store', type=str, \n help='directory for new dataset to train')\n \n # command line parameter for saving checkpoint path \n parser.add_argument('--save_dir',type=str,default='checkpoint',\n help='directory where checkpoint is saved')\n \n # command line parameter to input model chosen. Defaults to vgg16. Chosen model can be either vgg16 or densenet121\n parser.add_argument('--arch',type=str,default='vgg16',choices=('vgg16', 'densenet121'),\n help='chosen model: vgg16 or densenet121')\n \n # command line parameter to input learning rate. Defaults to 0.00001\n parser.add_argument('--learning_rate',type=float,default='0.00001',\n help='learning rate for model')\n \n # command line parameter to input number of hidden units\n parser.add_argument('--hidden_units',type=int,default=0,\n help='add number of units in hidden layer to list')\n \n # command line paramter to input epochs. Defaults to 5\n parser.add_argument('--epochs',type=int,default='5',\n help='number of epochs')\n \n # command line parameter for using gpu\n parser.add_argument('--gpu', action='store_true', default=False,\n help='Set a switch to true')\n \n #return parsed argument collection\n return parser.parse_args()","def input_setup(config):\n print(config.is_train)\n # Load data path\n if config.is_train:\n data, label = prepare_data(dataset=\"Train/DoF_Images (2)\")\n else:\n data, label = prepare_data(dataset=\"Test\")\n\n sub_input_sequence = []\n sub_label_sequence = []\n padding = abs(config.image_size - config.label_size) / 2 # 6\n nx = ny = 0\n\n if config.is_train:\n for i in range(len(data)):\n input_, label_ = preprocess(data[i], label[i], config.scale)\n\n if len(input_.shape) == 3:\n h, w, c = input_.shape\n else:\n h, w = input_.shape\n\n for x in range(0, h-config.image_size+1, config.stride):\n if i == 0:\n nx += 1; ny = 0\n for y in range(0, w-config.image_size+1, config.stride):\n if i == 0:\n ny += 1\n\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size\n , y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\n # print(sub_input.shape)\n # print(sub_label.shape)\n # Make channel value\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\n\n sub_input_sequence.append(sub_input)\n sub_label_sequence.append(sub_label)\n\n else:\n nx_l = []\n ny_l = []\n for i in range(len(data)):\n input_, label_ = preprocess(data[i], label[i], config.scale)\n\n if len(input_.shape) == 3:\n h, w, c = input_.shape\n else:\n h, w = input_.shape\n\n if w >= 4000 or h > 4000:\n input_ = cv2.resize(input_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\n label_ = cv2.resize(label_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\n w = int(w/2)\n h = int(h/2)\n\n # Numbers of sub-images in height and width of image are needed to compute merge operation.\n\n nx = ny = 0\n for x in range(0, h-config.image_size+1, config.stride):\n nx += 1; ny = 0\n for y in range(0, w-config.image_size+1, config.stride):\n ny += 1\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size, y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\n\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\n\n sub_input_sequence.append(sub_input)\n sub_label_sequence.append(sub_label)\n #print(\"nx: %d ny: %d\" % (nx, ny))\n nx_l.append(nx)\n ny_l.append(ny)\n \"\"\"\n len(sub_input_sequence) : the number of sub_input (33 x 33 x ch) in one image\n (sub_input_sequence[0]).shape : (33, 33, 1)\n \"\"\"\n # Make list to numpy array. With this transform\n arrdata = np.asarray(sub_input_sequence) # [?, 33, 33, 3]\n arrlabel = np.asarray(sub_label_sequence) # [?, 21, 21, 3]\n\n make_data(config, arrdata, arrlabel)\n print(\"make_data success\")\n if config.is_train:\n return nx, ny\n else:\n return nx_l, ny_l, len(data)","def prepare_data():\n gennet.prepare_data('Resnet50')","def _build(self, inputs):\n\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\n dims = inputs.get_shape().as_list()\n new_dim = 1\n for d in dims[1:]: # leave first axis as is (batch)\n new_dim = new_dim * d # multiply 'em up\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others","def __init__(self, args, args2):\n self.logger = logging.getLogger(self.__class__.__name__)\n\n self.inputUrl1 = args[\"input\"][0][\"value\"]\n self.inputUrl2 = args[\"input\"][1][\"value\"]\n self.outputUrl1 = args[\"output\"][0][\"value\"]\n self.featureCols = args[\"param\"][\"features\"]\n\n self.originalDF = None\n self.transformDF = None\n self.model = None\n\n self.dataUtil = utils.dataUtil(args2)","def init_input_pipeline(self, config):\n\n ######################\n # Calibrate parameters\n ######################\n\n print('Initiating input pipelines')\n\n # Update num classes in config\n config.num_classes = self.num_classes - len(self.ignored_labels)\n config.ignored_label_inds = [self.label_to_idx[ign_label] for ign_label in self.ignored_labels]\n\n print('ignored_label_inds:')\n print(config.ignored_label_inds)\n\n # Update network model in config\n config.network_model = self.network_model\n\n print('network_model:')\n print(config.network_model)\n\n # Calibrate generators to batch_num\n print('Calibrate generators to batch_num')\n self.batch_limit = self.calibrate_batches(config)\n\n # From config parameter, compute higher bound of neighbors number in a neighborhood\n hist_n = int(np.ceil(4 / 3 * np.pi * (config.density_parameter + 1) ** 3))\n\n # Initiate neighbors limit with higher bound\n print('Initiate neighbors limit with higher bound')\n self.neighborhood_limits = np.full(config.num_layers, hist_n, dtype=np.int32)\n\n # Calibrate max neighbors number\n print('Calibrate max neighbors number')\n self.calibrate_neighbors(config)\n\n ################################\n # Initiate tensorflow parameters\n ################################\n\n # Reset graph\n print('Reset graph')\n tf.reset_default_graph()\n\n # Set random seed (You also have to set it in network_architectures.weight_variable)\n #np.random.seed(42)\n #tf.set_random_seed(42)\n\n # Get generator and mapping function\n print('Get generator')\n gen_function, gen_types, gen_shapes = self.get_batch_gen('training', config)\n gen_function_val, _, _ = self.get_batch_gen('validation', config)\n print('Get mapping function')\n map_func = self.get_tf_mapping(config)\n\n ##################\n # Training dataset\n ##################\n\n # Create batched dataset from generator\n self.train_data = tf.data.Dataset.from_generator(gen_function,\n gen_types,\n gen_shapes)\n\n self.train_data = self.train_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\n\n # Prefetch data\n self.train_data = self.train_data.prefetch(10)\n\n ##############\n # Test dataset\n ##############\n\n # Create batched dataset from generator\n self.val_data = tf.data.Dataset.from_generator(gen_function_val,\n gen_types,\n gen_shapes)\n\n # Transform inputs\n self.val_data = self.val_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\n\n # Prefetch data\n self.val_data = self.val_data.prefetch(10)\n\n #################\n # Common iterator\n #################\n\n # create a iterator of the correct shape and type\n iter = tf.data.Iterator.from_structure(self.train_data.output_types, self.train_data.output_shapes)\n self.flat_inputs = iter.get_next()\n\n # create the initialisation operations\n self.train_init_op = iter.make_initializer(self.train_data)\n self.val_init_op = iter.make_initializer(self.val_data)","def forward(self, inputs):\n coords = inputs['point'].to(self.device)\n feat = inputs['feat'].to(self.device)\n\n out_features_list = []\n for i in range(len(self.point_features)):\n feat, _ = self.point_features[i]((feat, coords))\n out_features_list.append(feat)\n # feat: num_batches * 1024 * num_points -> num_batches * 1024 -> num_batches * 128\n feat = self.cloud_features(feat.max(dim=-1, keepdim=False).values)\n out_features_list.append(\n feat.unsqueeze(-1).repeat([1, 1, coords.size(-1)]))\n out = self.classifier(torch.cat(out_features_list, dim=1))\n return out.transpose(1, 2)","def _clone_and_prepare_features(feature_config):\n output_objects = []\n\n table_configs = {}\n\n for config in tf.nest.flatten(feature_config):\n # There should be a one-to-one mapping between new TableConfig objects and\n # old ones (as each TableConfig can be thought of as a table).\n table_configs[config.table] = table_configs.get(\n config.table,\n tf.tpu.experimental.embedding.TableConfig(\n vocabulary_size=config.table.vocabulary_size,\n dim=config.table.dim,\n initializer=config.table.initializer,\n optimizer=config.table.optimizer,\n quantization_config=config.table.quantization_config,\n combiner=config.table.combiner,\n name=config.table.name,\n ),\n )\n\n output_objects.append(\n tf.tpu.experimental.embedding.FeatureConfig(\n table=table_configs[config.table],\n max_sequence_length=config.max_sequence_length,\n output_shape=config.output_shape,\n validate_weights_and_indices=config.validate_weights_and_indices,\n name=config.name))\n\n # Fix up the optimizers.\n for _, new_table in table_configs.items():\n if new_table.optimizer is not None:\n new_table.optimizer = _normalize_and_prepare_optimizer(\n new_table.optimizer)\n\n return (tf.nest.pack_sequence_as(feature_config,\n output_objects), list(table_configs.items()))","def load_inputs(self):\n \n self.inputs = tf.placeholder(tf.int32, shape=(None,self.n_input), name='inputs')\n self.inputs_mask = tf.placeholder(tf.float32, shape=(None, self.n_input), name='inputs_mask')\n self.targets = tf.placeholder(tf.int32, shape=(None,1), name='targets')\n self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')","def input_fn(self, ctx=None):\n sup_dataset = self.supervised_input.make_parsed_dataset(ctx)\n unsup_dataset = self.unsupervised_input.make_parsed_dataset(ctx)\n\n dataset = tf.data.Dataset.zip((sup_dataset, unsup_dataset))\n dataset = dataset.map(_combine_sup_unsup_datasets)\n\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\n\n options = tf.data.Options()\n options.experimental_deterministic = False\n dataset = dataset.with_options(options)\n\n return dataset","def extract_features(self, inputs):\n x = self.conv1(inputs)\n x = self.maxpool1(x)\n x = self.conv2(x)\n x = self.conv3(x)\n x = self.maxpool2(x)\n\n x = self.inception3a(x)\n x = self.inception3b(x)\n x = self.maxpool3(x)\n x = self.inception4a(x)\n\n x = self.inception4b(x)\n x = self.inception4c(x)\n x = self.inception4d(x)\n\n x = self.inception4e(x)\n x = self.maxpool4(x)\n x = self.inception5a(x)\n x = self.inception5b(x)\n x = self.avgpool(x)\n x = torch.flatten(x,1)\n x = self.dropout(x)\n return x","def build_inputs(self):\n if self.mode == \"inference\":\n # In inference mode, images and inputs are fed via placeholders.\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_feed\")\n input_feed = tf.placeholder(\n dtype=tf.int64,\n shape=[None], # batch_size\n name=\"input_feed\")\n\n # Process image and insert batch dimensions.\n images = tf.expand_dims(self.load_image(image_feed), 0)\n input_seqs = tf.expand_dims(input_feed, 1)\n\n # No target sequences or input mask in inference mode.\n target_seqs = None\n input_mask = None\n else:\n def _load_example(serialized_example):\n encoded_image, caption = input_ops.parse_example(\n serialized_example,\n image_feature=self.config.image_feature_name,\n caption_feature=self.config.caption_feature_name)\n image = self.load_image(encoded_image)\n\n # strings.split expects a batch\n input_seqs, target_seqs, input_mask = input_ops.pad_caption_to_input(\n caption)\n return image, input_seqs, target_seqs, input_mask\n\n def _load_dataset(filename):\n return tf.data.TFRecordDataset(filename, buffer_size=16 * 1024 * 1024)\n\n df = tf.data.Dataset.list_files(\n self.config.input_file_pattern, shuffle=self.mode == \"train\")\n df = df.apply(\n tf.data.experimental.parallel_interleave(\n _load_dataset, cycle_length=64, sloppy=True))\n\n if self.mode == \"train\":\n df = df.repeat()\n df = df.shuffle(1024)\n\n df = df.apply(\n tf.data.experimental.map_and_batch(\n _load_example,\n self.config.batch_size,\n num_parallel_batches=8,\n drop_remainder=True))\n df = df.prefetch(8)\n images, input_seqs, target_seqs, input_mask = df.make_one_shot_iterator(\n ).get_next()\n\n self.images = images\n self.input_seqs = input_seqs\n self.target_seqs = target_seqs\n self.input_mask = input_mask","def create_inputs_recipe():\n module_name, _ = os.path.splitext(os.path.basename(__file__))\n path = os.path.join(CREATED_INPUTS_PATH_FOR_TESTS, module_name)\n os.makedirs(path, exist_ok=True)\n os.chdir(path)\n os.makedirs(\"inputs/\", exist_ok=True)\n print('Current working directory:\\n {:s}'.format(os.getcwd()))\n\n for filename, _ in input_pars:\n print('Downloading files...')\n basename = filename.split(\"_\")[0] + \".fits\"\n sci_path = download_from_archive(basename)\n sci_ad = astrodata.open(sci_path)\n data_label = sci_ad.data_label()\n\n print('Reducing pre-processed data:')\n logutils.config(file_name='log_{}.txt'.format(data_label))\n p = GNIRSLongslit([sci_ad])\n p.prepare(bad_wcs=\"fix\")\n p.addDQ()\n p.addVAR(read_noise=True)\n p.ADUToElectrons()\n p.addVAR(poisson_noise=True)\n # p.flatCorrect()\n p.makeIRAFCompatible()\n\n os.chdir(\"inputs/\")\n processed_ad = p.writeOutputs().pop()\n os.chdir(\"../\")\n print('Wrote pre-processed file to:\\n'\n ' {:s}'.format(processed_ad.filename))","def _prepare_batch(self, batch):\n try:\n from torch_geometric.data import Batch\n except:\n raise ValueError(\"This class requires PyTorch Geometric to be installed.\")\n\n inputs, labels, weights = batch\n pyg_graphs = [graph.to_pyg_graph() for graph in inputs[0]]\n inputs = Batch.from_data_list(pyg_graphs)\n _, labels, weights = super(GATModel, self)._prepare_batch(([], labels,\n weights))\n return inputs, labels, weights","def build_inputs(self):\n # in prediction mode, we use a batch size of one\n batch_size = self.config.batch_size\n \n if self.mode == \"prediction\":\n batch_size = 1\n \n # In inference mode, images and inputs are fed via placeholders.\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_feed\") # shape: scalar value\n\n #image_fn_feed = tf.placeholder(dtype=tf.string, shape=[], name=\"image_fn_feed\")\n \n #image_filename_queue = tf.train.string_input_producer([image_fn_feed]) # list of files to read\n \n #reader = tf.WholeFileReader()\n #_, image_feed = reader.read(image_filename_queue)\n \n \n text_feed = tf.placeholder(dtype=tf.int64,\n shape=[None, self.config.sentence_length], # shape 2D tensor - variable size (first dimension sentence sequence, second dimension token sequence (actually fixed size))\n name=\"text_feed\")\n \n # arbitrary labels (not used)\n mi_label = tf.constant(-1, dtype=tf.int64) \n sc_label = tf.constant(-1.0, dtype=tf.float32) \n\n image = self.process_image(image_feed)\n\n # Process image and insert batch dimensions.\n images = tf.expand_dims(self.process_image(image_feed), 0)\n input_seqs = tf.expand_dims(text_feed, 0) \n mi_labels = tf.expand_dims(mi_label, 0)\n sc_labels = tf.expand_dims(sc_label, 0)\n input_mask = tf.expand_dims(tf.constant([1], dtype=tf.int32) , 0)\n \n else:\n # Prefetch serialized SequenceExample protos.\n input_queue = input_ops.prefetch_input_data(\n self.reader,\n self.config.input_file_pattern,\n is_training=self.is_training(),\n batch_size=batch_size,\n values_per_shard=self.config.values_per_input_shard,\n input_queue_capacity_factor=self.config.input_queue_capacity_factor,\n num_reader_threads=self.config.num_input_reader_threads,\n mode=self.mode)\n\n # Image processing and random distortion. Split across multiple threads\n # with each thread applying a slightly different distortion.\n assert self.config.num_preprocess_threads % 2 == 0\n images_and_texts = []\n for thread_id in range(self.config.num_preprocess_threads):\n serialized_sequence_example = input_queue.dequeue()\n encoded_image, text, mi, sc = input_ops.parse_sequence_example(\n serialized_sequence_example,\n image_feature=self.config.image_feature_name,\n sentences_feature=self.config.sentences_feature_name,\n sentence_length=self.config.sentence_length,\n mi_feature=self.config.mi_feature_name,\n sc_feature=self.config.sc_feature_name)\n image = self.process_image(encoded_image, thread_id=thread_id)\n images_and_texts.append([image, text, mi, sc])\n\n # Batch inputs.\n queue_capacity = (2 * self.config.num_preprocess_threads *\n batch_size)\n images, input_seqs, mi_labels, sc_labels, input_mask = (\n input_ops.batch_with_dynamic_pad(images_and_texts,\n batch_size=batch_size,\n queue_capacity=queue_capacity))\n \n #print('Shapes') \n #print('Shape images: ' + str(images.get_shape()))\n #print('Shape input_seqs: ' + str(input_seqs.get_shape())) \n #print('Shape input_mask: ' + str(input_mask.get_shape())) \n\n self.images = images\n self.input_seqs = input_seqs\n if self.mode == \"prediction\":\n self.mi_labels = None\n self.sc_labels = None\n else:\n self.mi_labels = mi_labels\n self.sc_labels = sc_labels\n self.input_mask = input_mask","def train_input(config, params):\n\n def _grouping(pim, pla, iid):\n # group dataset elements as required by estimator\n features = {\n # 'rawimages': rim,\n 'proimages': pim,\n 'imageids': iid,\n # 'rawimagespaths': imp,\n # 'rawlabelspaths': lap,\n }\n labels = {\n # 'rawlabels': rla,\n 'prolabels': pla,\n }\n\n # next line for distributed debugging\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\n if params.distribute:\n # del features['rawimagespaths']\n # del features['rawlabelspaths']\n del features['imageids']\n\n return (features, labels)\n\n with tf.name_scope('input_pipeline'):\n dataset = prebatch_dataset(config, params)\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\n dataset = postbatch_dataset(dataset, config, params)\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\n options = tf.data.Options()\n options.experimental_autotune = True\n # seems than on average gives faster results\n dataset = dataset.prefetch(None).with_options(options)\n\n return dataset","def build_inputs(\n timesteps,\n latlon_dense_units,\n concat_dense_units,\n latent_dim,\n vocab_sizes,\n noise=False,\n mask=False,\n):\n latlon_input, latlon_embed = build_inputs_latlon(timesteps, latlon_dense_units)\n inputs = [latlon_input]\n embeddings = [latlon_embed]\n for key, val in vocab_sizes.items():\n cat_input, cat_embed = build_inputs_cat(timesteps, val, key)\n inputs.append(cat_input)\n embeddings.append(cat_embed)\n concat_input = layers.Concatenate(axis=2)(embeddings)\n unstacked = layers.Lambda(lambda x: tf.unstack(x, axis=1))(concat_input)\n d = layers.Dense(\n units=concat_dense_units,\n activation=\"relu\",\n kernel_initializer=initializers.he_uniform(seed=1),\n name=\"emb_trajpoint\",\n )\n if noise:\n noise_input = layers.Input(shape=(latent_dim,), name=\"input_noise\")\n inputs.append(noise_input)\n dense_outputs = [d(layers.Concatenate(axis=1)([x, noise_input])) for x in unstacked]\n else:\n dense_outputs = [d(x) for x in unstacked]\n if mask:\n inputs.append(layers.Input(shape=(timesteps, 1), name=\"input_mask\"))\n emb_traj = layers.Lambda(lambda x: tf.stack(x, axis=1))(dense_outputs)\n return (inputs, emb_traj)","def init_test_input_pipeline(self, config):\n\n print('Initiating test input pipelines')\n\n ######################\n # Calibrate parameters\n ######################\n\n # Update num classes in config\n config.num_classes = self.num_classes - len(self.ignored_labels)\n config.ignored_label_inds = [self.label_to_idx[ign_label] for ign_label in self.ignored_labels]\n\n # Update network model in config\n config.network_model = self.network_model\n\n # Update num classes in config\n\n if config.network_model == 'multi_segmentation':\n config.num_classes = self.num_parts\n elif config.network_model == 'segmentation':\n if self.ShapeNetPartType in self.label_names:\n config.num_classes = self.num_parts[self.name_to_label[self.ShapeNetPartType]]\n else:\n raise ValueError('Wrong object name given for ShapeNetPart single object segmentation')\n\n # Calibrate generators to batch_num\n self.batch_limit = self.calibrate_batches(config)\n\n # From config parameter, compute higher bound of neighbors number in a neighborhood\n hist_n = int(np.ceil(4 / 3 * np.pi * (config.density_parameter + 1) ** 3))\n\n # Initiate neighbors limit with higher bound\n self.neighborhood_limits = np.full(config.num_layers, hist_n, dtype=np.int32)\n\n # Calibrate max neighbors number\n self.calibrate_neighbors(config)\n\n ################################\n # Initiate tensorflow parameters\n ################################\n\n # Reset graph\n tf.reset_default_graph()\n\n # Set random seed (You also have to set it in network_architectures.weight_variable)\n #np.random.seed(42)\n #tf.set_random_seed(42)\n\n # Get generator and mapping function\n gen_function, gen_types, gen_shapes = self.get_batch_gen('test', config)\n map_func = self.get_tf_mapping(config)\n\n ##############\n # Test dataset\n ##############\n\n # Create batched dataset from generator\n self.test_data = tf.data.Dataset.from_generator(gen_function,\n gen_types,\n gen_shapes)\n\n self.test_data = self.test_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\n\n # Prefetch data\n self.test_data = self.test_data.prefetch(10)\n\n #################\n # Common iterator\n #################\n\n # create a iterator of the correct shape and type\n iter = tf.data.Iterator.from_structure(self.test_data.output_types, self.test_data.output_shapes)\n self.flat_inputs = iter.get_next()\n\n # create the initialisation operations\n self.test_init_op = iter.make_initializer(self.test_data)","def input_nodes(self):\n pass","def prepare_agent_input_data(event, context):\n print \"Preparing input data for the agent\"\n write_data_to_file(json.dumps(event), '/tmp/event.json')\n write_data_to_file('{ \"logStreamName\": \"%s\" }' % context.log_stream_name, '/tmp/context.json')","def _reset_parameters(self) -> None:\n self._setup_input = {\n \"P\": csc_matrix(2.0 * self.opt.P(self.p).toarray()),\n \"q\": self.opt.q(self.p).toarray().flatten(),\n }\n if self.opt_type in CONSTRAINED_OPT:\n A = self.opt.A(self.p)\n b = self.opt.b(self.p)\n self._setup_input[\"A\"] = csc_matrix(\n cs.vertcat(self.opt.M(self.p), A, -A).toarray()\n )\n self._setup_input[\"l\"] = (\n cs.vertcat(-self.opt.c(self.p), -b, b).toarray().flatten()\n )","def preprocessing_fn(inputs):\n\n outputs = inputs.copy()\n\n # Filter redundant features\n for key in FEATURES_TO_REMOVE:\n del outputs[key]\n\n # Convert degrees to radians\n pi = tf.constant(m.pi)\n wd_rad = inputs['wd (deg)'] * pi / 180.0\n\n # Calculate the wind x and y components.\n outputs['Wx'] = inputs['wv (m/s)'] * tf.math.cos(wd_rad)\n outputs['Wy'] = inputs['wv (m/s)'] * tf.math.sin(wd_rad)\n\n # Delete `wv (m/s)` after getting the wind vector\n del outputs['wv (m/s)']\n\n # Get day and year in seconds\n day = tf.cast(24*60*60, tf.float32)\n year = tf.cast((365.2425)*day, tf.float32)\n\n # Convert `Date Time` column into timestamps in seconds (using tfa helper function)\n timestamp_s = tfa.text.parse_time(outputs['Date Time'], time_format='%d.%m.%Y %H:%M:%S', output_unit='SECOND')\n timestamp_s = tf.cast(timestamp_s, tf.float32)\n \n # Convert timestamps into periodic signals\n outputs['Day sin'] = tf.math.sin(timestamp_s * (2 * pi / day))\n outputs['Day cos'] = tf.math.cos(timestamp_s * (2 * pi / day))\n outputs['Year sin'] = tf.math.sin(timestamp_s * (2 * pi / year))\n outputs['Year cos'] = tf.math.cos(timestamp_s * (2 * pi / year))\n\n # Delete unneeded columns\n del outputs['Date Time']\n del outputs['wd (deg)']\n\n # Final feature list\n FINAL_FEATURE_LIST = [\"p (mbar)\",\n \"T (degC)\",\n \"rh (%)\", \n \"VPmax (mbar)\", \n \"VPdef (mbar)\", \n \"sh (g/kg)\",\n \"rho (g/m**3)\",\n \"Wx\",\n \"Wy\",\n \"Day sin\",\n 'Day cos',\n 'Year sin',\n 'Year cos'\n ]\n\n # Scale selected numeric features\n for key in _SELECTED_NUMERIC_FEATURE_KEYS:\n outputs[key] = tft.scale_to_0_1(outputs[key])\n\n return outputs","def _clean_inputs(self, inputs):\n return inputs","def _collect_ipt_and_opt_nodes(self):\n for name, node in self._nodes_collection.items():\n if node.in_degree == 0:\n # NOTICE: what's usage of `scope`?\n self._input_nodes.append(name)\n\n if node.out_degree == 0:\n self._output_nodes.append(name)","def prepare_data(self, *args, **kwargs):\n # get paths to train and test splits\n _split_paths = [os.path.join(self.path_to_data, split)\n for split in os.listdir(self.path_to_data)]\n\n # for each split [train, test]\n for _path in _split_paths:\n _img_classes = os.listdir(_path) # get subfolders representing each class\n self.splits[os.path.basename(_path)] = []\n\n # get the images in pairs with its corresponding class\n for _class in _img_classes:\n _data = self.get_img_text_pair(os.path.join(_path, _class))\n\n if os.path.basename(_path) == 'train':\n self.weights[self.encode_label(_class)] = len(_data)\n self.splits[os.path.basename(_path)].extend(_data)","def setup(self):\n in_dataset, out_dataset = self.get_datasets()","def setup(self):\n in_dataset, out_dataset = self.get_datasets()"],"string":"[\n \"def construct_inputs(\\n cls,\\n training_data: Dict[str, SupervisedDataset],\\n task_feature: int,\\n rank: Optional[int] = None,\\n **kwargs: Any,\\n ) -> Dict[str, Any]:\\n inputs = super().construct_inputs(\\n training_data=training_data, task_feature=task_feature, rank=rank, **kwargs\\n )\\n inputs.pop(\\\"task_covar_prior\\\")\\n if \\\"train_Yvar\\\" not in inputs:\\n inputs[\\\"train_Yvar\\\"] = None\\n return inputs\",\n \"def preprocess(self, first_inputs,second_inputs,third_inputs):\\r\\n pass\",\n \"def _prep_inputs(self):\\n if self.x is not None:\\n self.x = np.array(self.x)\\n\\n if self.y is not None:\\n self.y = np.array(self.y)\\n\\n if self.z is not None:\\n for k in self.z.keys():\\n self.z[k] = np.array(self.z[k])\",\n \"def prepare_data_inputs(self, process, inputs, domain, **kwargs):\\n temp_process = process.copy()\\n\\n domains = {}\\n\\n if domain is not None:\\n domains[domain.name] = domain\\n\\n temp_process.domain = domain\\n\\n if not isinstance(inputs, (list, tuple)):\\n inputs = [inputs, ]\\n\\n temp_process.inputs.extend(inputs)\\n\\n if 'gridder' in kwargs:\\n temp_process.gridder = kwargs.pop('gridder')\\n\\n temp_process.add_parameters(**kwargs)\\n\\n processes, variables = temp_process.collect_input_processes()\\n\\n # Collect all the domains from nested processes\\n for item in list(processes.values()):\\n if item.domain is not None and item.domain.name not in domains:\\n domains[item.domain.name] = item.domain\\n\\n variable = json.dumps([x.to_dict() for x in list(variables.values())])\\n\\n domain = json.dumps([x.to_dict() for x in list(domains.values())])\\n\\n operation = json.dumps([x.to_dict() for x in list(processes.values())])\\n\\n return variable, domain, operation\",\n \"def prepare_infer_input(insts, bos_idx, eos_idx, src_pad_idx, n_head):\\n src_word, src_pos, src_slf_attn_bias, src_max_len = pad_batch_data(\\n [inst[0] + [eos_idx] for inst in insts],\\n src_pad_idx,\\n n_head,\\n is_target=False)\\n trg_src_attn_bias = np.tile(src_slf_attn_bias[:, :, ::src_max_len, :],\\n [1, 1, 1, 1]).astype(\\\"float32\\\")\\n src_word = src_word.reshape(-1, src_max_len)\\n src_pos = src_pos.reshape(-1, src_max_len)\\n\\n data_inputs = [src_word, src_pos, src_slf_attn_bias, trg_src_attn_bias]\\n return data_inputs\",\n \"def process_inputs(self, inputs):\",\n \"def processInputs(self):\",\n \"def setup(self):\\n\\n for name, infos in Rt.geom_dict.items():\\n if name in Rt.optim_var_dict:\\n self.add_input(name, val=infos[1][0])\",\n \"def prepare_inputs(self, **inputs):\\n true_inputs = {'imain_loc' : self.get_input_tensor(0, 'loc'),\\n 'imain_prec' : self.get_input_tensor(0, 'prec'),\\n 'ids_prec' : self.get_input_tensor(1, 'prec'),\\n 'ids_A' : self.get_input_tensor(1, 'A'),\\n 'iprior_scale' : self.get_input_tensor(2, 'scale')}\\n \\n if inputs:\\n print(\\\"\\\\t\\\\tUpdating defaults,\\\", self.name, \\\"with\\\", list(inputs.keys()))\\n true_inputs.update(inputs)\\n return true_inputs\",\n \"def _prepare_data(self):\\n #TODO hardcoded values need to change\\n print_info(\\\"Preprocessing the train data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"train\\\"),\\n self.TRAIN_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the test data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"test\\\"),\\n self.TEST_OUT_PATH)\\n\\n print_info(\\\"Preprocessing the validation data...\\\")\\n self._place_dataset(os.path.join(self._hparams[\\\"temp-data\\\"], \\\"val\\\"),\\n self.VAL_OUT_PATH)\",\n \"def _prepare_input_for_export(args, kwargs):\\n args, kwargs = _prepare_input_for_pytorch(args, kwargs)\\n if not kwargs and len(args) > 0 and isinstance(args[-1], dict):\\n onnx_inputs = args + ({},)\\n elif kwargs:\\n onnx_inputs = args + (kwargs,)\\n else:\\n onnx_inputs = args\\n return onnx_inputs\",\n \"def prepare_train_input(insts, bos_idx, eos_idx, src_pad_idx, trg_pad_idx,\\n n_head):\\n src_word, src_pos, src_slf_attn_bias, src_max_len = pad_batch_data(\\n [inst[0] + [eos_idx] for inst in insts],\\n src_pad_idx,\\n n_head,\\n is_target=False)\\n src_word = src_word.reshape(-1, src_max_len)\\n src_pos = src_pos.reshape(-1, src_max_len)\\n trg_word, trg_pos, trg_slf_attn_bias, trg_max_len = pad_batch_data(\\n [[bos_idx] + inst[1] for inst in insts],\\n trg_pad_idx,\\n n_head,\\n is_target=True)\\n trg_word = trg_word.reshape(-1, trg_max_len)\\n trg_pos = trg_pos.reshape(-1, trg_max_len)\\n\\n trg_src_attn_bias = np.tile(src_slf_attn_bias[:, :, ::src_max_len, :],\\n [1, 1, trg_max_len, 1]).astype(\\\"float32\\\")\\n\\n lbl_word, lbl_weight, num_token = pad_batch_data(\\n [inst[1] + [eos_idx] for inst in insts],\\n trg_pad_idx,\\n n_head,\\n is_target=False,\\n is_label=True,\\n return_attn_bias=False,\\n return_max_len=False,\\n return_num_token=True)\\n lbl_word = lbl_word.reshape(-1, 1)\\n lbl_weight = lbl_weight.reshape(-1, 1)\\n\\n data_inputs = [\\n src_word, src_pos, src_slf_attn_bias, trg_word, trg_pos,\\n trg_slf_attn_bias, trg_src_attn_bias, lbl_word, lbl_weight\\n ]\\n\\n return data_inputs\",\n \"def _buildInput (self):\\n\\n\\t\\tindata = self.config['input']\\n\\t\\tif not isinstance (indata, dict):\\n\\t\\t\\tindata = ','.join(utils.alwaysList (indata))\\t\\t\\t\\n\\t\\t\\tdepdchan = channel.fromChannels (*[d.channel for d in self.depends])\\n\\t\\t\\tindata = {indata: depdchan if self.depends else channel.fromArgv()}\\n\\t\\t\\t\\n\\t\\t# expand to one key-channel pairs\\n\\t\\tfor inkeys, invals in indata.iteritems():\\n\\t\\t\\tkeys = utils.split(inkeys, ',')\\n\\t\\t\\tif callable (invals):\\n\\t\\t\\t\\tvals = invals (*[d.channel.copy() for d in self.depends] if self.depends else channel.fromArgv())\\n\\t\\t\\t\\tvals = vals.split()\\n\\t\\t\\telif isinstance (invals, basestring): # only for files: \\\"/a/b/*.txt, /a/c/*.txt\\\"\\n\\t\\t\\t\\tvals = utils.split(invals, ',')\\n\\t\\t\\telif isinstance (invals, channel):\\n\\t\\t\\t\\tvals = invals.split()\\n\\t\\t\\telif isinstance (invals, list):\\n\\t\\t\\t\\tvals = channel.create(invals).split()\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise ValueError (\\\"%s: Unexpected values for input. Expect dict, list, str, channel, callable.\\\" % self._name())\\n\\t\\t\\t\\n\\t\\t\\twidth = len (vals)\\n\\t\\t\\tif len (keys) > width:\\n\\t\\t\\t\\traise ValueError ('%s: Not enough data for input variables.\\\\nVarialbes: %s\\\\nData: %s' % (self._name(), keys, vals))\\n\\t\\t\\t\\n\\t\\t\\tfor i, key in enumerate(keys):\\n\\t\\t\\t\\tintype = key.split(':')[-1]\\n\\t\\t\\t\\tthekey = key.split(':')[0]\\n\\t\\t\\t\\tval = vals[i].toList() #if isinstance(vals[i], channel) else vals[i]\\n\\n\\t\\t\\t\\tif intype not in proc.IN_VARTYPE + proc.IN_FILESTYPE + proc.IN_FILETYPE:\\n\\t\\t\\t\\t\\tintype = proc.IN_VARTYPE[0]\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif intype in proc.IN_FILESTYPE:\\n\\t\\t\\t\\t\\tfor x, v in enumerate(val):\\n\\t\\t\\t\\t\\t\\tif isinstance (v, basestring):\\n\\t\\t\\t\\t\\t\\t\\tval[x] = channel.fromPath (v).toList()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif self.length == 0: \\n\\t\\t\\t\\t\\tself.props['length'] = len (val)\\n\\t\\t\\t\\tif self.length != len (val):\\n\\t\\t\\t\\t\\traise ValueError ('%s: Expect same lengths for input channels, but got %s and %s (keys: %s).' % (self._name(), self.length, len (val), key))\\n\\t\\t\\t\\tself.props['indata'][thekey] = {\\n\\t\\t\\t\\t\\t'type': intype,\\n\\t\\t\\t\\t\\t'data': val\\n\\t\\t\\t\\t}\\n\\t\\t\\tself.props['jobs'] = [None] * self.length\",\n \"def extract_features(self, inputs):\\n pass\",\n \"def input_setup(config):\\n # Load data path, if is_train False, get test data\\n data = load_data(config.is_train, config.test_img)\\n \\n # Make sub_input and sub_label, if is_train false more return nx, ny\\n if config.is_train:\\n \\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_train(data, config)\\n else:\\n\\tsub_input_sequence, sub_label_sequence, nx, ny = make_sub_data_test(data, config)\\n\\n\\n # Make list to numpy array. With this transform\\n arrinput = np.asarray(sub_input_sequence) # [?, 41, 41, 3]\\n arrlabel = np.asarray(sub_label_sequence) # [?, 41, 41, 3]\\n make_data_hf(arrinput, arrlabel, config)\\n\\n return nx, ny\",\n \"def build_inputs(self):\\n if self.mode == \\\"encode\\\":\\n # Word embeddings are fed from an external vocabulary which has possibly\\n # been expanded (see vocabulary_expansion.py).\\n encode_ids1 = None\\n encode_ids2 = None\\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask1\\\")\\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask2\\\")\\n label = None\\n\\n elif self.mode == \\\"test\\\":\\n encode_ids1 = None\\n encode_ids2 = None\\n encode_mask1 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask1\\\")\\n encode_mask2 = tf.placeholder(tf.int8, (None, None), name=\\\"encode_mask2\\\")\\n label = None\\n \\n else:\\n # Prefetch serialized tf.Example protos.\\n input_queue = input_ops.prefetch_input_data(\\n self.reader,\\n self.config.input_file_pattern,\\n shuffle=self.config.shuffle_input_data,\\n capacity=self.config.input_queue_capacity,\\n num_reader_threads=self.config.num_input_reader_threads)\\n\\n # Deserialize a batch.\\n serialized = input_queue.dequeue_many(self.config.batch_size)\\n s1, s2, label = input_ops.parse_example_batch(\\n serialized)\\n\\n encode_ids1 = s1.ids\\n encode_ids2 = s2.ids\\n\\n encode_mask1 = s1.mask\\n encode_mask2 = s2.mask\\n \\n\\n\\n self.encode_ids1 = encode_ids1\\n self.encode_ids2 = encode_ids2\\n\\n self.encode_mask1 = encode_mask1\\n self.encode_mask2 = encode_mask2\\n\\n self.label = label\",\n \"def setup_layers(self, params):\\n\\n #\\n # Input layer\\n #\\n\\n # Input and encoding layers\\n layer_stack = [\\n tf.placeholder(\\n tf.int32,\\n name=\\\"input\\\",\\n shape=[None, params.in_size]\\n )\\n ]\\n\\n in_layer = layer_stack[0]\\n\\n good_chars = getattr(params, 'good_chars', tops.TextProcessor.DEFAULT_CHARS)\\n character_depth = len(good_chars) + 2\\n\\n layer_stack.append(\\n self.make_onehot_encode_layer(\\n layer_stack[-1],\\n character_depth\\n )\\n )\\n\\n # Add conv layers\\n for idx, num_nodes in enumerate(params.conv_nodes):\\n layer_stack.append(\\n self.make_conv_layer(\\n layer_stack[-1],\\n num_nodes,\\n 'conv_{}'.format(idx),\\n params.conv_params\\n )\\n )\\n\\n # Flatten convolutional layers\\n layer_stack.append(\\n tf.contrib.layers.flatten(\\n layer_stack[-1]\\n )\\n )\\n\\n # Add dense layers\\n for idx, num_nodes in enumerate(params.dense_nodes):\\n layer_stack.append(\\n self.make_dense_layer(\\n layer_stack[-1],\\n num_nodes,\\n 'dense_{}'.format(idx),\\n params.dense_params\\n )\\n )\\n\\n # Output layer is broken into two pieces. The pre/post the application\\n # of the activation function. That's because the loss functions\\n # for cross-entropy rely on the pre-activation scores in preact\\n\\n preact_out_layer, out_layer = self.make_dense_output_layer(\\n layer_stack[-1],\\n params.out_size,\\n params.output_params\\n )\\n\\n target_layer = tf.placeholder(\\n \\\"float\\\",\\n name=\\\"target\\\",\\n shape=[None, params.out_size]\\n )\\n\\n if params.output_params.activation in ['sigmoid']:\\n loss = tops.loss_sigmoid_ce(preact_out_layer, target_layer)\\n else:\\n loss = tops.loss_softmax_ce(preact_out_layer, target_layer)\\n\\n return in_layer, out_layer, target_layer, loss\",\n \"def _process_task_inputs(self):\\n _input = self._task.input\\n log.debug('Input parsing for %s and node %s from container', self._task.project_id, self._task.internal_id)\\n log.debug(_input)\\n\\n input_ports = dict()\\n for port in _input:\\n log.debug(port)\\n self._process_task_input(port, input_ports)\\n\\n log.debug('DUMPING json')\\n #dump json file\\n if input_ports:\\n file_name = os.path.join(self._executor.in_dir, 'input.json')\\n with open(file_name, 'w') as f:\\n json.dump(input_ports, f)\\n\\n log.debug('DUMPING DONE')\",\n \"def prepare_data(self):\\n data = self._get_dataset(self.hparams.dataset_path)\\n label_encoder = data[\\\"label_encoder\\\"]\\n del data[\\\"label_encoder\\\"]\\n\\n click.secho(\\\"Building inputs and labels.\\\", fg=\\\"yellow\\\")\\n datasets = {\\n \\\"train\\\": defaultdict(list),\\n \\\"valid\\\": defaultdict(list),\\n \\\"test\\\": defaultdict(list),\\n }\\n for dataset_name, dataset in data.items():\\n for sample in dataset:\\n instance = self.build_input(\\n self.tokenizer, sample[\\\"text\\\"], label_encoder, sample[\\\"label\\\"]\\n )\\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n\\n click.secho(\\\"Padding inputs and building tensors.\\\", fg=\\\"yellow\\\")\\n tensor_datasets = {\\\"train\\\": [], \\\"valid\\\": [], \\\"test\\\": []}\\n for dataset_name, dataset in datasets.items():\\n dataset = self.pad_dataset(dataset, padding=self.tokenizer.pad_index)\\n for input_name in MODEL_INPUTS:\\n if input_name == \\\"labels\\\":\\n tensor = torch.tensor(dataset[input_name], dtype=torch.float32)\\n else:\\n tensor = torch.tensor(dataset[input_name])\\n tensor_datasets[dataset_name].append(tensor)\\n\\n self.train_dataset = TensorDataset(*tensor_datasets[\\\"train\\\"])\\n self.valid_dataset = TensorDataset(*tensor_datasets[\\\"valid\\\"])\\n self.test_dataset = TensorDataset(*tensor_datasets[\\\"test\\\"])\\n click.secho(\\n \\\"Train dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.train_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Valid dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.valid_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\\n click.secho(\\n \\\"Test dataset (Batch, Candidates, Seq length): {}\\\".format(\\n self.test_dataset.tensors[0].shape\\n ),\\n fg=\\\"yellow\\\",\\n )\",\n \"def _prepare_input(\\n self, data: Union[Dict[str, torch.Tensor], torch.Tensor, np.ndarray]\\n ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\\n\\n # convert ot dict\\n if isinstance(data, torch.Tensor):\\n p4 = data\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n elif isinstance(data, np.ndarray):\\n p4 = torch.from_numpy(data)\\n data = dict()\\n data[\\\"p4\\\"] = p4\\n\\n node_ps = data[\\\"p4\\\"].to(device=self.device, dtype=self.dtype) * self.scale\\n if self.jet_features:\\n jet_p = torch.sum(node_ps, dim=-2).unsqueeze(-2)\\n node_ps = torch.cat((node_ps, jet_p), dim=-2)\\n\\n scalars = normsq4(node_ps).abs().sqrt().unsqueeze(-1)\\n if self.jet_features:\\n jet_mass = (\\n normsq4(torch.sum(node_ps, dim=-2))\\n .unsqueeze(-1)\\n .unsqueeze(-1)\\n .repeat(1, self.num_input_particles, 1)\\n )\\n scalars = torch.cat((scalars, jet_mass), dim=-1)\\n\\n # Calculate node masks and edge masks\\n if \\\"labels\\\" in data:\\n node_mask = data[\\\"labels\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"masks\\\" in data:\\n node_mask = data[\\\"masks\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n elif \\\"mask\\\" in data:\\n node_mask = data[\\\"mask\\\"].to(device=self.device)\\n node_mask = node_mask.to(torch.uint8)\\n else:\\n node_mask = data[\\\"p4\\\"][..., 0] != 0\\n node_mask = node_mask.to(device=self.device, dtype=torch.uint8)\\n if self.jet_features:\\n jet_mask = torch.ones_like(node_mask[..., 0:1])\\n jet_mask = jet_mask.to(device=self.device, dtype=torch.uint8)\\n node_mask = torch.cat((node_mask, jet_mask), dim=-1)\\n edge_mask = node_mask.unsqueeze(1) * node_mask.unsqueeze(2)\\n\\n if \\\"scalars\\\" in data.keys():\\n # (0,0) representation\\n scalars = torch.cat(\\n [scalars, data[\\\"scalars\\\"].to(device=self.device, dtype=self.dtype)],\\n dim=-1,\\n )\\n\\n return scalars, node_ps, node_mask, edge_mask\",\n \"def _prepare_input_for_onnx(\\n args, kwargs, remained_onnx_input_idx: Optional[Sequence[int]], flatten: bool\\n):\\n onnx_inputs = _prepare_input_for_export(args, kwargs)\\n if flatten:\\n onnx_inputs, _ = torch.jit._flatten(onnx_inputs)\\n elif onnx_inputs and onnx_inputs[-1] == {}:\\n # Handle empty kwargs (normally removed by flatten).\\n onnx_inputs = onnx_inputs[:-1]\\n if remained_onnx_input_idx is not None:\\n return [onnx_inputs[i] for i in remained_onnx_input_idx]\\n else:\\n return onnx_inputs\",\n \"def _prepare_forward_inputs(\\n device: torch.device,\\n input_dtype: Optional[torch.dtype],\\n *args: Any,\\n **kwargs: Any,\\n) -> Tuple[Any, Any]:\\n # TODO: Do not use the side stream for tensor copies for now; investigate\\n # the perf with/without it.\\n # TODO: For mixed precision, move the inputs to the compute device and cast\\n # to reduced-precision in a single `to()` call.\\n args_tuple, kwargs_tuple = _to_kwargs(args, kwargs, device.index, False)\\n args = args_tuple[0]\\n kwargs = kwargs_tuple[0]\\n if input_dtype is not None:\\n args, kwargs = _cast_fp_inputs_to_dtype(input_dtype, *args, **kwargs)\\n return args, kwargs\",\n \"def _transform_inputs(self) -> None:\\n self.inputs = None if self.inputs == {} else self.inputs\",\n \"def generate_input_data(self):\\n for socket_name, c in self.__taskobject.inputs.items():\\n if c['optional']:\\n self.__inputs[socket_name] = {'data': None, 'enable': False}\\n else:\\n self.__inputs[socket_name] = {'data': None, 'enable': True}\",\n \"def __init__(self, latent_space, input_features):\\r\\n\\r\\n self._latent_space = latent_space\\r\\n self._input_cells = input_features\\r\\n\\r\\n self._encoder = None\\r\\n self._decoder = None\\r\\n self._autoencoder = None\\r\\n self._configure_network()\",\n \"def prepareData(self, *data):\\n arguments = 8\\n (self.X, self.X_name, self.Y, self.Y_name, self.alignment,\\n self.model, self.annotations, self.args) = tuple(data[:arguments])\\n \\n self.width = self.args.beam_width\\n self.mathType = self.args.mathType\\n self.io_files = {\\n 'input': self.args.intermediate_input_files,\\n 'output': self.args.intermediate_output_files\\n }\\n self.repeat_width = self.args.repeat_width\\n self.cons_count = self.args.cons_count\\n self.posterior_processors = self.args.posterior_processors \\n\\n self.positionGenerator = \\\\\\n list(AlignmentBeamGenerator(self.alignment, self.width))\\n \\n for i in range(len(self.model.states)):\\n self.model.states[i].computeHints(self)\\n\\n return data[arguments:]\",\n \"def prepare_inputs(data, queries, tokenizer):\\n # Prepare inputs\\n table = pd.DataFrame.from_dict(data)\\n inputs = tokenizer(table=table, queries=queries,truncation=True, padding=True,return_tensors=\\\"pt\\\").to(device)\\n\\n # Return things\\n return table, inputs\",\n \"def _populate_input_data_transfer_fields(self):\\r\\n # Valid fields for the Route Stops input are described here:\\r\\n # https://pro.arcgis.com/en/pro-app/latest/arcpy/network-analyst/route-input-data-types.htm\\r\\n # Do not transfer RouteName or Sequence as these are explicitly controlled by this tool. Do not transfer\\r\\n # LocationType because we want all inputs to be Stops. Waypoints don't make sense for this analysis.\\r\\n int_types = [\\\"Integer\\\", \\\"SmallInteger\\\"]\\r\\n numerical_types = [\\\"Double\\\", \\\"Single\\\"] + int_types\\r\\n rt_stops_input_fields = {\\r\\n \\\"Name\\\": [\\\"String\\\"],\\r\\n \\\"AdditionalTime\\\": numerical_types,\\r\\n \\\"AdditionalDistance\\\": numerical_types,\\r\\n \\\"AdditionalCost\\\": numerical_types,\\r\\n \\\"TimeWindowStart\\\": [\\\"Date\\\"],\\r\\n \\\"TimeWindowEnd\\\": [\\\"Date\\\"],\\r\\n \\\"CurbApproach\\\": int_types,\\r\\n \\\"Bearing\\\": numerical_types,\\r\\n \\\"BearingTol\\\": numerical_types,\\r\\n \\\"NavLatency\\\": numerical_types,\\r\\n \\\"SourceID\\\": int_types,\\r\\n \\\"SourceOID\\\": int_types,\\r\\n \\\"PosAlong\\\": numerical_types,\\r\\n \\\"SideOfEdge\\\": int_types\\r\\n }\\r\\n # Preserve origin and destination input fields that match names and types\\r\\n origin_transfer_fields = [\\r\\n f.name for f in arcpy.ListFields(self.origins) if f.name in rt_stops_input_fields and\\r\\n f.type in rt_stops_input_fields[f.name]]\\r\\n self.rt_inputs[\\\"origin_transfer_fields\\\"] = origin_transfer_fields\\r\\n if origin_transfer_fields:\\r\\n LOGGER.info((\\r\\n \\\"Supported fields in the input Origins table that will be used in the analysis: \\\"\\r\\n f\\\"{origin_transfer_fields}\\\"\\r\\n ))\\r\\n destination_transfer_fields = [\\r\\n f.name for f in arcpy.ListFields(self.destinations) if f.name in rt_stops_input_fields and\\r\\n f.type in rt_stops_input_fields[f.name]]\\r\\n self.rt_inputs[\\\"destination_transfer_fields\\\"] = destination_transfer_fields\\r\\n if destination_transfer_fields:\\r\\n LOGGER.info((\\r\\n \\\"Supported fields in the input Destinations table that will be used in the analysis: \\\"\\r\\n f\\\"{destination_transfer_fields}\\\"\\r\\n ))\",\n \"def set_inputs(\\n self,\\n train_X: Tensor,\\n train_Y: Tensor,\\n train_Yvar: Optional[Tensor],\\n task_feature: int,\\n task_rank: Optional[int] = None,\\n ):\\n super().set_inputs(train_X, train_Y, train_Yvar)\\n # obtain a list of task indicies\\n all_tasks = train_X[:, task_feature].unique().to(dtype=torch.long).tolist()\\n self.task_feature = task_feature\\n self.num_tasks = len(all_tasks)\\n self.task_rank = task_rank or 1\\n # assume there is one column for task feature\\n self.ard_num_dims = self.train_X.shape[-1] - 1\",\n \"def feed_inputs(self):\\n feed_dict = collections.defaultdict(list)\\n for i in range(self._pipe.batch_size):\\n data = self.example_to_data(self._buffer.get())\\n for k, v in data.items():\\n feed_dict[k].append(v)\\n for k, v in self.features.items():\\n self._pipe.feed_input(self.features[k], feed_dict[k])\",\n \"def inputs_init():\\n input_user = tf.keras.Input((1, ))\\n input_item = tf.keras.Input((1, ))\\n input_rating = tf.keras.Input((1, ))\\n return input_user, input_item, input_rating\",\n \"def _train_input_fn():\\n\\t\\tprint('\\\\n\\\\nRunning _train_input_fn\\\\n\\\\n')\\n\\t\\tfeatures_placeholder = {\\n\\t\\t\\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), features['query_unigrams'][0].shape[0])),\\n\\t\\t\\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), features['doc_unigrams'][0][0].shape[0]))\\n\\t\\t\\t#'query_unigrams' : tf.placeholder(tf.string, (len(features['query_unigrams']), len(features['query_unigrams'][0]))),\\n\\t\\t\\t#'doc_unigrams' : tf.placeholder(tf.string, (len(features['doc_unigrams']), len(features['doc_unigrams'][0]), len(features['doc_unigrams'][0][0])))\\n\\t\\t\\t#k: tf.placeholder(tf.string, get_shape(v)) for k, v in six.iteritems(features)\\n\\t\\t\\tk: tf.placeholder(v.dtype, v.shape) for k, v in six.iteritems(features)\\n\\t\\t\\t#k: tf.sparse.placeholder(tf.string, [len(v)] + v[0].shape.as_list(), name=k) for k, v in six.iteritems(features)\\n\\t\\t\\t#k: tf.placeholder(tf.string, (len(v), len(v[0]), len(v[0][0]))) for k, v in six.iteritems(features)\\n\\t\\t}\\n\\t\\tlabels_placeholder = tf.placeholder(labels.dtype, labels.shape, name='label')\\n\\t\\tdataset = tf.data.Dataset.from_tensor_slices((features_placeholder,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tlabels_placeholder))\\n\\t\\t#dataset = dataset.shuffle(1000).repeat().batch(batch_size)\\n\\t\\tdataset = dataset.shuffle(batch_size*10).repeat().batch(batch_size)\\n\\t\\titerator = dataset.make_initializable_iterator()\\n\\t\\tfeed_dict = {labels_placeholder: labels}\\n\\t\\tfeed_dict.update(\\n\\t\\t\\t\\t{features_placeholder[k]: features[k] for k in features_placeholder})\\n\\n\\t\\tprint('feed_dict')\\n\\t\\tfor k,v in six.iteritems(feed_dict):\\n\\t\\t\\tprint(k.shape)\\n\\t\\t#\\tprint(v.shape)\\n\\t\\trun_options = tf.RunOptions(report_tensor_allocations_upon_oom = True)\\n\\t\\titerator_initializer_hook.iterator_initializer_fn = (\\n\\t\\t\\t\\tlambda sess: sess.run(iterator.initializer, feed_dict=feed_dict, options=run_options))\\n\\t\\treturn iterator.get_next()\",\n \"def __init__(self, n_latent_features=1024, reduced_size=64, input_type='default', use_masks=False, **kwargs):\\n super(AutoEncoderFeatureTransformer, self).__init__()\\n self.device = get_device()\\n self.use_masks = use_masks\\n\\n # Tunable parameters\\n self.n_latent_features = n_latent_features\\n self.reduced_size = reduced_size\\n self.input_type = input_type\\n\\n self.logger = logging.getLogger(AutoEncoderFeatureTransformer.__name__)\\n\\n self._construct_model()\",\n \"def prepare(self):\\n\\n inp = self.config.get('predict.input', 'X:0')\\n out = self.config.get('predict.output', 'output:0')\\n\\n # set input placeholder\\n self.input = self.graph.get_tensor_by_name(inp)\\n\\n # set output operation\\n if isinstance(out, str) or isinstance(out, unicode):\\n self.output = {out: self.graph.get_tensor_by_name(out)}\\n self.output_alone = True\\n elif isinstance(out, list):\\n self.output = {o: self.graph.get_tensor_by_name(o) for o in out}\\n self.output_alone = False\\n else:\\n raise LoaderException('incorrect predict.output type')\",\n \"def _RegisterInputs(self):\\n args = []\\n for source in ['FcA', 'FcB']:\\n gps_type = self._gps_type_per_source[source]\\n if gps_type == 'Septentrio':\\n args += [\\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.x'),\\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.y'),\\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.z'),\\n self._Arg('SeptentrioSolution', source, 'pvt_cartesian.mode'),\\n self._Arg('SeptentrioSolution', source,\\n 'pvt_cartesian.timestamp.tow'),\\n ]\\n elif gps_type == 'NovAtel':\\n args += [\\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_x'),\\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_y'),\\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_z'),\\n self._Arg('NovAtelSolution', source, 'best_xyz.pos_type'),\\n self._Arg('NovAtelSolution', source, 'best_xyz.timestamp.tow'),\\n ]\\n else:\\n assert False\\n return args\",\n \"def _prepare_for_submission(self, tempfolder, inputdict):\\n input_validator = self._get_input_validator(inputdict=inputdict)\\n local_input_folder = input_validator(\\n name='local_input_folder', valid_types=FolderData, required=False\\n )\\n remote_input_folder = input_validator(\\n name='remote_input_folder', valid_types=RemoteData, required=False\\n )\\n\\n parameters = input_validator(\\n name='parameters', valid_types=ParameterData\\n )\\n param_dict = self._get_validated_parameters_dict(parameters)\\n\\n projections = input_validator(\\n name='projections',\\n valid_types=(OrbitalData, List),\\n required=False\\n )\\n kpoints = input_validator(name='kpoints', valid_types=KpointsData)\\n kpoint_path = input_validator(\\n name='kpoint_path', valid_types=ParameterData, required=False\\n )\\n structure = input_validator(\\n name='structure', valid_types=StructureData\\n )\\n\\n settings = input_validator(\\n name='settings', valid_types=ParameterData, required=False\\n )\\n if settings is None:\\n settings_dict = {}\\n else:\\n settings_dict_raw = settings.get_dict()\\n settings_dict = {\\n key.lower(): val\\n for key, val in settings_dict_raw.items()\\n }\\n if len(settings_dict_raw) != len(settings_dict):\\n raise InputValidationError(\\n 'Input settings contain duplicate keys.'\\n )\\n pp_setup = settings_dict.pop('postproc_setup', False)\\n if pp_setup:\\n param_dict.update({'postproc_setup': True})\\n\\n if local_input_folder is None and remote_input_folder is None and pp_setup is False:\\n raise InputValidationError(\\n 'Either local_input_folder or remote_input_folder must be set.'\\n )\\n\\n code = input_validator(name='code', valid_types=Code)\\n\\n ############################################################\\n # End basic check on inputs\\n ############################################################\\n random_projections = settings_dict.pop('random_projections', False)\\n\\n write_win(\\n filename=tempfolder.get_abs_path(self._INPUT_FILE),\\n parameters=param_dict,\\n structure=structure,\\n kpoints=kpoints,\\n kpoint_path=kpoint_path,\\n projections=projections,\\n random_projections=random_projections,\\n )\\n\\n if remote_input_folder is not None:\\n remote_input_folder_uuid = remote_input_folder.get_computer().uuid\\n remote_input_folder_path = remote_input_folder.get_remote_path()\\n\\n t_dest = get_authinfo(\\n computer=remote_input_folder.get_computer(),\\n aiidauser=remote_input_folder.get_user()\\n ).get_transport()\\n with t_dest:\\n remote_folder_content = t_dest.listdir(\\n path=remote_input_folder_path\\n )\\n\\n if local_input_folder is not None:\\n local_folder_content = local_input_folder.get_folder_list()\\n if pp_setup:\\n required_files = []\\n else:\\n required_files = [\\n self._SEEDNAME + suffix for suffix in ['.mmn', '.amn']\\n ]\\n optional_files = [\\n self._SEEDNAME + suffix for suffix in ['.eig', '.chk', '.spn']\\n ]\\n input_files = required_files + optional_files\\n wavefunctions_files = ['UNK*']\\n\\n def files_finder(file_list, exact_patterns, glob_patterns):\\n result = [f for f in exact_patterns if (f in file_list)]\\n import fnmatch\\n for glob_p in glob_patterns:\\n result += fnmatch.filter(file_list, glob_p)\\n return result\\n\\n # Local FolderData has precedence over RemoteData\\n if local_input_folder is not None:\\n found_in_local = files_finder(\\n local_folder_content, input_files, wavefunctions_files\\n )\\n else:\\n found_in_local = []\\n if remote_input_folder is not None:\\n found_in_remote = files_finder(\\n remote_folder_content, input_files, wavefunctions_files\\n )\\n found_in_remote = [\\n f for f in found_in_remote if f not in found_in_local\\n ]\\n else:\\n found_in_remote = []\\n\\n not_found = [\\n f for f in required_files\\n if f not in found_in_remote + found_in_local\\n ]\\n if len(not_found) != 0:\\n raise InputValidationError(\\n \\\"{} necessary input files were not found: {} \\\".format(\\n len(not_found), ', '.join(str(nf) for nf in not_found)\\n )\\n )\\n\\n remote_copy_list = []\\n remote_symlink_list = []\\n local_copy_list = []\\n #Here we enforce that everything except checkpoints are symlinked\\n #because in W90 you never modify input files on the run\\n ALWAYS_COPY_FILES = [self._CHK_FILE]\\n for f in found_in_remote:\\n file_info = (\\n remote_input_folder_uuid,\\n os.path.join(remote_input_folder_path, f), os.path.basename(f)\\n )\\n if f in ALWAYS_COPY_FILES:\\n remote_copy_list.append(file_info)\\n else:\\n remote_symlink_list.append(file_info)\\n for f in found_in_local:\\n local_copy_list.append(\\n (local_input_folder.get_abs_path(f), os.path.basename(f))\\n )\\n\\n # Add any custom copy/sym links\\n remote_symlink_list += settings_dict.pop(\\n \\\"additional_remote_symlink_list\\\", []\\n )\\n remote_copy_list += settings_dict.pop(\\n \\\"additional_remote_copy_list\\\", []\\n )\\n local_copy_list += settings_dict.pop(\\\"additional_local_copy_list\\\", [])\\n\\n #######################################################################\\n\\n calcinfo = CalcInfo()\\n calcinfo.uuid = self.uuid\\n calcinfo.local_copy_list = local_copy_list\\n calcinfo.remote_copy_list = remote_copy_list\\n calcinfo.remote_symlink_list = remote_symlink_list\\n\\n codeinfo = CodeInfo()\\n codeinfo.code_uuid = code.uuid\\n #codeinfo.withmpi = True # Current version of W90 can be run in parallel\\n codeinfo.cmdline_params = [self._INPUT_FILE]\\n\\n calcinfo.codes_info = [codeinfo]\\n calcinfo.codes_run_mode = code_run_modes.SERIAL\\n\\n # Retrieve files\\n calcinfo.retrieve_list = []\\n calcinfo.retrieve_list.append(self._OUTPUT_FILE)\\n calcinfo.retrieve_list.append(self._ERROR_FILE)\\n if pp_setup:\\n calcinfo.retrieve_list.append(self._NNKP_FILE)\\n calcinfo.retrieve_singlefile_list = [\\n ('output_nnkp', 'singlefile', self._NNKP_FILE)\\n ]\\n\\n calcinfo.retrieve_list += [\\n '{}_band.dat'.format(self._SEEDNAME),\\n '{}_band.kpt'.format(self._SEEDNAME)\\n ]\\n\\n if settings_dict.pop('retrieve_hoppings', False):\\n calcinfo.retrieve_list += [\\n '{}_wsvec.dat'.format(self._SEEDNAME),\\n '{}_hr.dat'.format(self._SEEDNAME),\\n '{}_centres.xyz'.format(self._SEEDNAME),\\n ]\\n\\n # Retrieves bands automatically, if they are calculated\\n\\n calcinfo.retrieve_list += settings_dict.pop(\\n \\\"additional_retrieve_list\\\", []\\n )\\n\\n # pop input keys not used here\\n settings_dict.pop('seedname', None)\\n if settings_dict:\\n raise InputValidationError(\\n \\\"The following keys in settings are unrecognized: {}\\\".format(\\n settings_dict.keys()\\n )\\n )\\n\\n return calcinfo\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n for key in _DENSE_FLOAT_FEATURE_KEYS:\\n # Preserve this feature as a dense float, setting nan's to the mean.\\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\\n _fill_in_missing(inputs[key]))\\n\\n for key in _VOCAB_FEATURE_KEYS:\\n # Build a vocabulary for this feature.\\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\\n _fill_in_missing(inputs[key]),\\n top_k=_VOCAB_SIZE,\\n num_oov_buckets=_OOV_SIZE)\\n\\n for key in _BUCKET_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = tft.bucketize(\\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\\n always_return_num_quantiles=False)\\n\\n for key in _CATEGORICAL_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\\n\\n # Was this passenger a big tipper?\\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\\n tips = _fill_in_missing(inputs[_LABEL_KEY])\\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\\n tf.is_nan(taxi_fare),\\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\\n # Test if the tip was > 20% of the fare.\\n tf.cast(\\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\\n\\n return outputs\",\n \"def _setup_vasp_inputs(self):\\n\\n # Set the kpoints (kpoints)\\n if 'kpoints' in self.inputs:\\n self.ctx.inputs.kpoints = self.inputs.kpoints\\n elif 'kpoints_spacing' in self.inputs:\\n kpoints = orm.KpointsData()\\n kpoints.set_cell_from_structure(self.ctx.inputs.initial_structure)\\n kpoints.set_kpoints_mesh_from_density(self.inputs.kpoints_spacing.value * np.pi * 2)\\n self.ctx.inputs.kpoints = kpoints\\n elif 'kpoints_spacing_vasp' in self.inputs:\\n kpoints = orm.KpointsData()\\n kpoints.set_cell_from_structure(self.ctx.inputs.initial_structure)\\n kpoints.set_kpoints_mesh_from_density(self.inputs.kpoints_spacing.value)\\n self.ctx.inputs.kpoints = kpoints\\n else:\\n raise InputValidationError(\\\"Must supply either 'kpoints' or 'kpoints_spacing' or 'kpoints_spacing_vasp\\\")\\n\\n # Set settings\\n\\n unsupported_parameters = dict(VTST_ADDITIONAL_TAGS)\\n if 'settings' in self.inputs:\\n self.ctx.inputs.settings = self.inputs.settings\\n # Also check if the user supplied additional tags that is not in the supported file.\\n try:\\n unsupported_parameters = self.ctx.inputs.settings.unsupported_parameters\\n except AttributeError:\\n pass\\n\\n # Perform inputs massage to accommodate generalization in higher lying workchains\\n # and set parameters.\\n try:\\n parameters_massager = ParametersMassage(self.inputs.parameters, unsupported_parameters)\\n except Exception as exception: # pylint: disable=broad-except\\n return self.exit_codes.ERROR_IN_PARAMETER_MASSAGER.format(exception=exception) # pylint: disable=no-member\\n try:\\n # Only set if they exists\\n # Set any INCAR tags\\n self.ctx.inputs.parameters = parameters_massager.parameters.incar\\n # Set any dynamics input (currently only for selective dynamics, e.g. custom write to POSCAR)\\n self.ctx.inputs.dynamics = parameters_massager.parameters.dynamics\\n # Here we could set additional override flags, but those are not relevant for this VASP plugin\\n except AttributeError:\\n pass\\n\\n # Setup LDAU keys\\n if 'ldau_mapping' in self.inputs:\\n ldau_settings = self.inputs.ldau_mapping.get_dict()\\n ldau_keys = get_ldau_keys(self.ctx.inputs.initial_structure, **ldau_settings)\\n # Directly update the raw inputs passed to VaspCalculation\\n self.ctx.inputs.parameters.update(ldau_keys)\\n\\n # Set settings\\n if 'settings' in self.inputs:\\n self.ctx.inputs.settings = self.inputs.settings\\n\\n # Set options\\n # Options is very special, not storable and should be\\n # wrapped in the metadata dictionary, which is also not storable\\n # and should contain an entry for options\\n if 'options' in self.inputs:\\n options = {}\\n options.update(self.inputs.options)\\n self.ctx.inputs.metadata = {}\\n self.ctx.inputs.metadata['options'] = options\\n # Override the parser name if it is supplied by the user.\\n parser_name = self.ctx.inputs.metadata['options'].get('parser_name')\\n if parser_name:\\n self.ctx.inputs.metadata['options']['parser_name'] = parser_name\\n # Also make sure we specify the entry point for the\\n # Set MPI to True, unless the user specifies otherwise\\n withmpi = self.ctx.inputs.metadata['options'].get('withmpi', True)\\n self.ctx.inputs.metadata['options']['withmpi'] = withmpi\\n else:\\n raise InputValidationError('`options` not supplied')\\n\\n # Utilise default input/output selections\\n self.ctx.inputs.metadata['options']['input_filename'] = 'INCAR'\\n\\n # Set the CalcJobNode to have the same label as the WorkChain\\n self.ctx.inputs.metadata['label'] = self.inputs.metadata.get('label', '')\\n self.report(self.ctx.inputs.metadata)\\n\\n # Verify and set potentials (potcar)\\n if not self.inputs.potential_family.value:\\n self.report( # pylint: disable=not-callable\\n 'An empty string for the potential family name was detected.'\\n )\\n return self.exit_codes.ERROR_NO_POTENTIAL_FAMILY_NAME # pylint: disable=no-member\\n try:\\n self.ctx.inputs.potential = get_data_class('vasp.potcar').get_potcars_from_structure(\\n structure=self.inputs.initial_structure,\\n family_name=self.inputs.potential_family.value,\\n mapping=self.inputs.potential_mapping.get_dict()\\n )\\n except ValueError as err:\\n return compose_exit_code(self.exit_codes.ERROR_POTENTIAL_VALUE_ERROR.status, str(err)) # pylint: disable=no-member\\n except NotExistent as err:\\n return compose_exit_code(self.exit_codes.ERROR_POTENTIAL_DO_NOT_EXIST.status, str(err)) # pylint: disable=no-member\\n\\n self.ctx.verbose = bool(self.inputs.get('verbose', self._verbose))\\n\\n return None\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n\\n for key in ONE_HOT_FEATURES.keys():\\n dim = ONE_HOT_FEATURES[key]\\n int_value = tft.compute_and_apply_vocabulary(\\n fill_in_missing(inputs[key]), top_k=dim + 1\\n )\\n outputs[transformed_name(key)] = convert_num_to_one_hot(\\n int_value, num_labels=dim + 1\\n )\\n\\n for key, bucket_count in BUCKET_FEATURES.items():\\n temp_feature = tft.bucketize(\\n convert_zip_code(fill_in_missing(inputs[key])),\\n bucket_count,\\n )\\n outputs[transformed_name(key)] = convert_num_to_one_hot(\\n temp_feature, num_labels=bucket_count + 1\\n )\\n\\n for key in TEXT_FEATURES.keys():\\n outputs[transformed_name(key)] = fill_in_missing(inputs[key])\\n\\n outputs[transformed_name(LABEL_KEY)] = fill_in_missing(inputs[LABEL_KEY])\\n\\n return outputs\",\n \"def preprocess(args, g, features):\\n # g = dgl.to_homogeneous(g)\\n with torch.no_grad():\\n g.edata[\\\"weight\\\"] = calc_weight(g)\\n g.ndata[\\\"feat_0\\\"] = features\\n for hop in range(1, args['n_hops'] + 1):\\n g.update_all(fn.u_mul_e(f\\\"feat_{hop - 1}\\\", \\\"weight\\\", \\\"msg\\\"),\\n fn.sum(\\\"msg\\\", f\\\"feat_{hop}\\\"))\\n hop_feat_list = []\\n for hop in range(args['n_hops'] + 1):\\n hop_feat_list.append(g.ndata.pop(f\\\"feat_{hop}\\\"))\\n return hop_feat_list\",\n \"def build_input(self):\\n n_input = tf.placeholder(tf.int32, [None, None], name='n_input')\\n t_input = tf.placeholder(tf.int32, [None, None], name='t_input')\\n n_target = tf.placeholder(tf.int32, [None, None], name='n_target')\\n t_target = tf.placeholder(tf.int32, [None, None], name='t_target')\\n keep_prob = tf.placeholder(tf.float32, name='keep_prob')\\n return n_input, t_input, n_target, t_target, keep_prob\",\n \"def prepare_inputs(example):\\n return example['input_ids'], example['label_ids']\",\n \"def prepare_inputs(example):\\n return example['input_ids'], example['label_ids']\",\n \"def prepare_wf(self,wf,stk):\\n for lst in stk:\\n for op_tag in lst:\\n op = wf.get_data_from_uri(op_tag)\\n for inpname,il in op.input_locator.items():\\n if il.tp not in [opmod.runtime_type,opmod.workflow_item]:\\n # runtime inputs should be set directly, without using il.val.\\n # this is because il.val gets serialized in wf.wf_setup_dict().\\n # workflow_item inputs should be set later, during execution.\\n # the no_input case ends up setting the input to None\\n #op.inputs[inpname] = self.locate_input(il)\\n wf.set_op_item(op_tag,'inputs.'+inpname,self.locate_input(il))\",\n \"def _synth_input(self, path, files):\\n features = np.empty((0, 15))\\n for i in range(len(files)):\\n train_set = np.load(f'{path}coords/{files[i]}.npy')\\n train_set = train_set.reshape((train_set.shape[0], -1))\\n features = np.concatenate((features, train_set), axis=0)\\n self.input_ = F.normalize(torch.tensor(np.array(features), dtype=torch.float32))\",\n \"def train_input(config, params):\\n \\\"\\\"\\\"\\n rawimages: Nb x hf x wf x 3, tf.float32, in [0,1]\\n rawlabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\\n rawmetadata: Python dictionary with matadata (e.g. image shape, dtype)\\n proimages: Nb x hf x wf x 3, tf.float32, in [0,1]\\n prolabels: Nb x hf x wf, tf.int32, in [0,Nc-1]\\n \\\"\\\"\\\"\\n # runconfig = config.runconfig\\n # # otherconfig includes: train_preprocess, mappings\\n # otherconfig = config.otherconfig\\n # hparams = params\\n\\n # reading, mapping labels to problem from otherconfig['lids2cids'],\\n # batching, preprocessing with otherconfig['train_preprocess'], output\\n\\n # no obvious use of prodata metadata for now\\n with tf.variable_scope('input_pipeline'):\\n values = None\\n for num_dataset in range(len(params.tfrecords_list)): # , params.camvid_tfrecords_path]:\\n if values is None:\\n values = train_input_per_data(config, params, num_dataset)\\n values = list(values) + [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\\n else:\\n _values = list(train_input_per_data(config, params, num_dataset)) + \\\\\\n [num_dataset*tf.ones([params.Nb_list[num_dataset], ], dtype=tf.int32)]\\n values = [tf.concat((value1, value2), 0) for value1, value2 in zip(values, _values)]\\n\\n features = {'rawimages': values[1],\\n 'proimages': values[3],\\n 'rawimagespaths': values[0][0],\\n 'rawlabelspaths': values[0][1]}\\n labels = {'rawlabels': values[2],\\n 'prolabels': values[4],\\n 'domainlabels': values[5]}\\n return features, labels\",\n \"def _preprocess_data(\\n self, data_batch: Dict[str, Any]) -> Tuple[tf.Tensor, tf.Tensor]:\\n # Get input data, with shape [batch_size, dim_h, dim_w, dim_c].\\n input_data = data_batch['sdf_map']\\n\\n gt_data = input_data\\n\\n return input_data, gt_data\",\n \"def get_inputs(self,force_gen=False,comp_gridness_score=False,comp_tuning_index=True):\\n #print self.paramMap\\n \\n \\n self.inputs=SpatialInputs(sl.map_merge(self.paramMap,{'n':self.n_e}),\\n force_gen=force_gen,\\n comp_gridness_score=comp_gridness_score,\\n comp_tuning_index=comp_tuning_index) \\n \\n \\n self.inputs_flat=self.inputs.inputs_flat\\n \\n self.h_e=self.inputs_flat.T \\n self.h_i=np.zeros((self.N_i,self.NX))\\n self.h=np.vstack([self.h_e,self.h_i])\\n \\n self.gp=gl.GridProps(self.n_e,self.grid_T,self.grid_angle)\",\n \"def train_input_args():\\n # Create Parse using ArgumentParser\\n parser = argparse.ArgumentParser()\\n parser.add_argument('data_dir', type = str, help = 'Path to the data directory') \\n parser.add_argument('--lr', type = float, default = 0.001, help = 'Learning rate (0.001)') \\n parser.add_argument('--model', type = str, default = 'vgg16', help = 'TorchVision VGG model used: vgg19 or (vgg16)') \\n parser.add_argument('--hidden', type = int, default = 4096, help = 'Number of hidden units (4096)') \\n parser.add_argument('--epochs', type = int, default = 8, help = 'Number of training epochs (8)') \\n parser.add_argument('--gpu', type = bool, default = True, help = '(True) = GPU enabled, False = GPU disabled') \\n parser.add_argument('--chk', type = str, default = 'checkpoint', help = 'Checkpoint folder name') \\n return parser.parse_args()\",\n \"def forward(self, inputs):\\n features, coords = inputs\\n voxel_features, voxel_coords = self.voxelization(features, coords)\\n voxel_features = self.voxel_layers(voxel_features)\\n voxel_features = trilinear_devoxelize(voxel_features, voxel_coords,\\n self.resolution, self.training)\\n fused_features = voxel_features + self.point_features(features)\\n return fused_features, coords\",\n \"def train_input(config, params):\\n\\n def _grouping(rim, rla, pim, pla, imp, lap):\\n # group dataset elements as required by estimator\\n features = {\\n 'rawimages': rim,\\n 'proimages': pim,\\n 'rawimagespaths': imp,\\n 'rawlabelspaths': lap,\\n }\\n labels = {\\n 'rawlabels': rla,\\n 'prolabels': pla,\\n }\\n\\n # next line for distributed debugging\\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\\n if params.distribute:\\n del features['rawimagespaths']\\n del features['rawlabelspaths']\\n\\n return (features, labels)\\n\\n with tf.variable_scope('input_pipeline'):\\n dataset = prebatch_dataset(config, params)\\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\\n dataset = postbatch_dataset(dataset, config, params)\\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\\n dataset = dataset.prefetch(None)\\n\\n return dataset\",\n \"def _prepare_input_for_pytorch(args, kwargs):\\n if isinstance(args, (torch.Tensor, dict)):\\n args = (args,)\\n # In-place operators will update input tensor data as well.\\n # Thus inputs are replicated before every forward call.\\n args = copy.deepcopy(args)\\n if kwargs:\\n kwargs = copy.deepcopy(kwargs)\\n else:\\n kwargs = {}\\n return args, kwargs\",\n \"def prepare_inputs(token_mapping, w2v_W, w2v_U, sentences):\\n tokens = [tokenize(token_mapping, sentence) for sentence in sentences] \\n \\n depth = len(token_mapping)\\n one_hot_tokens = []\\n for sentence in tokens:\\n one_hot_sentence = []\\n for i, token in enumerate(sentence):\\n if token != token_mapping['#UNK#']:\\n one_hot_sentence.append(one_hot_encode(token, depth))\\n else:\\n if i <= 2:\\n context_tokens = sentence[:i] + sentence[i+1:i+3]\\n else:\\n context_tokens = sentence[i-2:i] + sentence[i+1:i+3]\\n context_one_hot = [one_hot_encode(token, depth) for token in context_tokens]\\n context_mean = np.mean(np.asarray(context_one_hot), axis=0)\\n one_hot_sentence.append(context_mean)\\n one_hot_tokens.append(one_hot_sentence)\\n \\n one_hot_tokens = [np.asarray(ls) for ls in one_hot_tokens]\\n vec_tokens = [word2vec(w2v_W, w2v_U, sentence) for sentence in tqdm(one_hot_tokens, desc='Vectorizing tokens')]\\n return vec_tokens\",\n \"def _preprocess_inputs(self, train_x_dict):\\n\\n numpy_arrays = []\\n for key, value in train_x_dict.items():\\n numpy_arrays.append(value)\\n logger.info(\\\"Appending feature of shape {}\\\".format(value.shape))\\n\\n # Currently train_x will have dimensions [features; samples; timesteps; symbols]\\n train_x = np.stack(numpy_arrays, axis=0)\\n train_x = self.reorder_input_dimensions(train_x)\\n\\n # Expand dataset if requested\\n if self._tensorflow_flags.predict_single_shares:\\n train_x = self.expand_input_data(train_x)\\n\\n train_x = self.verify_x_data(train_x)\\n\\n return train_x.astype(np.float32) # FIXME: set float32 in data transform, conditional on config file\",\n \"def processing_inputs(data, mk_cols_list, link_cols_list, cross_cols_list, WIDE_COLS, arrival=True):\\n print('*-'*40, processing_inputs)\\n if arrival:\\n mk_cols_list = mk_cols_list + ['lk_arrival_0_percent', 'lk_arrival_1_percent','lk_arrival_2_percent', 'lk_arrival_3_percent', 'lk_arrival_4_percent']\\n mk_cols_list = mk_cols_list + ['zsl_link_arrival_status_mean','zsl_link_arrival_status_nunique','zsl_link_arrival_status0','zsl_link_arrival_status1','zsl_link_arrival_status2','zsl_link_arrival_status3']\\n if 'lk_arrival_0_percent' in mk_cols_list:\\n print('The lk_arrival_0_percent in the mk_cols_list')\\n #print('*-' * 40, 'EXIT')\\n #sys.exit(0)\\n print('111'*40, 'HAVE FEATURES OF ARRIVAL')\\n else:\\n print('222'*40, 'HAVENOT FEATURES OF ARRIVAL')\\n if 'ata' in mk_cols_list:\\n print('The ata in the mk_cols_list')\\n print('*-' * 40, 'EXIT')\\n sys.exit(0)\\n if 'ata' in link_cols_list:\\n print('The ata in the link_cols_list')\\n if 'ata' in cross_cols_list:\\n print('The ata in the cross_cols_list')\\n if 'ata' in WIDE_COLS:\\n print('The ata in the WIDE_COLS')\\n print('*-' * 40, 'EXIT')\\n sys.exit(0)\\n data_link_inputs = preprocess_inputs(data, cols=link_cols_list)\\n data.drop(columns=link_cols_list, axis=1, inplace=True)\\n gc.collect()\\n print('drop the link_cols_list')\\n # print(data_link_inputs[:, :, :1])\\n # data['cross_id'] = data['cross_id'].str.replace('nan','0')\\n data_cross_inputs = preprocess_inputs(data, cols=cross_cols_list)\\n data.drop(columns=cross_cols_list, axis=1, inplace=True)\\n gc.collect()\\n print('drop the cross_cols_list')\\n\\n data_deep_input = data[mk_cols_list]\\n data_wide_input = data[WIDE_COLS].values\\n data_inputs_slice = data['slice_id'].values\\n data_labels = data['ata']\\n if arrival:\\n arrival_col = ['lk_arrival_0_percent', 'lk_arrival_1_percent',\\n 'lk_arrival_2_percent', 'lk_arrival_3_percent', 'lk_arrival_4_percent']\\n data_arrival = data[arrival_col]\\n print('*-'*40, 'data_arrival', data_arrival.shape)\\n return data_link_inputs, data_cross_inputs, data_deep_input, data_wide_input, data_inputs_slice, data_labels, data_arrival\\n else:\\n return data_link_inputs, data_cross_inputs, data_deep_input, data_wide_input, data_inputs_slice, data_labels\",\n \"def reconstruct_input_ext(self, model_in):\",\n \"def preprocess_model_inputs(self, data_batch):\\n\\n unique_ids, input_ids, input_mask, segment_ids, start_positions, \\\\\\n end_positions, cls_index, p_mask, is_impossible = data_batch\\n\\n x = {\\n \\\"input_ids\\\": input_ids,\\n \\\"attention_mask\\\": input_mask,\\n \\\"token_type_ids\\\": segment_ids,\\n \\\"cls_index\\\": cls_index,\\n \\\"p_mask\\\": p_mask\\n }\\n\\n y = {\\n \\\"unique_ids\\\": unique_ids,\\n \\\"start_positions\\\": start_positions,\\n \\\"end_positions\\\": end_positions,\\n \\\"is_impossible\\\": is_impossible,\\n }\\n\\n return x, y\",\n \"def _TransformInputs(self, _):\\n raise NotImplementedError()\",\n \"def transform(self, inputs: list, stage: str) -> datapack.DataPack:\",\n \"def _create_placeholders(self, n_features, n_classes):\\n\\n self.input_data = tf.placeholder(\\\"float\\\", [None, n_features], name='x-input')\\n self.input_labels = tf.placeholder(\\\"float\\\", [None, n_classes], name='y-input')\",\n \"def initialize_inputs(self) -> None:\\n self.inputs.lifts_per_truck_day = self.operations.lifts_per_truck_day()\\n self.inputs.avg_tonnes_per_m3 = self.operations.avg_tonnes_per_m3()\\n self.inputs.revenue_per_m3 = (\\n self.income_statement.revenue.operating_revenue\\n * self.inputs.allocation_to_collection_unit\\n / self.operations.productivity.total_m3_collected\\n )\\n self.inputs.num_customers = self.operations.productivity.num_customers\",\n \"def _init_inputs(self, in_channels, in_index, input_transform):\\n if input_transform is not None:\\n assert input_transform in ['resize_concat', 'multiple_select']\\n self.input_transform = input_transform\\n self.in_index = in_index\\n if input_transform is not None:\\n assert isinstance(in_channels, (list, tuple))\\n assert isinstance(in_index, (list, tuple))\\n assert len(in_channels) == len(in_index)\\n if input_transform == 'resize_concat':\\n self.in_channels = sum(in_channels)\\n else:\\n self.in_channels = in_channels\\n else:\\n assert isinstance(in_channels, int)\\n assert isinstance(in_index, int)\\n self.in_channels = in_channels\",\n \"def _init_inputs(self, in_channels, in_index, input_transform):\\n if input_transform is not None:\\n assert input_transform in ['resize_concat', 'multiple_select']\\n self.input_transform = input_transform\\n self.in_index = in_index\\n if input_transform is not None:\\n assert isinstance(in_channels, (list, tuple))\\n assert isinstance(in_index, (list, tuple))\\n assert len(in_channels) == len(in_index)\\n if input_transform == 'resize_concat':\\n self.in_channels = sum(in_channels)\\n else:\\n self.in_channels = in_channels\\n else:\\n assert isinstance(in_channels, int)\\n assert isinstance(in_index, int)\\n self.in_channels = in_channels\",\n \"def _init_inputs(self, in_channels, in_index, input_transform):\\n if input_transform is not None:\\n assert input_transform in ['resize_concat', 'multiple_select']\\n self.input_transform = input_transform\\n self.in_index = in_index\\n if input_transform is not None:\\n assert isinstance(in_channels, (list, tuple))\\n assert isinstance(in_index, (list, tuple))\\n assert len(in_channels) == len(in_index)\\n if input_transform == 'resize_concat':\\n self.in_channels = sum(in_channels)\\n else:\\n self.in_channels = in_channels\\n else:\\n assert isinstance(in_channels, int)\\n assert isinstance(in_index, int)\\n self.in_channels = in_channels\",\n \"def prepare_args():\\n parser = argparse.ArgumentParser(description='Args for training')\\n \\\"\\\"\\\"Optional arguments for pre-split train/test files\\n parser.add_argument('--train_file', type=str, default='data/train.npy')\\n parser.add_argument('--test_file', type=str, default='data/test.npy')\\n parser.add_argument('--label_file',\\n type=str,\\n default='data/train_labels.npy')\\n \\\"\\\"\\\"\\n parser.add_argument('--dataset_file', type=str, default='data/dev.npy')\\n parser.add_argument('--label_file',\\n type=str,\\n default='data/dev_labels.npy')\\n parser.add_argument('--context', type=int, default=1)\\n parser.add_argument('--batch_size', type=int, default=8)\\n parser.add_argument('--optimizer', type=str, default='SGD')\\n parser.add_argument('--model_name', type=str, default='SimpleNet')\\n parser.add_argument('--lr', type=float, default=3e-4)\\n parser.add_argument('--wd', type=float, default=0)\\n parser.add_argument('--num_epochs', type=int, default=1000)\\n parser.add_argument('--shuffle', action='store_true')\\n args_to_ret = parser.parse_args()\\n return args_to_ret\",\n \"def input_fn():\\n problem_count, batches = len(hparams.problems), []\\n with tf.name_scope(\\\"input_reader\\\"):\\n for n in xrange(problem_count):\\n if fixed_problem is not None and n != fixed_problem:\\n continue\\n problem_instance = hparams.problem_instances[n]\\n p_hparams = hparams.problems[n]\\n with tf.name_scope(\\\"problem_%d\\\" % n):\\n with tf.device(\\\"/cpu:0\\\"): # Input reading on CPU\\n capacity = (\\n p_hparams.max_expected_batch_size_per_shard * num_datashards)\\n feature_map = data_reader.input_pipeline(\\n problem_instance, data_file_patterns and data_file_patterns[n],\\n capacity, mode, hparams,\\n data_reader.hparams_to_batching_scheme(\\n hparams,\\n shard_multiplier=num_datashards,\\n drop_long_sequences=(mode == tf.contrib.learn.ModeKeys.TRAIN\\n or hparams.eval_drop_long_sequences),\\n length_multiplier=(p_hparams.batch_size_multiplier)))\\n\\n # Reverse inputs and targets features if the problem was reversed.\\n if problem_instance is not None:\\n problem_instance.maybe_reverse_features(feature_map)\\n problem_instance.maybe_copy_features(feature_map)\\n else:\\n if p_hparams.was_reversed:\\n inputs = feature_map[\\\"inputs\\\"]\\n targets = feature_map[\\\"targets\\\"]\\n feature_map[\\\"inputs\\\"] = targets\\n feature_map[\\\"targets\\\"] = inputs\\n # Use the inputs as the targets if the problem is a copy problem.\\n if p_hparams.was_copy:\\n feature_map[\\\"targets\\\"] = feature_map[\\\"inputs\\\"]\\n\\n # Ensure inputs and targets are proper rank.\\n while len(feature_map[\\\"inputs\\\"].get_shape()) != 4:\\n feature_map[\\\"inputs\\\"] = tf.expand_dims(feature_map[\\\"inputs\\\"], axis=-1)\\n while len(feature_map[\\\"targets\\\"].get_shape()) != 4:\\n feature_map[\\\"targets\\\"] = tf.expand_dims(\\n feature_map[\\\"targets\\\"], axis=-1)\\n\\n batches.append((feature_map[\\\"inputs\\\"], feature_map[\\\"targets\\\"],\\n tf.constant(n), tf.constant(p_hparams.input_space_id),\\n tf.constant(p_hparams.target_space_id)))\\n\\n # We choose which problem to process.\\n loss_moving_avgs = [] # Need loss moving averages for that.\\n for n in xrange(problem_count):\\n with tf.variable_scope(\\\"losses_avg\\\"):\\n loss_moving_avgs.append(\\n tf.get_variable(\\n \\\"problem_%d/total_loss\\\" % n, initializer=100.0,\\n trainable=False))\\n if fixed_problem is None:\\n if (hparams.problem_choice == \\\"uniform\\\" or\\n mode != tf.contrib.learn.ModeKeys.TRAIN):\\n problem_choice = tf.random_uniform(\\n [], maxval=problem_count, dtype=tf.int32)\\n elif hparams.problem_choice == \\\"adaptive\\\":\\n loss_moving_avgs = tf.stack(loss_moving_avgs)\\n problem_choice = tf.multinomial(\\n tf.reshape(loss_moving_avgs, [1, -1]), 1)\\n problem_choice = tf.to_int32(tf.squeeze(problem_choice))\\n elif hparams.problem_choice == \\\"distributed\\\":\\n assert worker_replicas >= problem_count\\n assert worker_replicas % problem_count == 0\\n problem_choice = tf.to_int32(worker_id % problem_count)\\n else:\\n raise ValueError(\\n \\\"Value of hparams.problem_choice is %s and must be \\\"\\n \\\"one of [uniform, adaptive, distributed]\\\" % hparams.problem_choice)\\n\\n # Inputs and targets conditional on problem_choice.\\n rand_inputs, rand_target, choice, inp_id, tgt_id = cond_on_index(\\n lambda n: batches[n], problem_choice, 0, problem_count - 1)\\n else:\\n problem_choice = tf.constant(fixed_problem)\\n # Take the only constructed batch, which is the fixed_problem.\\n rand_inputs, rand_target, choice, inp_id, tgt_id = batches[0]\\n\\n # Set shapes so the ranks are clear.\\n rand_inputs.set_shape([None, None, None, None])\\n rand_target.set_shape([None, None, None, None])\\n choice.set_shape([])\\n inp_id.set_shape([])\\n tgt_id.set_shape([])\\n # Forced shape obfuscation is necessary for inference.\\n if mode == tf.contrib.learn.ModeKeys.INFER:\\n rand_inputs._shape = tf.TensorShape([None, None, None, None]) # pylint: disable=protected-access\\n rand_target._shape = tf.TensorShape([None, None, None, None]) # pylint: disable=protected-access\\n\\n # Final feature map.\\n rand_feature_map = {\\n \\\"inputs\\\": rand_inputs,\\n \\\"problem_choice\\\": choice,\\n \\\"input_space_id\\\": inp_id,\\n \\\"target_space_id\\\": tgt_id\\n }\\n if mode == tf.contrib.learn.ModeKeys.INFER:\\n rand_feature_map[\\\"infer_targets\\\"] = rand_target\\n rand_target = None\\n # This is because of a bug in the tf.contrib.learn Estimator that\\n # short-circuits prediction if it doesn't see a QueueRunner.\\n # DummyQueueRunner implements the minimal expected interface but does\\n # nothing.\\n # TODO(rsepassi): Remove once we move to core Estimator.\\n tf.add_to_collection(tf.GraphKeys.QUEUE_RUNNERS, DummyQueueRunner())\\n return rand_feature_map, rand_target\",\n \"def _preprocess_input(self, dataset):\\n masker = self.masker or dataset.masker\\n\\n mask_img = masker.mask_img or masker.labels_img\\n if isinstance(mask_img, str):\\n mask_img = nib.load(mask_img)\\n\\n # Ensure that protected values are not included among _required_inputs\\n assert \\\"aggressive_mask\\\" not in self._required_inputs.keys(), \\\"This is a protected name.\\\"\\n\\n if \\\"aggressive_mask\\\" in self.inputs_.keys():\\n LGR.warning(\\\"Removing existing 'aggressive_mask' from Estimator.\\\")\\n self.inputs_.pop(\\\"aggressive_mask\\\")\\n\\n # A dictionary to collect masked image data, to be further reduced by the aggressive mask.\\n temp_image_inputs = {}\\n\\n for name, (type_, _) in self._required_inputs.items():\\n if type_ == \\\"image\\\":\\n # If no resampling is requested, check if resampling is required\\n if not self.resample:\\n check_imgs = {img: nib.load(img) for img in self.inputs_[name]}\\n _check_same_fov(**check_imgs, reference_masker=mask_img, raise_error=True)\\n imgs = list(check_imgs.values())\\n else:\\n # resampling will only occur if shape/affines are different\\n # making this harmless if all img shapes/affines are the same as the reference\\n imgs = [\\n resample_to_img(nib.load(img), mask_img, **self._resample_kwargs)\\n for img in self.inputs_[name]\\n ]\\n\\n # input to NiFtiLabelsMasker must be 4d\\n img4d = concat_imgs(imgs, ensure_ndim=4)\\n\\n # Mask required input images using either the dataset's mask or the estimator's.\\n temp_arr = masker.transform(img4d)\\n\\n # An intermediate step to mask out bad voxels.\\n # Can be dropped once PyMARE is able to handle masked arrays or missing data.\\n nonzero_voxels_bool = np.all(temp_arr != 0, axis=0)\\n nonnan_voxels_bool = np.all(~np.isnan(temp_arr), axis=0)\\n good_voxels_bool = np.logical_and(nonzero_voxels_bool, nonnan_voxels_bool)\\n\\n data = masker.transform(img4d)\\n\\n temp_image_inputs[name] = data\\n if \\\"aggressive_mask\\\" not in self.inputs_.keys():\\n self.inputs_[\\\"aggressive_mask\\\"] = good_voxels_bool\\n else:\\n # Remove any voxels that are bad in any image-based inputs\\n self.inputs_[\\\"aggressive_mask\\\"] = np.logical_or(\\n self.inputs_[\\\"aggressive_mask\\\"],\\n good_voxels_bool,\\n )\\n\\n # Further reduce image-based inputs to remove \\\"bad\\\" voxels\\n # (voxels with zeros or NaNs in any studies)\\n if \\\"aggressive_mask\\\" in self.inputs_.keys():\\n n_bad_voxels = (\\n self.inputs_[\\\"aggressive_mask\\\"].size - self.inputs_[\\\"aggressive_mask\\\"].sum()\\n )\\n if n_bad_voxels:\\n LGR.warning(\\n f\\\"Masking out {n_bad_voxels} additional voxels. \\\"\\n \\\"The updated masker is available in the Estimator.masker attribute.\\\"\\n )\\n\\n for name, raw_masked_data in temp_image_inputs.items():\\n self.inputs_[name] = raw_masked_data[:, self.inputs_[\\\"aggressive_mask\\\"]]\",\n \"def genInput(tasksInfo, results, origLocation, destLocation, typeGray, samplSize = 0.10):\\n print '\\\\nbegin of genInput\\\\n'\\n # Training / aplication\\n treina = True\\n verdade = False\\n\\n # Sampling pixels from image\\n sampl = True\\n if sampl == True:\\n buildSampl = True\\n else:\\n buildSampl = False\\n\\n # Write data to file\\n if treina:\\n outInput = open('trainInput.dat', 'w')\\n #~ outInput1par = open('trainInput1par.dat', 'w')\\n outOutput = open('trainOutput.dat', 'w')\\n outTasks = open('trainTasks.dat', 'w')\\n #~ outOutputClass = open('trainOutputClass.dat', 'w')\\n selecOut = open('selected.dat', 'w')\\n else:\\n outInput = open('aplicInput.dat', 'w')\\n outTasks = open('aplicTasks.dat', 'w')\\n #~ outInput1par = open('aplicInput1par.dat', 'w')\\n if verdade:\\n outOutput = open('verdadeOutput.dat', 'w')\\n #~ outOutputClass = open('verdadeOutputClass.dat', 'w')\\n\\n #Setting info on temporary directory for images\\n numberImages = 12\\n tmpImg = []\\n for i in range(numberImages):\\n tmpImg.append(destLocation+\\\"tmpImg_n\\\"+str(i+1).zfill(2)+\\\"/\\\")\\n\\n imgFile = []\\n imgFile.append('2011352')\\n imgFile.append('2011353')\\n imgFile.append('2011355')\\n imgFile.append('2011357')\\n imgFile.append('2011358')\\n imgFile.append('2011359')\\n imgFile.append('2011360')\\n imgFile.append('2011361')\\n imgFile.append('2011362')\\n imgFile.append('2011363')\\n imgFile.append('2011364')\\n imgFile.append('2011365')\\n\\n #If we need to skip line\\n finishLine = True\\n #Getting number of tasks\\n numberTasks = len(tasksInfo)\\n print 'number of tasks: ', numberTasks\\n for task in range(numberTasks):\\n #Geting the selected day for each task\\n taskId = tasksInfo[task]['taskId']\\n for img in range(numberImages):\\n imgName = tmpImg[img] + str(taskId) + '.tif'\\n #Openning image (and testing)\\n if os.path.exists(imgName) is False:\\n print 'INPUT -> Task miss: ' + str(taskId) + ' Image: ' + str(img) + ' Name: ' + imgName\\n finishLine = False\\n continue\\n print 'INPUT -> Task: ' + str(taskId) + ' Image: ' + str(img)\\n fileSat = gdal.Open(imgName, GA_ReadOnly)\\n if fileSat is None:\\n print 'Could not open ' + imgName\\n sys.exit(1)\\n # Read band values from image\\n rows = fileSat.RasterYSize\\n cols = fileSat.RasterXSize\\n R_band_sat = fileSat.GetRasterBand(1)\\n G_band_sat = fileSat.GetRasterBand(2)\\n B_band_sat = fileSat.GetRasterBand(3)\\n R_data_sat = R_band_sat.ReadAsArray(0, 0, cols, rows)\\n G_data_sat = G_band_sat.ReadAsArray(0, 0, cols, rows)\\n B_data_sat = B_band_sat.ReadAsArray(0, 0, cols, rows)\\n #Closing image\\n fileSat = None\\n\\n #If we are sampling the image, then we'll pick our samples\\n print 'sampl: ', sampl\\n print 'buildSampl: ', buildSampl\\n if ((sampl == True) and (buildSampl == True)):\\n universe = []\\n samplList = []\\n random.seed(8225)\\n for i in range(rows):\\n for j in range(cols):\\n universe.append([i,j])\\n sizeUniverse = len(universe)\\n samplSizeInt = int(samplSize * sizeUniverse)\\n print 'Sampling mode activated.'\\n print 'Using ', samplSizeInt, ' out of ', sizeUniverse, ' pixels.'\\n for i in range(samplSizeInt):\\n samplList.append(universe.pop(random.randint(0,len(universe)-1)))\\n buildSampl = False\\n\\n sumValueGray = 0.0\\n if (sampl == False):\\n #Working with the values\\n for i in range(rows):\\n for j in range(cols):\\n #~ valueString = str(float(R_data_sat[i,j])/255.0)+' '+str(float(G_data_sat[i,j])/255.0)+' '+str(float(B_data_sat[i,j])/255.0)\\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\\n sumValueGray = sumValueGray + valueGray\\n valueString = str(taskId)+' '+str(valueGray)\\n #~ outInput.write(\\\"%s \\\"%valueString)\\n sumValueString = str(taskId)+' '+str(sumValueGray/(rows*cols))\\n #~ outInput1par.write(\\\"%s \\\"%sumValueString)\\n outInput.write(\\\"%s \\\"%sumValueString)\\n else:\\n #Working with the sampled values\\n for idx in range(samplSizeInt):\\n i = samplList[idx][0]\\n j = samplList[idx][1]\\n valueGray = rgb2gray((float(R_data_sat[i,j])/255.0),(float(G_data_sat[i,j])/255.0),(float(B_data_sat[i,j])/255.0),typeGray)\\n sumValueGray = sumValueGray + valueGray\\n valueString = str(valueGray)\\n #~ outInput.write(\\\"%s \\\"%valueString)\\n sumValueString = str(sumValueGray/samplSizeInt)\\n #~ outInput1par.write(\\\"%s \\\"%sumValueString)\\n outInput.write(\\\"%s \\\"%sumValueString)\\n\\n #If we did not had a problem with missing task\\n if finishLine == True:\\n #Closing the line of the file\\n outInput.write(\\\"\\\\n\\\")\\n #~ outInput1par.write(\\\"\\\\n\\\")\\n outTasks.write(str(taskId)+\\\"\\\\n\\\")\\n else:\\n finishLine = True\\n\\n #If we are training (or we know the truth), then we also generate the truth\\n if treina or verdade:\\n selecName = '/home/eduardo/ForestWatchers/ann2besttile/results/tmpMosaic_n0/' + str(taskId) + '.tif'\\n #Openning image (and testing)\\n if os.path.exists(selecName) is False:\\n print 'OUTPUT -> Task miss: ' + str(taskId)\\n continue\\n #~ fileSelec = gdal.Open(selecName, GA_ReadOnly)\\n #~ if fileSelec is None:\\n #~ print 'Could not open ' + selecName\\n #~ sys.exit(1)\\n #~ # Read band values from image\\n #~ rows = fileSelec.RasterYSize\\n #~ cols = fileSelec.RasterXSize\\n #~ R_band_selec = fileSelec.GetRasterBand(1)\\n #~ G_band_selec = fileSelec.GetRasterBand(2)\\n #~ B_band_selec = fileSelec.GetRasterBand(3)\\n #~ R_data_selec = R_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ G_data_selec = G_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ B_data_selec = B_band_selec.ReadAsArray(0, 0, cols, rows)\\n #~ #Closing image\\n #~ fileSelec = None\\n#~ \\n #~ if (sampl == False):\\n #~ #Working with the values\\n #~ for i in range(rows):\\n #~ for j in range(cols):\\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\\n #~ valueString = str(valueGray)\\n #~ outOutput.write(\\\"%s \\\"%valueString)\\n #~ else:\\n #~ #Working with the values\\n #~ for idx in range(samplSizeInt):\\n #~ i = samplList[idx][0]\\n #~ j = samplList[idx][1]\\n #~ valueGray = rgb2gray((float(R_data_selec[i,j])/255.0),(float(G_data_selec[i,j])/255.0),(float(B_data_selec[i,j])/255.0),'gleam')\\n #~ valueString = str(valueGray)\\n #~ outOutput.write(\\\"%s \\\"%valueString)\\n#~ \\n #~ #Closing line of the file\\n #~ outOutput.write(\\\"\\\\n\\\")\\n\\n selectedTile = results[task].index(max(results[task]))\\n if selectedTile == 0:\\n selectedName = str(taskId) + ' 2011352'\\n selectedFile = '1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 1:\\n selectedName = str(taskId) + ' 2011353'\\n selectedFile = '0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 2:\\n selectedName = str(taskId) + ' 2011355'\\n selectedFile = '0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 3:\\n selectedName = str(taskId) + ' 2011357'\\n selectedFile = '0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 4:\\n selectedName = str(taskId) + ' 2011358'\\n selectedFile = '0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 5:\\n selectedName = str(taskId) + ' 2011359'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 6:\\n selectedName = str(taskId) + ' 2011360'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 7:\\n selectedName = str(taskId) + ' 2011361'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 0.0'\\n elif selectedTile == 8:\\n selectedName = str(taskId) + ' 2011362'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0'\\n elif selectedTile == 9:\\n selectedName = str(taskId) + ' 2011363'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0 0.0'\\n elif selectedTile == 10:\\n selectedName = str(taskId) + ' 2011364'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0 0.0'\\n elif selectedTile == 11:\\n selectedName = str(taskId) + ' 2011365'\\n selectedFile = '0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 1.0'\\n #~ outOutputClass.write(\\\"%s\\\\n\\\"%selectedFile)\\n outOutput.write(\\\"%s\\\\n\\\"%selectedFile)\\n selecOut.write(\\\"%s\\\\n\\\"%selectedName)\\n\\n # Close files\\n outInput.close()\\n outTasks.close()\\n #~ outInput1par.close()\\n if treina or verdade:\\n outOutput.close()\\n #~ outOutputClass.close()\\n selecOut.close()\\n\\n statusGenInput = 0\\n print '\\\\nend of genInput\\\\n'\\n return statusGenInput\",\n \"def input_fn():\\n bos_id = tf.constant(BOS_ID, tf.int32)\\n eos_id = tf.constant(EOS_ID, tf.int32)\\n\\n # For training, we want a lot of parallel reading and shuffling.\\n # For eval, we want no shuffling and parallel reading doesn't matter.\\n d = tf.data.TFRecordDataset(input_files)\\n if is_training:\\n d = d.repeat()\\n d = d.shuffle(buffer_size=100)\\n\\n d = d.map(lambda record: _decode_record(record, name_to_features))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([[bos_id], src_ids, [eos_id]], 0),\\n tf.concat([tgt_ids, [eos_id]], 0),\\n label))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n src_ids[:FLAGS.max_sequence_length],\\n tgt_ids[:FLAGS.max_sequence_length],\\n label\\n ))\\n\\n d = d.map(lambda src_ids, tgt_ids, label: (\\n tf.concat([src_ids, tgt_ids], 0),\\n tf.concat([tf.zeros_like(src_ids), tf.ones_like(tgt_ids)], 0),\\n label\\n ))\\n\\n d = d.map(lambda input_ids, segment_ids, label_ids: (\\n input_ids,\\n segment_ids,\\n tf.ones_like(input_ids),\\n label_ids\\n ))\\n\\n def batching_func(x):\\n return x.padded_batch(\\n batch_size,\\n # The entry is the source line rows;\\n # this has unknown-length vectors. The last entry is\\n # the source row size; this is a scalar.\\n padded_shapes=(\\n tf.TensorShape([None]), # src\\n tf.TensorShape([None]), # tgt\\n tf.TensorShape([None]),\\n tf.TensorShape([])), # src_len\\n # Pad the source sequences with eos tokens.\\n # (Though notice we don't generally need to do this since\\n # later on we will be masking out calculations past the true sequence.\\n padding_values=(\\n PAD_ID, # src\\n PAD_ID,\\n PAD_ID,\\n 0)) # src_len -- unused\\n\\n batched_dataset = batching_func(d)\\n features = batched_dataset.map(lambda input_ids, segment_ids, input_mask, label:\\n {\\n \\\"input_ids\\\": input_ids,\\n \\\"segment_ids\\\": segment_ids,\\n \\\"input_mask\\\": input_mask,\\n \\\"label_ids\\\": label\\n\\n })\\n\\n return features\",\n \"def prepare_test_inputs(input_dir):\\n # Prepare input parameters\\n parameters = Dict(dict={})\\n # example structure: bcc Fe\\n structure = StructureData(cell=[[1.42002584, 1.42002584, 1.42002584],\\n [1.42002584, -1.42002584, -1.42002584],\\n [-1.42002584, 1.42002584, -1.42002584]])\\n structure.append_atom(position=[0, 0, 0], symbols='Fe')\\n # create jij couplings input from csv export\\n jijs_expanded = np.load(os.path.join(input_dir, 'Jij_expanded.npy'))\\n jij_data = ArrayData()\\n jij_data.set_array('Jij_expanded', jijs_expanded)\\n\\n # set up calculation\\n inputs = {\\n 'parameters': parameters,\\n 'jij_data': jij_data,\\n 'structure': structure,\\n 'metadata': {\\n 'description': 'Test job submission with the aiida_spirit plugin',\\n },\\n }\\n\\n return inputs\",\n \"def _parse_inputs(self, skip=None):\\n if skip is None:\\n skip = []\\n skip += ['stim_files', 'labels', 'models']\\n\\n if self.inputs.no_bucket:\\n skip += ['out_file']\\n\\n return super(Decon, self)._parse_inputs(skip=skip)\",\n \"def __init__(self, dataset_name, split, *args, data_dir=None, **kwargs):\\n super(TfdsInput, self).__init__(*args, **kwargs)\\n self.dataset_name = dataset_name\\n self.split = split\\n self.data_dir = data_dir\",\n \"def extract_features(self, preprocessed_inputs, init_extraction=False):\\n if init_extraction:\\n preprocessed_inputs.get_shape().assert_has_rank(4)\\n shape_assert = tf.Assert(\\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\\n ['image size must at least be 33 in both height and width.'])\\n with tf.control_dependencies([shape_assert]):\\n with slim.arg_scope(self._conv_hyperparams):\\n with tf.variable_scope('MobilenetV1',\\n reuse=self._reuse_weights) as scope:\\n _, image_features = mobilenet_v1.mobilenet_v1_base(\\n preprocessed_inputs,\\n final_endpoint='Conv2d_13_pointwise',\\n min_depth=self._min_depth,\\n depth_multiplier=self._depth_multiplier,\\n scope=scope)\\n feature_head = image_features['Conv2d_13_pointwise']\\n feature_head = slim.conv2d(\\n feature_head,\\n 512, [3,3],\\n stride=1,\\n padding='SAME',\\n scope='Conv2d_Append_1x1_256'\\n )\\n feature_head = tf.nn.avg_pool(feature_head, strides=[1,1,1,1], ksize=[1,4,4,1],\\n padding='VALID', )\\n return feature_head\\n else:\\n preprocessed_inputs.get_shape().assert_has_rank(4)\\n shape_assert = tf.Assert(\\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\\n ['image size must at least be 33 in both height and width.'])\\n\\n\\n bottomup_features_names = [ 'Conv2d_11_pointwise', 'Conv2d_13_pointwise']\\n num_appended_layers = 0\\n #appended_channel_num = [512, 256, 256, 256]\\n appended_channel_num = [512]\\n\\n with tf.control_dependencies([shape_assert]):\\n with slim.arg_scope(self._conv_hyperparams):\\n with tf.variable_scope('MobilenetV1',\\n reuse=self._reuse_weights) as scope:\\n _, image_features = mobilenet_v1.mobilenet_v1_base(\\n preprocessed_inputs,\\n final_endpoint='Conv2d_13_pointwise',\\n min_depth=self._min_depth,\\n depth_multiplier=self._depth_multiplier,\\n scope=scope)\\n\\n topdown_features = self._topdown_feature_maps(\\n image_features,\\n bottomup_features_names=bottomup_features_names,\\n num_appended_layers = num_appended_layers,\\n appended_channel_num = appended_channel_num)\\n return topdown_features.values()\",\n \"def get_input_args():\\n \\n parser = argparse.ArgumentParser()\\n \\n # command line parameter for dataset path\\n parser.add_argument('data_directory', action='store', type=str, \\n help='directory for new dataset to train')\\n \\n # command line parameter for saving checkpoint path \\n parser.add_argument('--save_dir',type=str,default='checkpoint',\\n help='directory where checkpoint is saved')\\n \\n # command line parameter to input model chosen. Defaults to vgg16. Chosen model can be either vgg16 or densenet121\\n parser.add_argument('--arch',type=str,default='vgg16',choices=('vgg16', 'densenet121'),\\n help='chosen model: vgg16 or densenet121')\\n \\n # command line parameter to input learning rate. Defaults to 0.00001\\n parser.add_argument('--learning_rate',type=float,default='0.00001',\\n help='learning rate for model')\\n \\n # command line parameter to input number of hidden units\\n parser.add_argument('--hidden_units',type=int,default=0,\\n help='add number of units in hidden layer to list')\\n \\n # command line paramter to input epochs. Defaults to 5\\n parser.add_argument('--epochs',type=int,default='5',\\n help='number of epochs')\\n \\n # command line parameter for using gpu\\n parser.add_argument('--gpu', action='store_true', default=False,\\n help='Set a switch to true')\\n \\n #return parsed argument collection\\n return parser.parse_args()\",\n \"def input_setup(config):\\n print(config.is_train)\\n # Load data path\\n if config.is_train:\\n data, label = prepare_data(dataset=\\\"Train/DoF_Images (2)\\\")\\n else:\\n data, label = prepare_data(dataset=\\\"Test\\\")\\n\\n sub_input_sequence = []\\n sub_label_sequence = []\\n padding = abs(config.image_size - config.label_size) / 2 # 6\\n nx = ny = 0\\n\\n if config.is_train:\\n for i in range(len(data)):\\n input_, label_ = preprocess(data[i], label[i], config.scale)\\n\\n if len(input_.shape) == 3:\\n h, w, c = input_.shape\\n else:\\n h, w = input_.shape\\n\\n for x in range(0, h-config.image_size+1, config.stride):\\n if i == 0:\\n nx += 1; ny = 0\\n for y in range(0, w-config.image_size+1, config.stride):\\n if i == 0:\\n ny += 1\\n\\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size\\n , y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\\n # print(sub_input.shape)\\n # print(sub_label.shape)\\n # Make channel value\\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\\n\\n sub_input_sequence.append(sub_input)\\n sub_label_sequence.append(sub_label)\\n\\n else:\\n nx_l = []\\n ny_l = []\\n for i in range(len(data)):\\n input_, label_ = preprocess(data[i], label[i], config.scale)\\n\\n if len(input_.shape) == 3:\\n h, w, c = input_.shape\\n else:\\n h, w = input_.shape\\n\\n if w >= 4000 or h > 4000:\\n input_ = cv2.resize(input_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\\n label_ = cv2.resize(label_, dsize=(int(w/2), int(h/2)), interpolation=cv2.INTER_AREA)\\n w = int(w/2)\\n h = int(h/2)\\n\\n # Numbers of sub-images in height and width of image are needed to compute merge operation.\\n\\n nx = ny = 0\\n for x in range(0, h-config.image_size+1, config.stride):\\n nx += 1; ny = 0\\n for y in range(0, w-config.image_size+1, config.stride):\\n ny += 1\\n sub_input = input_[x:x+config.image_size, y:y+config.image_size] # [33 x 33]\\n sub_label = label_[x+int(padding):x+int(padding)+config.label_size, y+int(padding):y+int(padding)+config.label_size] # [21 x 21]\\n\\n sub_input = sub_input.reshape([config.image_size, config.image_size, 3])\\n sub_label = sub_label.reshape([config.label_size, config.label_size, 3])\\n\\n sub_input_sequence.append(sub_input)\\n sub_label_sequence.append(sub_label)\\n #print(\\\"nx: %d ny: %d\\\" % (nx, ny))\\n nx_l.append(nx)\\n ny_l.append(ny)\\n \\\"\\\"\\\"\\n len(sub_input_sequence) : the number of sub_input (33 x 33 x ch) in one image\\n (sub_input_sequence[0]).shape : (33, 33, 1)\\n \\\"\\\"\\\"\\n # Make list to numpy array. With this transform\\n arrdata = np.asarray(sub_input_sequence) # [?, 33, 33, 3]\\n arrlabel = np.asarray(sub_label_sequence) # [?, 21, 21, 3]\\n\\n make_data(config, arrdata, arrlabel)\\n print(\\\"make_data success\\\")\\n if config.is_train:\\n return nx, ny\\n else:\\n return nx_l, ny_l, len(data)\",\n \"def prepare_data():\\n gennet.prepare_data('Resnet50')\",\n \"def _build(self, inputs):\\n\\n # calculate how many slots we need from the 3 dimensions of the incoming conv layer (filter w/h plus depth)\\n dims = inputs.get_shape().as_list()\\n new_dim = 1\\n for d in dims[1:]: # leave first axis as is (batch)\\n new_dim = new_dim * d # multiply 'em up\\n return tf.reshape(inputs, [-1, new_dim]) # -1=keep this dimension as is (it could be anything as this is the number of samples) and flatten the others\",\n \"def __init__(self, args, args2):\\n self.logger = logging.getLogger(self.__class__.__name__)\\n\\n self.inputUrl1 = args[\\\"input\\\"][0][\\\"value\\\"]\\n self.inputUrl2 = args[\\\"input\\\"][1][\\\"value\\\"]\\n self.outputUrl1 = args[\\\"output\\\"][0][\\\"value\\\"]\\n self.featureCols = args[\\\"param\\\"][\\\"features\\\"]\\n\\n self.originalDF = None\\n self.transformDF = None\\n self.model = None\\n\\n self.dataUtil = utils.dataUtil(args2)\",\n \"def init_input_pipeline(self, config):\\n\\n ######################\\n # Calibrate parameters\\n ######################\\n\\n print('Initiating input pipelines')\\n\\n # Update num classes in config\\n config.num_classes = self.num_classes - len(self.ignored_labels)\\n config.ignored_label_inds = [self.label_to_idx[ign_label] for ign_label in self.ignored_labels]\\n\\n print('ignored_label_inds:')\\n print(config.ignored_label_inds)\\n\\n # Update network model in config\\n config.network_model = self.network_model\\n\\n print('network_model:')\\n print(config.network_model)\\n\\n # Calibrate generators to batch_num\\n print('Calibrate generators to batch_num')\\n self.batch_limit = self.calibrate_batches(config)\\n\\n # From config parameter, compute higher bound of neighbors number in a neighborhood\\n hist_n = int(np.ceil(4 / 3 * np.pi * (config.density_parameter + 1) ** 3))\\n\\n # Initiate neighbors limit with higher bound\\n print('Initiate neighbors limit with higher bound')\\n self.neighborhood_limits = np.full(config.num_layers, hist_n, dtype=np.int32)\\n\\n # Calibrate max neighbors number\\n print('Calibrate max neighbors number')\\n self.calibrate_neighbors(config)\\n\\n ################################\\n # Initiate tensorflow parameters\\n ################################\\n\\n # Reset graph\\n print('Reset graph')\\n tf.reset_default_graph()\\n\\n # Set random seed (You also have to set it in network_architectures.weight_variable)\\n #np.random.seed(42)\\n #tf.set_random_seed(42)\\n\\n # Get generator and mapping function\\n print('Get generator')\\n gen_function, gen_types, gen_shapes = self.get_batch_gen('training', config)\\n gen_function_val, _, _ = self.get_batch_gen('validation', config)\\n print('Get mapping function')\\n map_func = self.get_tf_mapping(config)\\n\\n ##################\\n # Training dataset\\n ##################\\n\\n # Create batched dataset from generator\\n self.train_data = tf.data.Dataset.from_generator(gen_function,\\n gen_types,\\n gen_shapes)\\n\\n self.train_data = self.train_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\\n\\n # Prefetch data\\n self.train_data = self.train_data.prefetch(10)\\n\\n ##############\\n # Test dataset\\n ##############\\n\\n # Create batched dataset from generator\\n self.val_data = tf.data.Dataset.from_generator(gen_function_val,\\n gen_types,\\n gen_shapes)\\n\\n # Transform inputs\\n self.val_data = self.val_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\\n\\n # Prefetch data\\n self.val_data = self.val_data.prefetch(10)\\n\\n #################\\n # Common iterator\\n #################\\n\\n # create a iterator of the correct shape and type\\n iter = tf.data.Iterator.from_structure(self.train_data.output_types, self.train_data.output_shapes)\\n self.flat_inputs = iter.get_next()\\n\\n # create the initialisation operations\\n self.train_init_op = iter.make_initializer(self.train_data)\\n self.val_init_op = iter.make_initializer(self.val_data)\",\n \"def forward(self, inputs):\\n coords = inputs['point'].to(self.device)\\n feat = inputs['feat'].to(self.device)\\n\\n out_features_list = []\\n for i in range(len(self.point_features)):\\n feat, _ = self.point_features[i]((feat, coords))\\n out_features_list.append(feat)\\n # feat: num_batches * 1024 * num_points -> num_batches * 1024 -> num_batches * 128\\n feat = self.cloud_features(feat.max(dim=-1, keepdim=False).values)\\n out_features_list.append(\\n feat.unsqueeze(-1).repeat([1, 1, coords.size(-1)]))\\n out = self.classifier(torch.cat(out_features_list, dim=1))\\n return out.transpose(1, 2)\",\n \"def _clone_and_prepare_features(feature_config):\\n output_objects = []\\n\\n table_configs = {}\\n\\n for config in tf.nest.flatten(feature_config):\\n # There should be a one-to-one mapping between new TableConfig objects and\\n # old ones (as each TableConfig can be thought of as a table).\\n table_configs[config.table] = table_configs.get(\\n config.table,\\n tf.tpu.experimental.embedding.TableConfig(\\n vocabulary_size=config.table.vocabulary_size,\\n dim=config.table.dim,\\n initializer=config.table.initializer,\\n optimizer=config.table.optimizer,\\n quantization_config=config.table.quantization_config,\\n combiner=config.table.combiner,\\n name=config.table.name,\\n ),\\n )\\n\\n output_objects.append(\\n tf.tpu.experimental.embedding.FeatureConfig(\\n table=table_configs[config.table],\\n max_sequence_length=config.max_sequence_length,\\n output_shape=config.output_shape,\\n validate_weights_and_indices=config.validate_weights_and_indices,\\n name=config.name))\\n\\n # Fix up the optimizers.\\n for _, new_table in table_configs.items():\\n if new_table.optimizer is not None:\\n new_table.optimizer = _normalize_and_prepare_optimizer(\\n new_table.optimizer)\\n\\n return (tf.nest.pack_sequence_as(feature_config,\\n output_objects), list(table_configs.items()))\",\n \"def load_inputs(self):\\n \\n self.inputs = tf.placeholder(tf.int32, shape=(None,self.n_input), name='inputs')\\n self.inputs_mask = tf.placeholder(tf.float32, shape=(None, self.n_input), name='inputs_mask')\\n self.targets = tf.placeholder(tf.int32, shape=(None,1), name='targets')\\n self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')\",\n \"def input_fn(self, ctx=None):\\n sup_dataset = self.supervised_input.make_parsed_dataset(ctx)\\n unsup_dataset = self.unsupervised_input.make_parsed_dataset(ctx)\\n\\n dataset = tf.data.Dataset.zip((sup_dataset, unsup_dataset))\\n dataset = dataset.map(_combine_sup_unsup_datasets)\\n\\n dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)\\n\\n options = tf.data.Options()\\n options.experimental_deterministic = False\\n dataset = dataset.with_options(options)\\n\\n return dataset\",\n \"def extract_features(self, inputs):\\n x = self.conv1(inputs)\\n x = self.maxpool1(x)\\n x = self.conv2(x)\\n x = self.conv3(x)\\n x = self.maxpool2(x)\\n\\n x = self.inception3a(x)\\n x = self.inception3b(x)\\n x = self.maxpool3(x)\\n x = self.inception4a(x)\\n\\n x = self.inception4b(x)\\n x = self.inception4c(x)\\n x = self.inception4d(x)\\n\\n x = self.inception4e(x)\\n x = self.maxpool4(x)\\n x = self.inception5a(x)\\n x = self.inception5b(x)\\n x = self.avgpool(x)\\n x = torch.flatten(x,1)\\n x = self.dropout(x)\\n return x\",\n \"def build_inputs(self):\\n if self.mode == \\\"inference\\\":\\n # In inference mode, images and inputs are fed via placeholders.\\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_feed\\\")\\n input_feed = tf.placeholder(\\n dtype=tf.int64,\\n shape=[None], # batch_size\\n name=\\\"input_feed\\\")\\n\\n # Process image and insert batch dimensions.\\n images = tf.expand_dims(self.load_image(image_feed), 0)\\n input_seqs = tf.expand_dims(input_feed, 1)\\n\\n # No target sequences or input mask in inference mode.\\n target_seqs = None\\n input_mask = None\\n else:\\n def _load_example(serialized_example):\\n encoded_image, caption = input_ops.parse_example(\\n serialized_example,\\n image_feature=self.config.image_feature_name,\\n caption_feature=self.config.caption_feature_name)\\n image = self.load_image(encoded_image)\\n\\n # strings.split expects a batch\\n input_seqs, target_seqs, input_mask = input_ops.pad_caption_to_input(\\n caption)\\n return image, input_seqs, target_seqs, input_mask\\n\\n def _load_dataset(filename):\\n return tf.data.TFRecordDataset(filename, buffer_size=16 * 1024 * 1024)\\n\\n df = tf.data.Dataset.list_files(\\n self.config.input_file_pattern, shuffle=self.mode == \\\"train\\\")\\n df = df.apply(\\n tf.data.experimental.parallel_interleave(\\n _load_dataset, cycle_length=64, sloppy=True))\\n\\n if self.mode == \\\"train\\\":\\n df = df.repeat()\\n df = df.shuffle(1024)\\n\\n df = df.apply(\\n tf.data.experimental.map_and_batch(\\n _load_example,\\n self.config.batch_size,\\n num_parallel_batches=8,\\n drop_remainder=True))\\n df = df.prefetch(8)\\n images, input_seqs, target_seqs, input_mask = df.make_one_shot_iterator(\\n ).get_next()\\n\\n self.images = images\\n self.input_seqs = input_seqs\\n self.target_seqs = target_seqs\\n self.input_mask = input_mask\",\n \"def create_inputs_recipe():\\n module_name, _ = os.path.splitext(os.path.basename(__file__))\\n path = os.path.join(CREATED_INPUTS_PATH_FOR_TESTS, module_name)\\n os.makedirs(path, exist_ok=True)\\n os.chdir(path)\\n os.makedirs(\\\"inputs/\\\", exist_ok=True)\\n print('Current working directory:\\\\n {:s}'.format(os.getcwd()))\\n\\n for filename, _ in input_pars:\\n print('Downloading files...')\\n basename = filename.split(\\\"_\\\")[0] + \\\".fits\\\"\\n sci_path = download_from_archive(basename)\\n sci_ad = astrodata.open(sci_path)\\n data_label = sci_ad.data_label()\\n\\n print('Reducing pre-processed data:')\\n logutils.config(file_name='log_{}.txt'.format(data_label))\\n p = GNIRSLongslit([sci_ad])\\n p.prepare(bad_wcs=\\\"fix\\\")\\n p.addDQ()\\n p.addVAR(read_noise=True)\\n p.ADUToElectrons()\\n p.addVAR(poisson_noise=True)\\n # p.flatCorrect()\\n p.makeIRAFCompatible()\\n\\n os.chdir(\\\"inputs/\\\")\\n processed_ad = p.writeOutputs().pop()\\n os.chdir(\\\"../\\\")\\n print('Wrote pre-processed file to:\\\\n'\\n ' {:s}'.format(processed_ad.filename))\",\n \"def _prepare_batch(self, batch):\\n try:\\n from torch_geometric.data import Batch\\n except:\\n raise ValueError(\\\"This class requires PyTorch Geometric to be installed.\\\")\\n\\n inputs, labels, weights = batch\\n pyg_graphs = [graph.to_pyg_graph() for graph in inputs[0]]\\n inputs = Batch.from_data_list(pyg_graphs)\\n _, labels, weights = super(GATModel, self)._prepare_batch(([], labels,\\n weights))\\n return inputs, labels, weights\",\n \"def build_inputs(self):\\n # in prediction mode, we use a batch size of one\\n batch_size = self.config.batch_size\\n \\n if self.mode == \\\"prediction\\\":\\n batch_size = 1\\n \\n # In inference mode, images and inputs are fed via placeholders.\\n image_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_feed\\\") # shape: scalar value\\n\\n #image_fn_feed = tf.placeholder(dtype=tf.string, shape=[], name=\\\"image_fn_feed\\\")\\n \\n #image_filename_queue = tf.train.string_input_producer([image_fn_feed]) # list of files to read\\n \\n #reader = tf.WholeFileReader()\\n #_, image_feed = reader.read(image_filename_queue)\\n \\n \\n text_feed = tf.placeholder(dtype=tf.int64,\\n shape=[None, self.config.sentence_length], # shape 2D tensor - variable size (first dimension sentence sequence, second dimension token sequence (actually fixed size))\\n name=\\\"text_feed\\\")\\n \\n # arbitrary labels (not used)\\n mi_label = tf.constant(-1, dtype=tf.int64) \\n sc_label = tf.constant(-1.0, dtype=tf.float32) \\n\\n image = self.process_image(image_feed)\\n\\n # Process image and insert batch dimensions.\\n images = tf.expand_dims(self.process_image(image_feed), 0)\\n input_seqs = tf.expand_dims(text_feed, 0) \\n mi_labels = tf.expand_dims(mi_label, 0)\\n sc_labels = tf.expand_dims(sc_label, 0)\\n input_mask = tf.expand_dims(tf.constant([1], dtype=tf.int32) , 0)\\n \\n else:\\n # Prefetch serialized SequenceExample protos.\\n input_queue = input_ops.prefetch_input_data(\\n self.reader,\\n self.config.input_file_pattern,\\n is_training=self.is_training(),\\n batch_size=batch_size,\\n values_per_shard=self.config.values_per_input_shard,\\n input_queue_capacity_factor=self.config.input_queue_capacity_factor,\\n num_reader_threads=self.config.num_input_reader_threads,\\n mode=self.mode)\\n\\n # Image processing and random distortion. Split across multiple threads\\n # with each thread applying a slightly different distortion.\\n assert self.config.num_preprocess_threads % 2 == 0\\n images_and_texts = []\\n for thread_id in range(self.config.num_preprocess_threads):\\n serialized_sequence_example = input_queue.dequeue()\\n encoded_image, text, mi, sc = input_ops.parse_sequence_example(\\n serialized_sequence_example,\\n image_feature=self.config.image_feature_name,\\n sentences_feature=self.config.sentences_feature_name,\\n sentence_length=self.config.sentence_length,\\n mi_feature=self.config.mi_feature_name,\\n sc_feature=self.config.sc_feature_name)\\n image = self.process_image(encoded_image, thread_id=thread_id)\\n images_and_texts.append([image, text, mi, sc])\\n\\n # Batch inputs.\\n queue_capacity = (2 * self.config.num_preprocess_threads *\\n batch_size)\\n images, input_seqs, mi_labels, sc_labels, input_mask = (\\n input_ops.batch_with_dynamic_pad(images_and_texts,\\n batch_size=batch_size,\\n queue_capacity=queue_capacity))\\n \\n #print('Shapes') \\n #print('Shape images: ' + str(images.get_shape()))\\n #print('Shape input_seqs: ' + str(input_seqs.get_shape())) \\n #print('Shape input_mask: ' + str(input_mask.get_shape())) \\n\\n self.images = images\\n self.input_seqs = input_seqs\\n if self.mode == \\\"prediction\\\":\\n self.mi_labels = None\\n self.sc_labels = None\\n else:\\n self.mi_labels = mi_labels\\n self.sc_labels = sc_labels\\n self.input_mask = input_mask\",\n \"def train_input(config, params):\\n\\n def _grouping(pim, pla, iid):\\n # group dataset elements as required by estimator\\n features = {\\n # 'rawimages': rim,\\n 'proimages': pim,\\n 'imageids': iid,\\n # 'rawimagespaths': imp,\\n # 'rawlabelspaths': lap,\\n }\\n labels = {\\n # 'rawlabels': rla,\\n 'prolabels': pla,\\n }\\n\\n # next line for distributed debugging\\n # tf.string tensors is not supported for DMA read/write to GPUs (TF bug)\\n if params.distribute:\\n # del features['rawimagespaths']\\n # del features['rawlabelspaths']\\n del features['imageids']\\n\\n return (features, labels)\\n\\n with tf.name_scope('input_pipeline'):\\n dataset = prebatch_dataset(config, params)\\n dataset = dataset.batch(get_temp_Nb(config, params.Nb))\\n dataset = postbatch_dataset(dataset, config, params)\\n dataset = dataset.map(_grouping, num_parallel_calls=NUM_PARALLEL_CALLS)\\n options = tf.data.Options()\\n options.experimental_autotune = True\\n # seems than on average gives faster results\\n dataset = dataset.prefetch(None).with_options(options)\\n\\n return dataset\",\n \"def build_inputs(\\n timesteps,\\n latlon_dense_units,\\n concat_dense_units,\\n latent_dim,\\n vocab_sizes,\\n noise=False,\\n mask=False,\\n):\\n latlon_input, latlon_embed = build_inputs_latlon(timesteps, latlon_dense_units)\\n inputs = [latlon_input]\\n embeddings = [latlon_embed]\\n for key, val in vocab_sizes.items():\\n cat_input, cat_embed = build_inputs_cat(timesteps, val, key)\\n inputs.append(cat_input)\\n embeddings.append(cat_embed)\\n concat_input = layers.Concatenate(axis=2)(embeddings)\\n unstacked = layers.Lambda(lambda x: tf.unstack(x, axis=1))(concat_input)\\n d = layers.Dense(\\n units=concat_dense_units,\\n activation=\\\"relu\\\",\\n kernel_initializer=initializers.he_uniform(seed=1),\\n name=\\\"emb_trajpoint\\\",\\n )\\n if noise:\\n noise_input = layers.Input(shape=(latent_dim,), name=\\\"input_noise\\\")\\n inputs.append(noise_input)\\n dense_outputs = [d(layers.Concatenate(axis=1)([x, noise_input])) for x in unstacked]\\n else:\\n dense_outputs = [d(x) for x in unstacked]\\n if mask:\\n inputs.append(layers.Input(shape=(timesteps, 1), name=\\\"input_mask\\\"))\\n emb_traj = layers.Lambda(lambda x: tf.stack(x, axis=1))(dense_outputs)\\n return (inputs, emb_traj)\",\n \"def init_test_input_pipeline(self, config):\\n\\n print('Initiating test input pipelines')\\n\\n ######################\\n # Calibrate parameters\\n ######################\\n\\n # Update num classes in config\\n config.num_classes = self.num_classes - len(self.ignored_labels)\\n config.ignored_label_inds = [self.label_to_idx[ign_label] for ign_label in self.ignored_labels]\\n\\n # Update network model in config\\n config.network_model = self.network_model\\n\\n # Update num classes in config\\n\\n if config.network_model == 'multi_segmentation':\\n config.num_classes = self.num_parts\\n elif config.network_model == 'segmentation':\\n if self.ShapeNetPartType in self.label_names:\\n config.num_classes = self.num_parts[self.name_to_label[self.ShapeNetPartType]]\\n else:\\n raise ValueError('Wrong object name given for ShapeNetPart single object segmentation')\\n\\n # Calibrate generators to batch_num\\n self.batch_limit = self.calibrate_batches(config)\\n\\n # From config parameter, compute higher bound of neighbors number in a neighborhood\\n hist_n = int(np.ceil(4 / 3 * np.pi * (config.density_parameter + 1) ** 3))\\n\\n # Initiate neighbors limit with higher bound\\n self.neighborhood_limits = np.full(config.num_layers, hist_n, dtype=np.int32)\\n\\n # Calibrate max neighbors number\\n self.calibrate_neighbors(config)\\n\\n ################################\\n # Initiate tensorflow parameters\\n ################################\\n\\n # Reset graph\\n tf.reset_default_graph()\\n\\n # Set random seed (You also have to set it in network_architectures.weight_variable)\\n #np.random.seed(42)\\n #tf.set_random_seed(42)\\n\\n # Get generator and mapping function\\n gen_function, gen_types, gen_shapes = self.get_batch_gen('test', config)\\n map_func = self.get_tf_mapping(config)\\n\\n ##############\\n # Test dataset\\n ##############\\n\\n # Create batched dataset from generator\\n self.test_data = tf.data.Dataset.from_generator(gen_function,\\n gen_types,\\n gen_shapes)\\n\\n self.test_data = self.test_data.map(map_func=map_func, num_parallel_calls=self.num_threads)\\n\\n # Prefetch data\\n self.test_data = self.test_data.prefetch(10)\\n\\n #################\\n # Common iterator\\n #################\\n\\n # create a iterator of the correct shape and type\\n iter = tf.data.Iterator.from_structure(self.test_data.output_types, self.test_data.output_shapes)\\n self.flat_inputs = iter.get_next()\\n\\n # create the initialisation operations\\n self.test_init_op = iter.make_initializer(self.test_data)\",\n \"def input_nodes(self):\\n pass\",\n \"def prepare_agent_input_data(event, context):\\n print \\\"Preparing input data for the agent\\\"\\n write_data_to_file(json.dumps(event), '/tmp/event.json')\\n write_data_to_file('{ \\\"logStreamName\\\": \\\"%s\\\" }' % context.log_stream_name, '/tmp/context.json')\",\n \"def _reset_parameters(self) -> None:\\n self._setup_input = {\\n \\\"P\\\": csc_matrix(2.0 * self.opt.P(self.p).toarray()),\\n \\\"q\\\": self.opt.q(self.p).toarray().flatten(),\\n }\\n if self.opt_type in CONSTRAINED_OPT:\\n A = self.opt.A(self.p)\\n b = self.opt.b(self.p)\\n self._setup_input[\\\"A\\\"] = csc_matrix(\\n cs.vertcat(self.opt.M(self.p), A, -A).toarray()\\n )\\n self._setup_input[\\\"l\\\"] = (\\n cs.vertcat(-self.opt.c(self.p), -b, b).toarray().flatten()\\n )\",\n \"def preprocessing_fn(inputs):\\n\\n outputs = inputs.copy()\\n\\n # Filter redundant features\\n for key in FEATURES_TO_REMOVE:\\n del outputs[key]\\n\\n # Convert degrees to radians\\n pi = tf.constant(m.pi)\\n wd_rad = inputs['wd (deg)'] * pi / 180.0\\n\\n # Calculate the wind x and y components.\\n outputs['Wx'] = inputs['wv (m/s)'] * tf.math.cos(wd_rad)\\n outputs['Wy'] = inputs['wv (m/s)'] * tf.math.sin(wd_rad)\\n\\n # Delete `wv (m/s)` after getting the wind vector\\n del outputs['wv (m/s)']\\n\\n # Get day and year in seconds\\n day = tf.cast(24*60*60, tf.float32)\\n year = tf.cast((365.2425)*day, tf.float32)\\n\\n # Convert `Date Time` column into timestamps in seconds (using tfa helper function)\\n timestamp_s = tfa.text.parse_time(outputs['Date Time'], time_format='%d.%m.%Y %H:%M:%S', output_unit='SECOND')\\n timestamp_s = tf.cast(timestamp_s, tf.float32)\\n \\n # Convert timestamps into periodic signals\\n outputs['Day sin'] = tf.math.sin(timestamp_s * (2 * pi / day))\\n outputs['Day cos'] = tf.math.cos(timestamp_s * (2 * pi / day))\\n outputs['Year sin'] = tf.math.sin(timestamp_s * (2 * pi / year))\\n outputs['Year cos'] = tf.math.cos(timestamp_s * (2 * pi / year))\\n\\n # Delete unneeded columns\\n del outputs['Date Time']\\n del outputs['wd (deg)']\\n\\n # Final feature list\\n FINAL_FEATURE_LIST = [\\\"p (mbar)\\\",\\n \\\"T (degC)\\\",\\n \\\"rh (%)\\\", \\n \\\"VPmax (mbar)\\\", \\n \\\"VPdef (mbar)\\\", \\n \\\"sh (g/kg)\\\",\\n \\\"rho (g/m**3)\\\",\\n \\\"Wx\\\",\\n \\\"Wy\\\",\\n \\\"Day sin\\\",\\n 'Day cos',\\n 'Year sin',\\n 'Year cos'\\n ]\\n\\n # Scale selected numeric features\\n for key in _SELECTED_NUMERIC_FEATURE_KEYS:\\n outputs[key] = tft.scale_to_0_1(outputs[key])\\n\\n return outputs\",\n \"def _clean_inputs(self, inputs):\\n return inputs\",\n \"def _collect_ipt_and_opt_nodes(self):\\n for name, node in self._nodes_collection.items():\\n if node.in_degree == 0:\\n # NOTICE: what's usage of `scope`?\\n self._input_nodes.append(name)\\n\\n if node.out_degree == 0:\\n self._output_nodes.append(name)\",\n \"def prepare_data(self, *args, **kwargs):\\n # get paths to train and test splits\\n _split_paths = [os.path.join(self.path_to_data, split)\\n for split in os.listdir(self.path_to_data)]\\n\\n # for each split [train, test]\\n for _path in _split_paths:\\n _img_classes = os.listdir(_path) # get subfolders representing each class\\n self.splits[os.path.basename(_path)] = []\\n\\n # get the images in pairs with its corresponding class\\n for _class in _img_classes:\\n _data = self.get_img_text_pair(os.path.join(_path, _class))\\n\\n if os.path.basename(_path) == 'train':\\n self.weights[self.encode_label(_class)] = len(_data)\\n self.splits[os.path.basename(_path)].extend(_data)\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\",\n \"def setup(self):\\n in_dataset, out_dataset = self.get_datasets()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.625194","0.61816275","0.59840703","0.5956487","0.59521675","0.5821427","0.57861555","0.57474005","0.5709486","0.57022744","0.570068","0.569275","0.56124747","0.5574784","0.55706114","0.5532864","0.55202353","0.5518523","0.5515399","0.55153596","0.5513564","0.5511433","0.5503158","0.5477451","0.54765177","0.5475008","0.54707146","0.54632145","0.5456583","0.5447484","0.54462606","0.5439172","0.543646","0.54342926","0.54306495","0.5409471","0.53988504","0.5388933","0.53549355","0.5353942","0.5347811","0.53453875","0.53453875","0.5343164","0.53411293","0.5340681","0.5325306","0.53230846","0.53119534","0.5307678","0.5299794","0.526877","0.5247506","0.5245502","0.523976","0.5232761","0.5226176","0.5224713","0.5218035","0.52161527","0.5215432","0.5210432","0.5210432","0.5210432","0.52040076","0.5199631","0.5189886","0.5182676","0.51806116","0.51744986","0.5172499","0.51651204","0.51619244","0.51583695","0.51529884","0.5149466","0.51466054","0.5144873","0.5144778","0.51375735","0.513177","0.5129024","0.51276875","0.5126936","0.5124686","0.5122885","0.51198334","0.51174676","0.51163787","0.5107801","0.5099166","0.5095521","0.50933456","0.5083593","0.508151","0.50737023","0.5069209","0.50688976","0.50683784","0.50683784"],"string":"[\n \"0.625194\",\n \"0.61816275\",\n \"0.59840703\",\n \"0.5956487\",\n \"0.59521675\",\n \"0.5821427\",\n \"0.57861555\",\n \"0.57474005\",\n \"0.5709486\",\n \"0.57022744\",\n \"0.570068\",\n \"0.569275\",\n \"0.56124747\",\n \"0.5574784\",\n \"0.55706114\",\n \"0.5532864\",\n \"0.55202353\",\n \"0.5518523\",\n \"0.5515399\",\n \"0.55153596\",\n \"0.5513564\",\n \"0.5511433\",\n \"0.5503158\",\n \"0.5477451\",\n \"0.54765177\",\n \"0.5475008\",\n \"0.54707146\",\n \"0.54632145\",\n \"0.5456583\",\n \"0.5447484\",\n \"0.54462606\",\n \"0.5439172\",\n \"0.543646\",\n \"0.54342926\",\n \"0.54306495\",\n \"0.5409471\",\n \"0.53988504\",\n \"0.5388933\",\n \"0.53549355\",\n \"0.5353942\",\n \"0.5347811\",\n \"0.53453875\",\n \"0.53453875\",\n \"0.5343164\",\n \"0.53411293\",\n \"0.5340681\",\n \"0.5325306\",\n \"0.53230846\",\n \"0.53119534\",\n \"0.5307678\",\n \"0.5299794\",\n \"0.526877\",\n \"0.5247506\",\n \"0.5245502\",\n \"0.523976\",\n \"0.5232761\",\n \"0.5226176\",\n \"0.5224713\",\n \"0.5218035\",\n \"0.52161527\",\n \"0.5215432\",\n \"0.5210432\",\n \"0.5210432\",\n \"0.5210432\",\n \"0.52040076\",\n \"0.5199631\",\n \"0.5189886\",\n \"0.5182676\",\n \"0.51806116\",\n \"0.51744986\",\n \"0.5172499\",\n \"0.51651204\",\n \"0.51619244\",\n \"0.51583695\",\n \"0.51529884\",\n \"0.5149466\",\n \"0.51466054\",\n \"0.5144873\",\n \"0.5144778\",\n \"0.51375735\",\n \"0.513177\",\n \"0.5129024\",\n \"0.51276875\",\n \"0.5126936\",\n \"0.5124686\",\n \"0.5122885\",\n \"0.51198334\",\n \"0.51174676\",\n \"0.51163787\",\n \"0.5107801\",\n \"0.5099166\",\n \"0.5095521\",\n \"0.50933456\",\n \"0.5083593\",\n \"0.508151\",\n \"0.50737023\",\n \"0.5069209\",\n \"0.50688976\",\n \"0.50683784\",\n \"0.50683784\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5643953"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":85190,"cells":{"query":{"kind":"string","value":"Test that the package provides customization_data that defines the function"},"document":{"kind":"string","value":"def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None"},"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 test_confirm_customization_details(self):\n pass","def pytest_funcarg__generate_golden_data(request):\r\n return request.config.option.generate_golden_data","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func","def test_function(self):\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"basic.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_function()\n\n expected = textwrap.dedent(\n '''\\\n def set_function_thing(value, another):\n \"\"\"Do something here.\"\"\"\n # Do something with these values\n # and more comment text, here.\n #\n if value:\n return 2\n\n # Another comment\n return 1'''\n )\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def test():\r\n\tassert calcolatrice.__author__ == \"help@castellanidavide.it\", \"sanity test failed\"\r\n\t#assert calcolatrice.<function>(<values>) == <the result(s) you would like to have>, \"<the fail message>\"\r","def test_datatransformationsetups_get(self):\n pass","def test_extra():\n return {\n 'conversion': functools.partial(\n conversion, is_train=False, is_extrapolation=True),\n }","def check_from_function(self):\n context = TestContext(session_context=ducktape_mock.session_context(),\n cls=DummyTest, function=DummyTest.test_function_description)\n assert context.description == \"function description\"","def test_contribute(self):\n pass","def test_function(self):\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"nested_folder\",\n \"another.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_nested_function()\n\n expected = textwrap.dedent(\n '''\\\n def set_function_thing(value, another):\n \"\"\"Do something here.\"\"\"\n # Do something with these values\n # and more comment text, here.\n #\n if value:\n return 2\n\n # Another comment\n return 1'''\n )\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def test(self,*args,**kwargs):\n print(\"[TEMPLATE ENGINE] 'testing' function not implemented\")\n pass","def test_meta_spec(self):\n spec = self.ci.meta_spec()\n self.assertIn('roc_data', spec)\n self.assertIsInstance(spec['roc_data'], lit_types.CurveDataPoints)\n self.assertIn('pr_data', spec)\n self.assertIsInstance(spec['pr_data'], lit_types.CurveDataPoints)","def test_prodcode_4(self):\n self.assertEqual(prodcode.functio(), \"production value\")","def c_test_mutate_function(self, function):\r\n return 1","def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)","def test_customization_template_crud():\n template_crud = pxe.CustomizationTemplate(\n name=generate_random_string(size=8),\n description=generate_random_string(size=16),\n image_type='RHEL-6',\n script_type='Kickstart',\n script_data='Testing the script')\n\n template_crud.create()\n with update(template_crud):\n template_crud.name = template_crud.name + \"_update\"\n template_crud.delete(cancel=False)","def test_RandomFunction_getter(self):\r\n self.assertEqual(self.cs_overview.RandomFunction, permutation)","def test_arguments(self):\n\n h.test_function_arguments(\n func=BaseTransformer.__init__,\n expected_arguments=[\"self\", \"columns\", \"copy\", \"verbose\"],\n expected_default_values=(None, True, False),\n )","def test(self):\n raise NotImplementedError","def test_func():\n pass","def test_function(eso_from_data:callable):\n print('Testing of eso_from_data with hardcoded data')\n # for context, relation, concepts_source in SEQUENCE:\n eso_from_data(0, 'site', 'contains', 'animal')","def test_process_data(self):\n pass","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def _test(self):","def runTest(self):\n super().runTest()\n self = funcs_utils.set_up(self)\n db_user = self.server[\"username\"]\n data = {\n \"acl\": [\n {\n \"grantee\": db_user,\n \"grantor\": db_user,\n \"privileges\":\n [\n {\n \"privilege_type\": \"X\",\n \"privilege\": True,\n \"with_grant\": True\n }\n ]\n }\n ],\n \"arguments\": [],\n \"funcowner\": db_user,\n \"lanname\": \"sql\",\n \"name\": \"test_function\",\n \"options\": [],\n \"proleakproof\": True,\n \"pronamespace\": 2200,\n \"prorettypename\": \"integer\",\n \"prosecdef\": True,\n \"prosrc\": \"SELECT 1;\",\n \"probin\": \"$libdir/\",\n \"provolatile\": \"s\",\n \"seclabels\": [],\n \"variables\": [{\n \"name\": \"search_path\",\n \"value\": \"public, pg_temp\"\n }]\n }\n\n data[\"name\"] = \"test_function_add_%s\" % str(uuid.uuid4())[1:8]\n if self.schema_id:\n data['pronamespace'] = self.schema_id\n else:\n self.schema_id = data['pronamespace']\n\n if self.server_version >= 120000:\n support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]\n funcs_utils.create_support_internal_function(\n self.server,\n self.db_name,\n self.schema_name,\n support_function_name\n )\n\n data['prosupportfuc'] = support_function_name\n\n if self.is_positive_test:\n response = self.create_function(data)\n else:\n if hasattr(self, 'is_mock_function'):\n def _get_sql(self, **kwargs):\n return False, ''\n with patch.object(FunctionView,\n self.mock_data[\"function_name\"],\n new=_get_sql):\n response = self.create_function(data)\n\n else:\n with patch(self.mock_data[\"function_name\"],\n return_value=eval(self.mock_data[\"return_value\"])):\n response = self.create_function(data)\n\n self.assertEqual(response.status_code,\n self.expected_data['status_code'])\n # Disconnect the database\n database_utils.disconnect_database(self, self.server_id, self.db_id)","def test_function(my_data):\n return my_data == 42","def test_schema():\n return 'test_schema'","def test_datatransformationsetups_post(self):\n pass","def test_something():","def test_function_callparams(self):\n\n @Configurable(conf=category('', Parameter('test', value=True)))\n def twist(test=None):\n return test\n\n value = twist()\n\n self.assertTrue(value)\n\n value = twist(False)\n\n self.assertFalse(value)\n\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\n\n value = twist()\n\n self.assertEqual(value, 1)","def setup_function(test_function):\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'symbol-list.dat',\n TEST_LOCATION + 'symbol-list.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model.dat',\n TEST_LOCATION + 'nn-model.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test.dat',\n TEST_LOCATION + 'nn-model_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test2.dat',\n TEST_LOCATION + 'nn-model_test2.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\n 'distance-tolerance_test.dat',\n TEST_LOCATION + 'distance-tolerance_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\n 'distance-tolerance_test2.dat',\n TEST_LOCATION + 'distance-tolerance_test2.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test.dat',\n TEST_LOCATION + 'training-set_test.dat')\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test2.dat',\n TEST_LOCATION + 'training-set_test2.dat')","def test_check_detail_code_returns_true():\n plugin_instance = PluginVipCustomisation()\n assert plugin_instance._check_detail_code('replace me with real xml') == True","def example_function():","def codegen_reload_data():\n return {\n \"package\": u\"fn_utilities\",\n \"message_destinations\": [u\"fn_utilities\"],\n \"functions\": [u\"utilities_artifact_hash\", u\"utilities_attachment_hash\", u\"utilities_attachment_to_base64\", u\"utilities_attachment_zip_extract\", u\"utilities_attachment_zip_list\", u\"utilities_base64_to_artifact\", u\"utilities_base64_to_attachment\", u\"utilities_call_rest_api\", u\"utilities_domain_distance\", u\"utilities_email_parse\", u\"utilities_excel_query\", u\"utilities_expand_url\", u\"utilities_extract_ssl_cert_from_url\", u\"utilities_get_contact_info\", u\"utilities_json2html\", u\"utilities_parse_ssl_certificate\", u\"utilities_pdfid\", u\"utilities_resilient_search\", u\"utilities_shell_command\", u\"utilities_string_to_attachment\", u\"utilities_timer\", u\"utilities_xml_transformation\"],\n \"workflows\": [u\"example_artifact_attachment_to_base64\", u\"example_artifact_hash\", u\"example_attachment_hash\", u\"example_attachment_to_base64\", u\"example_call_rest_api\", u\"example_create_artifacts_from_excel_data\", u\"example_domain_distance\", u\"example_email_parsing_artifact\", u\"example_email_parsing_attachment\", u\"example_extract_ssl_cert_from_url\", u\"example_get_incident_contact_info\", u\"example_get_task_contact_info\", u\"example_json2html\", u\"example_parse_ssl_certificate\", u\"example_pdfid\", u\"example_resilient_search\", u\"example_shell_command\", u\"example_string_to_attachment\", u\"example_timer\", u\"example_timer_parallel\", u\"example_xml_transformation\", u\"example_zip_list\", u\"example_zip_to_artifact\", u\"utilities_expand_url\"],\n \"actions\": [u\"Example: (Artifact) Attachment to Base64\", u\"Example: Artifact Hash\", u\"Example: Attachment Hash\", u\"Example: Attachment to Base64\", u\"Example: Call REST API\", u\"Example: Domain Distance\", u\"Example: Email Parsing (Artifact)\", u\"Example: Email Parsing (Attachment)\", u\"Example: Expand URL\", u\"Example: Extract SSL Certificate\", u\"Example: Get Incident Contact Info\", u\"Example: Get Task Contact Info\", u\"Example: JSON2HTML\", u\"Example: Parse SSL Certificate\", u\"Example: PDFiD\", u\"Example: Resilient Search\", u\"Example: Shell Command\", u\"Example: String to Attachment\", u\"Example: Timer Epoch\", u\"Example: Timers in Parallel\", u\"Example: Use Excel Data\", u\"Example: XML Transformation\", u\"Example: Zip Extract\", u\"Example: Zip List\"],\n \"incident_fields\": [],\n \"incident_artifact_types\": [],\n \"incident_types\": [],\n \"datatables\": [],\n \"automatic_tasks\": [],\n \"scripts\": [u\"Convert JSON to rich text v1.0\"],\n \"playbooks\": []\n }","def test_checkCustoms(self):\n self.failUnlessEqual(self.nice.opts['myflag'], \"PONY!\")\n self.failUnlessEqual(self.nice.opts['myparam'], \"Tofu WITH A PONY!\")","def test_data_in_param(self):","def test():\n pass","def test_methods_with_arguments(self):\n self.assertContains(self.response, \"<h3>Methods with arguments</h3>\")\n self.assertContains(self.response, \"<td>rename_company</td>\")\n self.assertContains(self.response, \"<td>dummy_function</td>\")\n self.assertContains(self.response, \"<td>suffix_company_name</td>\")","def dataproduct() -> None:\n pass","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # user_agent_string\n # Message Destinations:\n # useragentanalysis_fn\n # Functions:\n # fn_useragentanalysis\n # Workflows:\n # user_agent_workflow\n # Rules:\n # Example: User Agent Analysis\n\n\n yield ImportDefinition(u\"\"\"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\nMzk3MjUxNDN9\n\"\"\"\n )","def test_package(self):\n pass","def test_that_original_func_saved():\n\n assert callable(custom_sum.__original_func)","def test_doc():\n pass","def spec_tests():\n pass","def test_example(decorated_example):\n import visual_coding_2p_analysis","def test_alien_data(self):","def tests():","def unitary_test():","def test_data_object_vaporise(self):\n pass","def test_visualisations_get_visualisation_render_data(self):\n pass","def test():","def test():","def test_preprocessor(self, _get_page_preprocessor, _get_source_code_from_object):\n def _remove_comments_and_docstrings(node):\n for tag in node.find_all(\"span\", {\"class\": [\"c1\", \"sd\"]}):\n tag.decompose()\n\n _get_page_preprocessor.return_value = _remove_comments_and_docstrings\n _get_source_code_from_object.return_value = \"\"\n\n data = (\n os.path.join(\n _CURRENT_DIRECTORY,\n \"fake_project\",\n \"_modules\",\n \"fake_project\",\n \"basic.html\",\n ),\n \"set_function_thing\",\n )\n content = self._get_fake_project_function()\n\n expected = '''\\\ndef set_function_thing(value, another):\n \n \n \n \n if value:\n return 2\n\n \n return 1'''\n\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter","def pytest_generate_tests(metafunc):\n if \"maptype\" in metafunc.fixturenames:\n metafunc.parametrize(\"maptype\", ALL_ATTMAPS)","def test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def _test(self):\n pass","def test_mapper_func(data, schema):\n pass","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # execution_arn\n # lambda_function_name\n # lambda_payload\n # msg_body\n # phone_numbers\n # state_machine_async\n # state_machine_name\n # state_machine_payload\n # Message Destinations:\n # fn_aws_utilities\n # Functions:\n # fn_get_step_function_execution\n # fn_invoke_lambda\n # fn_invoke_step_function\n # fn_send_sms_via_sns\n # Workflows:\n # example_invoke_aws_lambda_python_addition\n # example_invoke_step_function_asynchronous\n # example_invoke_step_function_synchronous\n # example_send_sms_incident\n # Rules:\n # Example: Invoke AWS Lambda: Python Addition\n # Example: Invoke Step Function: Asynchronous\n # Example: Invoke Step Function: Synchronous\n # Example: Send SMS: Incident\n # Example: Send SMS: Incident [Menu Item]\n\n\n yield ImportDefinition(u\"\"\"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\nCg==\n\"\"\"\n )","def pytest_generate_tests(metafunc):\n if (\"solver\" in metafunc.fixturenames\n and \"coefficients\" in metafunc.fixturenames):\n _parametrize_solver_coefficients(metafunc)","def test_setup(funct):\n\n def decorated_setup():\n \"\"\"Decorated test setup.\"\"\"\n testdb.reload_db()\n funct()\n return decorated_setup","def test_arguments(self):\n\n h.test_function_arguments(\n func=ScalingTransformer.__init__,\n expected_arguments=[\"self\", \"columns\", \"scaler\", \"scaler_kwargs\"],\n expected_default_values=({},),\n )","def test_cont_larvaemutattion(): \n pass","def test_T01():","def template_for_test_functions():\r\n\r\n expected = \"\"\r\n actual = \"\"\r\n print_test_results(func, expected, actual)","def test_get_larvaemutation_function():\n \n f = get_larvaemutation_function('bin')\n assert 'function bin_larvaemutation' in str(f)\n f = get_larvaemutation_function('disc')\n assert 'function disc_larvaemutation' in str(f)","def before_test(self, func, *args, **kwargs):\n pass","def test_arguments(self):\n\n h.test_function_arguments(\n func=ScalingTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def test_function(arg_1):\n return arg_1 * 2","def before_call_used_args_add_description(self, args_values, code_reference, function_info, args_code):\n description = None\n if function_info == ('pandas.io.parsers', 'read_csv'):\n filename = args_values[0].split(os.path.sep)[-1]\n description = \"{}\".format(filename) # TODO: Add loaded columns as well\n elif function_info == ('pandas.core.frame', 'dropna'):\n description = \"dropna\"\n elif function_info == ('pandas.core.frame', '__getitem__'):\n # TODO: Can this also be a select?\n if isinstance(args_values, MlinspectSeries):\n self.code_reference_to_set_item_op[code_reference] = 'Selection'\n description = \"Select by series\" # TODO: prettier representation\n elif isinstance(args_values, str):\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\n key_arg = args_values\n description = \"to {}\".format([key_arg])\n elif isinstance(args_values, list):\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\n description = \"to {}\".format(args_values)\n elif function_info == ('pandas.core.frame', '__setitem__'):\n key_arg = args_values\n description = \"Sets columns {}\".format([key_arg])\n SetKeyInfo = namedtuple(\"SetKeyInfo\", [\"code_reference\", \"function_info\", \"args_code\"])\n self.set_key_info = SetKeyInfo(code_reference, function_info, args_code)\n elif function_info == ('pandas.core.frame', 'groupby'):\n description = \"Group by {}, \".format(args_values)\n self.code_reference_to_description[code_reference] = description\n if description:\n self.code_reference_to_description[code_reference] = description","def test_preprocessed_data(self):\n self.assertEqual(self.tester.preprocessed_data, [1, 2])","def test_extended(self, monkeypatch, script_runner):\n monkeypatch.setattr(\"builtins.input\", lambda _: \"n\")\n ret = script_runner.run(\n \"spectrafit\",\n \"spectrafit/test/test_data.txt\",\n \"-i\",\n \"spectrafit/test/test_input_2.json\",\n )\n assert ret.success\n assert ret.stderr == \"\"","def test_wraps():\n print('func')","def test_visualisations_get_visualisation(self):\n pass","def test_predictor():","def test_doc_fun(self):\n for fun in self.functions:\n self.assertTrue(len(fun.__doc__) > 0)","def testFunctionName(self):\n with self.assertRaises(AttributeError):\n Manager.Properties.Version.Set(get_object(TOP_OBJECT), {})","def test(self, dataset) -> None:\n raise NotImplementedError()","def test_visualize_recipe_taste(self):\n pass","def test_T1():","def test_T1():","def test_click_common_options(self) -> None:\n args = ['--debug', '--verbose']\n\n @click.command('test_func')\n @click_common_options\n def test_func(**kwargs: Dict[str, Any]) -> None:\n \"\"\"Function for testing options.\"\"\"\n click.echo(json.dumps(kwargs))\n\n result = json.loads(\n self.runner.invoke(test_func, args).output.replace('\\n', '')\n )\n\n self.assertEqual(result, {'debug': True, 'verbose': True})","def test(self) -> Any:\n pass","def test_load_from_function(self):\n self.test_table.load_from_function(create_small_test_odml)\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)","def test_arguments(self):\n\n h.test_function_arguments(\n func=BaseTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def test_base_opt_validate():\n opt = scheme._BaseOpt()\n with pytest.raises(NotImplementedError):\n opt.validate('foo', 'test-data')"],"string":"[\n \"def test_confirm_customization_details(self):\\n pass\",\n \"def pytest_funcarg__generate_golden_data(request):\\r\\n return request.config.option.generate_golden_data\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func\",\n \"def test_function(self):\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"basic.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_function()\\n\\n expected = textwrap.dedent(\\n '''\\\\\\n def set_function_thing(value, another):\\n \\\"\\\"\\\"Do something here.\\\"\\\"\\\"\\n # Do something with these values\\n # and more comment text, here.\\n #\\n if value:\\n return 2\\n\\n # Another comment\\n return 1'''\\n )\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def test():\\r\\n\\tassert calcolatrice.__author__ == \\\"help@castellanidavide.it\\\", \\\"sanity test failed\\\"\\r\\n\\t#assert calcolatrice.<function>(<values>) == <the result(s) you would like to have>, \\\"<the fail message>\\\"\\r\",\n \"def test_datatransformationsetups_get(self):\\n pass\",\n \"def test_extra():\\n return {\\n 'conversion': functools.partial(\\n conversion, is_train=False, is_extrapolation=True),\\n }\",\n \"def check_from_function(self):\\n context = TestContext(session_context=ducktape_mock.session_context(),\\n cls=DummyTest, function=DummyTest.test_function_description)\\n assert context.description == \\\"function description\\\"\",\n \"def test_contribute(self):\\n pass\",\n \"def test_function(self):\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"nested_folder\\\",\\n \\\"another.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_nested_function()\\n\\n expected = textwrap.dedent(\\n '''\\\\\\n def set_function_thing(value, another):\\n \\\"\\\"\\\"Do something here.\\\"\\\"\\\"\\n # Do something with these values\\n # and more comment text, here.\\n #\\n if value:\\n return 2\\n\\n # Another comment\\n return 1'''\\n )\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def test(self,*args,**kwargs):\\n print(\\\"[TEMPLATE ENGINE] 'testing' function not implemented\\\")\\n pass\",\n \"def test_meta_spec(self):\\n spec = self.ci.meta_spec()\\n self.assertIn('roc_data', spec)\\n self.assertIsInstance(spec['roc_data'], lit_types.CurveDataPoints)\\n self.assertIn('pr_data', spec)\\n self.assertIsInstance(spec['pr_data'], lit_types.CurveDataPoints)\",\n \"def test_prodcode_4(self):\\n self.assertEqual(prodcode.functio(), \\\"production value\\\")\",\n \"def c_test_mutate_function(self, function):\\r\\n return 1\",\n \"def test_customization_template_crud():\\n template_crud = pxe.CustomizationTemplate(\\n name=generate_random_string(size=8),\\n description=generate_random_string(size=16),\\n image_type='RHEL-6',\\n script_type='Kickstart',\\n script_data='Testing the script')\\n\\n template_crud.create()\\n with update(template_crud):\\n template_crud.name = template_crud.name + \\\"_update\\\"\\n template_crud.delete(cancel=False)\",\n \"def test_customization_template_crud():\\n template_crud = pxe.CustomizationTemplate(\\n name=generate_random_string(size=8),\\n description=generate_random_string(size=16),\\n image_type='RHEL-6',\\n script_type='Kickstart',\\n script_data='Testing the script')\\n\\n template_crud.create()\\n with update(template_crud):\\n template_crud.name = template_crud.name + \\\"_update\\\"\\n template_crud.delete(cancel=False)\",\n \"def test_RandomFunction_getter(self):\\r\\n self.assertEqual(self.cs_overview.RandomFunction, permutation)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=BaseTransformer.__init__,\\n expected_arguments=[\\\"self\\\", \\\"columns\\\", \\\"copy\\\", \\\"verbose\\\"],\\n expected_default_values=(None, True, False),\\n )\",\n \"def test(self):\\n raise NotImplementedError\",\n \"def test_func():\\n pass\",\n \"def test_function(eso_from_data:callable):\\n print('Testing of eso_from_data with hardcoded data')\\n # for context, relation, concepts_source in SEQUENCE:\\n eso_from_data(0, 'site', 'contains', 'animal')\",\n \"def test_process_data(self):\\n pass\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def _test(self):\",\n \"def runTest(self):\\n super().runTest()\\n self = funcs_utils.set_up(self)\\n db_user = self.server[\\\"username\\\"]\\n data = {\\n \\\"acl\\\": [\\n {\\n \\\"grantee\\\": db_user,\\n \\\"grantor\\\": db_user,\\n \\\"privileges\\\":\\n [\\n {\\n \\\"privilege_type\\\": \\\"X\\\",\\n \\\"privilege\\\": True,\\n \\\"with_grant\\\": True\\n }\\n ]\\n }\\n ],\\n \\\"arguments\\\": [],\\n \\\"funcowner\\\": db_user,\\n \\\"lanname\\\": \\\"sql\\\",\\n \\\"name\\\": \\\"test_function\\\",\\n \\\"options\\\": [],\\n \\\"proleakproof\\\": True,\\n \\\"pronamespace\\\": 2200,\\n \\\"prorettypename\\\": \\\"integer\\\",\\n \\\"prosecdef\\\": True,\\n \\\"prosrc\\\": \\\"SELECT 1;\\\",\\n \\\"probin\\\": \\\"$libdir/\\\",\\n \\\"provolatile\\\": \\\"s\\\",\\n \\\"seclabels\\\": [],\\n \\\"variables\\\": [{\\n \\\"name\\\": \\\"search_path\\\",\\n \\\"value\\\": \\\"public, pg_temp\\\"\\n }]\\n }\\n\\n data[\\\"name\\\"] = \\\"test_function_add_%s\\\" % str(uuid.uuid4())[1:8]\\n if self.schema_id:\\n data['pronamespace'] = self.schema_id\\n else:\\n self.schema_id = data['pronamespace']\\n\\n if self.server_version >= 120000:\\n support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]\\n funcs_utils.create_support_internal_function(\\n self.server,\\n self.db_name,\\n self.schema_name,\\n support_function_name\\n )\\n\\n data['prosupportfuc'] = support_function_name\\n\\n if self.is_positive_test:\\n response = self.create_function(data)\\n else:\\n if hasattr(self, 'is_mock_function'):\\n def _get_sql(self, **kwargs):\\n return False, ''\\n with patch.object(FunctionView,\\n self.mock_data[\\\"function_name\\\"],\\n new=_get_sql):\\n response = self.create_function(data)\\n\\n else:\\n with patch(self.mock_data[\\\"function_name\\\"],\\n return_value=eval(self.mock_data[\\\"return_value\\\"])):\\n response = self.create_function(data)\\n\\n self.assertEqual(response.status_code,\\n self.expected_data['status_code'])\\n # Disconnect the database\\n database_utils.disconnect_database(self, self.server_id, self.db_id)\",\n \"def test_function(my_data):\\n return my_data == 42\",\n \"def test_schema():\\n return 'test_schema'\",\n \"def test_datatransformationsetups_post(self):\\n pass\",\n \"def test_something():\",\n \"def test_function_callparams(self):\\n\\n @Configurable(conf=category('', Parameter('test', value=True)))\\n def twist(test=None):\\n return test\\n\\n value = twist()\\n\\n self.assertTrue(value)\\n\\n value = twist(False)\\n\\n self.assertFalse(value)\\n\\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\\n\\n value = twist()\\n\\n self.assertEqual(value, 1)\",\n \"def setup_function(test_function):\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'symbol-list.dat',\\n TEST_LOCATION + 'symbol-list.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model.dat',\\n TEST_LOCATION + 'nn-model.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test.dat',\\n TEST_LOCATION + 'nn-model_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'nn-model_test2.dat',\\n TEST_LOCATION + 'nn-model_test2.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\\n 'distance-tolerance_test.dat',\\n TEST_LOCATION + 'distance-tolerance_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER +\\n 'distance-tolerance_test2.dat',\\n TEST_LOCATION + 'distance-tolerance_test2.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test.dat',\\n TEST_LOCATION + 'training-set_test.dat')\\n shutil.copy2(TEST_LOCATION + PRE_TEST_FOLDER + 'training-set_test2.dat',\\n TEST_LOCATION + 'training-set_test2.dat')\",\n \"def test_check_detail_code_returns_true():\\n plugin_instance = PluginVipCustomisation()\\n assert plugin_instance._check_detail_code('replace me with real xml') == True\",\n \"def example_function():\",\n \"def codegen_reload_data():\\n return {\\n \\\"package\\\": u\\\"fn_utilities\\\",\\n \\\"message_destinations\\\": [u\\\"fn_utilities\\\"],\\n \\\"functions\\\": [u\\\"utilities_artifact_hash\\\", u\\\"utilities_attachment_hash\\\", u\\\"utilities_attachment_to_base64\\\", u\\\"utilities_attachment_zip_extract\\\", u\\\"utilities_attachment_zip_list\\\", u\\\"utilities_base64_to_artifact\\\", u\\\"utilities_base64_to_attachment\\\", u\\\"utilities_call_rest_api\\\", u\\\"utilities_domain_distance\\\", u\\\"utilities_email_parse\\\", u\\\"utilities_excel_query\\\", u\\\"utilities_expand_url\\\", u\\\"utilities_extract_ssl_cert_from_url\\\", u\\\"utilities_get_contact_info\\\", u\\\"utilities_json2html\\\", u\\\"utilities_parse_ssl_certificate\\\", u\\\"utilities_pdfid\\\", u\\\"utilities_resilient_search\\\", u\\\"utilities_shell_command\\\", u\\\"utilities_string_to_attachment\\\", u\\\"utilities_timer\\\", u\\\"utilities_xml_transformation\\\"],\\n \\\"workflows\\\": [u\\\"example_artifact_attachment_to_base64\\\", u\\\"example_artifact_hash\\\", u\\\"example_attachment_hash\\\", u\\\"example_attachment_to_base64\\\", u\\\"example_call_rest_api\\\", u\\\"example_create_artifacts_from_excel_data\\\", u\\\"example_domain_distance\\\", u\\\"example_email_parsing_artifact\\\", u\\\"example_email_parsing_attachment\\\", u\\\"example_extract_ssl_cert_from_url\\\", u\\\"example_get_incident_contact_info\\\", u\\\"example_get_task_contact_info\\\", u\\\"example_json2html\\\", u\\\"example_parse_ssl_certificate\\\", u\\\"example_pdfid\\\", u\\\"example_resilient_search\\\", u\\\"example_shell_command\\\", u\\\"example_string_to_attachment\\\", u\\\"example_timer\\\", u\\\"example_timer_parallel\\\", u\\\"example_xml_transformation\\\", u\\\"example_zip_list\\\", u\\\"example_zip_to_artifact\\\", u\\\"utilities_expand_url\\\"],\\n \\\"actions\\\": [u\\\"Example: (Artifact) Attachment to Base64\\\", u\\\"Example: Artifact Hash\\\", u\\\"Example: Attachment Hash\\\", u\\\"Example: Attachment to Base64\\\", u\\\"Example: Call REST API\\\", u\\\"Example: Domain Distance\\\", u\\\"Example: Email Parsing (Artifact)\\\", u\\\"Example: Email Parsing (Attachment)\\\", u\\\"Example: Expand URL\\\", u\\\"Example: Extract SSL Certificate\\\", u\\\"Example: Get Incident Contact Info\\\", u\\\"Example: Get Task Contact Info\\\", u\\\"Example: JSON2HTML\\\", u\\\"Example: Parse SSL Certificate\\\", u\\\"Example: PDFiD\\\", u\\\"Example: Resilient Search\\\", u\\\"Example: Shell Command\\\", u\\\"Example: String to Attachment\\\", u\\\"Example: Timer Epoch\\\", u\\\"Example: Timers in Parallel\\\", u\\\"Example: Use Excel Data\\\", u\\\"Example: XML Transformation\\\", u\\\"Example: Zip Extract\\\", u\\\"Example: Zip List\\\"],\\n \\\"incident_fields\\\": [],\\n \\\"incident_artifact_types\\\": [],\\n \\\"incident_types\\\": [],\\n \\\"datatables\\\": [],\\n \\\"automatic_tasks\\\": [],\\n \\\"scripts\\\": [u\\\"Convert JSON to rich text v1.0\\\"],\\n \\\"playbooks\\\": []\\n }\",\n \"def test_checkCustoms(self):\\n self.failUnlessEqual(self.nice.opts['myflag'], \\\"PONY!\\\")\\n self.failUnlessEqual(self.nice.opts['myparam'], \\\"Tofu WITH A PONY!\\\")\",\n \"def test_data_in_param(self):\",\n \"def test():\\n pass\",\n \"def test_methods_with_arguments(self):\\n self.assertContains(self.response, \\\"<h3>Methods with arguments</h3>\\\")\\n self.assertContains(self.response, \\\"<td>rename_company</td>\\\")\\n self.assertContains(self.response, \\\"<td>dummy_function</td>\\\")\\n self.assertContains(self.response, \\\"<td>suffix_company_name</td>\\\")\",\n \"def dataproduct() -> None:\\n pass\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # user_agent_string\\n # Message Destinations:\\n # useragentanalysis_fn\\n # Functions:\\n # fn_useragentanalysis\\n # Workflows:\\n # user_agent_workflow\\n # Rules:\\n # Example: User Agent Analysis\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nMzk3MjUxNDN9\\n\\\"\\\"\\\"\\n )\",\n \"def test_package(self):\\n pass\",\n \"def test_that_original_func_saved():\\n\\n assert callable(custom_sum.__original_func)\",\n \"def test_doc():\\n pass\",\n \"def spec_tests():\\n pass\",\n \"def test_example(decorated_example):\\n import visual_coding_2p_analysis\",\n \"def test_alien_data(self):\",\n \"def tests():\",\n \"def unitary_test():\",\n \"def test_data_object_vaporise(self):\\n pass\",\n \"def test_visualisations_get_visualisation_render_data(self):\\n pass\",\n \"def test():\",\n \"def test():\",\n \"def test_preprocessor(self, _get_page_preprocessor, _get_source_code_from_object):\\n def _remove_comments_and_docstrings(node):\\n for tag in node.find_all(\\\"span\\\", {\\\"class\\\": [\\\"c1\\\", \\\"sd\\\"]}):\\n tag.decompose()\\n\\n _get_page_preprocessor.return_value = _remove_comments_and_docstrings\\n _get_source_code_from_object.return_value = \\\"\\\"\\n\\n data = (\\n os.path.join(\\n _CURRENT_DIRECTORY,\\n \\\"fake_project\\\",\\n \\\"_modules\\\",\\n \\\"fake_project\\\",\\n \\\"basic.html\\\",\\n ),\\n \\\"set_function_thing\\\",\\n )\\n content = self._get_fake_project_function()\\n\\n expected = '''\\\\\\ndef set_function_thing(value, another):\\n \\n \\n \\n \\n if value:\\n return 2\\n\\n \\n return 1'''\\n\\n self._test(data, content, expected) # pylint: disable=no-value-for-parameter\",\n \"def pytest_generate_tests(metafunc):\\n if \\\"maptype\\\" in metafunc.fixturenames:\\n metafunc.parametrize(\\\"maptype\\\", ALL_ATTMAPS)\",\n \"def test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def _test(self):\\n pass\",\n \"def test_mapper_func(data, schema):\\n pass\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # execution_arn\\n # lambda_function_name\\n # lambda_payload\\n # msg_body\\n # phone_numbers\\n # state_machine_async\\n # state_machine_name\\n # state_machine_payload\\n # Message Destinations:\\n # fn_aws_utilities\\n # Functions:\\n # fn_get_step_function_execution\\n # fn_invoke_lambda\\n # fn_invoke_step_function\\n # fn_send_sms_via_sns\\n # Workflows:\\n # example_invoke_aws_lambda_python_addition\\n # example_invoke_step_function_asynchronous\\n # example_invoke_step_function_synchronous\\n # example_send_sms_incident\\n # Rules:\\n # Example: Invoke AWS Lambda: Python Addition\\n # Example: Invoke Step Function: Asynchronous\\n # Example: Invoke Step Function: Synchronous\\n # Example: Send SMS: Incident\\n # Example: Send SMS: Incident [Menu Item]\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nCg==\\n\\\"\\\"\\\"\\n )\",\n \"def pytest_generate_tests(metafunc):\\n if (\\\"solver\\\" in metafunc.fixturenames\\n and \\\"coefficients\\\" in metafunc.fixturenames):\\n _parametrize_solver_coefficients(metafunc)\",\n \"def test_setup(funct):\\n\\n def decorated_setup():\\n \\\"\\\"\\\"Decorated test setup.\\\"\\\"\\\"\\n testdb.reload_db()\\n funct()\\n return decorated_setup\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=ScalingTransformer.__init__,\\n expected_arguments=[\\\"self\\\", \\\"columns\\\", \\\"scaler\\\", \\\"scaler_kwargs\\\"],\\n expected_default_values=({},),\\n )\",\n \"def test_cont_larvaemutattion(): \\n pass\",\n \"def test_T01():\",\n \"def template_for_test_functions():\\r\\n\\r\\n expected = \\\"\\\"\\r\\n actual = \\\"\\\"\\r\\n print_test_results(func, expected, actual)\",\n \"def test_get_larvaemutation_function():\\n \\n f = get_larvaemutation_function('bin')\\n assert 'function bin_larvaemutation' in str(f)\\n f = get_larvaemutation_function('disc')\\n assert 'function disc_larvaemutation' in str(f)\",\n \"def before_test(self, func, *args, **kwargs):\\n pass\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=ScalingTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def test_function(arg_1):\\n return arg_1 * 2\",\n \"def before_call_used_args_add_description(self, args_values, code_reference, function_info, args_code):\\n description = None\\n if function_info == ('pandas.io.parsers', 'read_csv'):\\n filename = args_values[0].split(os.path.sep)[-1]\\n description = \\\"{}\\\".format(filename) # TODO: Add loaded columns as well\\n elif function_info == ('pandas.core.frame', 'dropna'):\\n description = \\\"dropna\\\"\\n elif function_info == ('pandas.core.frame', '__getitem__'):\\n # TODO: Can this also be a select?\\n if isinstance(args_values, MlinspectSeries):\\n self.code_reference_to_set_item_op[code_reference] = 'Selection'\\n description = \\\"Select by series\\\" # TODO: prettier representation\\n elif isinstance(args_values, str):\\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\\n key_arg = args_values\\n description = \\\"to {}\\\".format([key_arg])\\n elif isinstance(args_values, list):\\n self.code_reference_to_set_item_op[code_reference] = 'Projection'\\n description = \\\"to {}\\\".format(args_values)\\n elif function_info == ('pandas.core.frame', '__setitem__'):\\n key_arg = args_values\\n description = \\\"Sets columns {}\\\".format([key_arg])\\n SetKeyInfo = namedtuple(\\\"SetKeyInfo\\\", [\\\"code_reference\\\", \\\"function_info\\\", \\\"args_code\\\"])\\n self.set_key_info = SetKeyInfo(code_reference, function_info, args_code)\\n elif function_info == ('pandas.core.frame', 'groupby'):\\n description = \\\"Group by {}, \\\".format(args_values)\\n self.code_reference_to_description[code_reference] = description\\n if description:\\n self.code_reference_to_description[code_reference] = description\",\n \"def test_preprocessed_data(self):\\n self.assertEqual(self.tester.preprocessed_data, [1, 2])\",\n \"def test_extended(self, monkeypatch, script_runner):\\n monkeypatch.setattr(\\\"builtins.input\\\", lambda _: \\\"n\\\")\\n ret = script_runner.run(\\n \\\"spectrafit\\\",\\n \\\"spectrafit/test/test_data.txt\\\",\\n \\\"-i\\\",\\n \\\"spectrafit/test/test_input_2.json\\\",\\n )\\n assert ret.success\\n assert ret.stderr == \\\"\\\"\",\n \"def test_wraps():\\n print('func')\",\n \"def test_visualisations_get_visualisation(self):\\n pass\",\n \"def test_predictor():\",\n \"def test_doc_fun(self):\\n for fun in self.functions:\\n self.assertTrue(len(fun.__doc__) > 0)\",\n \"def testFunctionName(self):\\n with self.assertRaises(AttributeError):\\n Manager.Properties.Version.Set(get_object(TOP_OBJECT), {})\",\n \"def test(self, dataset) -> None:\\n raise NotImplementedError()\",\n \"def test_visualize_recipe_taste(self):\\n pass\",\n \"def test_T1():\",\n \"def test_T1():\",\n \"def test_click_common_options(self) -> None:\\n args = ['--debug', '--verbose']\\n\\n @click.command('test_func')\\n @click_common_options\\n def test_func(**kwargs: Dict[str, Any]) -> None:\\n \\\"\\\"\\\"Function for testing options.\\\"\\\"\\\"\\n click.echo(json.dumps(kwargs))\\n\\n result = json.loads(\\n self.runner.invoke(test_func, args).output.replace('\\\\n', '')\\n )\\n\\n self.assertEqual(result, {'debug': True, 'verbose': True})\",\n \"def test(self) -> Any:\\n pass\",\n \"def test_load_from_function(self):\\n self.test_table.load_from_function(create_small_test_odml)\\n self.assertEqual(self.test_table._odmldict, self.expected_odmldict)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=BaseTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def test_base_opt_validate():\\n opt = scheme._BaseOpt()\\n with pytest.raises(NotImplementedError):\\n opt.validate('foo', 'test-data')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6494149","0.62934417","0.62290233","0.62290233","0.60117173","0.5846331","0.57936054","0.5786965","0.5635037","0.56308526","0.5616144","0.5589976","0.5589475","0.55771124","0.55632764","0.55560976","0.55560976","0.55545074","0.55533385","0.5547361","0.5543377","0.5532135","0.55139357","0.5511307","0.5511307","0.5511307","0.5511307","0.5511307","0.55053586","0.5494615","0.5494497","0.5489223","0.54674715","0.54649305","0.5458733","0.54512227","0.5448855","0.54482","0.54376274","0.54259557","0.54153574","0.5414865","0.54120886","0.5409382","0.5403355","0.54027426","0.5398599","0.5393094","0.538076","0.5379329","0.5352565","0.534741","0.5343311","0.53406215","0.5334656","0.5334656","0.5331914","0.5314834","0.53067654","0.5306021","0.5306021","0.5306021","0.53035945","0.5296665","0.52910346","0.5279128","0.52761793","0.5276157","0.5274706","0.5272256","0.5271776","0.52655655","0.52612823","0.5258445","0.52480435","0.52475417","0.522465","0.52237034","0.52185","0.5206442","0.52041125","0.5203758","0.520372","0.52008206","0.5198753","0.5198753","0.5197282","0.51946944","0.51810217","0.51716983","0.5169671"],"string":"[\n \"0.6494149\",\n \"0.62934417\",\n \"0.62290233\",\n \"0.62290233\",\n \"0.60117173\",\n \"0.5846331\",\n \"0.57936054\",\n \"0.5786965\",\n \"0.5635037\",\n \"0.56308526\",\n \"0.5616144\",\n \"0.5589976\",\n \"0.5589475\",\n \"0.55771124\",\n \"0.55632764\",\n \"0.55560976\",\n \"0.55560976\",\n \"0.55545074\",\n \"0.55533385\",\n \"0.5547361\",\n \"0.5543377\",\n \"0.5532135\",\n \"0.55139357\",\n \"0.5511307\",\n \"0.5511307\",\n \"0.5511307\",\n \"0.5511307\",\n \"0.5511307\",\n \"0.55053586\",\n \"0.5494615\",\n \"0.5494497\",\n \"0.5489223\",\n \"0.54674715\",\n \"0.54649305\",\n \"0.5458733\",\n \"0.54512227\",\n \"0.5448855\",\n \"0.54482\",\n \"0.54376274\",\n \"0.54259557\",\n \"0.54153574\",\n \"0.5414865\",\n \"0.54120886\",\n \"0.5409382\",\n \"0.5403355\",\n \"0.54027426\",\n \"0.5398599\",\n \"0.5393094\",\n \"0.538076\",\n \"0.5379329\",\n \"0.5352565\",\n \"0.534741\",\n \"0.5343311\",\n \"0.53406215\",\n \"0.5334656\",\n \"0.5334656\",\n \"0.5331914\",\n \"0.5314834\",\n \"0.53067654\",\n \"0.5306021\",\n \"0.5306021\",\n \"0.5306021\",\n \"0.53035945\",\n \"0.5296665\",\n \"0.52910346\",\n \"0.5279128\",\n \"0.52761793\",\n \"0.5276157\",\n \"0.5274706\",\n \"0.5272256\",\n \"0.5271776\",\n \"0.52655655\",\n \"0.52612823\",\n \"0.5258445\",\n \"0.52480435\",\n \"0.52475417\",\n \"0.522465\",\n \"0.52237034\",\n \"0.52185\",\n \"0.5206442\",\n \"0.52041125\",\n \"0.5203758\",\n \"0.520372\",\n \"0.52008206\",\n \"0.5198753\",\n \"0.5198753\",\n \"0.5197282\",\n \"0.51946944\",\n \"0.51810217\",\n \"0.51716983\",\n \"0.5169671\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6025656"},"document_rank":{"kind":"string","value":"12"}}},{"rowIdx":85191,"cells":{"query":{"kind":"string","value":"Test calling with sample values for the parameters"},"document":{"kind":"string","value":"def test_success(self, worksheet, circuits_app, attachment_id, incident_id, task_id, excel_ranges,\n excel_defined_names, expected_results):\n function_params = {\n \"attachment_id\": attachment_id,\n \"excel_ranges\": excel_ranges,\n \"excel_defined_names\": excel_defined_names,\n \"incident_id\": incident_id,\n \"task_id\": task_id\n }\n # get the expected data\n res_path = os.path.join(os.path.dirname(__file__), expected_results)\n with open(res_path, 'r') as file:\n expected = file.read()\n # mock the worksheet processing data\n worksheet = worksheet.return_value\n worksheet.parse.return_value = None\n worksheet.result = expected\n results = call_utilities_excel_query_function(circuits_app, function_params)\n\n assert expected.replace(' ', '') == results.replace(' ', '')"},"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 __call__(self, params):\r\n return self.sample(params)","def sample(self, *args, **kwargs):","def test_function_callparams(self):\n\n @Configurable(conf=category('', Parameter('test', value=True)))\n def twist(test=None):\n return test\n\n value = twist()\n\n self.assertTrue(value)\n\n value = twist(False)\n\n self.assertFalse(value)\n\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\n\n value = twist()\n\n self.assertEqual(value, 1)","def sample(self):","def test_parameters(self):\n self.assert_initialize_driver()\n #reply = self.driver_client.cmd_dvr('get_resource', Parameter.ALL)\n #self.assert_driver_parameters(reply, verify_sample_interval=True)","def sample(self, x):","def test_data_in_param(self):","def test_sample(self):\n dist = self.many_samples([0, 0, 0, 1])\n self.assertEquals(3, dist.argMax())\n\n dist = self.many_samples([1, 0, 0, 0, 0])\n self.assertEquals(0, dist.argMax())\n\n dist = self.many_samples([0.5, 0, 0, 0.25, 0.25])\n self.assertAlmostEquals(dist[0], 0.5, delta=0.01)\n self.assertAlmostEquals(dist[3], 0.25, delta=0.01)\n self.assertAlmostEquals(dist[4], 0.25, delta=0.01)\n self.assertEquals(dist[1], 0)\n self.assertEquals(dist[2], 0)\n\n with self.assertRaises(AssertionError):\n diffp.sample([0.5, 0.5, 0.01])","def c_test_run_inp(self, temp_params, base_locals):\r\n return 1","def c_test_run_inp(self, temp_params, base_locals):\r\n return 1","def _sample_likelihood_params(self):\r\n self._sample_omega()\r\n self._sample_beta()\r\n self._sample_r()","def test_predictor():","def c_test_set_inp(self, param, value):\r\n ret = 1\r\n if \"__hash__\" not in dir(param): # param must be hashable\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is not hashable. It will be unable to be set in a dict.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is hashable.\")\r\n if param in [\"population_size\", \"time_constraint\", \"generations\", \"point_count\",\r\n \"PSO_VELOCITY_WEIGHT\", \"PSO_INDIVIDUAL_WEIGHT\", \"PSO_GROUP_WEIGHT\"]:\r\n if not ((isinstance(value, int) or\r\n isinstance(value, float) or\r\n isinstance(value, long))):\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be of a number. It is \" + str(value))\r\n ret = 0\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set to a number.\")\r\n if value < 0:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be greater than zero.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is greater than zero.\")\r\n if param in [\"population_size\", \"generations\", \"point_count\"]:\r\n if not isinstance(value, int):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be an integer. It is \" + str(value))\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is an integer.\")\r\n if param in [\"fitness_function\", \"weighting_bias\"]:\r\n if not callable(value):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be a callable function.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is a callable function.\")\r\n if param == \"end_condition\":\r\n if value not in [\"time_constraint\", \"generations\"]:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be 'time_constraint' or 'generations'\")\r\n else:\r\n if self.verbosity > 1:\r\n print(\"ERROR: \" + param + \" is a correct string.\")\r\n if param == \"seed\":\r\n if not (value is None or isinstance(value, int)):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is incorrectly set.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set.\")\r\n return ret","def test_get_measure_parameters(self):\n pass","def c_test_set_inp(self, param, value):\r\n ret = 1\r\n if \"__hash__\" not in dir(param): # param must be hashable\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is not hashable. It will be unable to be set in a dict.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is hashable.\")\r\n if param in [\"population_size\", \"time_constraint\", \"generations\", \"point_count\"]:\r\n if not ((isinstance(value, int) or\r\n isinstance(value, float) or\r\n isinstance(value, long))):\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be of a number. It is \" + str(value))\r\n ret = 0\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set to a number.\")\r\n if value < 0:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be greater than zero.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is greater than zero.\")\r\n if param in [\"population_size\", \"generations\", \"point_count\"]:\r\n if not isinstance(value, int):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be an integer. It is \" + str(value))\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is an integer.\")\r\n if param in [\"fitness_function\", \"population_function\",\r\n \"mutate_function\", \"cross_function\", \"weighting_bias\"]:\r\n if not callable(value):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be a callable function.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is a callable function.\")\r\n if param == \"end_condition\":\r\n if value not in [\"time_constraint\", \"generations\"]:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be 'time_constraint' or 'generations'\")\r\n else:\r\n if self.verbosity > 1:\r\n print(\"ERROR: \" + param + \" is a correct string.\")\r\n if param == \"seed\":\r\n if not (value is None or isinstance(value, int)):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is incorrectly set.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set.\")\r\n return ret","def prepare(params, samples):\r\n return","def sample(self, like_params):\n\t\traise NotImplementedError","def c_test_set_inp(self, param, value):\r\n ret = 1\r\n if \"__hash__\" not in dir(param): # param must be hashable\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is not hashable. It will be unable to be set in a dict.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is hashable.\")\r\n if param in [\"population_size\", \"time_constraint\", \"generations\"]:\r\n if not ((isinstance(value, int) or\r\n isinstance(value, float) or\r\n isinstance(value, long))):\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be of a number. It is \" + str(value))\r\n ret = 0\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set to a number.\")\r\n if value < 0:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be greater than zero.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is greater than zero.\")\r\n if param in [\"population_size\", \"generations\"]:\r\n if not isinstance(value, int):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be an integer. It is \" + str(value))\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is an integer.\")\r\n if param in [\"fitness_function\", \"population_function\",\r\n \"mutate_function\", \"cross_function\", \"weighting_bias\"]:\r\n if not callable(value):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be a callable function.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is a callable function.\")\r\n if param == \"end_condition\":\r\n if value not in [\"time_constraint\", \"generations\"]:\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" needs to be 'time_constraint' or 'generations'\")\r\n else:\r\n if self.verbosity > 1:\r\n print(\"ERROR: \" + param + \" is a correct string.\")\r\n if param == \"seed\":\r\n if not (value is None or isinstance(value, int)):\r\n ret = 0\r\n if self.verbosity > 0:\r\n print(\"ERROR: \" + param + \" is incorrectly set.\")\r\n else:\r\n if self.verbosity > 1:\r\n print(param + \" is correctly set.\")\r\n return ret","def test_call(self):\r\n exp = {'method_name': 'BEST',\r\n 'rho_vals': [\r\n (0.75, '8'),\r\n (0.5, '1,11'),\r\n (0.5107142857142857, '1,8,11'),\r\n (0.47857142857142854, '1,6,8,11'),\r\n (0.46071428571428574, '1,5,6,8,9'),\r\n (0.4357142857142857, '1,5,6,8,9,11'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10'),\r\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10,11'),\r\n (0.16785714285714282, '1,2,3,4,5,6,7,8,9,10,11')],\r\n 'num_vars': 11,\r\n 'vars': ['TOT_ORG_CARB = 1', 'SILT_CLAY = 2',\r\n 'ELEVATION = 3', 'SOIL_MOISTURE_DEFICIT = 4',\r\n 'CARB_NITRO_RATIO = 5', 'ANNUAL_SEASON_TEMP = 6',\r\n 'ANNUAL_SEASON_PRECPT = 7', 'PH = 8',\r\n 'CMIN_RATE = 9', 'LONGITUDE = 10',\r\n 'LATITUDE = 11']}\r\n\r\n # the difference caused by the new spearmans_rho function is in the\r\n # final decimal place of the rho_vals. its not a significant difference,\r\n # but the test is failing because we are doing a dict comparison for\r\n # float values.\r\n obs = self.best()\r\n self.assertEqual(exp['method_name'], obs['method_name'])\r\n self.assertEqual(exp['num_vars'], obs['num_vars'])\r\n self.assertEqual(exp['vars'], obs['vars'])\r\n for i, j in zip(exp['rho_vals'], obs['rho_vals']):\r\n assert_almost_equal(i[0], j[0])\r\n self.assertEqual(i[1], j[1])\r\n # check that the keys are the same since we have checked all the values\r\n # we expect to be there are the same\r\n self.assertTrue(set(exp.keys()) == set(obs.keys()))","def test_call(self, MetricClass, seed):\n m = MetricClass()\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\n result0 = np.array(m.result(strategy)) # from `result` method\n result1 = np.array(m(strategy)) # from __call__\n assert np.equal(result0, result1).all()","def test_singleLine(self):\n self.performTestForParams()","def sample_function(self, a, b):\r\n return a + b","def test_suite():\r\n test(intercept(1, 6, 3, 12) == 3.0)\r\n test(intercept(6, 1, 1, 6) == 7.0)\r\n test(intercept(4, 6, 12, 8) == 5.0)","def sample_refine(self, **kwargs):","def test_SMEB_args():\n testing_function('sme_bl', bilinear=True)","def sample_survey(self, **kwargs):","def test_compatible_data(cps_subsample, puf_subsample,\n allparams, reform_xx,\n tc_objs, allparams_batch):\n # pylint: disable=too-many-arguments,too-many-locals\n # pylint: disable=too-many-statements,too-many-branches\n\n # Check NPARAMS value\n assert NPARAMS == len(allparams)\n\n # Get taxcalc objects from tc_objs fixture\n rec_xx, c_xx, puftest = tc_objs\n\n # These parameters are exempt because they are not active under\n # current law and activating them would deactivate other parameters,\n # or if it is difficult to devise a test for them.\n exempt_from_testing = [\n 'CG_ec', 'CG_reinvest_ec_rt',\n 'II_prt', 'ID_prt', 'ID_crt',\n 'CR_SchR_hc', 'ACTC_ChildNum'\n ]\n\n # Loop through the parameters in allparams_batch\n errmsg = 'ERROR: {} {}\\n'\n errors = ''\n for pname in allparams_batch:\n param = allparams_batch[pname]\n max_listed = param['valid_values']['max']\n # handle links to other params or self\n if isinstance(max_listed, str):\n if isinstance(allparams[max_listed]['value'][0], list):\n max_val = allparams[max_listed]['value'][0]\n else:\n max_val = float(allparams[max_listed]['value'][0])\n else:\n if isinstance(param['value'][0], list):\n max_val = [max_listed] * len(param['value'][0])\n else:\n max_val = max_listed\n min_listed = param['valid_values']['min']\n if isinstance(min_listed, str):\n if isinstance(allparams[min_listed]['value'][0], list):\n min_val = allparams[min_listed]['value'][0]\n else:\n min_val = float(allparams[min_listed]['value'][0])\n else:\n if isinstance(param['value'][0], list):\n min_val = [min_listed] * len(param['value'][0])\n else:\n min_val = min_listed\n # create reform dictionaries\n max_reform = copy.deepcopy(reform_xx)\n min_reform = copy.deepcopy(reform_xx)\n max_reform[XX_YEAR][str(pname)] = [max_val]\n min_reform[XX_YEAR][str(pname)] = [min_val]\n # assess whether max reform changes results\n if puftest:\n rec_yy = Records(data=puf_subsample)\n else:\n rec_yy = Records.cps_constructor(data=cps_subsample)\n p_yy = Policy()\n p_yy.implement_reform(max_reform, raise_errors=False)\n c_yy = Calculator(policy=p_yy, records=rec_yy, verbose=False)\n c_yy.advance_to_year(TEST_YEAR)\n c_yy.calc_all()\n if pname.startswith('BEN') and pname.endswith('_repeal'):\n max_reform_change = (\n c_yy.weighted_total('benefit_cost_total') -\n c_xx.weighted_total('benefit_cost_total')\n )\n else:\n max_reform_change = (\n c_yy.weighted_total('combined') -\n c_xx.weighted_total('combined')\n )\n min_reform_change = 0\n # assess whether min reform changes results, if max reform did not\n if max_reform_change == 0:\n p_yy = Policy()\n p_yy.implement_reform(min_reform, raise_errors=False)\n c_yy = Calculator(policy=p_yy, records=rec_xx)\n c_yy.advance_to_year(TEST_YEAR)\n c_yy.calc_all()\n if pname.startswith('BEN') and pname.endswith('_repeal'):\n min_reform_change = (\n c_yy.weighted_total('benefit_cost_total') -\n c_xx.weighted_total('benefit_cost_total')\n )\n else:\n min_reform_change = (\n c_yy.weighted_total('combined') -\n c_xx.weighted_total('combined')\n )\n if min_reform_change == 0 and pname not in exempt_from_testing:\n if puftest:\n if param['compatible_data']['puf'] is True:\n errors += errmsg.format(pname, 'is not True for puf')\n else:\n if param['compatible_data']['cps'] is True:\n errors += errmsg.format(pname, 'is not True for cps')\n if max_reform_change != 0 or min_reform_change != 0:\n if puftest:\n if param['compatible_data']['puf'] is False:\n errors += errmsg.format(pname, 'is not False for puf')\n else:\n if param['compatible_data']['cps'] is False:\n errors += errmsg.format(pname, 'is not False for cps')\n # test failure if any errors\n if errors:\n print(errors)\n assert 'compatible_data' == 'invalid'","def test_call(self):\r\n x = self.FWP({'x': 3})\r\n self.assertEqual(x(), 3)","def test_sample(self):\n ## You don't *have* to declare a doc string, but it's good\n ## practice.\n\n ## Here we're making a \"sample_call()\", passing self.token as\n ## the authentication token. For available calls and the\n ## order of arguments, check out ksapi.py. The return value\n ## will be an httplib.HTTPResponse object with additional\n ## 'body' (str) and 'obj' (dict) attributes. If a status code\n ## greater than or equal to 400 is returned from the other\n ## end, an exception will be raised; the response will be\n ## attached to the 'response' attribute of the exception, and\n ## the status will be on the 'status' attribute of the\n ## exception. Note that redirects are followed.\n resp = self.ks.sample_call(self.token, 'argument 1', 'argument 2')\n\n # Verify that resp is correct\n util.assert_equal(resp.status, 200)\n util.assert_in('sample', resp.obj)\n ## Place your various assertions about the response here.\n\n ## Rinse, lather, repeat. You should perform only a single\n ## test per test method, but if you're doing creation tests,\n ## it makes sense to include the deletion test in the same\n ## test method. Remember, the only control you have over test\n ## ordering is by setting up dependencies (@dtest.depends()).\n ## No return value is necessary.","def test_run_sim_1():\n rnd = rand.Arrivals(36, 41)\n sim.run_sim(3, 2, 5, 6, 22, rnd)","def param_vals_test(param_dict):\n file_msg = param_dict['Prog_msg']\n ##\n ## Testing if `wget` exists in the system\n if is_tool('wget'):\n pass\n else:\n msg = '{0} You need to have `wget` installed in your system to run '\n msg += 'this script. You can download the entire dataset at {1}.\\n\\t\\t'\n msg += 'Exiting....'\n msg = msg.format(file_msg, param_dict['url_catl'])\n raise ValueError(msg)\n ##\n ## Checking that Esmeralda is not ran when doing 'SO' halos\n if (param_dict['halotype'] == 'so') and (param_dict['sample'] == 20):\n msg = '{0} The `halotype`==`so` and `sample`==`20` are no compatible '\n msg += 'input parameters.\\n\\t\\t'\n msg += 'Exiting...'\n msg = msg.format(file_msg)\n raise ValueError(msg)\n ##\n ## Checking that `hod_model_n` is set to zero for FoF-Halos\n if (param_dict['halotype'] == 'fof') and (param_dict['hod_n'] != 0):\n msg = '{0} The `halotype`==`{1}` and `hod_n`==`{2}` are no compatible '\n msg += 'input parameters.\\n\\t\\t'\n msg += 'Exiting...'\n msg = msg.format( file_msg,\n param_dict['halotype'],\n param_dict['hod_n'])\n raise ValueError(msg)\n ##\n ## Checking input different types of `test_train_opt`\n #\n # `sample_frac`\n if (param_dict['test_train_opt'] == 'sample_frac'):\n # `sample_frac`\n if not ((param_dict['sample_frac'] > 0) and\n (param_dict['sample_frac'] <= 1.)):\n msg = '{0} `sample_frac` ({1}) must be between (0,1]'.format(\n file_msg, param_dict['sample_frac'])\n raise ValueError(msg)\n # `test_size`\n if not ((param_dict['test_size'] > 0) and\n (param_dict['test_size'] < 1)):\n msg = '{0} `test_size` ({1}) must be between (0,1)'.format(\n file_msg, param_dict['test_size'])\n raise ValueError(msg)\n #\n # boxes_n\n if (param_dict['test_train_opt'] == 'boxes_n'):\n box_n_arr = num.array(param_dict['box_idx'].split('_')).astype(int)\n box_n_diff = num.diff(box_n_arr)\n # Larger than zero\n if not (all(box_n_arr >= 0)):\n msg = '{0} All values in `box_idx` ({1}) must be larger than 0!'\n msg = msg.format(file_msg, box_n_arr)\n raise ValueError(msg)\n # Difference between elements\n if not (all(box_n_diff > 0)):\n msg = '{0} The value of `box_idx` ({1}) is not valid!'.format(\n file_msg, param_dict['box_idx'])\n raise ValueError(msg)\n #\n # `box_test`\n if (param_dict['test_train_opt'] == 'box_sample_frac'):\n # Value of `box_test`\n if not (param_dict['box_test'] >= 0):\n msg = '{0} `box_test` ({1}) must be larger or equal to `0`.'\n msg = msg.format(file_msg, param_dict['box_test'])\n raise ValueError(msg)\n # Testing `test_size`\n # `test_size`\n if not ((param_dict['test_size'] > 0) and\n (param_dict['test_size'] < 1)):\n msg = '{0} `test_size` ({1}) must be between (0,1)'.format(\n file_msg, param_dict['test_size'])\n raise ValueError(msg)\n ##\n ## Checking that `kf_splits` is larger than `2`\n if (param_dict['kf_splits'] < 2):\n msg = '{0} The value for `kf_splits` ({1}) must be LARGER than `2`'\n msg += 'Exiting...'\n msg = msg.format(param_dict['Prog_msg'], param_dict['kf_splits'])\n raise ValueError(msg)\n ##\n ## Checking that `n_predict` is not smaller than `1`.\n if (param_dict['n_predict'] < 1):\n msg = '{0} The value for `n_predict` ({1}) must be LARGER than `1`'\n msg += 'Exiting...'\n msg = msg.format(param_dict['Prog_msg'], param_dict['n_predict'])\n raise ValueError(msg)","def test_sample(system_generator):\n\n name, test = system_generator()\n print(name)\n\n w_F, w_R, N_k = test.sample([10, 8], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([1, 1], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([10, 0], mode=\"wFwR\")\n w_F, w_R, N_k = test.sample([0, 5], mode=\"wFwR\")","def test_call_default_params(self):\r\n\r\n exp = {'0': ('R27DLI_4812', 'CTGGGCCGTATCTC'),\r\n 'ref1': ('ref1', 'GGGGGGGAAAAAAAAAAAAA'),\r\n '2': ('W3Cecum_4858', 'TTGGGCCGTGTCTCAGT'),\r\n 'ref0': ('ref0', 'CCCAAAAAAATTTTTT'),\r\n }\r\n app = ReferenceRepSetPicker(params={'Algorithm': 'first',\r\n 'ChoiceF': first_id})\r\n obs = app(self.tmp_seq_filepath,\r\n self.tmp_otu_filepath,\r\n self.ref_seq_filepath)\r\n self.assertEqual(obs, exp)","def test(self, x={}, **kwargs):\n return 0","def test_call(self):\r\n self.assertEqual(self.single_dms(), {})\r\n self.assertEqual(self.single_dms(10), {})\r\n self.assertEqual(self.single_dms(0), {})","def sample(self):\r\n raise NotImplementedError","def test_SMEL_args():\n testing_function('sme', bilinear=False)","def test_independent_parameter(self, mocker):\r\n spy = mocker.spy(qml.gradients.finite_difference, \"generate_shifted_tapes\")\r\n\r\n with qml.tape.JacobianTape() as tape:\r\n qml.RX(0.543, wires=[0])\r\n qml.RY(-0.654, wires=[1])\r\n qml.expval(qml.PauliZ(0))\r\n\r\n dev = qml.device(\"default.qubit\", wires=2)\r\n tapes, fn = finite_diff(tape)\r\n res = fn(dev.batch_execute(tapes))\r\n assert res.shape == (1, 2)\r\n\r\n assert len(spy.call_args_list) == 1\r\n\r\n # only called for parameter 0\r\n assert spy.call_args[0][0:2] == (tape, 0)","def test_twoLines(self):\n self.performTestForParams()","def test_basic_execution(self):","def test_call(self):\r\n self.assertEqual(self.cs_overview(), {})\r\n self.assertEqual(self.cs_overview(10), {})","def test_call_na_samples(self):\r\n est = Chao1MultinomialPointEstimator(asarray([4, 3, 4, 5]))\r\n obs = est(42)\r\n self.assertEqual(obs, (None, None, None, None))","def test_calls(self):\n ex = self.ex\n m = self.m\n n = self.n\n\n nreps = random.randint(1, 10)\n ex.nreps = nreps\n ex.vary[\"X\"][\"with\"].add(\"rep\")\n ex.infer_lds()\n\n cmds = ex.generate_cmds()\n\n idx = random.randint(0, nreps - 1)\n self.assertIn([\"name\", m, n, \"X_%d\" % idx, m, \"Y\", m, \"Z\", n], cmds)","def __call__(self, example):\n return self.test(example)","def test_getSampleCount(self):\r\n self.assertEqual(self.estimator1.getSampleCount(), 1)","def test_get_run(self):\n pass","def test_run_sim():\n rnd = rand.Arrivals(31, 40)\n sim.run_sim(2, 1, 3, 4, 24, rnd)","def test_function(arg_1):\n return arg_1 * 2","def runtest(self):","def c_test_run_inp(self, temp_params, base_locals):\r\n ret = 1\r\n for key, val in temp_params.items():\r\n ret = ret and self.c_test_set_inp(key, val)\r\n return ret","def sample(self, state, model_args, model_kwargs):\n raise NotImplementedError","def sample(self, num_samples, **kwargs):\n pass","def getTestResults():","def test_call_default_params(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp = {'0': 'R27DLI_4812',\r\n '1': 'U1PLI_7889',\r\n '2': 'W3Cecum_4858',\r\n '3': 'R27DLI_3243',\r\n }\r\n app = GenericRepSetPicker(params={'Algorithm': 'first',\r\n 'ChoiceF': first_id})\r\n obs = app(self.tmp_seq_filepath, self.tmp_otu_filepath)\r\n self.assertEqual(obs, exp)","def test_call(make_runner: Callable[..., TargetFunctionRunner]) -> None:\n runner = make_runner(target_dummy)\n config = runner._scenario.configspace.get_default_configuration()\n\n SEED = 2345\n status, cost, _, _ = runner.run(config=config, instance=None, seed=SEED, budget=None)\n\n assert cost == SEED\n assert status == StatusType.SUCCESS","def test_class_callparams(self):\n\n @Configurable(\n conf=[\n Parameter('test0', value=True),\n Parameter('test1', value=False)\n ]\n )\n class Test(object):\n\n def __init__(self, test0=None):\n\n super(Test, self).__init__()\n\n self.test0 = test0\n\n test = Test()\n\n self.assertTrue(test.test0)\n self.assertFalse(test.test1)","def test_threeLines(self):\n self.performTestForParams()","def test_vargs(self):","def run_sample(self):\n # there will be validation failures for sample data\n self.validate_req(ignore_failure=True)\n runner_fn = self.model_runner.execute_model_for_sample_data\n return self.do_handle_request(runner_fn)","def test_arguments(self):\n\n h.test_function_arguments(\n func=ScalingTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def test(self, dataset):\n\n outputs, errors = self.use(dataset)\n\n ## PUT CODE HERE ##\n # I put the code in the \"use\" function, seems better :-)\n\n return outputs, errors","def test_T01():","def evaluate_samples(self, samples, eval_key=None, missing=None):\n pass","def __call__(self, sample, random_state=None):\n raise NotImplementedError","def test_with_explicit_sample_args(self):\n test_dict = CliArgs('sample', ['-a', '26', '-s', 'somefile', '-n', '-u', 'foo', '-v']).__dict__\n self.assertEqual('foo', test_dict['user'])\n self.assertEqual(1, test_dict['verbosity'])\n self.assertEqual('26', test_dict['analyzer_profile'])","def test_call_alt_params(self):\r\n otu_picker = BlastOtuPicker({'max_e_value': 1e-30})\r\n expected = {}\r\n actual = otu_picker(self.seqs_fp,\r\n refseqs_fp=self.reference_seqs_fp)\r\n self.assertEqual(actual, expected)\r\n\r\n self.otu_picker = BlastOtuPicker(\r\n {'max_e_value': 1e-3, 'Similarity': 0.90})\r\n expected_90 = {'ref1': ['s3', 's2', 's1'],\r\n 'ref2': ['s4'],\r\n 'ref3': ['s5'],\r\n 'ref4': ['s6']}\r\n actual = self.otu_picker(self.seqs_fp,\r\n refseqs_fp=self.reference_seqs_fp)\r\n self.assertEqual(actual, expected_90)","def test_call_default_params(self):\r\n\r\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\r\n\r\n exp = {0: ['cdhit_test_seqs_0'],\r\n 1: ['cdhit_test_seqs_1'],\r\n 2: ['cdhit_test_seqs_2'],\r\n 3: ['cdhit_test_seqs_3'],\r\n 4: ['cdhit_test_seqs_4'],\r\n 5: ['cdhit_test_seqs_5'],\r\n 6: ['cdhit_test_seqs_6'],\r\n 7: ['cdhit_test_seqs_7'],\r\n 8: ['cdhit_test_seqs_8'],\r\n 9: ['cdhit_test_seqs_9']}\r\n\r\n app = CdHitOtuPicker(params={})\r\n obs = app(self.tmp_seq_filepath1)\r\n self.assertEqual(obs, exp)","def sample(self, num, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def test():","def test():","def sample(self, context: Context) -> T:\n ...","def test_get(self):\n obs = self.tester.get('1.SKM7.640188')\n exp = PrepSample('1.SKM7.640188', self.tester)\n self.assertEqual(obs, exp)","def test_callPrice(self):\n call_price1 = calculator.BlackScholes.call_price(**self.params_1)\n call_price2 = calculator.BlackScholes.call_price(**self.params_2)\n self.assertAlmostEqual(call_price1,10.45,delta=0.01)\n self.assertAlmostEqual(call_price2,7.965,delta=0.01)","def test_task_params(self, task_mock):\n from sosbeacon.event.message import get_student_broadcast_task\n\n student_key = Mock()\n student_key.urlsafe.return_value = \"ASTUDENTKEY\"\n\n event_key = Mock()\n event_key.urlsafe.return_value = \"ANEVENTKEY\"\n\n message_key = Mock()\n message_key.urlsafe.return_value = \"SOMEMESSAGEKEY\"\n\n batch_id = \"THEBATCHID\"\n\n get_student_broadcast_task(\n student_key, event_key, message_key, batch_id)\n\n check_params = {\n 'student': 'ASTUDENTKEY',\n 'event': 'ANEVENTKEY',\n 'message': 'SOMEMESSAGEKEY',\n 'batch': 'THEBATCHID',\n }\n self.assertEqual(check_params, task_mock.call_args[1]['params'])","def test_make_request_parameters(self, m_requests, m_sleep):\r\n request = testing.DummyRequest({mut.URL_KEY: SAMPLE_URL, \r\n mut.PARAMETERS_KEY: json.dumps(SAMPLE_PARAMETERS)})\r\n m_response, response_dict = self.mock_response()\r\n m_requests.get.return_value = m_response\r\n self.assertEqual(response_dict, mut.make_request(request))\r\n m_requests.get.assert_called_with(url=SAMPLE_URL, \r\n params=SAMPLE_PARAMETERS)\r\n m_sleep.assert_called_with(mut.SECURITY_SLEEP)","def test_asdf_from_call():\n config_file = t_path(\n Path('steps') / 'jwst_generic_pars-makeliststep_0001.asdf'\n )\n results = MakeListStep.call(config_file=config_file)\n\n assert results == DEFAULT_RESULT","def sample(self):\n raise NotImplementedError(\"Override me!\")","def test_call(self):\r\n\r\n expected = {'ref1': ['s3', 's2', 's1'],\r\n 'ref2': ['s4']}\r\n actual = self.otu_picker(self.seqs_fp,\r\n refseqs_fp=self.reference_seqs_pr_fp)\r\n self.assertEqual(actual, expected)","def Check(self, parameters):","def test_foo(self):\n self.ran = True\n 1 / 0","def test__call__(self):\n kwargs = dict(\n name='b',\n type=int,\n converter=dummy_converter,\n validator=dummy_validator,\n metadata={'meta': 'data'},\n )\n vark = VarKeyword()(**kwargs)\n name, fparam = self.assert_mapping_and_get_fparam(vark)\n assert isinstance(fparam, FParameter)\n assert name == kwargs['name']\n assert immutable.asdict(fparam) == dict(\n FPARAM_VKW_DEFAULTS,\n **kwargs,\n interface_name=kwargs['name'],\n )","def test_suite():\r\n test(slope(5, 3, 4, 2) == 1.0)\r\n test(slope(1, 2, 3, 2) == 0.0)\r\n test(slope(1, 2, 3, 3) == 0.5)\r\n test(slope(2, 4, 1, 2) == 2.0)","def test_0():\n sync.gen_multi_fake_data()#default is only one randomly selected data set\n sync.main(testing=True)","async def test_successful_samples(self):\n self.set_source_parameter(\"test_result\", [\"success\"])\n response = await self.collect(get_request_json_return_value=self.JMETER_JSON)\n self.assert_measurement(response, value=\"242\", entities=[])","def test_name_and_value_arguments(self):\n mock_call = Call(\"some_name\", 1024, 3.1415, \"hello\")\n assert_that(str(mock_call), equal_to(\"Call(some_name, 1024, 3.1415, hello)\"))","def test_getSampleCount(self):\r\n self.assertEqual(self.res1.getSampleCount(), 0)\r\n\r\n self.res1.addSample('S1', 42)\r\n self.assertEqual(self.res1.getSampleCount(), 1)\r\n\r\n self.res1.addSample('S2', 43)\r\n self.assertEqual(self.res1.getSampleCount(), 2)","def test_arguments(self):\n\n h.test_function_arguments(\n func=BaseTransformer.fit,\n expected_arguments=[\"self\", \"X\", \"y\"],\n expected_default_values=(None,),\n )","def inner_test(param: dict):\n pass","def __call__(self, samples_number):\n self.sampler.sample(samples_number)","def sample(self):\n # This method is set in __init__.\n pass","def test_basiccall(self):\n ex = self.ex\n i = self.i\n\n sig = (\"name\", \"char*\", \"int*\", \"double*\", \"double*\")\n ex.call = BasicCall(sig, \"N\", 100, 1.5, [10000])\n cmds = ex.generate_cmds()\n self.assertIn([\"name\", \"N\", 100, 1.5, [10000]], cmds)\n\n # now with a range\n lenrange = random.randint(1, 10)\n ex.range = [i, range(lenrange)]\n ex.call = BasicCall(sig, \"N\", i - 1, 1.5, [i * i])\n cmds = ex.generate_cmds()\n idx = random.randint(0, lenrange - 1)\n self.assertIn([\"name\", \"N\", idx - 1, 1.5, [idx * idx]], cmds)","def inner_test(param: int):\n pass","def inner_test(param: int):\n pass","def inner_test(param: int):\n pass","def test_call(self):\r\n expected = {0: ['s2'],\r\n 1: ['s3', 's4', 's1'],\r\n 2: ['s7'],\r\n 3: ['s6', 's5']}\r\n actual = self.otu_picker(self.small_seq_path)\r\n self.assertEqual(actual, expected)","def __call__(self, parameter_values, random_state=None):\n self.train_model(parameter_values, random_state=random_state)\n log_dict = self.simulate(random_state)\n return log_dict","def test_1sample(self):\r\n c = AlphaDiversityCalc(observed_otus)\r\n self.assertEqual(c(data_path=self.single_sample_otu_table_fp), [2])","def sample(self):\n raise NotImplementedError","def sample(self):\n raise NotImplementedError","def test_function(arg):\n return arg * 2","def test_run_a_scan_on_sdp_subarray_in_low():"],"string":"[\n \"def __call__(self, params):\\r\\n return self.sample(params)\",\n \"def sample(self, *args, **kwargs):\",\n \"def test_function_callparams(self):\\n\\n @Configurable(conf=category('', Parameter('test', value=True)))\\n def twist(test=None):\\n return test\\n\\n value = twist()\\n\\n self.assertTrue(value)\\n\\n value = twist(False)\\n\\n self.assertFalse(value)\\n\\n Configurable.get_annotations(twist)[0].conf['']['test'].value = 1\\n\\n value = twist()\\n\\n self.assertEqual(value, 1)\",\n \"def sample(self):\",\n \"def test_parameters(self):\\n self.assert_initialize_driver()\\n #reply = self.driver_client.cmd_dvr('get_resource', Parameter.ALL)\\n #self.assert_driver_parameters(reply, verify_sample_interval=True)\",\n \"def sample(self, x):\",\n \"def test_data_in_param(self):\",\n \"def test_sample(self):\\n dist = self.many_samples([0, 0, 0, 1])\\n self.assertEquals(3, dist.argMax())\\n\\n dist = self.many_samples([1, 0, 0, 0, 0])\\n self.assertEquals(0, dist.argMax())\\n\\n dist = self.many_samples([0.5, 0, 0, 0.25, 0.25])\\n self.assertAlmostEquals(dist[0], 0.5, delta=0.01)\\n self.assertAlmostEquals(dist[3], 0.25, delta=0.01)\\n self.assertAlmostEquals(dist[4], 0.25, delta=0.01)\\n self.assertEquals(dist[1], 0)\\n self.assertEquals(dist[2], 0)\\n\\n with self.assertRaises(AssertionError):\\n diffp.sample([0.5, 0.5, 0.01])\",\n \"def c_test_run_inp(self, temp_params, base_locals):\\r\\n return 1\",\n \"def c_test_run_inp(self, temp_params, base_locals):\\r\\n return 1\",\n \"def _sample_likelihood_params(self):\\r\\n self._sample_omega()\\r\\n self._sample_beta()\\r\\n self._sample_r()\",\n \"def test_predictor():\",\n \"def c_test_set_inp(self, param, value):\\r\\n ret = 1\\r\\n if \\\"__hash__\\\" not in dir(param): # param must be hashable\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is not hashable. It will be unable to be set in a dict.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is hashable.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"time_constraint\\\", \\\"generations\\\", \\\"point_count\\\",\\r\\n \\\"PSO_VELOCITY_WEIGHT\\\", \\\"PSO_INDIVIDUAL_WEIGHT\\\", \\\"PSO_GROUP_WEIGHT\\\"]:\\r\\n if not ((isinstance(value, int) or\\r\\n isinstance(value, float) or\\r\\n isinstance(value, long))):\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def test_get_measure_parameters(self):\\n pass\",\n \"def c_test_set_inp(self, param, value):\\r\\n ret = 1\\r\\n if \\\"__hash__\\\" not in dir(param): # param must be hashable\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is not hashable. It will be unable to be set in a dict.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is hashable.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"time_constraint\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not ((isinstance(value, int) or\\r\\n isinstance(value, float) or\\r\\n isinstance(value, long))):\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\", \\\"point_count\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"population_function\\\",\\r\\n \\\"mutate_function\\\", \\\"cross_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def prepare(params, samples):\\r\\n return\",\n \"def sample(self, like_params):\\n\\t\\traise NotImplementedError\",\n \"def c_test_set_inp(self, param, value):\\r\\n ret = 1\\r\\n if \\\"__hash__\\\" not in dir(param): # param must be hashable\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is not hashable. It will be unable to be set in a dict.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is hashable.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n if not ((isinstance(value, int) or\\r\\n isinstance(value, float) or\\r\\n isinstance(value, long))):\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be of a number. It is \\\" + str(value))\\r\\n ret = 0\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set to a number.\\\")\\r\\n if value < 0:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be greater than zero.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is greater than zero.\\\")\\r\\n if param in [\\\"population_size\\\", \\\"generations\\\"]:\\r\\n if not isinstance(value, int):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be an integer. It is \\\" + str(value))\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is an integer.\\\")\\r\\n if param in [\\\"fitness_function\\\", \\\"population_function\\\",\\r\\n \\\"mutate_function\\\", \\\"cross_function\\\", \\\"weighting_bias\\\"]:\\r\\n if not callable(value):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be a callable function.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is a callable function.\\\")\\r\\n if param == \\\"end_condition\\\":\\r\\n if value not in [\\\"time_constraint\\\", \\\"generations\\\"]:\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" needs to be 'time_constraint' or 'generations'\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is a correct string.\\\")\\r\\n if param == \\\"seed\\\":\\r\\n if not (value is None or isinstance(value, int)):\\r\\n ret = 0\\r\\n if self.verbosity > 0:\\r\\n print(\\\"ERROR: \\\" + param + \\\" is incorrectly set.\\\")\\r\\n else:\\r\\n if self.verbosity > 1:\\r\\n print(param + \\\" is correctly set.\\\")\\r\\n return ret\",\n \"def test_call(self):\\r\\n exp = {'method_name': 'BEST',\\r\\n 'rho_vals': [\\r\\n (0.75, '8'),\\r\\n (0.5, '1,11'),\\r\\n (0.5107142857142857, '1,8,11'),\\r\\n (0.47857142857142854, '1,6,8,11'),\\r\\n (0.46071428571428574, '1,5,6,8,9'),\\r\\n (0.4357142857142857, '1,5,6,8,9,11'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10'),\\r\\n (0.38928571428571423, '1,2,4,5,6,7,8,9,10,11'),\\r\\n (0.16785714285714282, '1,2,3,4,5,6,7,8,9,10,11')],\\r\\n 'num_vars': 11,\\r\\n 'vars': ['TOT_ORG_CARB = 1', 'SILT_CLAY = 2',\\r\\n 'ELEVATION = 3', 'SOIL_MOISTURE_DEFICIT = 4',\\r\\n 'CARB_NITRO_RATIO = 5', 'ANNUAL_SEASON_TEMP = 6',\\r\\n 'ANNUAL_SEASON_PRECPT = 7', 'PH = 8',\\r\\n 'CMIN_RATE = 9', 'LONGITUDE = 10',\\r\\n 'LATITUDE = 11']}\\r\\n\\r\\n # the difference caused by the new spearmans_rho function is in the\\r\\n # final decimal place of the rho_vals. its not a significant difference,\\r\\n # but the test is failing because we are doing a dict comparison for\\r\\n # float values.\\r\\n obs = self.best()\\r\\n self.assertEqual(exp['method_name'], obs['method_name'])\\r\\n self.assertEqual(exp['num_vars'], obs['num_vars'])\\r\\n self.assertEqual(exp['vars'], obs['vars'])\\r\\n for i, j in zip(exp['rho_vals'], obs['rho_vals']):\\r\\n assert_almost_equal(i[0], j[0])\\r\\n self.assertEqual(i[1], j[1])\\r\\n # check that the keys are the same since we have checked all the values\\r\\n # we expect to be there are the same\\r\\n self.assertTrue(set(exp.keys()) == set(obs.keys()))\",\n \"def test_call(self, MetricClass, seed):\\n m = MetricClass()\\n strategy = RandomTrader(seed=seed).run(make_randomwalk(seed=seed))\\n result0 = np.array(m.result(strategy)) # from `result` method\\n result1 = np.array(m(strategy)) # from __call__\\n assert np.equal(result0, result1).all()\",\n \"def test_singleLine(self):\\n self.performTestForParams()\",\n \"def sample_function(self, a, b):\\r\\n return a + b\",\n \"def test_suite():\\r\\n test(intercept(1, 6, 3, 12) == 3.0)\\r\\n test(intercept(6, 1, 1, 6) == 7.0)\\r\\n test(intercept(4, 6, 12, 8) == 5.0)\",\n \"def sample_refine(self, **kwargs):\",\n \"def test_SMEB_args():\\n testing_function('sme_bl', bilinear=True)\",\n \"def sample_survey(self, **kwargs):\",\n \"def test_compatible_data(cps_subsample, puf_subsample,\\n allparams, reform_xx,\\n tc_objs, allparams_batch):\\n # pylint: disable=too-many-arguments,too-many-locals\\n # pylint: disable=too-many-statements,too-many-branches\\n\\n # Check NPARAMS value\\n assert NPARAMS == len(allparams)\\n\\n # Get taxcalc objects from tc_objs fixture\\n rec_xx, c_xx, puftest = tc_objs\\n\\n # These parameters are exempt because they are not active under\\n # current law and activating them would deactivate other parameters,\\n # or if it is difficult to devise a test for them.\\n exempt_from_testing = [\\n 'CG_ec', 'CG_reinvest_ec_rt',\\n 'II_prt', 'ID_prt', 'ID_crt',\\n 'CR_SchR_hc', 'ACTC_ChildNum'\\n ]\\n\\n # Loop through the parameters in allparams_batch\\n errmsg = 'ERROR: {} {}\\\\n'\\n errors = ''\\n for pname in allparams_batch:\\n param = allparams_batch[pname]\\n max_listed = param['valid_values']['max']\\n # handle links to other params or self\\n if isinstance(max_listed, str):\\n if isinstance(allparams[max_listed]['value'][0], list):\\n max_val = allparams[max_listed]['value'][0]\\n else:\\n max_val = float(allparams[max_listed]['value'][0])\\n else:\\n if isinstance(param['value'][0], list):\\n max_val = [max_listed] * len(param['value'][0])\\n else:\\n max_val = max_listed\\n min_listed = param['valid_values']['min']\\n if isinstance(min_listed, str):\\n if isinstance(allparams[min_listed]['value'][0], list):\\n min_val = allparams[min_listed]['value'][0]\\n else:\\n min_val = float(allparams[min_listed]['value'][0])\\n else:\\n if isinstance(param['value'][0], list):\\n min_val = [min_listed] * len(param['value'][0])\\n else:\\n min_val = min_listed\\n # create reform dictionaries\\n max_reform = copy.deepcopy(reform_xx)\\n min_reform = copy.deepcopy(reform_xx)\\n max_reform[XX_YEAR][str(pname)] = [max_val]\\n min_reform[XX_YEAR][str(pname)] = [min_val]\\n # assess whether max reform changes results\\n if puftest:\\n rec_yy = Records(data=puf_subsample)\\n else:\\n rec_yy = Records.cps_constructor(data=cps_subsample)\\n p_yy = Policy()\\n p_yy.implement_reform(max_reform, raise_errors=False)\\n c_yy = Calculator(policy=p_yy, records=rec_yy, verbose=False)\\n c_yy.advance_to_year(TEST_YEAR)\\n c_yy.calc_all()\\n if pname.startswith('BEN') and pname.endswith('_repeal'):\\n max_reform_change = (\\n c_yy.weighted_total('benefit_cost_total') -\\n c_xx.weighted_total('benefit_cost_total')\\n )\\n else:\\n max_reform_change = (\\n c_yy.weighted_total('combined') -\\n c_xx.weighted_total('combined')\\n )\\n min_reform_change = 0\\n # assess whether min reform changes results, if max reform did not\\n if max_reform_change == 0:\\n p_yy = Policy()\\n p_yy.implement_reform(min_reform, raise_errors=False)\\n c_yy = Calculator(policy=p_yy, records=rec_xx)\\n c_yy.advance_to_year(TEST_YEAR)\\n c_yy.calc_all()\\n if pname.startswith('BEN') and pname.endswith('_repeal'):\\n min_reform_change = (\\n c_yy.weighted_total('benefit_cost_total') -\\n c_xx.weighted_total('benefit_cost_total')\\n )\\n else:\\n min_reform_change = (\\n c_yy.weighted_total('combined') -\\n c_xx.weighted_total('combined')\\n )\\n if min_reform_change == 0 and pname not in exempt_from_testing:\\n if puftest:\\n if param['compatible_data']['puf'] is True:\\n errors += errmsg.format(pname, 'is not True for puf')\\n else:\\n if param['compatible_data']['cps'] is True:\\n errors += errmsg.format(pname, 'is not True for cps')\\n if max_reform_change != 0 or min_reform_change != 0:\\n if puftest:\\n if param['compatible_data']['puf'] is False:\\n errors += errmsg.format(pname, 'is not False for puf')\\n else:\\n if param['compatible_data']['cps'] is False:\\n errors += errmsg.format(pname, 'is not False for cps')\\n # test failure if any errors\\n if errors:\\n print(errors)\\n assert 'compatible_data' == 'invalid'\",\n \"def test_call(self):\\r\\n x = self.FWP({'x': 3})\\r\\n self.assertEqual(x(), 3)\",\n \"def test_sample(self):\\n ## You don't *have* to declare a doc string, but it's good\\n ## practice.\\n\\n ## Here we're making a \\\"sample_call()\\\", passing self.token as\\n ## the authentication token. For available calls and the\\n ## order of arguments, check out ksapi.py. The return value\\n ## will be an httplib.HTTPResponse object with additional\\n ## 'body' (str) and 'obj' (dict) attributes. If a status code\\n ## greater than or equal to 400 is returned from the other\\n ## end, an exception will be raised; the response will be\\n ## attached to the 'response' attribute of the exception, and\\n ## the status will be on the 'status' attribute of the\\n ## exception. Note that redirects are followed.\\n resp = self.ks.sample_call(self.token, 'argument 1', 'argument 2')\\n\\n # Verify that resp is correct\\n util.assert_equal(resp.status, 200)\\n util.assert_in('sample', resp.obj)\\n ## Place your various assertions about the response here.\\n\\n ## Rinse, lather, repeat. You should perform only a single\\n ## test per test method, but if you're doing creation tests,\\n ## it makes sense to include the deletion test in the same\\n ## test method. Remember, the only control you have over test\\n ## ordering is by setting up dependencies (@dtest.depends()).\\n ## No return value is necessary.\",\n \"def test_run_sim_1():\\n rnd = rand.Arrivals(36, 41)\\n sim.run_sim(3, 2, 5, 6, 22, rnd)\",\n \"def param_vals_test(param_dict):\\n file_msg = param_dict['Prog_msg']\\n ##\\n ## Testing if `wget` exists in the system\\n if is_tool('wget'):\\n pass\\n else:\\n msg = '{0} You need to have `wget` installed in your system to run '\\n msg += 'this script. You can download the entire dataset at {1}.\\\\n\\\\t\\\\t'\\n msg += 'Exiting....'\\n msg = msg.format(file_msg, param_dict['url_catl'])\\n raise ValueError(msg)\\n ##\\n ## Checking that Esmeralda is not ran when doing 'SO' halos\\n if (param_dict['halotype'] == 'so') and (param_dict['sample'] == 20):\\n msg = '{0} The `halotype`==`so` and `sample`==`20` are no compatible '\\n msg += 'input parameters.\\\\n\\\\t\\\\t'\\n msg += 'Exiting...'\\n msg = msg.format(file_msg)\\n raise ValueError(msg)\\n ##\\n ## Checking that `hod_model_n` is set to zero for FoF-Halos\\n if (param_dict['halotype'] == 'fof') and (param_dict['hod_n'] != 0):\\n msg = '{0} The `halotype`==`{1}` and `hod_n`==`{2}` are no compatible '\\n msg += 'input parameters.\\\\n\\\\t\\\\t'\\n msg += 'Exiting...'\\n msg = msg.format( file_msg,\\n param_dict['halotype'],\\n param_dict['hod_n'])\\n raise ValueError(msg)\\n ##\\n ## Checking input different types of `test_train_opt`\\n #\\n # `sample_frac`\\n if (param_dict['test_train_opt'] == 'sample_frac'):\\n # `sample_frac`\\n if not ((param_dict['sample_frac'] > 0) and\\n (param_dict['sample_frac'] <= 1.)):\\n msg = '{0} `sample_frac` ({1}) must be between (0,1]'.format(\\n file_msg, param_dict['sample_frac'])\\n raise ValueError(msg)\\n # `test_size`\\n if not ((param_dict['test_size'] > 0) and\\n (param_dict['test_size'] < 1)):\\n msg = '{0} `test_size` ({1}) must be between (0,1)'.format(\\n file_msg, param_dict['test_size'])\\n raise ValueError(msg)\\n #\\n # boxes_n\\n if (param_dict['test_train_opt'] == 'boxes_n'):\\n box_n_arr = num.array(param_dict['box_idx'].split('_')).astype(int)\\n box_n_diff = num.diff(box_n_arr)\\n # Larger than zero\\n if not (all(box_n_arr >= 0)):\\n msg = '{0} All values in `box_idx` ({1}) must be larger than 0!'\\n msg = msg.format(file_msg, box_n_arr)\\n raise ValueError(msg)\\n # Difference between elements\\n if not (all(box_n_diff > 0)):\\n msg = '{0} The value of `box_idx` ({1}) is not valid!'.format(\\n file_msg, param_dict['box_idx'])\\n raise ValueError(msg)\\n #\\n # `box_test`\\n if (param_dict['test_train_opt'] == 'box_sample_frac'):\\n # Value of `box_test`\\n if not (param_dict['box_test'] >= 0):\\n msg = '{0} `box_test` ({1}) must be larger or equal to `0`.'\\n msg = msg.format(file_msg, param_dict['box_test'])\\n raise ValueError(msg)\\n # Testing `test_size`\\n # `test_size`\\n if not ((param_dict['test_size'] > 0) and\\n (param_dict['test_size'] < 1)):\\n msg = '{0} `test_size` ({1}) must be between (0,1)'.format(\\n file_msg, param_dict['test_size'])\\n raise ValueError(msg)\\n ##\\n ## Checking that `kf_splits` is larger than `2`\\n if (param_dict['kf_splits'] < 2):\\n msg = '{0} The value for `kf_splits` ({1}) must be LARGER than `2`'\\n msg += 'Exiting...'\\n msg = msg.format(param_dict['Prog_msg'], param_dict['kf_splits'])\\n raise ValueError(msg)\\n ##\\n ## Checking that `n_predict` is not smaller than `1`.\\n if (param_dict['n_predict'] < 1):\\n msg = '{0} The value for `n_predict` ({1}) must be LARGER than `1`'\\n msg += 'Exiting...'\\n msg = msg.format(param_dict['Prog_msg'], param_dict['n_predict'])\\n raise ValueError(msg)\",\n \"def test_sample(system_generator):\\n\\n name, test = system_generator()\\n print(name)\\n\\n w_F, w_R, N_k = test.sample([10, 8], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([1, 1], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([10, 0], mode=\\\"wFwR\\\")\\n w_F, w_R, N_k = test.sample([0, 5], mode=\\\"wFwR\\\")\",\n \"def test_call_default_params(self):\\r\\n\\r\\n exp = {'0': ('R27DLI_4812', 'CTGGGCCGTATCTC'),\\r\\n 'ref1': ('ref1', 'GGGGGGGAAAAAAAAAAAAA'),\\r\\n '2': ('W3Cecum_4858', 'TTGGGCCGTGTCTCAGT'),\\r\\n 'ref0': ('ref0', 'CCCAAAAAAATTTTTT'),\\r\\n }\\r\\n app = ReferenceRepSetPicker(params={'Algorithm': 'first',\\r\\n 'ChoiceF': first_id})\\r\\n obs = app(self.tmp_seq_filepath,\\r\\n self.tmp_otu_filepath,\\r\\n self.ref_seq_filepath)\\r\\n self.assertEqual(obs, exp)\",\n \"def test(self, x={}, **kwargs):\\n return 0\",\n \"def test_call(self):\\r\\n self.assertEqual(self.single_dms(), {})\\r\\n self.assertEqual(self.single_dms(10), {})\\r\\n self.assertEqual(self.single_dms(0), {})\",\n \"def sample(self):\\r\\n raise NotImplementedError\",\n \"def test_SMEL_args():\\n testing_function('sme', bilinear=False)\",\n \"def test_independent_parameter(self, mocker):\\r\\n spy = mocker.spy(qml.gradients.finite_difference, \\\"generate_shifted_tapes\\\")\\r\\n\\r\\n with qml.tape.JacobianTape() as tape:\\r\\n qml.RX(0.543, wires=[0])\\r\\n qml.RY(-0.654, wires=[1])\\r\\n qml.expval(qml.PauliZ(0))\\r\\n\\r\\n dev = qml.device(\\\"default.qubit\\\", wires=2)\\r\\n tapes, fn = finite_diff(tape)\\r\\n res = fn(dev.batch_execute(tapes))\\r\\n assert res.shape == (1, 2)\\r\\n\\r\\n assert len(spy.call_args_list) == 1\\r\\n\\r\\n # only called for parameter 0\\r\\n assert spy.call_args[0][0:2] == (tape, 0)\",\n \"def test_twoLines(self):\\n self.performTestForParams()\",\n \"def test_basic_execution(self):\",\n \"def test_call(self):\\r\\n self.assertEqual(self.cs_overview(), {})\\r\\n self.assertEqual(self.cs_overview(10), {})\",\n \"def test_call_na_samples(self):\\r\\n est = Chao1MultinomialPointEstimator(asarray([4, 3, 4, 5]))\\r\\n obs = est(42)\\r\\n self.assertEqual(obs, (None, None, None, None))\",\n \"def test_calls(self):\\n ex = self.ex\\n m = self.m\\n n = self.n\\n\\n nreps = random.randint(1, 10)\\n ex.nreps = nreps\\n ex.vary[\\\"X\\\"][\\\"with\\\"].add(\\\"rep\\\")\\n ex.infer_lds()\\n\\n cmds = ex.generate_cmds()\\n\\n idx = random.randint(0, nreps - 1)\\n self.assertIn([\\\"name\\\", m, n, \\\"X_%d\\\" % idx, m, \\\"Y\\\", m, \\\"Z\\\", n], cmds)\",\n \"def __call__(self, example):\\n return self.test(example)\",\n \"def test_getSampleCount(self):\\r\\n self.assertEqual(self.estimator1.getSampleCount(), 1)\",\n \"def test_get_run(self):\\n pass\",\n \"def test_run_sim():\\n rnd = rand.Arrivals(31, 40)\\n sim.run_sim(2, 1, 3, 4, 24, rnd)\",\n \"def test_function(arg_1):\\n return arg_1 * 2\",\n \"def runtest(self):\",\n \"def c_test_run_inp(self, temp_params, base_locals):\\r\\n ret = 1\\r\\n for key, val in temp_params.items():\\r\\n ret = ret and self.c_test_set_inp(key, val)\\r\\n return ret\",\n \"def sample(self, state, model_args, model_kwargs):\\n raise NotImplementedError\",\n \"def sample(self, num_samples, **kwargs):\\n pass\",\n \"def getTestResults():\",\n \"def test_call_default_params(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp = {'0': 'R27DLI_4812',\\r\\n '1': 'U1PLI_7889',\\r\\n '2': 'W3Cecum_4858',\\r\\n '3': 'R27DLI_3243',\\r\\n }\\r\\n app = GenericRepSetPicker(params={'Algorithm': 'first',\\r\\n 'ChoiceF': first_id})\\r\\n obs = app(self.tmp_seq_filepath, self.tmp_otu_filepath)\\r\\n self.assertEqual(obs, exp)\",\n \"def test_call(make_runner: Callable[..., TargetFunctionRunner]) -> None:\\n runner = make_runner(target_dummy)\\n config = runner._scenario.configspace.get_default_configuration()\\n\\n SEED = 2345\\n status, cost, _, _ = runner.run(config=config, instance=None, seed=SEED, budget=None)\\n\\n assert cost == SEED\\n assert status == StatusType.SUCCESS\",\n \"def test_class_callparams(self):\\n\\n @Configurable(\\n conf=[\\n Parameter('test0', value=True),\\n Parameter('test1', value=False)\\n ]\\n )\\n class Test(object):\\n\\n def __init__(self, test0=None):\\n\\n super(Test, self).__init__()\\n\\n self.test0 = test0\\n\\n test = Test()\\n\\n self.assertTrue(test.test0)\\n self.assertFalse(test.test1)\",\n \"def test_threeLines(self):\\n self.performTestForParams()\",\n \"def test_vargs(self):\",\n \"def run_sample(self):\\n # there will be validation failures for sample data\\n self.validate_req(ignore_failure=True)\\n runner_fn = self.model_runner.execute_model_for_sample_data\\n return self.do_handle_request(runner_fn)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=ScalingTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def test(self, dataset):\\n\\n outputs, errors = self.use(dataset)\\n\\n ## PUT CODE HERE ##\\n # I put the code in the \\\"use\\\" function, seems better :-)\\n\\n return outputs, errors\",\n \"def test_T01():\",\n \"def evaluate_samples(self, samples, eval_key=None, missing=None):\\n pass\",\n \"def __call__(self, sample, random_state=None):\\n raise NotImplementedError\",\n \"def test_with_explicit_sample_args(self):\\n test_dict = CliArgs('sample', ['-a', '26', '-s', 'somefile', '-n', '-u', 'foo', '-v']).__dict__\\n self.assertEqual('foo', test_dict['user'])\\n self.assertEqual(1, test_dict['verbosity'])\\n self.assertEqual('26', test_dict['analyzer_profile'])\",\n \"def test_call_alt_params(self):\\r\\n otu_picker = BlastOtuPicker({'max_e_value': 1e-30})\\r\\n expected = {}\\r\\n actual = otu_picker(self.seqs_fp,\\r\\n refseqs_fp=self.reference_seqs_fp)\\r\\n self.assertEqual(actual, expected)\\r\\n\\r\\n self.otu_picker = BlastOtuPicker(\\r\\n {'max_e_value': 1e-3, 'Similarity': 0.90})\\r\\n expected_90 = {'ref1': ['s3', 's2', 's1'],\\r\\n 'ref2': ['s4'],\\r\\n 'ref3': ['s5'],\\r\\n 'ref4': ['s6']}\\r\\n actual = self.otu_picker(self.seqs_fp,\\r\\n refseqs_fp=self.reference_seqs_fp)\\r\\n self.assertEqual(actual, expected_90)\",\n \"def test_call_default_params(self):\\r\\n\\r\\n # adapted from test_app.test_cd_hit.test_cdhit_clusters_from_seqs\\r\\n\\r\\n exp = {0: ['cdhit_test_seqs_0'],\\r\\n 1: ['cdhit_test_seqs_1'],\\r\\n 2: ['cdhit_test_seqs_2'],\\r\\n 3: ['cdhit_test_seqs_3'],\\r\\n 4: ['cdhit_test_seqs_4'],\\r\\n 5: ['cdhit_test_seqs_5'],\\r\\n 6: ['cdhit_test_seqs_6'],\\r\\n 7: ['cdhit_test_seqs_7'],\\r\\n 8: ['cdhit_test_seqs_8'],\\r\\n 9: ['cdhit_test_seqs_9']}\\r\\n\\r\\n app = CdHitOtuPicker(params={})\\r\\n obs = app(self.tmp_seq_filepath1)\\r\\n self.assertEqual(obs, exp)\",\n \"def sample(self, num, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def test():\",\n \"def test():\",\n \"def sample(self, context: Context) -> T:\\n ...\",\n \"def test_get(self):\\n obs = self.tester.get('1.SKM7.640188')\\n exp = PrepSample('1.SKM7.640188', self.tester)\\n self.assertEqual(obs, exp)\",\n \"def test_callPrice(self):\\n call_price1 = calculator.BlackScholes.call_price(**self.params_1)\\n call_price2 = calculator.BlackScholes.call_price(**self.params_2)\\n self.assertAlmostEqual(call_price1,10.45,delta=0.01)\\n self.assertAlmostEqual(call_price2,7.965,delta=0.01)\",\n \"def test_task_params(self, task_mock):\\n from sosbeacon.event.message import get_student_broadcast_task\\n\\n student_key = Mock()\\n student_key.urlsafe.return_value = \\\"ASTUDENTKEY\\\"\\n\\n event_key = Mock()\\n event_key.urlsafe.return_value = \\\"ANEVENTKEY\\\"\\n\\n message_key = Mock()\\n message_key.urlsafe.return_value = \\\"SOMEMESSAGEKEY\\\"\\n\\n batch_id = \\\"THEBATCHID\\\"\\n\\n get_student_broadcast_task(\\n student_key, event_key, message_key, batch_id)\\n\\n check_params = {\\n 'student': 'ASTUDENTKEY',\\n 'event': 'ANEVENTKEY',\\n 'message': 'SOMEMESSAGEKEY',\\n 'batch': 'THEBATCHID',\\n }\\n self.assertEqual(check_params, task_mock.call_args[1]['params'])\",\n \"def test_make_request_parameters(self, m_requests, m_sleep):\\r\\n request = testing.DummyRequest({mut.URL_KEY: SAMPLE_URL, \\r\\n mut.PARAMETERS_KEY: json.dumps(SAMPLE_PARAMETERS)})\\r\\n m_response, response_dict = self.mock_response()\\r\\n m_requests.get.return_value = m_response\\r\\n self.assertEqual(response_dict, mut.make_request(request))\\r\\n m_requests.get.assert_called_with(url=SAMPLE_URL, \\r\\n params=SAMPLE_PARAMETERS)\\r\\n m_sleep.assert_called_with(mut.SECURITY_SLEEP)\",\n \"def test_asdf_from_call():\\n config_file = t_path(\\n Path('steps') / 'jwst_generic_pars-makeliststep_0001.asdf'\\n )\\n results = MakeListStep.call(config_file=config_file)\\n\\n assert results == DEFAULT_RESULT\",\n \"def sample(self):\\n raise NotImplementedError(\\\"Override me!\\\")\",\n \"def test_call(self):\\r\\n\\r\\n expected = {'ref1': ['s3', 's2', 's1'],\\r\\n 'ref2': ['s4']}\\r\\n actual = self.otu_picker(self.seqs_fp,\\r\\n refseqs_fp=self.reference_seqs_pr_fp)\\r\\n self.assertEqual(actual, expected)\",\n \"def Check(self, parameters):\",\n \"def test_foo(self):\\n self.ran = True\\n 1 / 0\",\n \"def test__call__(self):\\n kwargs = dict(\\n name='b',\\n type=int,\\n converter=dummy_converter,\\n validator=dummy_validator,\\n metadata={'meta': 'data'},\\n )\\n vark = VarKeyword()(**kwargs)\\n name, fparam = self.assert_mapping_and_get_fparam(vark)\\n assert isinstance(fparam, FParameter)\\n assert name == kwargs['name']\\n assert immutable.asdict(fparam) == dict(\\n FPARAM_VKW_DEFAULTS,\\n **kwargs,\\n interface_name=kwargs['name'],\\n )\",\n \"def test_suite():\\r\\n test(slope(5, 3, 4, 2) == 1.0)\\r\\n test(slope(1, 2, 3, 2) == 0.0)\\r\\n test(slope(1, 2, 3, 3) == 0.5)\\r\\n test(slope(2, 4, 1, 2) == 2.0)\",\n \"def test_0():\\n sync.gen_multi_fake_data()#default is only one randomly selected data set\\n sync.main(testing=True)\",\n \"async def test_successful_samples(self):\\n self.set_source_parameter(\\\"test_result\\\", [\\\"success\\\"])\\n response = await self.collect(get_request_json_return_value=self.JMETER_JSON)\\n self.assert_measurement(response, value=\\\"242\\\", entities=[])\",\n \"def test_name_and_value_arguments(self):\\n mock_call = Call(\\\"some_name\\\", 1024, 3.1415, \\\"hello\\\")\\n assert_that(str(mock_call), equal_to(\\\"Call(some_name, 1024, 3.1415, hello)\\\"))\",\n \"def test_getSampleCount(self):\\r\\n self.assertEqual(self.res1.getSampleCount(), 0)\\r\\n\\r\\n self.res1.addSample('S1', 42)\\r\\n self.assertEqual(self.res1.getSampleCount(), 1)\\r\\n\\r\\n self.res1.addSample('S2', 43)\\r\\n self.assertEqual(self.res1.getSampleCount(), 2)\",\n \"def test_arguments(self):\\n\\n h.test_function_arguments(\\n func=BaseTransformer.fit,\\n expected_arguments=[\\\"self\\\", \\\"X\\\", \\\"y\\\"],\\n expected_default_values=(None,),\\n )\",\n \"def inner_test(param: dict):\\n pass\",\n \"def __call__(self, samples_number):\\n self.sampler.sample(samples_number)\",\n \"def sample(self):\\n # This method is set in __init__.\\n pass\",\n \"def test_basiccall(self):\\n ex = self.ex\\n i = self.i\\n\\n sig = (\\\"name\\\", \\\"char*\\\", \\\"int*\\\", \\\"double*\\\", \\\"double*\\\")\\n ex.call = BasicCall(sig, \\\"N\\\", 100, 1.5, [10000])\\n cmds = ex.generate_cmds()\\n self.assertIn([\\\"name\\\", \\\"N\\\", 100, 1.5, [10000]], cmds)\\n\\n # now with a range\\n lenrange = random.randint(1, 10)\\n ex.range = [i, range(lenrange)]\\n ex.call = BasicCall(sig, \\\"N\\\", i - 1, 1.5, [i * i])\\n cmds = ex.generate_cmds()\\n idx = random.randint(0, lenrange - 1)\\n self.assertIn([\\\"name\\\", \\\"N\\\", idx - 1, 1.5, [idx * idx]], cmds)\",\n \"def inner_test(param: int):\\n pass\",\n \"def inner_test(param: int):\\n pass\",\n \"def inner_test(param: int):\\n pass\",\n \"def test_call(self):\\r\\n expected = {0: ['s2'],\\r\\n 1: ['s3', 's4', 's1'],\\r\\n 2: ['s7'],\\r\\n 3: ['s6', 's5']}\\r\\n actual = self.otu_picker(self.small_seq_path)\\r\\n self.assertEqual(actual, expected)\",\n \"def __call__(self, parameter_values, random_state=None):\\n self.train_model(parameter_values, random_state=random_state)\\n log_dict = self.simulate(random_state)\\n return log_dict\",\n \"def test_1sample(self):\\r\\n c = AlphaDiversityCalc(observed_otus)\\r\\n self.assertEqual(c(data_path=self.single_sample_otu_table_fp), [2])\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def sample(self):\\n raise NotImplementedError\",\n \"def test_function(arg):\\n return arg * 2\",\n \"def test_run_a_scan_on_sdp_subarray_in_low():\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74978554","0.7458379","0.6806208","0.67182815","0.66871434","0.66065896","0.6550513","0.6408485","0.63945335","0.63945335","0.6393947","0.63818336","0.6375116","0.6333833","0.6326504","0.6301726","0.6289962","0.62281895","0.6223233","0.6222367","0.6206715","0.6137851","0.61317784","0.6123086","0.6121871","0.6110917","0.610759","0.6099668","0.60828805","0.60818666","0.60803485","0.6079015","0.6063601","0.60596406","0.60576284","0.6055172","0.6024769","0.6009363","0.59995484","0.5997914","0.59927475","0.59876215","0.59803134","0.5976497","0.5974824","0.59476054","0.59456897","0.59404063","0.5940147","0.59272027","0.59138393","0.5913369","0.5906317","0.5895403","0.58918977","0.5884573","0.5874926","0.5863186","0.58475274","0.58426964","0.58346117","0.5834428","0.58321446","0.58318007","0.5819463","0.5815574","0.5814182","0.5812179","0.5806082","0.5806082","0.58008","0.57958144","0.57937825","0.57930017","0.57880473","0.5782187","0.5781512","0.57810926","0.576528","0.5760902","0.5757734","0.57528853","0.5752634","0.5747617","0.5746099","0.5734991","0.5726615","0.57176316","0.57166755","0.5715229","0.5710759","0.5698892","0.5698892","0.5698892","0.56950516","0.56874144","0.568538","0.56853765","0.56853765","0.56823516","0.56785786"],"string":"[\n \"0.74978554\",\n \"0.7458379\",\n \"0.6806208\",\n \"0.67182815\",\n \"0.66871434\",\n \"0.66065896\",\n \"0.6550513\",\n \"0.6408485\",\n \"0.63945335\",\n \"0.63945335\",\n \"0.6393947\",\n \"0.63818336\",\n \"0.6375116\",\n \"0.6333833\",\n \"0.6326504\",\n \"0.6301726\",\n \"0.6289962\",\n \"0.62281895\",\n \"0.6223233\",\n \"0.6222367\",\n \"0.6206715\",\n \"0.6137851\",\n \"0.61317784\",\n \"0.6123086\",\n \"0.6121871\",\n \"0.6110917\",\n \"0.610759\",\n \"0.6099668\",\n \"0.60828805\",\n \"0.60818666\",\n \"0.60803485\",\n \"0.6079015\",\n \"0.6063601\",\n \"0.60596406\",\n \"0.60576284\",\n \"0.6055172\",\n \"0.6024769\",\n \"0.6009363\",\n \"0.59995484\",\n \"0.5997914\",\n \"0.59927475\",\n \"0.59876215\",\n \"0.59803134\",\n \"0.5976497\",\n \"0.5974824\",\n \"0.59476054\",\n \"0.59456897\",\n \"0.59404063\",\n \"0.5940147\",\n \"0.59272027\",\n \"0.59138393\",\n \"0.5913369\",\n \"0.5906317\",\n \"0.5895403\",\n \"0.58918977\",\n \"0.5884573\",\n \"0.5874926\",\n \"0.5863186\",\n \"0.58475274\",\n \"0.58426964\",\n \"0.58346117\",\n \"0.5834428\",\n \"0.58321446\",\n \"0.58318007\",\n \"0.5819463\",\n \"0.5815574\",\n \"0.5814182\",\n \"0.5812179\",\n \"0.5806082\",\n \"0.5806082\",\n \"0.58008\",\n \"0.57958144\",\n \"0.57937825\",\n \"0.57930017\",\n \"0.57880473\",\n \"0.5782187\",\n \"0.5781512\",\n \"0.57810926\",\n \"0.576528\",\n \"0.5760902\",\n \"0.5757734\",\n \"0.57528853\",\n \"0.5752634\",\n \"0.5747617\",\n \"0.5746099\",\n \"0.5734991\",\n \"0.5726615\",\n \"0.57176316\",\n \"0.57166755\",\n \"0.5715229\",\n \"0.5710759\",\n \"0.5698892\",\n \"0.5698892\",\n \"0.5698892\",\n \"0.56950516\",\n \"0.56874144\",\n \"0.568538\",\n \"0.56853765\",\n \"0.56853765\",\n \"0.56823516\",\n \"0.56785786\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":85192,"cells":{"query":{"kind":"string","value":"Uses the Win32 registry to return a iterator of serial (COM) ports existing on this computer."},"document":{"kind":"string","value":"def _enumerate_serial_ports():\r\n path = 'HARDWARE\\\\DEVICEMAP\\\\SERIALCOMM'\r\n try:\r\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\r\n except WindowsError:\r\n raise IterationError\r\n\r\n for i in itertools.count():\r\n try:\r\n val = winreg.EnumValue(key, i)\r\n yield (str(val[1]), str(val[0]))\r\n except EnvironmentError:\r\n break"},"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 enumerate_serial_ports():\n path = 'HARDWARE\\\\DEVICEMAP\\\\SERIALCOMM'\n try:\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\n except WindowsError:\n raise IterationError\n\n for i in itertools.count():\n try:\n val = winreg.EnumValue(key, i)\n# print 'comval',val\n yield (str(val[1]), str(val[0]))\n except EnvironmentError:\n break","def enumerate_serial_ports():\n path = 'HARDWARE\\\\DEVICEMAP\\\\SERIALCOMM'\n try:\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\n except WindowsError:\n raise Exception\n \n for i in itertools.count():\n try:\n val = winreg.EnumValue(key, i)\n yield (str(val[1])) # , str(val[0]))\n except EnvironmentError:\n break","def serial_ports(self):\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def serial_ports(self):\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def serial_ports():\n if os.name == 'nt':\n # windows\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n yield 'COM' + str(i + 1)\n except serial.SerialException:\n pass\n else:\n # unix\n for port in list_ports.comports():\n yield port[0]","def serial_ports():\n if sys.platform.startswith('win'):\n result = []\n for i in range(256):\n try:\n s = serial.Serial(i)\n s.close()\n result.append('COM' + str(i + 1))\n except serial.SerialException:\n pass\n return result\n\n elif sys.platform.startswith('linux'):\n return glob.glob('/dev/rf*')\n\n elif sys.platform.startswith('darwin'):\n return glob.glob('/dev/tty.*')","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\r\n\tif sys.platform.startswith('win'):\r\n\t\tports = ['COM%s' % (i + 1) for i in range(256)]\r\n\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n\t\t# this excludes your current terminal \"/dev/tty\"\r\n\t\tports = glob.glob('/dev/tty[A-Za-z]*')\r\n\telif sys.platform.startswith('darwin'):\r\n\t\tports = glob.glob('/dev/cu.usb*')\r\n\telse:\r\n\t\traise EnvironmentError('Unsupported platform')\r\n\r\n\tresult = []\r\n\tfor port in ports:\r\n\t\t#print(port)\r\n\t\ttry:\r\n\t\t\ts = serial.Serial(port)\r\n\t\t\ts.close()\r\n\t\t\tresult.append(port)\r\n\t\texcept (OSError, serial.SerialException):\r\n\t\t\tpass\r\n\treturn result","def list_available_ports():\n ports = [u\"COM%s\" % (i + 1) for i in range(16)]\n results = []\n\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n results.append(port)\n print(u\"Find {0} device.\".format(port))\n except (OSError, serial.SerialException):\n pass\n\n return results","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(32)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/ttyUSB*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\r\n if sys.platform.startswith('win'):\r\n ports = ['COM%s' % (i + 1) for i in range(256)]\r\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n # this excludes your current terminal \"/dev/tty\"\r\n ports = glob.glob('/dev/tty[A-Za-z]*')\r\n elif sys.platform.startswith('darwin'):\r\n ports = glob.glob('/dev/tty.*')\r\n else:\r\n raise EnvironmentError('Unsupported platform')\r\n\r\n result = []\r\n for port in ports:\r\n try:\r\n s = serial.Serial(port)\r\n s.close()\r\n result.append(port)\r\n except (OSError, serial.SerialException):\r\n pass\r\n return result","def serial_ports():\r\n if sys.platform.startswith('win'):\r\n ports = ['COM%s' % (i + 1) for i in range(256)]\r\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n # this excludes your current terminal \"/dev/tty\"\r\n ports = glob.glob('/dev/tty[A-Za-z]*')\r\n elif sys.platform.startswith('darwin'):\r\n ports = glob.glob('/dev/tty.*')\r\n else:\r\n raise EnvironmentError('Unsupported platform')\r\n\r\n result = []\r\n for port in ports:\r\n try:\r\n s = serial.Serial(port)\r\n s.close()\r\n result.append(port)\r\n except (OSError, serial.SerialException):\r\n pass\r\n return result","def find_available_ports():\n ports = ['COM%s' % (i + 1) for i in range(256)]\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith(\n 'cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.usb*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port, timeout=.000001)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def list_serial_ports():\r\n if sys.platform.startswith('win'):\r\n ports = ['COM%s' % (i + 1) for i in range(256)]\r\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n # this excludes your current terminal \"/dev/tty\"\r\n ports = glob.glob('/dev/tty[A-Za-z]*')\r\n elif sys.platform.startswith('darwin'):\r\n ports = glob.glob('/dev/tty.*')\r\n else:\r\n raise EnvironmentError('Unsupported platform')\r\n\r\n result = []\r\n for port in ports:\r\n try:\r\n s = Serial(port)\r\n s.close()\r\n result.append(port)\r\n except (OSError, serial.SerialException):\r\n pass\r\n return result","def get_serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n \n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def list_serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serialPorts():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def list_serial_ports():\r\n\tif sys.platform.startswith('win'):\r\n\t\tports = ['COM%s' % (i + 1) for i in range(256)]\r\n\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\r\n\t\t# this excludes your current terminal \"/dev/tty\"\r\n\t\tports = glob.glob('/dev/tty[A-Za-z]*')\r\n\telif sys.platform.startswith('darwin'):\r\n\t\tports = glob.glob('/dev/tty.*')\r\n\telse:\r\n\t\traise EnvironmentError('Unsupported platform')\r\n\r\n\tresult = []\r\n\tfor port in ports:\r\n\t\ttry:\r\n\t\t\ts = serial.Serial(port)\r\n\t\t\ts.close()\r\n\t\t\tresult.append(port)\r\n\t\texcept (OSError, serial.SerialException):\r\n\t\t\tpass\r\n\treturn result","def serial_ports():\r\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))","def get_com_list_TEST(self):\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n self._coms = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.dtr = False\n s.close()\n\n self._coms.append(port)\n except (OSError, serial.SerialException):\n pass\n return self._coms","def serial_ports():\n# ports = glob.glob('/dev/tty[A-Za-z]*')\n ports = glob.glob('/dev/ttyACM*')\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (serial.SerialException) as e:\n print(e)\n return result","def iterate_comports():\n PortsGUIDs = (GUID * 8)() # so far only seen one used, so hope 8 are enough...\n ports_guids_size = DWORD()\n if not SetupDiClassGuidsFromName(\n \"Ports\",\n PortsGUIDs,\n ctypes.sizeof(PortsGUIDs),\n ctypes.byref(ports_guids_size)):\n raise ctypes.WinError()\n\n ModemsGUIDs = (GUID * 8)() # so far only seen one used, so hope 8 are enough...\n modems_guids_size = DWORD()\n if not SetupDiClassGuidsFromName(\n \"Modem\",\n ModemsGUIDs,\n ctypes.sizeof(ModemsGUIDs),\n ctypes.byref(modems_guids_size)):\n raise ctypes.WinError()\n\n GUIDs = PortsGUIDs[:ports_guids_size.value] + ModemsGUIDs[:modems_guids_size.value]\n\n # repeat for all possible GUIDs\n for index in range(len(GUIDs)):\n bInterfaceNumber = None\n g_hdi = SetupDiGetClassDevs(\n ctypes.byref(GUIDs[index]),\n None,\n NULL,\n DIGCF_PRESENT) # was DIGCF_PRESENT|DIGCF_DEVICEINTERFACE which misses CDC ports\n\n devinfo = SP_DEVINFO_DATA()\n devinfo.cbSize = ctypes.sizeof(devinfo)\n index = 0\n while SetupDiEnumDeviceInfo(g_hdi, index, ctypes.byref(devinfo)):\n index += 1\n\n # get the real com port name\n hkey = SetupDiOpenDevRegKey(\n g_hdi,\n ctypes.byref(devinfo),\n DICS_FLAG_GLOBAL,\n 0,\n DIREG_DEV, # DIREG_DRV for SW info\n KEY_READ)\n port_name_buffer = ctypes.create_unicode_buffer(250)\n port_name_length = ULONG(ctypes.sizeof(port_name_buffer))\n RegQueryValueEx(\n hkey,\n \"PortName\",\n None,\n None,\n ctypes.byref(port_name_buffer),\n ctypes.byref(port_name_length))\n RegCloseKey(hkey)\n\n # unfortunately does this method also include parallel ports.\n # we could check for names starting with COM or just exclude LPT\n # and hope that other \"unknown\" names are serial ports...\n if port_name_buffer.value.startswith('LPT'):\n continue\n\n # hardware ID\n szHardwareID = ctypes.create_unicode_buffer(250)\n # try to get ID that includes serial number\n if not SetupDiGetDeviceInstanceId(\n g_hdi,\n ctypes.byref(devinfo),\n #~ ctypes.byref(szHardwareID),\n szHardwareID,\n ctypes.sizeof(szHardwareID) - 1,\n None):\n # fall back to more generic hardware ID if that would fail\n if not SetupDiGetDeviceRegistryProperty(\n g_hdi,\n ctypes.byref(devinfo),\n SPDRP_HARDWAREID,\n None,\n ctypes.byref(szHardwareID),\n ctypes.sizeof(szHardwareID) - 1,\n None):\n # Ignore ERROR_INSUFFICIENT_BUFFER\n if ctypes.GetLastError() != ERROR_INSUFFICIENT_BUFFER:\n raise ctypes.WinError()\n # stringify\n szHardwareID_str = szHardwareID.value\n\n info = list_ports_common.ListPortInfo(port_name_buffer.value, skip_link_detection=True)\n\n # in case of USB, make a more readable string, similar to that form\n # that we also generate on other platforms\n if szHardwareID_str.startswith('USB'):\n m = re.search(r'VID_([0-9a-f]{4})(&PID_([0-9a-f]{4}))?(&MI_(\\d{2}))?(\\\\(.*))?', szHardwareID_str, re.I)\n if m:\n info.vid = int(m.group(1), 16)\n if m.group(3):\n info.pid = int(m.group(3), 16)\n if m.group(5):\n bInterfaceNumber = int(m.group(5))\n\n # Check that the USB serial number only contains alphanumeric characters. It\n # may be a windows device ID (ephemeral ID) for composite devices.\n if m.group(7) and re.match(r'^\\w+$', m.group(7)):\n info.serial_number = m.group(7)\n else:\n info.serial_number = get_parent_serial_number(devinfo.DevInst, info.vid, info.pid)\n\n # calculate a location string\n loc_path_str = ctypes.create_unicode_buffer(500)\n if SetupDiGetDeviceRegistryProperty(\n g_hdi,\n ctypes.byref(devinfo),\n SPDRP_LOCATION_PATHS,\n None,\n ctypes.byref(loc_path_str),\n ctypes.sizeof(loc_path_str) - 1,\n None):\n m = re.finditer(r'USBROOT\\((\\w+)\\)|#USB\\((\\w+)\\)', loc_path_str.value)\n location = []\n for g in m:\n if g.group(1):\n location.append('{:d}'.format(int(g.group(1)) + 1))\n else:\n if len(location) > 1:\n location.append('.')\n else:\n location.append('-')\n location.append(g.group(2))\n if bInterfaceNumber is not None:\n location.append(':{}.{}'.format(\n 'x', # XXX how to determine correct bConfigurationValue?\n bInterfaceNumber))\n if location:\n info.location = ''.join(location)\n info.hwid = info.usb_info()\n elif szHardwareID_str.startswith('FTDIBUS'):\n m = re.search(r'VID_([0-9a-f]{4})\\+PID_([0-9a-f]{4})(\\+(\\w+))?', szHardwareID_str, re.I)\n if m:\n info.vid = int(m.group(1), 16)\n info.pid = int(m.group(2), 16)\n if m.group(4):\n info.serial_number = m.group(4)\n # USB location is hidden by FDTI driver :(\n info.hwid = info.usb_info()\n else:\n info.hwid = szHardwareID_str\n\n # friendly name\n szFriendlyName = ctypes.create_unicode_buffer(250)\n if SetupDiGetDeviceRegistryProperty(\n g_hdi,\n ctypes.byref(devinfo),\n SPDRP_FRIENDLYNAME,\n #~ SPDRP_DEVICEDESC,\n None,\n ctypes.byref(szFriendlyName),\n ctypes.sizeof(szFriendlyName) - 1,\n None):\n info.description = szFriendlyName.value\n #~ else:\n # Ignore ERROR_INSUFFICIENT_BUFFER\n #~ if ctypes.GetLastError() != ERROR_INSUFFICIENT_BUFFER:\n #~ raise IOError(\"failed to get details for %s (%s)\" % (devinfo, szHardwareID.value))\n # ignore errors and still include the port in the list, friendly name will be same as port name\n\n # manufacturer\n szManufacturer = ctypes.create_unicode_buffer(250)\n if SetupDiGetDeviceRegistryProperty(\n g_hdi,\n ctypes.byref(devinfo),\n SPDRP_MFG,\n #~ SPDRP_DEVICEDESC,\n None,\n ctypes.byref(szManufacturer),\n ctypes.sizeof(szManufacturer) - 1,\n None):\n info.manufacturer = szManufacturer.value\n yield info\n SetupDiDestroyDeviceInfoList(g_hdi)","def enumerate_serial_devices(self):\n\n ports = list(list_ports.comports())\n\n return ports","def scan_serial(self,event):\n if str(platform.system()) == 'Windows':\n tempList = ['COM%s' % (i + 1) for i in range(256)]\n elif str(platform.system()) == 'Linux':\n tempList = glob.glob('/dev/tty[A-Za-z]*')\n elif str(platform.system()) == 'Darwin':\n tempList = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError(\"Unsupported platform\")\n\n results = []\n for a_port in tempList:\n try:\n s = serial.Serial(a_port)\n s.close()\n results.append(a_port)\n except serial.SerialException:\n pass\n return results","def get_ports():\r\n ports = serial.tools.list_ports.comports()\r\n return ports","def test_list_ports():\n print(\"List of available ports: \",\n [comport.device for comport in list_ports.comports()])\n\n serial_ports = list_ports.comports()\n\n ndi_port_names = []\n max_com_port = 0\n for port_number, serial_port in enumerate(serial_ports):\n ndi_port_names.append(ndiDeviceName(port_number))\n try:\n windows_port_number = int(serial_port.device.replace('COM', ''))\n if windows_port_number > max_com_port:\n max_com_port = windows_port_number\n except ValueError:\n # we're probably not on windows, so don't care\n pass\n\n while len(ndi_port_names) < max_com_port:\n port_number = len(ndi_port_names)\n ndi_port_names.append(ndiDeviceName(port_number))\n\n for serial_port in serial_ports:\n pyserial_port_name = serial_port.device\n print(\"Checking port:\", pyserial_port_name,\n \"in ndi_port_names: \", ndi_port_names)\n if 'linux' not in sys.platform:\n assert pyserial_port_name in ndi_port_names","def get_ports_list() -> List[str]:\n return [comport.device for comport in serial.tools.list_ports.comports()]","def serial_port(self):\n for port in comports():\n try:\n s = Serial(port[0])\n s.close()\n return port[0]\n except SerialException as e:\n continue","def com_select():\n if 'win' in sys.platform:\n ports = [x.device\n for x in comports()]\n else:\n ports = ['/dev/' + x.device\n for x in comports() if 'AMA' not in x.name and x.name]\n return ports","def buscarPuertos():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def get_serial_ports():\n ports_detailed = [tuple(port) for port in list(serial.tools.list_ports.comports())]\n ports = []\n for port in ports_detailed:\n ports.append(port[0])\n return ports","def get_available_serials():\n ports_string = subprocess.check_output(['python3', '-m', 'serial.tools.list_ports']).decode(\"utf-8\").strip()\n print(\"FOUND: \" + ports_string)\n if len(ports_string) == 0:\n print(\"stubs used as no ports found\")\n return [\"/dev/ttyUSB0\", \"/dev/ttyUSB1\"]\n return ports_string.split('\\n')","def com_port():\n port = ListPortInfo(DEFAULT_PORT)\n port.serial_number = \"1234\"\n port.manufacturer = \"Virtual serial port\"\n port.device = DEFAULT_PORT\n port.description = \"Some serial port\"\n\n return port","def _discover_port(self):\n # if MAC get list of ports\n if sys.platform.startswith('darwin'):\n locations = glob.glob('/dev/tty.[usb*]*')\n locations = glob.glob('/dev/tty.[wchusb*]*') + locations\n locations.append('end')\n # for everyone else, here is a list of possible ports\n else:\n locations = ['dev/ttyACM0', '/dev/ttyACM0', '/dev/ttyACM1',\n '/dev/ttyACM2', '/dev/ttyACM3', '/dev/ttyACM4',\n '/dev/ttyACM5', '/dev/ttyUSB0', '/dev/ttyUSB1',\n '/dev/ttyUSB2', '/dev/ttyUSB3', '/dev/ttyUSB4',\n '/dev/ttyUSB5', '/dev/ttyUSB6', '/dev/ttyUSB7',\n '/dev/ttyUSB8', '/dev/ttyUSB9',\n '/dev/ttyUSB10',\n '/dev/ttyS0', '/dev/ttyS1', '/dev/ttyS2',\n '/dev/tty.usbserial', '/dev/tty.usbmodem', 'com2',\n 'com3', 'com4', 'com5', 'com6', 'com7', 'com8',\n 'com9', 'com10', 'com11', 'com12', 'com13',\n 'com14', 'com15', 'com16', 'com17', 'com18',\n 'com19', 'com20', 'com21', 'com1', 'end'\n ]\n\n detected = None\n for device in locations:\n try:\n serialport = serial.Serial(device, 57600, timeout=0)\n detected = device\n serialport.close()\n break\n except serial.SerialException:\n if device == 'end':\n if self.log_output:\n logging.exception(\n 'Unable to find Serial Port, Please plug in '\n 'cable or check cable connections.')\n else:\n print('Unable to find Serial Port, Please plug in '\n 'cable or check cable connections.')\n detected = None\n exit()\n if self.log_output:\n log_string = 'Using COM Port: ' + detected\n logging.info(log_string)\n else:\n print('{}{}\\n'.format('Using COM Port:', detected))\n return detected","def findDevices(self):\n devs = []\n for name, (serServer, port) in self.serialLinks.items():\n if serServer not in self.client.servers:\n continue\n server = self.client[serServer]\n ports = yield server.list_serial_ports()\n if port not in ports:\n continue\n devName = '%s - %s' % (serServer, port)\n devs += [(devName, (server, port))]\n returnValue(devs)","def findDevices(self):\n devs = []\n for name in self.serialLinks:\n port = self.serialLinks[name]\n if name not in self.client.servers:\n continue\n server = self.client[name]\n ports = yield server.list_serial_ports()\n print ports\n if port not in ports:\n continue\n devName = '%s - %s' % (name, port)\n devs += [(devName, (server, port))]\n returnValue(devs)","def serial_path():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result","def serial_ports():\n if sys.platform.startswith('win'):\n ports = ['COM%s' % (i + 1) for i in range(256)]\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\n # this excludes your current terminal \"/dev/tty\"\n ports = glob.glob('/dev/tty[A-Za-z]*')\n elif sys.platform.startswith('darwin'):\n ports = glob.glob('/dev/tty.*')\n else:\n raise EnvironmentError('Unsupported platform')\n\n result = []\n for port in ports:\n try:\n s = serial.Serial(port)\n s.close()\n result.append(port)\n except (OSError, serial.SerialException):\n pass\n return result\n\n\n # isAngleChanged = True\n # pastAngle = Current_Coord['ang']\n # resetStates()\n # # temp\n # angle = 0\n # while current_mode == mode['Mapping']:\n # updateCurrCordinate(distance, angle)\n # # needs a way to keep track if the distance and the angle has changed!!\n # # if angle is changed the first time; add onto the trace.\n # if angle != pastAngle:\n # if not isAngleChanged:\n # addCurrToParameter()\n # isAngleChanged = 1\n # pastAngle = angle\n # # Has stopped rotating and back to moving.\n # if isAngleChanged and distance != 0:\n # isAngleChanged = 0\n # # when it exists the while loop == the bot has stopped. adding stopping point\n # # into the list\n # addCurrToParameter()","def look_for_available_ports():\n available_ports = glob.glob('/dev/ttyACM*')\n print(\"Available porst: \")\n print(available_ports)\n\n return available_ports","def list_ports():\n print '\\nHere is the list of available ports on this machine:'\n # lp.comports returns a list of (port, description, hardware ID) tuples\n iterator = sorted(lp.comports())\n for port, desc, hwid in iterator:\n print port\n exit()","def find_COM(self, cmd, name, ctrl_port, pbar=None):\n \n for self.port in [ctrl_port] + ['COM%s' % (i + 1) for i in range(256)]:\n\n try:\n # open the port\n self.ser = serial.Serial(self.port, baudrate=9600, timeout=0.2)\n\n # send an identifier command\n self.ser.write(cmd)\n time.sleep(0.2)\n\n # read the response\n resp = self.ser.read(100)\n \n if resp[:len(name)] == name:\n # run initialization if a valid port was open\n self.initialize(pbar=pbar)\n break\n \n else:\n self.ser.close()\n \n except:\n pass","def enumerate_midi_devices(self):\n\n ports = self.midiout.get_ports()\n\n return ports","def GetDeviceSerials(self):\n return self._device_serial_index.keys()","def read_all_rom_ports(self):\n return self.ROM_PORT","def _com_port(self, tid):\n winreg.Enum = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,\n r'SYSTEM\\CurrentControlSet\\Enum')\n usb_devs = winreg.OpenKey(winreg.Enum, 'USB')\n logger.debug(\"_com_port usb_devs %r\",\n list(self.iter_keys_as_str(usb_devs)))\n\n logger.debug(\"_com_port looking up usb id in all usb devices\")\n dev_keys = []\n for name, vid in zip(self.iter_keys_as_str(usb_devs),\n self.iter_keys(usb_devs)):\n try:\n dev_keys.append(winreg.OpenKey(vid, tid))\n if logger.isEnabledFor(DEBUG):\n logger.debug(\n \"Found usb id %s in %s with subkeys %r\", tid, name,\n list(self.iter_keys_as_str(winreg.OpenKey(vid, tid))))\n except OSError:\n pass\n\n logger.debug(\"_com_port Detecting port with Device Parameter\")\n for key in dev_keys:\n try:\n param = winreg.OpenKey(key, \"Device Parameters\")\n port, regtype = winreg.QueryValueEx(param, 'PortName')\n logger.debug('_com_port port %r regtype %r', port, regtype)\n return port\n except OSError as e:\n logger.debug(\"Exception %r %s\", key, str(e))\n pass\n\n logger.debug(\"_com_port Detecting port by following symlinks\")\n for key in dev_keys:\n try:\n ports = []\n parent_id, regtype = winreg.QueryValueEx(key, 'ParentIdPrefix')\n logger.debug(\"_com_port parent_id %r regtype %r\")\n for VID in self.iter_keys(usb_devs):\n candidate_keys = [k for k in self.iter_keys_as_str(VID)\n if parent_id in k]\n for dev in candidate_keys:\n logger.debug(\n \"_com_port recursive port detection with %r\", dev)\n maybe_port = self._com_port(dev)\n if maybe_port:\n return maybe_port\n except OSError as e:\n logger.debug(\"Exception %r %s\", key, str(e))\n pass\n\n # If everything fails, return None\n return None","def get_all_device_ports() -> List[str]:\n devices = [comport.device for comport in serial.tools.list_ports.comports()]\n result = list()\n for comport in devices:\n try:\n # find comport with our device\n ser = serial.Serial(comport, timeout=0.2)\n command: bytes = bytes(\"ping\\r\\n\", encoding='utf-8')\n ser.write(command)\n answer: str = ser.readall().decode('utf-8')\n ser.close()\n if 'Ok' in answer:\n result.append(comport)\n except serial.SerialException:\n continue\n return result","def list_ports(self):\n return self.ironic_client.port.list()","def get_working_serial_ports(excludes=()):\n excludes = set(excludes)\n # Last command is included so that it's compatible with OS X Sierra\n # Note: If you are running OS X Sierra, do not access the directory through vagrant ssh\n # Instead access it through Volumes/vagrant/PieCentral\n ports = set(glob.glob(\"/dev/ttyACM*\") + glob.glob(\"/dev/ttyUSB*\")\n + glob.glob(\"/dev/tty.usbmodem*\"))\n ports.difference_update(excludes)\n try:\n virtual_device_config_file = os.path.join(os.path.dirname(__file__), \"virtual_devices.txt\")\n ports.update(open(virtual_device_config_file, \"r\").read().split())\n except IOError:\n pass\n\n serials = []\n port_names = []\n for port in ports:\n try:\n serials.append(serial.Serial(port, 115200))\n port_names.append(port)\n except serial.serialutil.SerialException:\n print(\"Cannot Open Serial Port: \" + str(port))\n return serials, port_names","def get_port_list(self):\r\n self.ports = Manager().dict()\r\n self.value = Manager().dict()\r\n self.sensors = dict()\r\n for p in self.device.ports['input']:\r\n if p.enabled:\r\n self.ports[p.number] = p\r\n self.value[p.number] = 'Connexion à la carte'\r\n self.sensors[p.number] = Sensor.get(p._type)","def getListOfPorts(self):\n return _libsbml.CompModelPlugin_getListOfPorts(self)","def port_list(self):\n return self._port_list","def __set_port_list(self):\n\n self._coms = [str(i.device) for i in sorted(self.ports)]","def print_serial_ports():\n for port, description, hwid in sorted(comports()):\n print(f\"{port!r}\\n description: {description!r}\\n hwid: {hwid!r}\")","def find_ports(self):\n\n #\n # If a port is searching for Myo devices, wait\n #\n port_searching = False\n for port in self.ports_searching.keys():\n if self.ports_searching[port]:\n port_searching = True\n break\n\n if port_searching:\n self.warn_user(\"A port is currently searching for devices.\")\n return\n\n self.myo_counts.clear()\n self.ports_found.clear()\n self.progress_bars.clear()\n\n expec_manufac = \"Bluegiga\"\n expec_name = \"Low Energy Dongle\"\n ports_found = 0\n\n for port in comports():\n #\n # If this is a Bluegiga - Low Energy Dongle\n #\n port_attr = port.__dict__\n if not (\n (\"manufacturer\" in port_attr.keys()) and\n ((\"product\" in port_attr.keys()) or (\"description\" in port_attr.keys())) and\n (\"device\" in port_attr.keys())\n ):\n continue\n\n if not (\n (expec_manufac in port_attr[\"manufacturer\"]) or\n ((expec_name in port_attr[\"product\"]) and (expec_name in port_attr[\"description\"]))\n ):\n continue\n\n # Styling\n port_list_entry = QListWidgetItem(port_attr[\"device\"])\n port_list_entry.setIcon(QIcon(join(abspath(__file__).replace(\"data_tools.py\", \"\"), \"icons/sp.png\")))\n port_list_entry.port_idx = ports_found\n port_list_entry.port = port_attr[\"device\"]\n self.ports_found.insertItem(ports_found, port_list_entry);\n ports_found += 1\n self.myo_counts.append(0) # No Myo devices found for this newly found port yet","def refresh(self):\n self.ports = list(serial.tools.list_ports.comports())","def detect_ports():\n devices = []\n for p in list_ports.comports():\n for d in DESCRIPTORS:\n if d in p.device.lower():\n _in = p.hwid\n devices.append(p.device)\n return devices","def find_arduino(portsfound):\r\n comPort = 'None'\r\n num_of_connection = len(portsfound)\r\n\r\n for i in range(0, num_of_connection):\r\n port = foundPorts[i]\r\n cnvt_str_port = str(port)\r\n\r\n if 'ttyACM' in cnvt_str_port:\r\n splitPort = cnvt_str_port.split(' ')\r\n comPort = (splitPort[0])\r\n\r\n return comPort","def ports(self):\r\n # check connected to chip\r\n if not self._core.is_connected():\r\n raise ka_exceptions.NotConnectedError()\r\n\r\n # check symbols are loaded\r\n self._core.sym.assert_have_symbols()\r\n\r\n # get the symbols we need\r\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\r\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\r\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\r\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\r\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\r\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\r\n\r\n def read_dm(addr):\r\n return self._core.dm[addr]\r\n\r\n # get the read and write offset\r\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n read_offset = map(read_dm, read_offset_addr)\r\n write_offset = map(read_dm, write_offset_addr)\r\n\r\n # get the read and write limit\r\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\r\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\r\n read_limit = map(read_dm, read_limit_addr)\r\n write_limit = map(read_dm, write_limit_addr)\r\n\r\n # get the port size\r\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\r\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\r\n # calculate size mask (size-1) for non-zero sizes\r\n read_mask = map(lambda s: s - (s>0), read_size)\r\n write_mask = map(lambda s: s - (s>0), write_size)\r\n\r\n # calculate data/space in port\r\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\r\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\r\n\r\n # read port configs\r\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\r\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\r\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\r\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\r\n\r\n # extract data size (in octets) from config\r\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\r\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\r\n\r\n # decode configs into strings\r\n read_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"No Sign Ext\" if (c & 0x8) else \"Sign Ext\" ), \\\r\n read_conf, read_data_size)\r\n write_conf_str = map(lambda c,s: (\"8\" if s==1 else (\"16\" if s==2 else (\"24\" if s==3 else \"??\"))) + \"-bit, \" \\\r\n + (\"Big Endian\" if (c & 0x4) else \"Little Endian\") + \", \" \\\r\n + (\"Saturate\" if (c & 0x8) else \"No Saturate\"), \\\r\n write_conf, write_space_size)\r\n\r\n # print information\r\n print \"Read ports:\\n Port Status Offset Address Size(Bytes) Data Config\"\r\n for i in range(len(read_offset_addr)):\r\n if read_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i\r\n\r\n print \"Write ports:\\n Port Status Offset Address Size(Bytes) Space Config\"\r\n for i in range(len(write_offset_addr)):\r\n if write_offset_addr[i]:\r\n print \" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\" % \\\r\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\r\n else:\r\n print \" %2i Disabled\" % i","def get_ftdi_ports():\n ftdi_vid = 0x0403\n ftdi_pid = 0x6001\n\n # Get a list of FTDI Com Ports based on their VID/PID\n ftdi_ports = []\n com_ports = list_ports.comports()\n\n for port in com_ports:\n if port.vid == ftdi_vid and port.pid == ftdi_pid:\n ftdi_ports.append(port.device)\n return ftdi_ports","def _get_available_usb_devices(self, regexp=None, include_links=True) -> list:\n logger.debug(\n f\"_get_available_usb_devices(regexp={regexp}, include_links={include_links})\"\n )\n if not regexp:\n ports = serial_list_ports.comports(include_links=include_links)\n else:\n # cast as list because it's a generator and I want an easy return type\n # How many USB devices could a user possibly have?\n ports = list(\n serial_list_ports.grep(regexp=regexp, include_links=include_links)\n )\n return ports","def enumerate_devices():\n devices = list(\n map(XInputJoystick, list(range(XInputJoystick.max_devices))))\n return [device for device in devices if device.is_connected()]","def get_platform_serial_port():\n return get_system_serial_port(platform.system())","def probe_ports( self, ):\r\n ports = self.com_driver.list_available()\r\n self.gui.print_info_string( \"\" )\r\n self.gui.print_info_string( \"Reported Ports from driver:\" )\r\n self.gui.print_info_string( \"\" )\r\n if len( ports ) == 0:\r\n self.gui.print_info_string( \"None \\n\" )\r\n else:\r\n for i_port in ports:\r\n self.gui.print_info_string( i_port[0] )\r\n #self.gui.print_info_string( \"\\n\" )\r\n\r\n self.close_driver()\r\n\r\n self.gui.print_info_string( \"\\nProbe Ports from parameters:\\n\" )\r\n ports = self.com_driver.probe_available( self.parameters.port_list )\r\n ix_line = 0 # what is this ??\r\n for i_port in ports:\r\n ix_line += 1\r\n self.gui.print_info_string( str( i_port ) )\r\n if ix_line == 10:\r\n ix_line = 0\r\n self.gui.print_info_string( \"\\n\" )\r\n #logger.log( fll, a_str )\r\n\r\n return","def get_serial_port(self, nIndex):\n\t\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetSerialPort', self.handle, nIndex))","def _GetPorts(self):\n ports = []\n for start, end in self.term.destination_port:\n if start == end:\n ports.append(str(start))\n else:\n ports.append('%d-%d' % (start, end))\n return ports","def getDeviceSwitchPorts(self, serial: str):\n\n metadata = {\n 'tags': ['switch', 'configure', 'ports'],\n 'operation': 'getDeviceSwitchPorts',\n }\n resource = f'/devices/{serial}/switch/ports'\n\n return self._session.get(metadata, resource)","def find_valons_with_dmesg():\n \n try:\n dmesg = check_output('dmesg | grep \"FT232RL\"',shell=True)\n except subprocess.CalledProcessError:\n # grep failed so no ports found\n return []\n lines = dmesg.split('\\n')\n lines = [x for x in lines if len(x) > 0]\n m = usbre.search(lines[-1])\n usbport = m.group('port')\n try:\n dmesg = check_output(('dmesg | grep \"usb %s.*now attached to\"' % usbport),shell=True)\n except subprocess.CalledProcessError:\n # grep failed so no ports found\n return []\n lines = dmesg.split('\\n')\n lines = [x for x in lines if len(x) > 0]\n lines = lines[-1:]\n ports = []\n for ln in lines[::-1]:\n idx = ln.find('ttyUSB')\n if idx >= 0:\n port = '/dev/' + ln[idx:]\n if port not in ports:\n ports.append(port)\n return ports","def get_keys(cell):\n return list(cell.portlist.keys())","def _find_serial_connection():\n import serial.tools.list_ports\n\n # Generate a search string including our VID/PID.\n vid_pid = f\"{ApolloDebugger.VENDOR_ID:04x}:{ApolloDebugger.PRODUCT_ID:04x}\"\n\n for port in serial.tools.list_ports.grep(vid_pid):\n return serial.Serial(port.device, USBAnalyzerApplet._BAUD_RATE)\n\n raise IOError(\"could not find a debug connection!\")","def get_serial_ports_count(self):\n\t\treturn call_sdk_function('PrlSrvCfg_GetSerialPortsCount', self.handle)","def get_ports(cls):\n return cls._open_ports.copy()","def _list_modi_ports() -> List[ListPortInfo]:\n def __is_modi_port(port):\n return (\n port.manufacturer == \"LUXROBO\"\n or port.product == \"MODI Network Module\"\n or port.description == \"MODI Network Module\"\n or (port.vid == 12254 and port.pid == 2))\n\n return [port for port in stl.comports() if __is_modi_port(port)]","def list_ports():\n non_working_ports = []\n dev_port = 0\n working_ports = []\n available_ports = []\n while len(non_working_ports) < 6: # if there are more than 5 non working ports stop the testing. \n camera = cv2.VideoCapture(dev_port)\n if not camera.isOpened():\n non_working_ports.append(dev_port)\n print(\"Port %s is not working.\" %dev_port)\n else:\n is_reading, img = camera.read()\n w = camera.get(3)\n h = camera.get(4)\n if is_reading:\n print(\"Port %s is working and reads images (%s x %s)\" %(dev_port,h,w))\n working_ports.append(dev_port)\n else:\n print(\"Port %s for camera ( %s x %s) is present but does not reads.\" %(dev_port,h,w))\n available_ports.append(dev_port)\n dev_port +=1\n return available_ports,working_ports,non_working_ports","def get_serial_port(self, nIndex):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetSerialPort', self.handle, nIndex))","def get_serial_ports_count(self):\n\t\treturn call_sdk_function('PrlVmCfg_GetSerialPortsCount', self.handle)","def read_all_ram_ports(self):\n return self.RAM_PORT","def updateAvailablePorts(self):\n # Build a port list\n device_list_all = comports()\n self.device_choices = list()\n for device in device_list_all:\n self.device_choices.append(device[0])\n\n if len(self.device_choices) < 1:\n tkinter.messagebox.showerror('No Available Serial Ports','No serial ports are available.')","def scan():\n debug(\"CBA4.scan()\")\n num = MpOrLibUsb.get_device_count()\n devices = []\n i = 0\n while i < num:\n cba = CBA4(interface=MpOrLibUsb(i))\n i += 1\n sn = cba.get_serial_number()\n if sn:\n devices.append(sn)\n cba.close()\n #end loop\n return devices\n #end scan()","def autoguessports(phonemodule):\n\n res=[]\n\n ports=[(islikelyportscore(port, phonemodule), port) for port in comscan.comscan()+usbscan.usbscan()+bitflingscan.flinger.scan() if port['available']]\n\n ports.sort()\n\n return [ (port['name'], port) for score,port in ports if score>=0]","def exposed_ports(self) -> list[\"Port\"]:\n _args: list[Arg] = []\n _ctx = self._select(\"exposedPorts\", _args)\n _ctx = Port(_ctx)._select_multiple(\n _description=\"description\",\n _port=\"port\",\n _protocol=\"protocol\",\n )\n return _ctx.execute_sync(list[Port])","def ask_for_port():\n sys.stderr.write(\"\\n--- Available ports:\\n\\n\")\n ports = []\n # for n, (port, desc, hwid) in enumerate(sorted(comports()), 1):\n for n, (port, desc, hwid) in enumerate(\n sorted(serial.tools.list_ports.grep(r\"usb\")), 1\n ):\n # sys.stderr.write(' {:2}: {:20}\\n\\n'.format(n, port))\n sys.stderr.write(\" {:2}: {:20}: {}\\n\".format(n, port, desc))\n ports.append(port)\n if len(ports):\n while True:\n port = prompt_input(\"\\n--- Enter port index or full name or X to exit: \")\n\n sys.stderr.write(\"\\n\")\n\n if port.upper() == \"X\":\n sys.exit(0)\n try:\n index = int(port) - 1\n if not 0 <= index < len(ports):\n LOGGER.warning(\"*** Invalid index!\")\n continue\n except ValueError:\n pass\n else:\n port = ports[index]\n return port\n else:\n LOGGER.warning(\"*** No serial ports detected ... aborting\")\n sys.exit(0)","def taken_ports():\n odoo = 'odoo' if env.api.system != 'wheezy' else 'openerp'\n ports = sudo('grep _port /srv/{odoo}/*/*cfg /srv/{odoo}/*/*/*cfg'\n '|cut -d= -f2|sort|uniq'\n .format(odoo=odoo)).splitlines()\n ports += sudo('grep \\.bind /srv/{odoo}/*/*cfg /srv/{odoo}/*/*/*cfg'\n '|cut -d= -f2|cut -d: -f2|sort|uniq'\n .format(odoo=odoo)).splitlines()\n ports = sorted(set(int(p.strip()) for p in ports if p.strip().isdigit()))\n puts('Already taken ports: {}'.format(', '.join(str(p) for p in ports)))\n if not ports: # assume 8000 is taken and is the first\n ports = [8000]\n return ports","def get_ports(self) -> tuple:\n return self._current_dev_manager.get_ports()","def get_all_port(self, conf, dpid):\n\t\tpass","def get_subscribers():\n # TODO: make calls to each device asynchronous so we don't block\n # trying to read from an unresponsive device on start up.\n PortList = serial.tools.list_ports.comports()\n manager.executor = ThreadPoolExecutor(max_workers=len(PortList))\n for port in PortList:\n if port.device in IGNORE_LIST:\n continue\n log.info('Found {}'.format(port.device))\n ser = serial.Serial(port.device, baudrate=115200)\n looping = True\n while looping:\n b = pyvesc.encode(pyvesc.ReqSubscription('t'))\n ser.reset_input_buffer()\n ser.write(b)\n l = ser.read()\n if l == b'\\x02' or l == b'\\x03':\n # It's a VESC message!\n looping = not init_vesc_driver(port, ser, l)\n else:\n # It's a JSON message!\n looping = not init_json_driver(port, ser, l)","def discover_channels(path, serial_number, callback, cancellation_token, channel_termination_token, logger):\n if path == None:\n # This regex should match all desired port names on macOS,\n # Linux and Windows but might match some incorrect port names.\n regex = r'^(/dev/tty\\.usbmodem.*|/dev/ttyACM.*|COM[0-9]+)$'\n else:\n regex = \"^\" + path + \"$\"\n\n known_devices = []\n def device_matcher(port_name):\n if port_name in known_devices:\n return False\n return bool(re.match(regex, port_name))\n\n def did_disconnect(port_name, device):\n device.close()\n # TODO: yes there is a race condition here in case you wonder.\n known_devices.pop(known_devices.index(port_name))\n\n while not cancellation_token.is_set():\n all_ports = find_pyserial_ports() + find_dev_serial_ports()\n new_ports = filter(device_matcher, all_ports)\n for port_name in new_ports:\n try:\n serial_device = SerialStreamTransport(port_name, DEFAULT_BAUDRATE)\n input_stream = fibre.protocol.PacketFromStreamConverter(serial_device)\n output_stream = fibre.protocol.StreamBasedPacketSink(serial_device)\n channel = fibre.protocol.Channel(\n \"serial port {}@{}\".format(port_name, DEFAULT_BAUDRATE),\n input_stream, output_stream, channel_termination_token, logger)\n channel.serial_device = serial_device\n except serial.serialutil.SerialException:\n logger.debug(\"Serial device init failed. Ignoring this port. More info: \" + traceback.format_exc())\n known_devices.append(port_name)\n else:\n known_devices.append(port_name)\n channel._channel_broken.subscribe(lambda: did_disconnect(port_name, serial_device))\n callback(channel)\n time.sleep(1)","def parsePortName(portinfo):\n portlist = []\n for port in portinfo:\n if sys.platform.startswith('win'):\n portlist.append(port[0])\n elif sys.platform.startswith('darwin') or sys.platform.startswith('linux'):\n if 'usbserial' in port[0]:\n namelist = port[0].split('-')\n portlist.append(namelist[-1])\n return portlist","def _ports(self):\n try:\n return self._graph.node[self.node_id][\"_ports\"]\n except KeyError:\n log.debug(\"No interfaces initialised for %s\" % self)\n return","def get_ports(self):\n return self._ports","def get_open_port_numbers(host):\n ports_per_host =[]\n for h in host:\n ports = h.findAll(\"port\")\n for port in ports:\n port_id = check_if_unicode(port[\"portid\"])\n ports_per_host.append(port_id)\n return ports_per_host","def win_service_iter():\n for name, display_name in cext.winservice_enumerate():\n yield WindowsService(py2_strencode(name), py2_strencode(display_name))","def _init_hw(self):\n portlist = []\n # try to exactly match by HID\n if self.USB_HID:\n match = list_ports.grep(self.USB_HID)\n try: portlist.append(next(match))\n except StopIteration:\n logger.warning(\"no serial devices with deviceid=\\\"{!s}\\\" were found\".format(self.USB_HID))\n\n # try to match first available serial device\n if not portlist:\n logger.info(\"Discovering available serial devices...\")\n portlist = list_ports.comports()\n for p in list(portlist):\n # TODO: this may be an imperfect check for a valid device\n if p.vid is None:\n portlist.remove(p)\n\n for p in portlist:\n PORT = p.device\n try:\n self.serial = serial.Serial(PORT, self.BAUD, timeout=0, writeTimeout=0)\n logger.info(\"Connected to serial device ({!s})\".format(device_info(p)))\n if not hasattr(self.serial, 'cancel_read'):\n self.serial.timeout = 1\n break\n except serial.serialutil.SerialException:\n continue\n\n if self.serial is None:\n if not portlist:\n logger.warning(\"no serial devices were discovered\")\n else:\n logger.warning(\"failed to open connection to any of the discovered serial devices: %s\", *[\"\\n - {}\".format(device_info(p)) for p in portlist])\n # logger.debug(p.device, p.name, p.description, p.hwid, p.vid, p.pid, p.serial_number, p.location, p.manufacturer, p.product, p.interface)\n if not self.initialized:\n self._activate_emulator_mode()","def elite11_finder(serial_port) -> list[str]:\n logger.debug(f\"Looking for Elite11 pumps on {serial_port}...\")\n # Static counter for device type across different serial ports\n if \"counter\" not in elite11_finder.__dict__:\n elite11_finder.counter = 0 # type: ignore\n\n try:\n link = HarvardApparatusPumpIO(port=serial_port)\n except InvalidConfiguration:\n # This is necessary only on failure to release the port for the other inspector\n return []\n\n # Check for echo\n link._serial.write(b\"\\r\\n\")\n if link._serial.readline() != b\"\\n\":\n # This is necessary only on failure to release the port for the other inspector\n link._serial.close()\n return []\n\n # Parse status prompt\n pump = link._serial.readline().decode(\"ascii\")\n if pump[0:2].isdigit():\n address = int(pump[0:2])\n else:\n address = 0\n\n try:\n test_pump = Elite11(\n link,\n syringe_diameter=\"20 mm\",\n syringe_volume=\"10 ml\",\n address=address,\n )\n asyncio.run(test_pump.pump_info())\n except InvalidConfiguration:\n # This is necessary only on failure to release the port for the other inspector\n link._serial.close()\n return []\n\n logger.info(f\"Elite11 found on <{serial_port}>\")\n\n # Local variable for enumeration\n elite11_finder.counter += 1 # type: ignore\n cfg = f\"[device.elite11-{elite11_finder.counter}]\" # type:ignore\n cfg += dedent(\n f\"\"\"\n type = \"Elite11\"\n port = \"{serial_port}\"\n address = {address}\n syringe_diameter = \"XXX mm\" # Specify syringe diameter!\n syringe_volume = \"YYY ml\" # Specify syringe volume!\\n\\n\"\"\"\n )\n return [cfg]","def port_channels(input_interfaces):\n ports = []\n for interface in input_interfaces:\n interface_lower = str(interface).lower()\n if interface_lower.startswith('po'):\n ports.append(interface)\n return ports"],"string":"[\n \"def enumerate_serial_ports():\\n path = 'HARDWARE\\\\\\\\DEVICEMAP\\\\\\\\SERIALCOMM'\\n try:\\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\\n except WindowsError:\\n raise IterationError\\n\\n for i in itertools.count():\\n try:\\n val = winreg.EnumValue(key, i)\\n# print 'comval',val\\n yield (str(val[1]), str(val[0]))\\n except EnvironmentError:\\n break\",\n \"def enumerate_serial_ports():\\n path = 'HARDWARE\\\\\\\\DEVICEMAP\\\\\\\\SERIALCOMM'\\n try:\\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\\n except WindowsError:\\n raise Exception\\n \\n for i in itertools.count():\\n try:\\n val = winreg.EnumValue(key, i)\\n yield (str(val[1])) # , str(val[0]))\\n except EnvironmentError:\\n break\",\n \"def serial_ports(self):\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def serial_ports(self):\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def serial_ports():\\n if os.name == 'nt':\\n # windows\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n yield 'COM' + str(i + 1)\\n except serial.SerialException:\\n pass\\n else:\\n # unix\\n for port in list_ports.comports():\\n yield port[0]\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n result = []\\n for i in range(256):\\n try:\\n s = serial.Serial(i)\\n s.close()\\n result.append('COM' + str(i + 1))\\n except serial.SerialException:\\n pass\\n return result\\n\\n elif sys.platform.startswith('linux'):\\n return glob.glob('/dev/rf*')\\n\\n elif sys.platform.startswith('darwin'):\\n return glob.glob('/dev/tty.*')\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\r\\n\\tif sys.platform.startswith('win'):\\r\\n\\t\\tports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n\\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n\\t\\t# this excludes your current terminal \\\"/dev/tty\\\"\\r\\n\\t\\tports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n\\telif sys.platform.startswith('darwin'):\\r\\n\\t\\tports = glob.glob('/dev/cu.usb*')\\r\\n\\telse:\\r\\n\\t\\traise EnvironmentError('Unsupported platform')\\r\\n\\r\\n\\tresult = []\\r\\n\\tfor port in ports:\\r\\n\\t\\t#print(port)\\r\\n\\t\\ttry:\\r\\n\\t\\t\\ts = serial.Serial(port)\\r\\n\\t\\t\\ts.close()\\r\\n\\t\\t\\tresult.append(port)\\r\\n\\t\\texcept (OSError, serial.SerialException):\\r\\n\\t\\t\\tpass\\r\\n\\treturn result\",\n \"def list_available_ports():\\n ports = [u\\\"COM%s\\\" % (i + 1) for i in range(16)]\\n results = []\\n\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n results.append(port)\\n print(u\\\"Find {0} device.\\\".format(port))\\n except (OSError, serial.SerialException):\\n pass\\n\\n return results\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(32)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/ttyUSB*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\r\\n if sys.platform.startswith('win'):\\r\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n # this excludes your current terminal \\\"/dev/tty\\\"\\r\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n elif sys.platform.startswith('darwin'):\\r\\n ports = glob.glob('/dev/tty.*')\\r\\n else:\\r\\n raise EnvironmentError('Unsupported platform')\\r\\n\\r\\n result = []\\r\\n for port in ports:\\r\\n try:\\r\\n s = serial.Serial(port)\\r\\n s.close()\\r\\n result.append(port)\\r\\n except (OSError, serial.SerialException):\\r\\n pass\\r\\n return result\",\n \"def serial_ports():\\r\\n if sys.platform.startswith('win'):\\r\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n # this excludes your current terminal \\\"/dev/tty\\\"\\r\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n elif sys.platform.startswith('darwin'):\\r\\n ports = glob.glob('/dev/tty.*')\\r\\n else:\\r\\n raise EnvironmentError('Unsupported platform')\\r\\n\\r\\n result = []\\r\\n for port in ports:\\r\\n try:\\r\\n s = serial.Serial(port)\\r\\n s.close()\\r\\n result.append(port)\\r\\n except (OSError, serial.SerialException):\\r\\n pass\\r\\n return result\",\n \"def find_available_ports():\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith(\\n 'cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.usb*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port, timeout=.000001)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def list_serial_ports():\\r\\n if sys.platform.startswith('win'):\\r\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n # this excludes your current terminal \\\"/dev/tty\\\"\\r\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n elif sys.platform.startswith('darwin'):\\r\\n ports = glob.glob('/dev/tty.*')\\r\\n else:\\r\\n raise EnvironmentError('Unsupported platform')\\r\\n\\r\\n result = []\\r\\n for port in ports:\\r\\n try:\\r\\n s = Serial(port)\\r\\n s.close()\\r\\n result.append(port)\\r\\n except (OSError, serial.SerialException):\\r\\n pass\\r\\n return result\",\n \"def get_serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n \\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def list_serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serialPorts():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def list_serial_ports():\\r\\n\\tif sys.platform.startswith('win'):\\r\\n\\t\\tports = ['COM%s' % (i + 1) for i in range(256)]\\r\\n\\telif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\r\\n\\t\\t# this excludes your current terminal \\\"/dev/tty\\\"\\r\\n\\t\\tports = glob.glob('/dev/tty[A-Za-z]*')\\r\\n\\telif sys.platform.startswith('darwin'):\\r\\n\\t\\tports = glob.glob('/dev/tty.*')\\r\\n\\telse:\\r\\n\\t\\traise EnvironmentError('Unsupported platform')\\r\\n\\r\\n\\tresult = []\\r\\n\\tfor port in ports:\\r\\n\\t\\ttry:\\r\\n\\t\\t\\ts = serial.Serial(port)\\r\\n\\t\\t\\ts.close()\\r\\n\\t\\t\\tresult.append(port)\\r\\n\\t\\texcept (OSError, serial.SerialException):\\r\\n\\t\\t\\tpass\\r\\n\\treturn result\",\n \"def serial_ports():\\r\\n return list(map(lambda listportinfo: listportinfo.device, list_ports.comports()))\",\n \"def get_com_list_TEST(self):\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n self._coms = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.dtr = False\\n s.close()\\n\\n self._coms.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return self._coms\",\n \"def serial_ports():\\n# ports = glob.glob('/dev/tty[A-Za-z]*')\\n ports = glob.glob('/dev/ttyACM*')\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (serial.SerialException) as e:\\n print(e)\\n return result\",\n \"def iterate_comports():\\n PortsGUIDs = (GUID * 8)() # so far only seen one used, so hope 8 are enough...\\n ports_guids_size = DWORD()\\n if not SetupDiClassGuidsFromName(\\n \\\"Ports\\\",\\n PortsGUIDs,\\n ctypes.sizeof(PortsGUIDs),\\n ctypes.byref(ports_guids_size)):\\n raise ctypes.WinError()\\n\\n ModemsGUIDs = (GUID * 8)() # so far only seen one used, so hope 8 are enough...\\n modems_guids_size = DWORD()\\n if not SetupDiClassGuidsFromName(\\n \\\"Modem\\\",\\n ModemsGUIDs,\\n ctypes.sizeof(ModemsGUIDs),\\n ctypes.byref(modems_guids_size)):\\n raise ctypes.WinError()\\n\\n GUIDs = PortsGUIDs[:ports_guids_size.value] + ModemsGUIDs[:modems_guids_size.value]\\n\\n # repeat for all possible GUIDs\\n for index in range(len(GUIDs)):\\n bInterfaceNumber = None\\n g_hdi = SetupDiGetClassDevs(\\n ctypes.byref(GUIDs[index]),\\n None,\\n NULL,\\n DIGCF_PRESENT) # was DIGCF_PRESENT|DIGCF_DEVICEINTERFACE which misses CDC ports\\n\\n devinfo = SP_DEVINFO_DATA()\\n devinfo.cbSize = ctypes.sizeof(devinfo)\\n index = 0\\n while SetupDiEnumDeviceInfo(g_hdi, index, ctypes.byref(devinfo)):\\n index += 1\\n\\n # get the real com port name\\n hkey = SetupDiOpenDevRegKey(\\n g_hdi,\\n ctypes.byref(devinfo),\\n DICS_FLAG_GLOBAL,\\n 0,\\n DIREG_DEV, # DIREG_DRV for SW info\\n KEY_READ)\\n port_name_buffer = ctypes.create_unicode_buffer(250)\\n port_name_length = ULONG(ctypes.sizeof(port_name_buffer))\\n RegQueryValueEx(\\n hkey,\\n \\\"PortName\\\",\\n None,\\n None,\\n ctypes.byref(port_name_buffer),\\n ctypes.byref(port_name_length))\\n RegCloseKey(hkey)\\n\\n # unfortunately does this method also include parallel ports.\\n # we could check for names starting with COM or just exclude LPT\\n # and hope that other \\\"unknown\\\" names are serial ports...\\n if port_name_buffer.value.startswith('LPT'):\\n continue\\n\\n # hardware ID\\n szHardwareID = ctypes.create_unicode_buffer(250)\\n # try to get ID that includes serial number\\n if not SetupDiGetDeviceInstanceId(\\n g_hdi,\\n ctypes.byref(devinfo),\\n #~ ctypes.byref(szHardwareID),\\n szHardwareID,\\n ctypes.sizeof(szHardwareID) - 1,\\n None):\\n # fall back to more generic hardware ID if that would fail\\n if not SetupDiGetDeviceRegistryProperty(\\n g_hdi,\\n ctypes.byref(devinfo),\\n SPDRP_HARDWAREID,\\n None,\\n ctypes.byref(szHardwareID),\\n ctypes.sizeof(szHardwareID) - 1,\\n None):\\n # Ignore ERROR_INSUFFICIENT_BUFFER\\n if ctypes.GetLastError() != ERROR_INSUFFICIENT_BUFFER:\\n raise ctypes.WinError()\\n # stringify\\n szHardwareID_str = szHardwareID.value\\n\\n info = list_ports_common.ListPortInfo(port_name_buffer.value, skip_link_detection=True)\\n\\n # in case of USB, make a more readable string, similar to that form\\n # that we also generate on other platforms\\n if szHardwareID_str.startswith('USB'):\\n m = re.search(r'VID_([0-9a-f]{4})(&PID_([0-9a-f]{4}))?(&MI_(\\\\d{2}))?(\\\\\\\\(.*))?', szHardwareID_str, re.I)\\n if m:\\n info.vid = int(m.group(1), 16)\\n if m.group(3):\\n info.pid = int(m.group(3), 16)\\n if m.group(5):\\n bInterfaceNumber = int(m.group(5))\\n\\n # Check that the USB serial number only contains alphanumeric characters. It\\n # may be a windows device ID (ephemeral ID) for composite devices.\\n if m.group(7) and re.match(r'^\\\\w+$', m.group(7)):\\n info.serial_number = m.group(7)\\n else:\\n info.serial_number = get_parent_serial_number(devinfo.DevInst, info.vid, info.pid)\\n\\n # calculate a location string\\n loc_path_str = ctypes.create_unicode_buffer(500)\\n if SetupDiGetDeviceRegistryProperty(\\n g_hdi,\\n ctypes.byref(devinfo),\\n SPDRP_LOCATION_PATHS,\\n None,\\n ctypes.byref(loc_path_str),\\n ctypes.sizeof(loc_path_str) - 1,\\n None):\\n m = re.finditer(r'USBROOT\\\\((\\\\w+)\\\\)|#USB\\\\((\\\\w+)\\\\)', loc_path_str.value)\\n location = []\\n for g in m:\\n if g.group(1):\\n location.append('{:d}'.format(int(g.group(1)) + 1))\\n else:\\n if len(location) > 1:\\n location.append('.')\\n else:\\n location.append('-')\\n location.append(g.group(2))\\n if bInterfaceNumber is not None:\\n location.append(':{}.{}'.format(\\n 'x', # XXX how to determine correct bConfigurationValue?\\n bInterfaceNumber))\\n if location:\\n info.location = ''.join(location)\\n info.hwid = info.usb_info()\\n elif szHardwareID_str.startswith('FTDIBUS'):\\n m = re.search(r'VID_([0-9a-f]{4})\\\\+PID_([0-9a-f]{4})(\\\\+(\\\\w+))?', szHardwareID_str, re.I)\\n if m:\\n info.vid = int(m.group(1), 16)\\n info.pid = int(m.group(2), 16)\\n if m.group(4):\\n info.serial_number = m.group(4)\\n # USB location is hidden by FDTI driver :(\\n info.hwid = info.usb_info()\\n else:\\n info.hwid = szHardwareID_str\\n\\n # friendly name\\n szFriendlyName = ctypes.create_unicode_buffer(250)\\n if SetupDiGetDeviceRegistryProperty(\\n g_hdi,\\n ctypes.byref(devinfo),\\n SPDRP_FRIENDLYNAME,\\n #~ SPDRP_DEVICEDESC,\\n None,\\n ctypes.byref(szFriendlyName),\\n ctypes.sizeof(szFriendlyName) - 1,\\n None):\\n info.description = szFriendlyName.value\\n #~ else:\\n # Ignore ERROR_INSUFFICIENT_BUFFER\\n #~ if ctypes.GetLastError() != ERROR_INSUFFICIENT_BUFFER:\\n #~ raise IOError(\\\"failed to get details for %s (%s)\\\" % (devinfo, szHardwareID.value))\\n # ignore errors and still include the port in the list, friendly name will be same as port name\\n\\n # manufacturer\\n szManufacturer = ctypes.create_unicode_buffer(250)\\n if SetupDiGetDeviceRegistryProperty(\\n g_hdi,\\n ctypes.byref(devinfo),\\n SPDRP_MFG,\\n #~ SPDRP_DEVICEDESC,\\n None,\\n ctypes.byref(szManufacturer),\\n ctypes.sizeof(szManufacturer) - 1,\\n None):\\n info.manufacturer = szManufacturer.value\\n yield info\\n SetupDiDestroyDeviceInfoList(g_hdi)\",\n \"def enumerate_serial_devices(self):\\n\\n ports = list(list_ports.comports())\\n\\n return ports\",\n \"def scan_serial(self,event):\\n if str(platform.system()) == 'Windows':\\n tempList = ['COM%s' % (i + 1) for i in range(256)]\\n elif str(platform.system()) == 'Linux':\\n tempList = glob.glob('/dev/tty[A-Za-z]*')\\n elif str(platform.system()) == 'Darwin':\\n tempList = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError(\\\"Unsupported platform\\\")\\n\\n results = []\\n for a_port in tempList:\\n try:\\n s = serial.Serial(a_port)\\n s.close()\\n results.append(a_port)\\n except serial.SerialException:\\n pass\\n return results\",\n \"def get_ports():\\r\\n ports = serial.tools.list_ports.comports()\\r\\n return ports\",\n \"def test_list_ports():\\n print(\\\"List of available ports: \\\",\\n [comport.device for comport in list_ports.comports()])\\n\\n serial_ports = list_ports.comports()\\n\\n ndi_port_names = []\\n max_com_port = 0\\n for port_number, serial_port in enumerate(serial_ports):\\n ndi_port_names.append(ndiDeviceName(port_number))\\n try:\\n windows_port_number = int(serial_port.device.replace('COM', ''))\\n if windows_port_number > max_com_port:\\n max_com_port = windows_port_number\\n except ValueError:\\n # we're probably not on windows, so don't care\\n pass\\n\\n while len(ndi_port_names) < max_com_port:\\n port_number = len(ndi_port_names)\\n ndi_port_names.append(ndiDeviceName(port_number))\\n\\n for serial_port in serial_ports:\\n pyserial_port_name = serial_port.device\\n print(\\\"Checking port:\\\", pyserial_port_name,\\n \\\"in ndi_port_names: \\\", ndi_port_names)\\n if 'linux' not in sys.platform:\\n assert pyserial_port_name in ndi_port_names\",\n \"def get_ports_list() -> List[str]:\\n return [comport.device for comport in serial.tools.list_ports.comports()]\",\n \"def serial_port(self):\\n for port in comports():\\n try:\\n s = Serial(port[0])\\n s.close()\\n return port[0]\\n except SerialException as e:\\n continue\",\n \"def com_select():\\n if 'win' in sys.platform:\\n ports = [x.device\\n for x in comports()]\\n else:\\n ports = ['/dev/' + x.device\\n for x in comports() if 'AMA' not in x.name and x.name]\\n return ports\",\n \"def buscarPuertos():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def get_serial_ports():\\n ports_detailed = [tuple(port) for port in list(serial.tools.list_ports.comports())]\\n ports = []\\n for port in ports_detailed:\\n ports.append(port[0])\\n return ports\",\n \"def get_available_serials():\\n ports_string = subprocess.check_output(['python3', '-m', 'serial.tools.list_ports']).decode(\\\"utf-8\\\").strip()\\n print(\\\"FOUND: \\\" + ports_string)\\n if len(ports_string) == 0:\\n print(\\\"stubs used as no ports found\\\")\\n return [\\\"/dev/ttyUSB0\\\", \\\"/dev/ttyUSB1\\\"]\\n return ports_string.split('\\\\n')\",\n \"def com_port():\\n port = ListPortInfo(DEFAULT_PORT)\\n port.serial_number = \\\"1234\\\"\\n port.manufacturer = \\\"Virtual serial port\\\"\\n port.device = DEFAULT_PORT\\n port.description = \\\"Some serial port\\\"\\n\\n return port\",\n \"def _discover_port(self):\\n # if MAC get list of ports\\n if sys.platform.startswith('darwin'):\\n locations = glob.glob('/dev/tty.[usb*]*')\\n locations = glob.glob('/dev/tty.[wchusb*]*') + locations\\n locations.append('end')\\n # for everyone else, here is a list of possible ports\\n else:\\n locations = ['dev/ttyACM0', '/dev/ttyACM0', '/dev/ttyACM1',\\n '/dev/ttyACM2', '/dev/ttyACM3', '/dev/ttyACM4',\\n '/dev/ttyACM5', '/dev/ttyUSB0', '/dev/ttyUSB1',\\n '/dev/ttyUSB2', '/dev/ttyUSB3', '/dev/ttyUSB4',\\n '/dev/ttyUSB5', '/dev/ttyUSB6', '/dev/ttyUSB7',\\n '/dev/ttyUSB8', '/dev/ttyUSB9',\\n '/dev/ttyUSB10',\\n '/dev/ttyS0', '/dev/ttyS1', '/dev/ttyS2',\\n '/dev/tty.usbserial', '/dev/tty.usbmodem', 'com2',\\n 'com3', 'com4', 'com5', 'com6', 'com7', 'com8',\\n 'com9', 'com10', 'com11', 'com12', 'com13',\\n 'com14', 'com15', 'com16', 'com17', 'com18',\\n 'com19', 'com20', 'com21', 'com1', 'end'\\n ]\\n\\n detected = None\\n for device in locations:\\n try:\\n serialport = serial.Serial(device, 57600, timeout=0)\\n detected = device\\n serialport.close()\\n break\\n except serial.SerialException:\\n if device == 'end':\\n if self.log_output:\\n logging.exception(\\n 'Unable to find Serial Port, Please plug in '\\n 'cable or check cable connections.')\\n else:\\n print('Unable to find Serial Port, Please plug in '\\n 'cable or check cable connections.')\\n detected = None\\n exit()\\n if self.log_output:\\n log_string = 'Using COM Port: ' + detected\\n logging.info(log_string)\\n else:\\n print('{}{}\\\\n'.format('Using COM Port:', detected))\\n return detected\",\n \"def findDevices(self):\\n devs = []\\n for name, (serServer, port) in self.serialLinks.items():\\n if serServer not in self.client.servers:\\n continue\\n server = self.client[serServer]\\n ports = yield server.list_serial_ports()\\n if port not in ports:\\n continue\\n devName = '%s - %s' % (serServer, port)\\n devs += [(devName, (server, port))]\\n returnValue(devs)\",\n \"def findDevices(self):\\n devs = []\\n for name in self.serialLinks:\\n port = self.serialLinks[name]\\n if name not in self.client.servers:\\n continue\\n server = self.client[name]\\n ports = yield server.list_serial_ports()\\n print ports\\n if port not in ports:\\n continue\\n devName = '%s - %s' % (name, port)\\n devs += [(devName, (server, port))]\\n returnValue(devs)\",\n \"def serial_path():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\",\n \"def serial_ports():\\n if sys.platform.startswith('win'):\\n ports = ['COM%s' % (i + 1) for i in range(256)]\\n elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):\\n # this excludes your current terminal \\\"/dev/tty\\\"\\n ports = glob.glob('/dev/tty[A-Za-z]*')\\n elif sys.platform.startswith('darwin'):\\n ports = glob.glob('/dev/tty.*')\\n else:\\n raise EnvironmentError('Unsupported platform')\\n\\n result = []\\n for port in ports:\\n try:\\n s = serial.Serial(port)\\n s.close()\\n result.append(port)\\n except (OSError, serial.SerialException):\\n pass\\n return result\\n\\n\\n # isAngleChanged = True\\n # pastAngle = Current_Coord['ang']\\n # resetStates()\\n # # temp\\n # angle = 0\\n # while current_mode == mode['Mapping']:\\n # updateCurrCordinate(distance, angle)\\n # # needs a way to keep track if the distance and the angle has changed!!\\n # # if angle is changed the first time; add onto the trace.\\n # if angle != pastAngle:\\n # if not isAngleChanged:\\n # addCurrToParameter()\\n # isAngleChanged = 1\\n # pastAngle = angle\\n # # Has stopped rotating and back to moving.\\n # if isAngleChanged and distance != 0:\\n # isAngleChanged = 0\\n # # when it exists the while loop == the bot has stopped. adding stopping point\\n # # into the list\\n # addCurrToParameter()\",\n \"def look_for_available_ports():\\n available_ports = glob.glob('/dev/ttyACM*')\\n print(\\\"Available porst: \\\")\\n print(available_ports)\\n\\n return available_ports\",\n \"def list_ports():\\n print '\\\\nHere is the list of available ports on this machine:'\\n # lp.comports returns a list of (port, description, hardware ID) tuples\\n iterator = sorted(lp.comports())\\n for port, desc, hwid in iterator:\\n print port\\n exit()\",\n \"def find_COM(self, cmd, name, ctrl_port, pbar=None):\\n \\n for self.port in [ctrl_port] + ['COM%s' % (i + 1) for i in range(256)]:\\n\\n try:\\n # open the port\\n self.ser = serial.Serial(self.port, baudrate=9600, timeout=0.2)\\n\\n # send an identifier command\\n self.ser.write(cmd)\\n time.sleep(0.2)\\n\\n # read the response\\n resp = self.ser.read(100)\\n \\n if resp[:len(name)] == name:\\n # run initialization if a valid port was open\\n self.initialize(pbar=pbar)\\n break\\n \\n else:\\n self.ser.close()\\n \\n except:\\n pass\",\n \"def enumerate_midi_devices(self):\\n\\n ports = self.midiout.get_ports()\\n\\n return ports\",\n \"def GetDeviceSerials(self):\\n return self._device_serial_index.keys()\",\n \"def read_all_rom_ports(self):\\n return self.ROM_PORT\",\n \"def _com_port(self, tid):\\n winreg.Enum = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,\\n r'SYSTEM\\\\CurrentControlSet\\\\Enum')\\n usb_devs = winreg.OpenKey(winreg.Enum, 'USB')\\n logger.debug(\\\"_com_port usb_devs %r\\\",\\n list(self.iter_keys_as_str(usb_devs)))\\n\\n logger.debug(\\\"_com_port looking up usb id in all usb devices\\\")\\n dev_keys = []\\n for name, vid in zip(self.iter_keys_as_str(usb_devs),\\n self.iter_keys(usb_devs)):\\n try:\\n dev_keys.append(winreg.OpenKey(vid, tid))\\n if logger.isEnabledFor(DEBUG):\\n logger.debug(\\n \\\"Found usb id %s in %s with subkeys %r\\\", tid, name,\\n list(self.iter_keys_as_str(winreg.OpenKey(vid, tid))))\\n except OSError:\\n pass\\n\\n logger.debug(\\\"_com_port Detecting port with Device Parameter\\\")\\n for key in dev_keys:\\n try:\\n param = winreg.OpenKey(key, \\\"Device Parameters\\\")\\n port, regtype = winreg.QueryValueEx(param, 'PortName')\\n logger.debug('_com_port port %r regtype %r', port, regtype)\\n return port\\n except OSError as e:\\n logger.debug(\\\"Exception %r %s\\\", key, str(e))\\n pass\\n\\n logger.debug(\\\"_com_port Detecting port by following symlinks\\\")\\n for key in dev_keys:\\n try:\\n ports = []\\n parent_id, regtype = winreg.QueryValueEx(key, 'ParentIdPrefix')\\n logger.debug(\\\"_com_port parent_id %r regtype %r\\\")\\n for VID in self.iter_keys(usb_devs):\\n candidate_keys = [k for k in self.iter_keys_as_str(VID)\\n if parent_id in k]\\n for dev in candidate_keys:\\n logger.debug(\\n \\\"_com_port recursive port detection with %r\\\", dev)\\n maybe_port = self._com_port(dev)\\n if maybe_port:\\n return maybe_port\\n except OSError as e:\\n logger.debug(\\\"Exception %r %s\\\", key, str(e))\\n pass\\n\\n # If everything fails, return None\\n return None\",\n \"def get_all_device_ports() -> List[str]:\\n devices = [comport.device for comport in serial.tools.list_ports.comports()]\\n result = list()\\n for comport in devices:\\n try:\\n # find comport with our device\\n ser = serial.Serial(comport, timeout=0.2)\\n command: bytes = bytes(\\\"ping\\\\r\\\\n\\\", encoding='utf-8')\\n ser.write(command)\\n answer: str = ser.readall().decode('utf-8')\\n ser.close()\\n if 'Ok' in answer:\\n result.append(comport)\\n except serial.SerialException:\\n continue\\n return result\",\n \"def list_ports(self):\\n return self.ironic_client.port.list()\",\n \"def get_working_serial_ports(excludes=()):\\n excludes = set(excludes)\\n # Last command is included so that it's compatible with OS X Sierra\\n # Note: If you are running OS X Sierra, do not access the directory through vagrant ssh\\n # Instead access it through Volumes/vagrant/PieCentral\\n ports = set(glob.glob(\\\"/dev/ttyACM*\\\") + glob.glob(\\\"/dev/ttyUSB*\\\")\\n + glob.glob(\\\"/dev/tty.usbmodem*\\\"))\\n ports.difference_update(excludes)\\n try:\\n virtual_device_config_file = os.path.join(os.path.dirname(__file__), \\\"virtual_devices.txt\\\")\\n ports.update(open(virtual_device_config_file, \\\"r\\\").read().split())\\n except IOError:\\n pass\\n\\n serials = []\\n port_names = []\\n for port in ports:\\n try:\\n serials.append(serial.Serial(port, 115200))\\n port_names.append(port)\\n except serial.serialutil.SerialException:\\n print(\\\"Cannot Open Serial Port: \\\" + str(port))\\n return serials, port_names\",\n \"def get_port_list(self):\\r\\n self.ports = Manager().dict()\\r\\n self.value = Manager().dict()\\r\\n self.sensors = dict()\\r\\n for p in self.device.ports['input']:\\r\\n if p.enabled:\\r\\n self.ports[p.number] = p\\r\\n self.value[p.number] = 'Connexion à la carte'\\r\\n self.sensors[p.number] = Sensor.get(p._type)\",\n \"def getListOfPorts(self):\\n return _libsbml.CompModelPlugin_getListOfPorts(self)\",\n \"def port_list(self):\\n return self._port_list\",\n \"def __set_port_list(self):\\n\\n self._coms = [str(i.device) for i in sorted(self.ports)]\",\n \"def print_serial_ports():\\n for port, description, hwid in sorted(comports()):\\n print(f\\\"{port!r}\\\\n description: {description!r}\\\\n hwid: {hwid!r}\\\")\",\n \"def find_ports(self):\\n\\n #\\n # If a port is searching for Myo devices, wait\\n #\\n port_searching = False\\n for port in self.ports_searching.keys():\\n if self.ports_searching[port]:\\n port_searching = True\\n break\\n\\n if port_searching:\\n self.warn_user(\\\"A port is currently searching for devices.\\\")\\n return\\n\\n self.myo_counts.clear()\\n self.ports_found.clear()\\n self.progress_bars.clear()\\n\\n expec_manufac = \\\"Bluegiga\\\"\\n expec_name = \\\"Low Energy Dongle\\\"\\n ports_found = 0\\n\\n for port in comports():\\n #\\n # If this is a Bluegiga - Low Energy Dongle\\n #\\n port_attr = port.__dict__\\n if not (\\n (\\\"manufacturer\\\" in port_attr.keys()) and\\n ((\\\"product\\\" in port_attr.keys()) or (\\\"description\\\" in port_attr.keys())) and\\n (\\\"device\\\" in port_attr.keys())\\n ):\\n continue\\n\\n if not (\\n (expec_manufac in port_attr[\\\"manufacturer\\\"]) or\\n ((expec_name in port_attr[\\\"product\\\"]) and (expec_name in port_attr[\\\"description\\\"]))\\n ):\\n continue\\n\\n # Styling\\n port_list_entry = QListWidgetItem(port_attr[\\\"device\\\"])\\n port_list_entry.setIcon(QIcon(join(abspath(__file__).replace(\\\"data_tools.py\\\", \\\"\\\"), \\\"icons/sp.png\\\")))\\n port_list_entry.port_idx = ports_found\\n port_list_entry.port = port_attr[\\\"device\\\"]\\n self.ports_found.insertItem(ports_found, port_list_entry);\\n ports_found += 1\\n self.myo_counts.append(0) # No Myo devices found for this newly found port yet\",\n \"def refresh(self):\\n self.ports = list(serial.tools.list_ports.comports())\",\n \"def detect_ports():\\n devices = []\\n for p in list_ports.comports():\\n for d in DESCRIPTORS:\\n if d in p.device.lower():\\n _in = p.hwid\\n devices.append(p.device)\\n return devices\",\n \"def find_arduino(portsfound):\\r\\n comPort = 'None'\\r\\n num_of_connection = len(portsfound)\\r\\n\\r\\n for i in range(0, num_of_connection):\\r\\n port = foundPorts[i]\\r\\n cnvt_str_port = str(port)\\r\\n\\r\\n if 'ttyACM' in cnvt_str_port:\\r\\n splitPort = cnvt_str_port.split(' ')\\r\\n comPort = (splitPort[0])\\r\\n\\r\\n return comPort\",\n \"def ports(self):\\r\\n # check connected to chip\\r\\n if not self._core.is_connected():\\r\\n raise ka_exceptions.NotConnectedError()\\r\\n\\r\\n # check symbols are loaded\\r\\n self._core.sym.assert_have_symbols()\\r\\n\\r\\n # get the symbols we need\\r\\n READ_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.read_port_offset_addr')\\r\\n WRITE_OFFSET_ADDR = self._core.sym.varfind('$cbuffer.write_port_offset_addr')\\r\\n READ_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.read_port_limit_addr')\\r\\n WRITE_LIMIT_ADDR = self._core.sym.varfind('$cbuffer.write_port_limit_addr')\\r\\n READ_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.read_port_buffer_size')\\r\\n WRITE_BUFFER_SIZE = self._core.sym.varfind('$cbuffer.write_port_buffer_size')\\r\\n\\r\\n def read_dm(addr):\\r\\n return self._core.dm[addr]\\r\\n\\r\\n # get the read and write offset\\r\\n read_offset_addr = self._read_var_with_size_check(READ_OFFSET_ADDR.addr, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_offset_addr = self._read_var_with_size_check(WRITE_OFFSET_ADDR.addr, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n read_offset = map(read_dm, read_offset_addr)\\r\\n write_offset = map(read_dm, write_offset_addr)\\r\\n\\r\\n # get the read and write limit\\r\\n read_limit_addr = self._read_var_with_size_check(READ_LIMIT_ADDR.addr, READ_LIMIT_ADDR.size_in_addressable_units)\\r\\n write_limit_addr = self._read_var_with_size_check(WRITE_LIMIT_ADDR.addr, WRITE_LIMIT_ADDR.size_in_addressable_units)\\r\\n read_limit = map(read_dm, read_limit_addr)\\r\\n write_limit = map(read_dm, write_limit_addr)\\r\\n\\r\\n # get the port size\\r\\n read_size = self._read_var_with_size_check(READ_BUFFER_SIZE.addr, READ_BUFFER_SIZE.size_in_addressable_units)\\r\\n write_size = self._read_var_with_size_check(WRITE_BUFFER_SIZE.addr, WRITE_BUFFER_SIZE.size_in_addressable_units)\\r\\n # calculate size mask (size-1) for non-zero sizes\\r\\n read_mask = map(lambda s: s - (s>0), read_size)\\r\\n write_mask = map(lambda s: s - (s>0), write_size)\\r\\n\\r\\n # calculate data/space in port\\r\\n read_data = map(lambda l,o,m: (l - o) & m, read_limit, read_offset, read_mask)\\r\\n write_space = map(lambda l,o,m: (l - o) & m - 1, write_limit, write_offset, write_mask)\\r\\n\\r\\n # read port configs\\r\\n READ_CONF_BASE = self._core.sym.constfind('$READ_PORT0_CONFIG').value\\r\\n WRITE_CONF_BASE = self._core.sym.constfind('$WRITE_PORT0_CONFIG').value\\r\\n read_conf = self._read_var_with_size_check(READ_CONF_BASE, READ_OFFSET_ADDR.size_in_addressable_units)\\r\\n write_conf = self._read_var_with_size_check(WRITE_CONF_BASE, WRITE_OFFSET_ADDR.size_in_addressable_units)\\r\\n\\r\\n # extract data size (in octets) from config\\r\\n read_data_size = map(lambda c: (c & 0x3) + 1, read_conf)\\r\\n write_space_size = map(lambda c: (c & 0x3) + 1, write_conf)\\r\\n\\r\\n # decode configs into strings\\r\\n read_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"No Sign Ext\\\" if (c & 0x8) else \\\"Sign Ext\\\" ), \\\\\\r\\n read_conf, read_data_size)\\r\\n write_conf_str = map(lambda c,s: (\\\"8\\\" if s==1 else (\\\"16\\\" if s==2 else (\\\"24\\\" if s==3 else \\\"??\\\"))) + \\\"-bit, \\\" \\\\\\r\\n + (\\\"Big Endian\\\" if (c & 0x4) else \\\"Little Endian\\\") + \\\", \\\" \\\\\\r\\n + (\\\"Saturate\\\" if (c & 0x8) else \\\"No Saturate\\\"), \\\\\\r\\n write_conf, write_space_size)\\r\\n\\r\\n # print information\\r\\n print \\\"Read ports:\\\\n Port Status Offset Address Size(Bytes) Data Config\\\"\\r\\n for i in range(len(read_offset_addr)):\\r\\n if read_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, read_offset_addr[i], read_offset_addr[i], read_size[i], read_size[i], read_data[i]/read_data_size[i], read_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\\r\\n\\r\\n print \\\"Write ports:\\\\n Port Status Offset Address Size(Bytes) Space Config\\\"\\r\\n for i in range(len(write_offset_addr)):\\r\\n if write_offset_addr[i]:\\r\\n print \\\" %2i Enabled %6i (0x%04X) %5i (0x%04X) %5i %s\\\" % \\\\\\r\\n (i, write_offset_addr[i], write_offset_addr[i], write_size[i], write_size[i], write_space[i]/write_space_size[i], write_conf_str[i])\\r\\n else:\\r\\n print \\\" %2i Disabled\\\" % i\",\n \"def get_ftdi_ports():\\n ftdi_vid = 0x0403\\n ftdi_pid = 0x6001\\n\\n # Get a list of FTDI Com Ports based on their VID/PID\\n ftdi_ports = []\\n com_ports = list_ports.comports()\\n\\n for port in com_ports:\\n if port.vid == ftdi_vid and port.pid == ftdi_pid:\\n ftdi_ports.append(port.device)\\n return ftdi_ports\",\n \"def _get_available_usb_devices(self, regexp=None, include_links=True) -> list:\\n logger.debug(\\n f\\\"_get_available_usb_devices(regexp={regexp}, include_links={include_links})\\\"\\n )\\n if not regexp:\\n ports = serial_list_ports.comports(include_links=include_links)\\n else:\\n # cast as list because it's a generator and I want an easy return type\\n # How many USB devices could a user possibly have?\\n ports = list(\\n serial_list_ports.grep(regexp=regexp, include_links=include_links)\\n )\\n return ports\",\n \"def enumerate_devices():\\n devices = list(\\n map(XInputJoystick, list(range(XInputJoystick.max_devices))))\\n return [device for device in devices if device.is_connected()]\",\n \"def get_platform_serial_port():\\n return get_system_serial_port(platform.system())\",\n \"def probe_ports( self, ):\\r\\n ports = self.com_driver.list_available()\\r\\n self.gui.print_info_string( \\\"\\\" )\\r\\n self.gui.print_info_string( \\\"Reported Ports from driver:\\\" )\\r\\n self.gui.print_info_string( \\\"\\\" )\\r\\n if len( ports ) == 0:\\r\\n self.gui.print_info_string( \\\"None \\\\n\\\" )\\r\\n else:\\r\\n for i_port in ports:\\r\\n self.gui.print_info_string( i_port[0] )\\r\\n #self.gui.print_info_string( \\\"\\\\n\\\" )\\r\\n\\r\\n self.close_driver()\\r\\n\\r\\n self.gui.print_info_string( \\\"\\\\nProbe Ports from parameters:\\\\n\\\" )\\r\\n ports = self.com_driver.probe_available( self.parameters.port_list )\\r\\n ix_line = 0 # what is this ??\\r\\n for i_port in ports:\\r\\n ix_line += 1\\r\\n self.gui.print_info_string( str( i_port ) )\\r\\n if ix_line == 10:\\r\\n ix_line = 0\\r\\n self.gui.print_info_string( \\\"\\\\n\\\" )\\r\\n #logger.log( fll, a_str )\\r\\n\\r\\n return\",\n \"def get_serial_port(self, nIndex):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetSerialPort', self.handle, nIndex))\",\n \"def _GetPorts(self):\\n ports = []\\n for start, end in self.term.destination_port:\\n if start == end:\\n ports.append(str(start))\\n else:\\n ports.append('%d-%d' % (start, end))\\n return ports\",\n \"def getDeviceSwitchPorts(self, serial: str):\\n\\n metadata = {\\n 'tags': ['switch', 'configure', 'ports'],\\n 'operation': 'getDeviceSwitchPorts',\\n }\\n resource = f'/devices/{serial}/switch/ports'\\n\\n return self._session.get(metadata, resource)\",\n \"def find_valons_with_dmesg():\\n \\n try:\\n dmesg = check_output('dmesg | grep \\\"FT232RL\\\"',shell=True)\\n except subprocess.CalledProcessError:\\n # grep failed so no ports found\\n return []\\n lines = dmesg.split('\\\\n')\\n lines = [x for x in lines if len(x) > 0]\\n m = usbre.search(lines[-1])\\n usbport = m.group('port')\\n try:\\n dmesg = check_output(('dmesg | grep \\\"usb %s.*now attached to\\\"' % usbport),shell=True)\\n except subprocess.CalledProcessError:\\n # grep failed so no ports found\\n return []\\n lines = dmesg.split('\\\\n')\\n lines = [x for x in lines if len(x) > 0]\\n lines = lines[-1:]\\n ports = []\\n for ln in lines[::-1]:\\n idx = ln.find('ttyUSB')\\n if idx >= 0:\\n port = '/dev/' + ln[idx:]\\n if port not in ports:\\n ports.append(port)\\n return ports\",\n \"def get_keys(cell):\\n return list(cell.portlist.keys())\",\n \"def _find_serial_connection():\\n import serial.tools.list_ports\\n\\n # Generate a search string including our VID/PID.\\n vid_pid = f\\\"{ApolloDebugger.VENDOR_ID:04x}:{ApolloDebugger.PRODUCT_ID:04x}\\\"\\n\\n for port in serial.tools.list_ports.grep(vid_pid):\\n return serial.Serial(port.device, USBAnalyzerApplet._BAUD_RATE)\\n\\n raise IOError(\\\"could not find a debug connection!\\\")\",\n \"def get_serial_ports_count(self):\\n\\t\\treturn call_sdk_function('PrlSrvCfg_GetSerialPortsCount', self.handle)\",\n \"def get_ports(cls):\\n return cls._open_ports.copy()\",\n \"def _list_modi_ports() -> List[ListPortInfo]:\\n def __is_modi_port(port):\\n return (\\n port.manufacturer == \\\"LUXROBO\\\"\\n or port.product == \\\"MODI Network Module\\\"\\n or port.description == \\\"MODI Network Module\\\"\\n or (port.vid == 12254 and port.pid == 2))\\n\\n return [port for port in stl.comports() if __is_modi_port(port)]\",\n \"def list_ports():\\n non_working_ports = []\\n dev_port = 0\\n working_ports = []\\n available_ports = []\\n while len(non_working_ports) < 6: # if there are more than 5 non working ports stop the testing. \\n camera = cv2.VideoCapture(dev_port)\\n if not camera.isOpened():\\n non_working_ports.append(dev_port)\\n print(\\\"Port %s is not working.\\\" %dev_port)\\n else:\\n is_reading, img = camera.read()\\n w = camera.get(3)\\n h = camera.get(4)\\n if is_reading:\\n print(\\\"Port %s is working and reads images (%s x %s)\\\" %(dev_port,h,w))\\n working_ports.append(dev_port)\\n else:\\n print(\\\"Port %s for camera ( %s x %s) is present but does not reads.\\\" %(dev_port,h,w))\\n available_ports.append(dev_port)\\n dev_port +=1\\n return available_ports,working_ports,non_working_ports\",\n \"def get_serial_port(self, nIndex):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetSerialPort', self.handle, nIndex))\",\n \"def get_serial_ports_count(self):\\n\\t\\treturn call_sdk_function('PrlVmCfg_GetSerialPortsCount', self.handle)\",\n \"def read_all_ram_ports(self):\\n return self.RAM_PORT\",\n \"def updateAvailablePorts(self):\\n # Build a port list\\n device_list_all = comports()\\n self.device_choices = list()\\n for device in device_list_all:\\n self.device_choices.append(device[0])\\n\\n if len(self.device_choices) < 1:\\n tkinter.messagebox.showerror('No Available Serial Ports','No serial ports are available.')\",\n \"def scan():\\n debug(\\\"CBA4.scan()\\\")\\n num = MpOrLibUsb.get_device_count()\\n devices = []\\n i = 0\\n while i < num:\\n cba = CBA4(interface=MpOrLibUsb(i))\\n i += 1\\n sn = cba.get_serial_number()\\n if sn:\\n devices.append(sn)\\n cba.close()\\n #end loop\\n return devices\\n #end scan()\",\n \"def autoguessports(phonemodule):\\n\\n res=[]\\n\\n ports=[(islikelyportscore(port, phonemodule), port) for port in comscan.comscan()+usbscan.usbscan()+bitflingscan.flinger.scan() if port['available']]\\n\\n ports.sort()\\n\\n return [ (port['name'], port) for score,port in ports if score>=0]\",\n \"def exposed_ports(self) -> list[\\\"Port\\\"]:\\n _args: list[Arg] = []\\n _ctx = self._select(\\\"exposedPorts\\\", _args)\\n _ctx = Port(_ctx)._select_multiple(\\n _description=\\\"description\\\",\\n _port=\\\"port\\\",\\n _protocol=\\\"protocol\\\",\\n )\\n return _ctx.execute_sync(list[Port])\",\n \"def ask_for_port():\\n sys.stderr.write(\\\"\\\\n--- Available ports:\\\\n\\\\n\\\")\\n ports = []\\n # for n, (port, desc, hwid) in enumerate(sorted(comports()), 1):\\n for n, (port, desc, hwid) in enumerate(\\n sorted(serial.tools.list_ports.grep(r\\\"usb\\\")), 1\\n ):\\n # sys.stderr.write(' {:2}: {:20}\\\\n\\\\n'.format(n, port))\\n sys.stderr.write(\\\" {:2}: {:20}: {}\\\\n\\\".format(n, port, desc))\\n ports.append(port)\\n if len(ports):\\n while True:\\n port = prompt_input(\\\"\\\\n--- Enter port index or full name or X to exit: \\\")\\n\\n sys.stderr.write(\\\"\\\\n\\\")\\n\\n if port.upper() == \\\"X\\\":\\n sys.exit(0)\\n try:\\n index = int(port) - 1\\n if not 0 <= index < len(ports):\\n LOGGER.warning(\\\"*** Invalid index!\\\")\\n continue\\n except ValueError:\\n pass\\n else:\\n port = ports[index]\\n return port\\n else:\\n LOGGER.warning(\\\"*** No serial ports detected ... aborting\\\")\\n sys.exit(0)\",\n \"def taken_ports():\\n odoo = 'odoo' if env.api.system != 'wheezy' else 'openerp'\\n ports = sudo('grep _port /srv/{odoo}/*/*cfg /srv/{odoo}/*/*/*cfg'\\n '|cut -d= -f2|sort|uniq'\\n .format(odoo=odoo)).splitlines()\\n ports += sudo('grep \\\\.bind /srv/{odoo}/*/*cfg /srv/{odoo}/*/*/*cfg'\\n '|cut -d= -f2|cut -d: -f2|sort|uniq'\\n .format(odoo=odoo)).splitlines()\\n ports = sorted(set(int(p.strip()) for p in ports if p.strip().isdigit()))\\n puts('Already taken ports: {}'.format(', '.join(str(p) for p in ports)))\\n if not ports: # assume 8000 is taken and is the first\\n ports = [8000]\\n return ports\",\n \"def get_ports(self) -> tuple:\\n return self._current_dev_manager.get_ports()\",\n \"def get_all_port(self, conf, dpid):\\n\\t\\tpass\",\n \"def get_subscribers():\\n # TODO: make calls to each device asynchronous so we don't block\\n # trying to read from an unresponsive device on start up.\\n PortList = serial.tools.list_ports.comports()\\n manager.executor = ThreadPoolExecutor(max_workers=len(PortList))\\n for port in PortList:\\n if port.device in IGNORE_LIST:\\n continue\\n log.info('Found {}'.format(port.device))\\n ser = serial.Serial(port.device, baudrate=115200)\\n looping = True\\n while looping:\\n b = pyvesc.encode(pyvesc.ReqSubscription('t'))\\n ser.reset_input_buffer()\\n ser.write(b)\\n l = ser.read()\\n if l == b'\\\\x02' or l == b'\\\\x03':\\n # It's a VESC message!\\n looping = not init_vesc_driver(port, ser, l)\\n else:\\n # It's a JSON message!\\n looping = not init_json_driver(port, ser, l)\",\n \"def discover_channels(path, serial_number, callback, cancellation_token, channel_termination_token, logger):\\n if path == None:\\n # This regex should match all desired port names on macOS,\\n # Linux and Windows but might match some incorrect port names.\\n regex = r'^(/dev/tty\\\\.usbmodem.*|/dev/ttyACM.*|COM[0-9]+)$'\\n else:\\n regex = \\\"^\\\" + path + \\\"$\\\"\\n\\n known_devices = []\\n def device_matcher(port_name):\\n if port_name in known_devices:\\n return False\\n return bool(re.match(regex, port_name))\\n\\n def did_disconnect(port_name, device):\\n device.close()\\n # TODO: yes there is a race condition here in case you wonder.\\n known_devices.pop(known_devices.index(port_name))\\n\\n while not cancellation_token.is_set():\\n all_ports = find_pyserial_ports() + find_dev_serial_ports()\\n new_ports = filter(device_matcher, all_ports)\\n for port_name in new_ports:\\n try:\\n serial_device = SerialStreamTransport(port_name, DEFAULT_BAUDRATE)\\n input_stream = fibre.protocol.PacketFromStreamConverter(serial_device)\\n output_stream = fibre.protocol.StreamBasedPacketSink(serial_device)\\n channel = fibre.protocol.Channel(\\n \\\"serial port {}@{}\\\".format(port_name, DEFAULT_BAUDRATE),\\n input_stream, output_stream, channel_termination_token, logger)\\n channel.serial_device = serial_device\\n except serial.serialutil.SerialException:\\n logger.debug(\\\"Serial device init failed. Ignoring this port. More info: \\\" + traceback.format_exc())\\n known_devices.append(port_name)\\n else:\\n known_devices.append(port_name)\\n channel._channel_broken.subscribe(lambda: did_disconnect(port_name, serial_device))\\n callback(channel)\\n time.sleep(1)\",\n \"def parsePortName(portinfo):\\n portlist = []\\n for port in portinfo:\\n if sys.platform.startswith('win'):\\n portlist.append(port[0])\\n elif sys.platform.startswith('darwin') or sys.platform.startswith('linux'):\\n if 'usbserial' in port[0]:\\n namelist = port[0].split('-')\\n portlist.append(namelist[-1])\\n return portlist\",\n \"def _ports(self):\\n try:\\n return self._graph.node[self.node_id][\\\"_ports\\\"]\\n except KeyError:\\n log.debug(\\\"No interfaces initialised for %s\\\" % self)\\n return\",\n \"def get_ports(self):\\n return self._ports\",\n \"def get_open_port_numbers(host):\\n ports_per_host =[]\\n for h in host:\\n ports = h.findAll(\\\"port\\\")\\n for port in ports:\\n port_id = check_if_unicode(port[\\\"portid\\\"])\\n ports_per_host.append(port_id)\\n return ports_per_host\",\n \"def win_service_iter():\\n for name, display_name in cext.winservice_enumerate():\\n yield WindowsService(py2_strencode(name), py2_strencode(display_name))\",\n \"def _init_hw(self):\\n portlist = []\\n # try to exactly match by HID\\n if self.USB_HID:\\n match = list_ports.grep(self.USB_HID)\\n try: portlist.append(next(match))\\n except StopIteration:\\n logger.warning(\\\"no serial devices with deviceid=\\\\\\\"{!s}\\\\\\\" were found\\\".format(self.USB_HID))\\n\\n # try to match first available serial device\\n if not portlist:\\n logger.info(\\\"Discovering available serial devices...\\\")\\n portlist = list_ports.comports()\\n for p in list(portlist):\\n # TODO: this may be an imperfect check for a valid device\\n if p.vid is None:\\n portlist.remove(p)\\n\\n for p in portlist:\\n PORT = p.device\\n try:\\n self.serial = serial.Serial(PORT, self.BAUD, timeout=0, writeTimeout=0)\\n logger.info(\\\"Connected to serial device ({!s})\\\".format(device_info(p)))\\n if not hasattr(self.serial, 'cancel_read'):\\n self.serial.timeout = 1\\n break\\n except serial.serialutil.SerialException:\\n continue\\n\\n if self.serial is None:\\n if not portlist:\\n logger.warning(\\\"no serial devices were discovered\\\")\\n else:\\n logger.warning(\\\"failed to open connection to any of the discovered serial devices: %s\\\", *[\\\"\\\\n - {}\\\".format(device_info(p)) for p in portlist])\\n # logger.debug(p.device, p.name, p.description, p.hwid, p.vid, p.pid, p.serial_number, p.location, p.manufacturer, p.product, p.interface)\\n if not self.initialized:\\n self._activate_emulator_mode()\",\n \"def elite11_finder(serial_port) -> list[str]:\\n logger.debug(f\\\"Looking for Elite11 pumps on {serial_port}...\\\")\\n # Static counter for device type across different serial ports\\n if \\\"counter\\\" not in elite11_finder.__dict__:\\n elite11_finder.counter = 0 # type: ignore\\n\\n try:\\n link = HarvardApparatusPumpIO(port=serial_port)\\n except InvalidConfiguration:\\n # This is necessary only on failure to release the port for the other inspector\\n return []\\n\\n # Check for echo\\n link._serial.write(b\\\"\\\\r\\\\n\\\")\\n if link._serial.readline() != b\\\"\\\\n\\\":\\n # This is necessary only on failure to release the port for the other inspector\\n link._serial.close()\\n return []\\n\\n # Parse status prompt\\n pump = link._serial.readline().decode(\\\"ascii\\\")\\n if pump[0:2].isdigit():\\n address = int(pump[0:2])\\n else:\\n address = 0\\n\\n try:\\n test_pump = Elite11(\\n link,\\n syringe_diameter=\\\"20 mm\\\",\\n syringe_volume=\\\"10 ml\\\",\\n address=address,\\n )\\n asyncio.run(test_pump.pump_info())\\n except InvalidConfiguration:\\n # This is necessary only on failure to release the port for the other inspector\\n link._serial.close()\\n return []\\n\\n logger.info(f\\\"Elite11 found on <{serial_port}>\\\")\\n\\n # Local variable for enumeration\\n elite11_finder.counter += 1 # type: ignore\\n cfg = f\\\"[device.elite11-{elite11_finder.counter}]\\\" # type:ignore\\n cfg += dedent(\\n f\\\"\\\"\\\"\\n type = \\\"Elite11\\\"\\n port = \\\"{serial_port}\\\"\\n address = {address}\\n syringe_diameter = \\\"XXX mm\\\" # Specify syringe diameter!\\n syringe_volume = \\\"YYY ml\\\" # Specify syringe volume!\\\\n\\\\n\\\"\\\"\\\"\\n )\\n return [cfg]\",\n \"def port_channels(input_interfaces):\\n ports = []\\n for interface in input_interfaces:\\n interface_lower = str(interface).lower()\\n if interface_lower.startswith('po'):\\n ports.append(interface)\\n return ports\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.86018956","0.8531883","0.7983318","0.7983318","0.7980792","0.7802933","0.77502596","0.7742627","0.7668107","0.764201","0.7632164","0.7632164","0.7631555","0.75972277","0.75972277","0.75972277","0.75972277","0.7596552","0.75547063","0.7551492","0.75014937","0.7501313","0.7483864","0.7473284","0.7432911","0.74105287","0.7382988","0.7359116","0.7353058","0.7182947","0.71824706","0.7087124","0.70331615","0.70144826","0.70039964","0.6881585","0.68796206","0.6861981","0.6774171","0.67480505","0.6745203","0.67451596","0.66194594","0.6613773","0.6580788","0.64067644","0.63206035","0.6298562","0.62705946","0.6269923","0.62365615","0.62235963","0.61929154","0.61774445","0.6058916","0.6042555","0.6022337","0.59953445","0.5990893","0.5970008","0.5952247","0.5943144","0.5866773","0.5864557","0.585891","0.5853627","0.5848664","0.5838938","0.5829875","0.58239317","0.5823683","0.58230126","0.5806151","0.576453","0.576343","0.5749252","0.57370895","0.5736135","0.57259244","0.5704086","0.56745076","0.5674217","0.56688946","0.5655316","0.56271553","0.5622209","0.562086","0.5615651","0.56127656","0.55735844","0.5568965","0.5557259","0.55266404","0.55193555","0.5517406","0.55131346","0.5504527","0.5488601","0.54850477","0.54813105"],"string":"[\n \"0.86018956\",\n \"0.8531883\",\n \"0.7983318\",\n \"0.7983318\",\n \"0.7980792\",\n \"0.7802933\",\n \"0.77502596\",\n \"0.7742627\",\n \"0.7668107\",\n \"0.764201\",\n \"0.7632164\",\n \"0.7632164\",\n \"0.7631555\",\n \"0.75972277\",\n \"0.75972277\",\n \"0.75972277\",\n \"0.75972277\",\n \"0.7596552\",\n \"0.75547063\",\n \"0.7551492\",\n \"0.75014937\",\n \"0.7501313\",\n \"0.7483864\",\n \"0.7473284\",\n \"0.7432911\",\n \"0.74105287\",\n \"0.7382988\",\n \"0.7359116\",\n \"0.7353058\",\n \"0.7182947\",\n \"0.71824706\",\n \"0.7087124\",\n \"0.70331615\",\n \"0.70144826\",\n \"0.70039964\",\n \"0.6881585\",\n \"0.68796206\",\n \"0.6861981\",\n \"0.6774171\",\n \"0.67480505\",\n \"0.6745203\",\n \"0.67451596\",\n \"0.66194594\",\n \"0.6613773\",\n \"0.6580788\",\n \"0.64067644\",\n \"0.63206035\",\n \"0.6298562\",\n \"0.62705946\",\n \"0.6269923\",\n \"0.62365615\",\n \"0.62235963\",\n \"0.61929154\",\n \"0.61774445\",\n \"0.6058916\",\n \"0.6042555\",\n \"0.6022337\",\n \"0.59953445\",\n \"0.5990893\",\n \"0.5970008\",\n \"0.5952247\",\n \"0.5943144\",\n \"0.5866773\",\n \"0.5864557\",\n \"0.585891\",\n \"0.5853627\",\n \"0.5848664\",\n \"0.5838938\",\n \"0.5829875\",\n \"0.58239317\",\n \"0.5823683\",\n \"0.58230126\",\n \"0.5806151\",\n \"0.576453\",\n \"0.576343\",\n \"0.5749252\",\n \"0.57370895\",\n \"0.5736135\",\n \"0.57259244\",\n \"0.5704086\",\n \"0.56745076\",\n \"0.5674217\",\n \"0.56688946\",\n \"0.5655316\",\n \"0.56271553\",\n \"0.5622209\",\n \"0.562086\",\n \"0.5615651\",\n \"0.56127656\",\n \"0.55735844\",\n \"0.5568965\",\n \"0.5557259\",\n \"0.55266404\",\n \"0.55193555\",\n \"0.5517406\",\n \"0.55131346\",\n \"0.5504527\",\n \"0.5488601\",\n \"0.54850477\",\n \"0.54813105\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.860505"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85193,"cells":{"query":{"kind":"string","value":"Create scatter error plot to compare the Prediction. There is an example of how to use it in the main function below"},"document":{"kind":"string","value":"def scatter_error_plot(y_true, y_predict, datelist,\n xlab='Dates', ylab='Units sold', title='Error analysis',\n ticks_separation='weeks'):\n plt.style.use('seaborn')\n\n #create plot\n fig=plt.figure(figsize=(15,10))\n \n #plot things\n plt.plot(datelist,y_true, label=r'True Values' ,\n linestyle='--', linewidth=2)\n plt.plot(datelist,y_predict, label=r'Predicted Values',\n linestyle='--', linewidth=2)\n plt.scatter(datelist,y_true)\n plt.scatter(datelist,y_predict)\n \n #labels\n plt.xlabel(xlab)\n plt.ylabel(ylab)\n plt.title(title)\n \n #set ticks every week\n if ticks_separation == 'days':\n plt.gca().xaxis.set_major_locator(matplotlib.dates.DayLocator())\n \n elif ticks_separation == 'weeks':\n plt.gca().xaxis.set_major_locator(matplotlib.dates.WeekdayLocator())\n \n elif ticks_separation == 'months':\n plt.gca().xaxis.set_major_locator(matplotlib.dates.MonthLocator())\n \n elif ticks_separation == 'days':\n plt.gca().xaxis.set_major_locator(matplotlib.dates.YearLocator())\n\n \n #set week format\n plt.gca().xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%d %b'))\n \n \n plt.legend(loc='best')\n \n #increase all text\n ax=plt.gca()\n for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n ax.get_xticklabels() + ax.get_yticklabels() + ax.legend().get_texts()):\n item.set_fontsize(18)\n \n \n return fig"},"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 plot_errors(self):\n\n plt.title(\"Prediction Error\")\n plt.plot(self.errors)\n plt.ylabel(\"MSE (Mean Squared Error)\")\n plt.xlabel(\"Iteration\")\n plt.show()","def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\n\tcompObserved = []\n\tSStotalWarmth = 0\n\tSSresWarmth = 0\n\tSStotalComp = 0\n\tSSresComp = 0\n\tkeys = parser.getMappings(normalized)[0].keys()\n\tfor key in keys:\n\n\t\tif \"_\" in key:\n\t\t\twarmthAxis, compAxis = getPlotData(key)\n\t\t\twarmthPred.append(warmthAxis[3])\n\t\t\twarmthObserved.append(warmthAxis[2])\n\t\t\tcompPred.append(compAxis[3])\n\t\t\tcompObserved.append(compAxis[2])\n\n\tmeanObservedWarmth = np.mean(warmthObserved)\n\tmeanObservedComp = np.mean(compObserved)\n\tfor i in range(0, len(warmthObserved)):\n\t\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\n\t\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\n\t\tSStotalComp += (compObserved[i] - meanObservedComp)**2\n\t\tSSresComp += (compObserved[i] - compPred[i])**2\n\n\n\tplt.axis([0, 100, 0, 100])\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.title(\"Observed vs Predicted Warmth\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(warmthObserved, warmthPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()\n\n\tfig = plt.figure(1)\n\tax = fig.add_subplot(111)\n\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\n\tprint(r_value**2)\n\ttext = ax.text(60, 20, \"R^2 value: \" + str(r_value**2) , \\\n fontsize = 12, color = 'black')\n\tplt.axis([0, 100, 0, 100])\n\tplt.title(\"Observed vs Predicted Competence\")\n\tplt.ylabel(\"Predicted Value\")\n\tplt.xlabel(\"Observed Value\")\n\tplt.scatter(compObserved, compPred)\n\tplt.plot([0,100], [0,100])\n\tplt.show()","def _draw_error_scatter(self, p1, p2, var, color='red', marker='*', ax=None, obslabels=None):\n\n if ax is None:\n f = pl.figure()\n ax = f.add_subplot(111)\n d1 = self._get_model_error(p1, var) # this gives a dict with (key,value)\n d2 = self._get_model_error(p2, var)\n\n if len(d1) == 0:\n return None\n if len(d2) == 0:\n return None\n\n x = []\n y = []\n labels = []\n for k in d1.keys():\n labels.append(k)\n x.append(d1[k])\n #find corresponding model in second observation\n for l in d2.keys():\n if l == k:\n y.append(d2[k])\n x = np.asarray(x)\n y = np.asarray(y)\n\n if len(x) != len(y):\n print(d1)\n print(d2)\n raise ValueError('The length of the arrays are not the same !')\n\n slope, intercept, r_value, p_value, std_err = stats.mstats.linregress(x, y)\n if r_value is None:\n return ax\n else:\n ax.plot(x, y, marker=marker, color=color, label=self._pos2label(p1, obslabels) + ' vs. ' + self._pos2label(p2, obslabels) + ' ($r$=' + str(round(r_value, 2)) + ')', linestyle='None')\n return ax","def _single_prediction_error_plot(self, scatter_data, color):\n # figure\n p = default_figure(\n {\n \"tools\": \"pan,wheel_zoom,box_zoom,reset\",\n \"toolbar_location\": \"right\"\n }\n )\n\n # scatter\n p.scatter(scatter_data[0], scatter_data[1], color=color, size=16, fill_alpha=0.8)\n\n # baseline of x=y\n slope = Slope(\n gradient=1,\n y_intercept=0,\n line_width=1,\n line_color=self.plot_design.models_dummy_color,\n line_dash=\"dashed\"\n )\n p.add_layout(slope)\n\n # plot specific styling\n p.xaxis.axis_label = \"Actual\"\n p.yaxis.axis_label = \"Predicted\"\n\n formatter = FuncTickFormatter(code=self._formatter_code) # negative numbers are having a wacky formatting\n # formatters must be created independently, cannot be reused between plots\n p.xaxis.formatter = formatter\n p.yaxis.formatter = formatter\n\n p.toolbar.autohide = True\n\n return p","def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\n fig, axes = plt.subplots()\n\n x = np.arange(len(losses))\n\n axes.plot(x, losses)\n axes.set_ylabel(\"Loss (cross entropy)\")\n axes.set_xlabel(\"Number of iterations\")\n axes.set_title(model_title) \n\n plt.show() \n\n return None","def plot_errors(loss_train, loss_val, jet):\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\n plt.xlabel('Epochs')\n plt.ylabel('Loss')\n plt.legend()\n plt.show()","def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\n plt.xlabel('Number of Epochs');\n plt.ylabel('RMSE');\n plt.legend()\n plt.grid()\n plt.savefig(\"../results/test_train_rmse_\"+path)\n plt.show()","def plot_model_error(x_train, x_test, y_train, y_test, model, \\\n save_fig_fname, label):\n # Assertions\n assert isinstance(x_train, np.ndarray)\n assert isinstance(x_test, np.ndarray)\n assert isinstance(y_train, np.ndarray)\n assert isinstance(y_test, np.ndarray)\n assert isinstance(save_fig_fname, (str, type(None))), \\\n 'Wrong Type: desired output file name must be a string'\n if type(save_fig_fname) is str:\n assert save_fig_fname.endswith('.png'),\\\n 'output_file string must include the .png extension'\n\n # Functionality\n y_train = y_train.reshape(-1,1)\n y_test = y_test.reshape(-1,1)\n plt.figure(figsize=(8, 10), dpi=100)\n plt.subplot(211)\n plt.scatter(y_train, model.predict(x_train), color='r', label='train')\n plt.scatter(y_test, model.predict(x_test), color='blue', label='test')\n plt.xlabel('Actual %s' % label, fontsize=12)\n plt.ylabel('Predicted %s' %label, fontsize=12)\n plt.legend(loc='upper center')\n\n plt.subplot(212)\n plt.scatter(y_train, model.predict(x_train)-y_train, color = 'r', \\\n label = 'train', marker= 'x')\n plt.scatter(y_test, model.predict(x_test)-y_test, color = 'blue', \\\n label = 'test', marker = 'x')\n plt.axhline(0, ls='--')\n plt.xlabel('Actual %s' % label, fontsize=12)\n plt.ylabel('Prediction error %s' % label, fontsize=12)\n plt.legend(loc='upper center')\n\n if save_fig_fname is not None:\n plt.savefig(save_fig_fname)\n else:\n plt.show()","def plot_model_error(self, var, obslabels=None):\n\n fig = plt.figure()\n gs = gridspec.GridSpec(1, 2, wspace=0.05, hspace=0.05, bottom=0.2, width_ratios=[3, 1])\n ax = fig.add_subplot(gs[0])\n\n # 1 vs. 2\n self._draw_error_scatter(1, 2, var, color='red', marker='o', ax=ax, obslabels=obslabels)\n\n # 1 vs. 3\n self._draw_error_scatter(1, 3, var, color='green', marker='*', ax=ax, obslabels=obslabels)\n\n # 1 vs. 4\n self._draw_error_scatter(1, 4, var, color='blue', marker='^', ax=ax, obslabels=obslabels)\n\n # 2 vs. 3\n self._draw_error_scatter(2, 3, var, color='grey', marker='x', ax=ax, obslabels=obslabels)\n\n # 2 vs 4\n self._draw_error_scatter(2, 4, var, color='m', marker='+', ax=ax, obslabels=obslabels)\n\n # 3 vs 4\n self._draw_error_scatter(3, 4, var, color='c', marker='h', ax=ax, obslabels=obslabels)\n\n if ax is not None:\n ax.legend(prop={'size': 8}, ncol=1, fancybox=True, loc='upper left')\n ax.set_xlabel('$\\epsilon$ (observation X)')\n ax.set_ylabel('$\\epsilon$ (observation Y)')\n\n xmi, xma = ax.get_xlim()\n ymi, yma = ax.get_ylim()\n\n ax.set_ylim(min(xmi, ymi), max(xma, yma))\n ax.set_xlim(min(xmi, ymi), max(xma, yma))\n ax.grid()\n ax.set_title('Comparison of model errors: ' + var.upper())\n ax.plot(ax.get_xlim(), ax.get_xlim(), 'k--') # 1:1 line\n return fig","def error():\n\n # Make data set using errors\n dataset_a = DataSet(oscillating,error_y=oscillating_error,plot='error_bar',label='Data and error')\n dataset_a.set_error(interval=5,width=1,cap=2)\n dataset_b = DataSet(oscillating,plot='error_shade',error_y=oscillating_error,order=0,colour='lightgrey',label='Error')\n dataset_c = DataSet(oscillating,plot='line',order=1,colour='firebrick',label='Data')\n\n # Make line graph with error bars\n plot_bar = Plot()\n plot_bar.set_legend(legend=True)\n plot_bar.add_dataset(dataset_a)\n plot_bar.plot()\n plot_bar.save(name='./figures/2d_error_bar',fmt='png')\n plot_bar.display()\n\n # Make line graph with shaded errors\n plot_shade = Plot()\n plot_shade.set_legend(legend=True,location='upper left')\n plot_shade.add_dataset(dataset_b)\n plot_shade.add_dataset(dataset_c)\n plot_shade.plot()\n plot_shade.save(name='./figures/2d_error_shade',fmt='png')\n plot_shade.display()","def scatter_plot(x_train, y_train, x_test, y_test, class1, class2):\n train_c0 = x_train[y_train == 0, :]\n train_c1 = x_train[y_train == 1, :]\n test_c0 = x_test[y_test == 0, :]\n test_c1 = x_test[y_test == 1, :]\n fig, a = plt.subplots(1, 2)\n fig.set_size_inches(11, 5)\n a[0].scatter(train_c0[:, 0], train_c0[:, 1], color='green', label=class1)\n a[0].scatter(train_c1[:, 0], train_c1[:, 1], color='red', label=class2)\n a[0].legend()\n a[0].set_title('Train Set')\n a[1].scatter(test_c0[:, 0], test_c0[:, 1], color='green', label=class1)\n a[1].scatter(test_c1[:, 0], test_c1[:, 1], color='red', label=class2)\n a[1].legend()\n a[1].set_title('Test Set')\n plt.show()","def plot_failures(features, labels, errors):\n model = TSNE(n_components=2, random_state=0, init=\"pca\", metric=\"correlation\")\n transformed = model.fit_transform(features)\n errors = map(lambda x: 30 if x else 10, errors)\n\n print(\"Data transformed, now plotting...\")\n\n # Plotting\n x = transformed[:, 0]\n y = transformed[:, 1]\n colors = labels\n areas = errors\n\n plt.scatter(x, y, c=colors, s=areas, edgecolors='none')\n plt.xlabel(\"t-SNE component 1\")\n plt.ylabel(\"t-SNE component 2\")\n plt.show()","def train_test_error(e_train, e_test, model_params):\n\n fig = plt.figure(figsize=FIG_SIZE)\n plt.plot(model_params, e_train, label='Training Set')\n plt.plot(model_params, e_train, label='Test Set')\n plt.xlabel('Model Parameter')\n plt.ylabel('MSE of model')\n plt.legend()\n\n return fig","def error_plot(training_costs, test_costs, learning_rate, accuracy, test_accuracy, val_accuracy, layers, data_size,\n n_neighbours, dropout_rate):\n\n plt.plot(training_costs, label=\"Training loss\")\n plt.plot(test_costs, label=\"Test loss\")\n plt.xlabel(\"Iterations\", size='medium')\n plt.ylabel(\"Cost function (%)\", size='medium')\n plt.suptitle(\"Cost function while training the neural network\", size='medium', ha='center')\n plt.title(\"layers: {} with dropout rate of {}, learning rate: {}\".format(layers, dropout_rate, learning_rate),\n size='small', ha='center')\n plt.figtext(0.77, 0.35, \"Training accuracy\\n{0:.2f}%\".format(accuracy), size='medium')\n plt.figtext(0.77, 0.25, \"Test accuracy\\n{0:.2f}%\".format(test_accuracy), size='medium')\n plt.figtext(0.77, 0.15, \"Validation accuracy\\n{0:.2f}%\".format(val_accuracy), size='medium')\n if n_neighbours == 0:\n plt.figtext(0.77, 0.80, \"Neighbours\\nexcluded\", size='medium')\n else:\n plt.figtext(0.77, 0.80, \"{} neighbours\\nincluded\".format(n_neighbours), size='medium')\n plt.figtext(0.77, 0.70, \"{}\\nsamples\".format(data_size))\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\n plt.subplots_adjust(right=0.75)\n working_dir = os.path.dirname(os.path.abspath(__file__))\n saving(working_dir + \"/output_ANN/error_plots/{}_error_{}\".format(n_neighbours, data_size))","def classificationError():\n print('Computing Classification Test Error')\n\n dl1, dl2 = CIFAR10TestLoader() \n err1, err2 = [], []\n\n # load every model \n with open('classification_error.csv','w') as clf:\n writer = csv.writer(clf)\n writer.writerow(['Classification Error Dataset 1','Classification Error Dataset 2'])\n\n for i in tqdm(range(5,95,2)):\n mtl = MTL()\n PATH = os.getcwd() + '/mtl_model_{d1}_vs_{d2}.pth'.format(d1=i, d2=100-i)\n mtl.load_state_dict(state_dict=torch.load(PATH))\n\n e1, e2 = accuracy(dl1, mtl), accuracy(dl2, mtl)\n err1.append(e1)\n err2.append(e2)\n writer.writerow([e1,e2])\n \n fig, ax_left = plt.subplots()\n ax_right = ax_left.twinx()\n ax_left.plot([0.05 + 0.02* i for i in range(45)], err1, color='black')\n ax_right.plot([0.05 + 0.02* i for i in range(45)], err2, color='red')\n ax_right.set_ylabel('Dataset 2 (red) accuracy')\n ax_left.set_ylabel('Dataset 1 (black) accuracy')\n ax_left.set_xlabel('Percentage of points from dataset 1 in training set')\n plt.title('Classification Accuracy over both datasets')\n plt.savefig('classification_error_plots.pdf')","def draw_bonus_error(error):\n f, ax = plt.subplots()\n vertices = np.arange(10, 50)\n ax.plot(vertices, error[10:], 'b', label='Error')\n plt.xlabel('Rounds')\n plt.ylabel('Misclassification Error')\n plt.title('Misclassification Error: l = 10, m = 20, n = 40')\n plt.legend(loc='upper left')\n plt.grid(True)\n plt.show()","def actual_pred_plot(preds):\r\n actual_pred = pd.DataFrame(columns=['Cost', 'prediction'])\r\n actual_pred['Cost'] = all_data['2020':].iloc[:, -1][1:len(preds) + 1]\r\n actual_pred['prediction'] = preds[:, -1]\r\n\r\n from keras.metrics import MeanSquaredError\r\n m = MeanSquaredError()\r\n m.update_state(np.array(actual_pred['Cost']), np.array(actual_pred['prediction']))\r\n\r\n return m.result().numpy(), actual_pred.plot()","def plot_scatter(self):\n if Trainer.y_pred is None or Trainer.y_true is None:\n messagebox.showerror(\"Information\", \"Please train the model first before plotting\")\n return\n\n fig = plt.figure(figsize=(8, 4))\n plt.xlabel(\"Prediction\")\n plt.ylabel(\"Target\")\n plt.figtext(0, 0, f\"RMSE: {self.test_rmse}\", fontsize=13)\n plt.grid()\n plt.scatter(x=Trainer.y_true, y=Trainer.y_pred, c='b', s=1)\n\n win = tk.Toplevel()\n win.wm_title(\"Window\")\n win.geometry(\"1000x500\")\n\n # specify the window as master\n canvas = FigureCanvasTkAgg(fig, master=win)\n canvas.draw()\n canvas.get_tk_widget().grid(row=0, column=0, sticky=tk.W)\n\n # navigation toolbar\n toolbarFrame = tk.Frame(master=win)\n toolbarFrame.grid(row=1, column=0)\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)","def plot_scatter(x_variable, y_variable, df, x_title, y_title):\n slope, intercept, r_value, p_value, std_err = stats.linregress(\n df[x_variable], df[y_variable])\n plot = sns.regplot(x=x_variable, y=y_variable, data=df, line_kws={'label':\n \"y={0:.3f}x+{1:.3f}\".format(slope, intercept)})\n plot.set(xlabel=x_title, ylabel=y_title + ' (K)')\n title = y_title + ' Versus ' + x_title\n plot.set_title(title)\n plot.legend()\n plot.figure.savefig(title.replace(' ', '_'))\n plt.figure()","def plot_error(k_vals, error):\n\n plt.plot(k_vals,error)\n plt.xlabel('k-value')\n plt.ylabel('Cost')\n plt.show()","def PlotComparison(result_values, descrete, continuous, jitter=100):\n df = result_values.copy()\n np.random.seed(0)\n df[continuous] = df[continuous] + np.random.randint(low=-jitter, high=jitter, size=len(df))\n base = alt.Chart(df).transform_calculate(\n ymin=\"datum.mean-2*datum.std\",\n ymax=\"datum.mean+2*datum.std\",\n ).properties(\n title = '[Interactive] Accuracy by Params'\n )\n \n points = base.mark_point(\n filled=True,\n size=10\n ).encode(\n x=continuous,\n y=alt.Y('mean:Q'),#, scale=alt.Scale(domain=(0.55, 0.7))),\n color=descrete,\n tooltip=['mean','std']\n )\n\n errorbars = base.mark_errorbar().encode(\n x=continuous,\n y=alt.Y(\"ymin:Q\",title='Accuracy'),\n y2=\"ymax:Q\",\n color=descrete,\n )\n\n return(points + errorbars)","def plot_error(class_incorreto):\n epochs = np.arange(1, num_iter + 1)\n plt.plot(epochs, class_incorreto)\n plt.xlabel('Iterações')\n plt.ylabel('Classificados incorretamente')\n plt.show()","def prediction_error_plot(self, prediction_errors):\n prediction_errors = assess_models_names(prediction_errors)\n _ = []\n i = 0\n for model, scatter_points in prediction_errors:\n if i == 0:\n color = self.plot_design.models_color_tuple[0]\n i += 1\n else:\n color = self.plot_design.models_color_tuple[1]\n plot = self._single_prediction_error_plot(scatter_points, color)\n _.append(Panel(child=plot, title=model))\n\n main_plot = Tabs(tabs=_)\n return main_plot","def plot_loss(training_errors, validation_errors):\n plt.xscale('Log')\n plt.xlabel('Epochs')\n plt.ylabel('Mean Actual Error')\n plt.plot(training_errors, label = \"Training Error\", \\\n color = 'blue')\n plt.plot(validation_errors, label = \"Validation Error\", \\\n color = 'red')\n plt.legend()\n # Saves plot automatically, adjust filename as needed.\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\n plt.show()","def display_errors(errors_index,img_errors,pred_errors, obs_errors):\n n = 0\n nrows = 3\n ncols = 3\n fig, ax = plt.subplots(nrows,ncols,sharex=True,sharey=True)\n for row in range(nrows):\n for col in range(ncols):\n error = errors_index[n]\n ax[row,col].imshow((img_errors[error]).reshape((28,28)))\n ax[row,col].set_title(\"Predicted label :{}\\nTrue label :{}\".format(pred_errors[error],obs_errors[error]))\n n += 1","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def plot_result(data, gt_y, pred_y):\n assert data.shape[0] == gt_y.shape[0]\n assert data.shape[0] == pred_y.shape[0]\n\n plt.figure()\n\n plt.subplot(1, 2, 1)\n plt.title('Ground Truth', fontsize=18)\n\n for idx in range(data.shape[0]):\n if gt_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.subplot(1, 2, 2)\n plt.title('Prediction', fontsize=18)\n\n for idx in range(data.shape[0]):\n if pred_y[idx] == 0:\n plt.plot(data[idx][0], data[idx][1], 'ro')\n else:\n plt.plot(data[idx][0], data[idx][1], 'bo')\n\n plt.show()","def prediction_error(y_true, y_pred, ax=None):\n _check_parameter_validity(y_true, y_pred)\n if ax is None:\n ax = plt.gca()\n\n model = LinearRegression()\n\n if isinstance(y_true, pd.Series):\n y_true = y_true.values\n y_reshaped = y_true.reshape((-1, 1))\n\n # it is necessary to fit the model with y_true and y_pred\n # to get the best fit line representing the error trend\n model.fit(y_reshaped, y_pred)\n x = np.linspace(min(min(y_true), min(y_pred)), max(max(y_true), max(y_pred)))\n y = model.intercept_ + model.coef_ * x\n ax.plot(x, y, \"-b\", label=\"best fit\")\n\n # identity line\n ax.plot(x, x, \"--k\", label=\"identity\")\n\n # scatter plot\n ax.scatter(y_true, y_pred)\n\n # R2\n r2 = model.score(y_reshaped, y_pred)\n plt.plot([], [], \" \", label=f\"R2 = {round(r2,5)}\")\n\n _set_ax_settings(ax, \"y_true\", \"y_pred\", \"Prediction Error\")\n ax.legend(loc=\"upper left\")\n return ax","def analysis_plot(predictions, ys):\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\n\n residuals = ys - predictions\n\n # Plot 1 - Predicted vs Actual\n sns.scatterplot(predictions, ys, ax=ax1)\n ax1.set_title('Predicted vs Actual', fontsize=20)\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\n\n # Plot 2 - Residuals PLot (predicted vs residuals)\n sns.scatterplot(predictions, residuals, ax=ax2)\n ax2.set_title('Residuals Plot', fontsize=20)\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\n\n # Plot 3 - QQ Plot\n sm.qqplot(residuals, ax=ax3, line='s')\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\n\n plt.show();","def _plot_errors(self):\n for task_id, loss_type in self.task_ids.iteritems():\n x = np.arange(len(self.training_errors[task_id]))\n fig, ax = plt.subplots(1, 1)\n ax.set_xlabel('Number of epochs of training')\n if loss_type is LossTypes.mse:\n ax.set_ylabel('RMSE Error')\n elif loss_type is LossTypes.cross_entropy:\n ax.set_xlabel('(1 - accuracy)')\n plt.plot(x, self.training_errors[task_id], 'r', label='training')\n plt.plot(x, self.validation_errors[task_id], 'b', label='validation')\n plt.legend(loc=\"best\", framealpha=0.3)\n fig.savefig(\"error-curve-task-{}.png\".format(task_id))\n plt.close('all')","def plot_cv_errors(errors, lambdas , K , path): \n colors = cycle([\"aqua\", \"black\", \"blue\", \"fuchsia\", \"gray\", \"green\", \"lime\", \"maroon\", \"navy\", \"olive\", \"purple\", \"red\", \"silver\", \"teal\", \"yellow\"])\n \n markers = cycle([ \".\", \",\", \"o\", \"v\" , \"^\" , \">\", \"1\", \"2\", \"3\", \"4\", \"8\", \"s\", \"p\", \"*\", \"h\"])\n \n \n for i, data in enumerate(errors):\n \n lambda_str = ('%f' % lambdas[i]).rstrip('0').rstrip('.')\n plt.plot(range(len(data)), data, marker=next(markers), label='$\\lambda$ = %s'%lambda_str);\n \n plt.ylim(0.975 , 0.99)\n #plt.xlim(0 , 50)\n plt.title('ALS-WR Learning Curve, K = %d'% K)\n plt.xlabel('Number of Epochs');\n plt.ylabel('RMSE');\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n plt.grid()\n plt.savefig(\"../results/\"+path)\n plt.show()","def plot_error(self, maxstep=20):\n plt.ion()\n plt.xlabel(\"step\")\n plt.ylabel(\"Ave Logloss (bits)\")\n train_errors = []\n if self.dataset.test:\n test_errors = []\n for i in range(maxstep):\n self.learn(1)\n train_errors.append( sum(self.logloss(tple) for tple in self.dataset.train)\n /len(self.dataset.train))\n if self.dataset.test:\n test_errors.append( sum(self.logloss(tple) for tple in self.dataset.test)\n /len(self.dataset.test))\n plt.plot(range(1,maxstep+1),train_errors,\n label=str(self.num_classes)+\" classes. Training set\")\n if self.dataset.test:\n plt.plot(range(1,maxstep+1),test_errors,\n label=str(self.num_classes)+\" classes. Test set\")\n plt.legend()\n plt.draw()","def graph_error_over_generation(self, with_scatter=False):\n mean_errors = []\n best_individual_errors = []\n\n for i in range(len(self.generations)):\n best_individual_errors.append(\n self.get_low_fitness_individual(i).fitness)\n mean_errors.append(\n np.mean([j.fitness for j in self.generations[i]]))\n\n plt.figure(figsize=(10, 5))\n ax = plt.subplot()\n if with_scatter:\n self.plot_error_scatter()\n mean_error_line, = plt.plot(\n range(len(self.generations)),\n mean_errors,\n label='Mean Error of Individuals',\n color='b')\n best_individual_error_line, = plt.plot(\n range(len(self.generations)),\n best_individual_errors,\n label='Lowest Error of an Individual',\n color='green')\n plt.xticks(\n [i for i in range(0, self.config.max_generations, 5)],\n [i for i in range(0, self.config.max_generations, 5)])\n hfont = {'fontname': 'Helvetica'}\n plt.xlabel('Generation', **hfont)\n plt.ylabel('Error', **hfont)\n ax.spines['right'].set_visible(False)\n ax.spines['top'].set_visible(False)\n\n plt.legend(\n handles=[mean_error_line, best_individual_error_line],\n loc='upper right',\n bbox_to_anchor=(1, 1.1))\n plt.savefig('figures/Parameter Tuning Figure/error_over_generation.svg')","def plot_scatter(df):\n fig = px.scatter(df, x=\"preds\", y=\"truth\", title=\"Predictions vs True Values\", color=\"mae\")\n wandb.log({f\"Predictions vs True Values\": fig})\n\n # Poor Results\n df = df.query(\"mae > 2\")\n fig = px.scatter(df, x=\"preds\", y=\"truth\", title=\"Predictions vs True Values\", color=\"mae\")\n wandb.log({f\"Predictions vs True Values [mae > 2]\": fig})","def scatter_with_err_bar(\n x: ArrayLike | str,\n y: ArrayLike | str,\n df: pd.DataFrame | None = None,\n xerr: ArrayLike | None = None,\n yerr: ArrayLike | None = None,\n ax: plt.Axes | None = None,\n xlabel: str = \"Actual\",\n ylabel: str = \"Predicted\",\n title: str | None = None,\n **kwargs: Any,\n) -> plt.Axes:\n x, y = df_to_arrays(df, x, y)\n ax = ax or plt.gca()\n\n styles = dict(markersize=6, fmt=\"o\", ecolor=\"g\", capthick=2, elinewidth=2)\n ax.errorbar(x, y, xerr=xerr, yerr=yerr, **kwargs, **styles)\n\n # identity line\n ax.axline((0, 0), (1, 1), alpha=0.5, zorder=0, linestyle=\"dashed\", color=\"black\")\n\n annotate_metrics(x, y, ax=ax)\n\n ax.set(xlabel=xlabel, ylabel=ylabel, title=title)\n\n return ax","def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\n train_x_pos = [0, 4, 8, 12]\n cv_x_pos = [1, 5, 9, 13]\n test_x_pos = [2, 6, 10, 14]\n ticks = cv_x_pos\n\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\n\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\n\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\n\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\n\n fig, ax = plt.subplots()\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\n ax.set_ylabel('Accuracy')\n ax.set_xticks(ticks)\n ax.set_xticklabels(labels)\n ax.set_title('Models')\n ax.yaxis.grid(True)\n ax.legend()\n plt.tight_layout()","def plot_data(x_plot, X_train, X_test, y_train, y_test, low, high):\n s = 15\n plt.plot(x_plot, ground_truth(x_plot), alpha=0.5, label='ground truth')\n plt.scatter(X_train, y_train, s=s, alpha=0.2)\n plt.scatter(X_test, y_test, s=s, alpha=0.2, color='red')\n plt.xlim((low, high))\n plt.ylabel('y')\n plt.xlabel('x')\n plt.legend(loc='upper left')\n plt.show()","def visualization(epochs, mse_tr, mse_te):\n plt.semilogx(epochs, mse_tr, marker=\".\", color='b', label='train error')\n plt.semilogx(epochs, mse_te, marker=\".\", color='r', label='test error')\n plt.xlabel(\"k\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation\")","def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_time):\n ax.plot([y_true.min(), y_true.max()],\n [y_true.min(), y_true.max()],\n '--r', linewidth=2)\n ax.scatter(y_true, y_pred, alpha=0.2)\n\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.get_xaxis().tick_bottom()\n ax.get_yaxis().tick_left()\n ax.spines['left'].set_position(('outward', 10))\n ax.spines['bottom'].set_position(('outward', 10))\n ax.set_xlim([y_true.min(), y_true.max()])\n ax.set_ylim([y_true.min(), y_true.max()])\n ax.set_xlabel('Measured')\n ax.set_ylabel('Predicted')\n extra = plt.Rectangle((0, 0), 0, 0, fc=\"w\", fill=False,\n edgecolor='none', linewidth=0)\n ax.legend([extra], [scores], loc='upper left')\n title = title + '\\n Evaluation in {:.2f} seconds'.format(elapsed_time)\n ax.set_title(title)","def reconstruction_errors(identifier, train_errors, vali_errors,\n generated_errors, random_errors):\n print(identifier)\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\n axarr[0].set_title(\"train reconstruction errors\")\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\n axarr[1].set_title('vali reconstruction errors')\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\n axarr[2].set_title('generated reconstruction errors')\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\n axarr[3].set_title('random reconstruction errors')\n for ax in axarr:\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"bottom\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n ax.spines[\"left\"].set_visible(False)\n ax.tick_params(bottom='off', left='off')\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n axarr[3].set_xlim(0, 0.05)\n plt.tight_layout()\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\n return True","def plot_regression(e_predict, e_true, ax=None, label='', e_max=0.5):\n ax = ax or plt.gca()\n ax.scatter(e_true, e_predict, lw=0, alpha=0.5, s=10)\n ax.set_xlabel('True shear')\n ax.set_ylabel('Predicted shear')\n ax.set_xlim(0, e_max)\n ax.set_ylim(0, e_max)\n ax.plot([0, e_max], [0, e_max], 'r--')\n R2 = sklearn.metrics.r2_score(e_true, e_predict)\n ax.text(0.05, 0.9, f'{label}$R^2 = {R2:.2f}$',\n transform=ax.transAxes, fontsize=16, color='r')","def build_scatterplot(budget):\n frame = load_frames(budget=budget)\n X = frame[metrics]\n Y = frame['y']\n\n predicted = cross_val_predict(get_best_models(budget=budget, tool=settings.algo), X, Y, cv=20)\n\n fig, ax = plt.subplots()\n ax.scatter(Y, predicted, edgecolors=(0, 0, 0))\n ax.plot([Y.min(), Y.max()], [Y.min(), Y.max()], 'k--', lw=4)\n ax.set_xlabel('Measured')\n ax.set_ylabel('Predicted')\n plt.savefig('{}/cv-error-{}-{}.pdf'.format(settings.PLOTS, settings.algo, budget))","def visualize_interactive_plot(df, err_param_name, data, scatter_cmap, reduced_data_column, on_click):\n df = df.groupby(err_param_name).first().reset_index()\n labels = df[\"labels\"][0]\n\n # plot the data of each error parameter combination\n for i, _ in enumerate(df[reduced_data_column]):\n reduced_data = df[reduced_data_column][i]\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.scatter(reduced_data.T[0], reduced_data.T[1], c=labels, cmap=scatter_cmap, marker=\".\", s=40, picker=True)\n x_min, x_max, y_min, y_max = get_lims(reduced_data)\n ax.set_xlim(x_min, x_max)\n ax.set_ylim(y_min, y_max)\n err_param_val = round(df[err_param_name][i], 3)\n ax.set_title(err_param_name + \"=\" + str(err_param_val))\n ax.set_xticks([])\n ax.set_yticks([])\n\n reduced_T = reduced_data.T\n\n # without creating a class the plots would use wrong values of i\n class Plot:\n def __init__(self, i, fig, reduced_T, on_click):\n self.i = i\n self.fig = fig\n self.cid = self.fig.canvas.mpl_connect('pick_event', self)\n self.reduced_T = reduced_T\n self.on_click = on_click\n\n def __call__(self, event):\n if len(event.ind) == 0:\n return False\n mevent = event.mouseevent\n closest = event.ind[0]\n\n def dist(x0, y0, x1, y1):\n return (x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1)\n\n # find closest data point\n for elem in event.ind:\n best_dist = dist(self.reduced_T[0][elem], self.reduced_T[1][elem], mevent.xdata, mevent.ydata)\n new_dist = dist(self.reduced_T[0][closest], self.reduced_T[1][closest], mevent.xdata, mevent.ydata)\n if best_dist > new_dist:\n closest = elem\n\n # get original and modified data points\n original = data[closest]\n modified = df[\"interactive_err_data\"][self.i][closest]\n\n self.on_click(original, modified)\n\n Plot(i, fig, reduced_T, on_click)","def cross_validation_visualization(lambdas, loss_train, loss_test):\n plt.semilogx(lambdas, loss_train, marker=\".\", color='b', label='train error')\n plt.semilogx(lambdas, loss_test, marker=\".\", color='r', label='test error')\n plt.xlabel(\"lambda\")\n plt.ylabel(\"rmse\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_mse\")","def plot_rank_sensitivity(\n dmd_train_error, dmd_test_error, optdmd_train_error, optdmd_test_error\n):\n\n # Generate figure.\n fig, axes = plt.subplots(\n 1, 2, figsize=(fig_width, fig_width / 4), sharex=True, sharey=True\n )\n\n # Misc.\n rank = np.arange(1, dmd_test_error.shape[0] + 1)\n\n #####\n # TRAINING ERROR\n #####\n\n # Plot the vanilla DMD error.\n axes[0].plot(rank, dmd_train_error)\n # Plot the OptDMD error.\n axes[0].plot(rank, optdmd_train_error, ls=\"--\")\n # Add decorators.\n axes[0].set(\n xlabel=r\"Rank of the DMD model\",\n ylabel=r\"Normalized error\",\n title=r\"Training dataset\",\n )\n axes[0].grid(True)\n\n #####\n # TESTING ERROR\n #####\n\n # Plot the vanilla DMD error.\n axes[1].plot(rank, np.mean(dmd_test_error, axis=1), label=r\"Regular DMD\")\n axes[1].fill_between(\n rank,\n np.mean(dmd_test_error, axis=1) + np.std(dmd_test_error, axis=1),\n np.mean(dmd_test_error, axis=1) - np.std(dmd_test_error, axis=1),\n alpha=0.25,\n )\n # Plot the OptDMD error.\n axes[1].plot(\n rank, np.mean(optdmd_test_error, axis=1), ls=\"--\", label=r\"Optimal DMD\"\n )\n axes[1].fill_between(\n rank,\n np.mean(optdmd_test_error, axis=1) + np.std(optdmd_test_error, axis=1),\n np.mean(optdmd_test_error, axis=1) - np.std(optdmd_test_error, axis=1),\n alpha=0.25,\n )\n # Add decorators.\n axes[1].set(\n xlim=(0, rank.max()),\n xlabel=r\"Rank of the DMD model\",\n ylim=(0, 1),\n title=r\"Testing dataset\",\n )\n axes[1].grid(True)\n axes[1].legend(loc=0)\n\n return","def scatter(target, predictions, threshold=0, ideal_prediction_line=True):\n\n plt.plot(target, predictions, linewidth=0, marker='o', zorder=1);\n if threshold is not None:\n xlim = plt.xlim()\n ylim = plt.ylim()\n plt.hlines(threshold, xlim[0], xlim[1], linestyles='dotted', color='red')\n plt.vlines(threshold, ylim[0], ylim[1], linestyles='dotted', color='red')\n plt.xlim(xlim)\n plt.ylim(ylim)\n if ideal_prediction_line:\n plt.plot([target.min(), target.max()], [target.min(), target.max()], label='Ideal prediction')\n plt.legend()\n plt.title('Predicted returns VS actual returns')\n plt.xlabel('Actual return')\n plt.ylabel('Predicted return');","def visualizePredictions(testData,knn_predictions):\r\n testData.visualize.scatterPlot('Petal length','Petal width')\r\n testData.dataDict[testData.reference] = knn_predictions\r\n testData.visualize.scatterPlot('Petal length','Petal width')\r\n\r\n pass","def display_convergence_error(train_losses, valid_losses):\n if len(valid_losses) > 0:\n plt.plot(len(train_losses), train_losses, color=\"red\")\n plt.plot(len(valid_losses), valid_losses, color=\"blue\")\n plt.legend([\"Train\", \"Valid\"])\n else:\n plt.plot(len(train_losses), train_losses, color=\"red\")\n plt.legend([\"Train\"])\n plt.xlabel('Epoch')\n plt.ylabel('Loss')\n plt.show()","def plot_loss():\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\n loss = df['loss'].values\n val_loss = df['val_loss'].values\n x = [i for i in range(1, len(loss) + 1)]\n\n plt.plot(x, loss, label='Train loss')\n plt.plot(x, val_loss, label='Val loss')\n\n plt.xlabel('Epochs')\n plt.ylabel('Contrastive Loss')\n plt.title('Train and test loss')\n plt.grid(True)\n plt.legend(shadow=True, fontsize='x-large')\n\n plt.show()","def plot_predictions(\n train_data, train_labels, test_data, test_labels, predictions=None\n):\n plt.figure(figsize=(10, 7))\n\n # Plot training data in blue\n plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n\n # Plot test data in green\n plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n\n if predictions is not None:\n # Plot the predictions in red (predictions were made on the test data)\n plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n\n # Show the legend\n plt.legend(prop={\"size\": 14})","def validate(self, input_data):\n self.assert_data_shape(input_data)\n\n y = input_data[1]\n hat_y, variance = self.predict(input_data[0])\n\n # plt.scatter(hat_y, input_data[1], s=1)\n # plt.show()\n\n return self.stat(y, hat_y)","def plot_error_curve(ax,\n y_true,\n y_pred,\n uncert_meas,\n label,\n every_nth,\n window_size=10):\n error = (y_true[::every_nth] - y_pred[::every_nth])**2\n error, uncert_meas = np.array(error), np.array(uncert_meas[::every_nth])\n sorted_inds = generate_order(uncert_meas)\n sorted_error = error[sorted_inds]\n smooth_error = moving_average(sorted_error, window_size)\n ax.plot(np.arange(len(smooth_error)), smooth_error, label=label)","def regression_analysis(cls, y_true, y_pred, path=None):\n residual = y_true - y_pred\n print(\"Histogram\")\n cls.histogram(residual, \"Residual\")\n print(\"Scatter\")\n cls.scatter_plot(y_pred, residual, \"pred\", \"residual\", path=path)\n print(\"Scatter\")\n cls.scatter_plot( y_true, y_pred, \"y_test\", \"pred\", path=path)","def plot(model, samples):\n # compute responsiblity values\n resp = model.predict_proba(samples)\n\n # plot\n plt.axis('equal')\n plt.scatter(samples[:,0], samples[:,1], c=resp)\n plt.show()","def ScatterPlot_LWR(X_train, y_train, X_test, y_test, reg, tau, degree):\r\n\r\n # Set model instances\r\n y_pred = reg.predict(X_train, y_train, X_test)\r\n theta = reg.theta\r\n\r\n # R-squared\r\n rsq = r2_score(y_test, y_pred)\r\n\r\n # Set figure object\r\n fig = plt.figure(figsize=(20, 10))\r\n\r\n # Create x_axis values\r\n x_tmp = np.arange(0, 1.1, 0.01)\r\n x_limit = np.arange(0, 1.1, 0.01)\r\n x_limit = x_limit.reshape((x_limit.shape[0], 1))\r\n\r\n # Transform x_axis values\r\n poly = PolynomialFeatures(degree)\r\n x_limit = poly.fit_transform(x_limit)\r\n\r\n # Predictions\r\n hypothesis = np.dot(x_limit, theta)\r\n\r\n # Scatter plots\r\n plt.scatter(X_train, y_train, color='green', label='Training Set', s = 150)\r\n plt.scatter(X_test, y_test, color='blue', label='Testing Set', s = 150)\r\n plt.scatter(X_test, y_pred, color='red', label='Prediction Points', s = 150)\r\n plt.plot(x_tmp, hypothesis, color='purple', label='Predictions')\r\n\r\n # Set figure parameters\r\n plt.xlabel(\"$x_1$\", fontsize=18)\r\n plt.ylabel(\"$x_1$\", fontsize=18)\r\n plt.title('Locally Weighted Regression, Degree = {}, $r^2$ = {:.2f} '.format(\r\n degree, rsq), fontsize=18)\r\n plt.tick_params(axis='x', labelsize=15)\r\n plt.tick_params(axis='y', labelsize=15)\r\n\r\n # Legend Patches\r\n green_patch = mpatches.Patch(color='green', label='Training Set')\r\n blue_patch = mpatches.Patch(color='blue', label='Testing Set')\r\n red_patch = mpatches.Patch(color='red', label='Predictions')\r\n purple_patch = mpatches.Patch(\r\n color='purple', label='Locally Weighted Regressor')\r\n\r\n patches = [green_patch, blue_patch, red_patch, purple_patch]\r\n\r\n legend = plt.legend(handles=patches, loc='upper right',\r\n borderaxespad=0., fontsize=14)\r\n\r\n return fig","def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\n fig1, ax1 = plt.subplots()\n ax1.scatter(train_data_full[\"Weight\"], train_data_full[\"Height\"], color = 'blue')\n\n # De-standarize\n train_mean = train_data_full[\"Weight\"].mean()\n train_std = train_data_full[\"Weight\"].std()\n train_data_for_plot = train_mean + train_data[\"Weight\"] * train_std\n\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\n ax1.set_xlabel(\"Height\")\n ax1.set_ylabel(\"Weight\")\n\n fig2, ax2 = plt.subplots()\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\n ax2.set_xlabel(\"Iteration\")\n ax2.set_ylabel(\"MSE\")\n\n fig3, ax3 = plt.subplots()\n np_gradient_ws = np.array(thetas)\n\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\n x, y = np.meshgrid(w, b)\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\n fig3.colorbar(cp, ax = ax3)\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\n if niter > 0:\n thetas_to_plot = np_gradient_ws[:niter]\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\n ax3.set_xlabel(r'$w$')\n ax3.set_ylabel(r'$b$')\n return fig1, fig2, fig3","def report(self, X, y):\n predict = self.model.predict(X)\n\n skplt.estimators.plot_feature_importances(\n self.model, x_tick_rotation=90)\n plt.show()\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=predict)\n lims = [\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\n ]\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\n ax.set_aspect('equal')\n ax.set_xlim(lims)\n ax.set_ylim(lims)\n ax.set_xlabel(\"Observed\")\n ax.set_ylabel(\"Predict\")\n ax.set_title(\"Predict vs. Observed\")\n plt.show()\n\n residuals = y - predict\n\n fig, ax = plt.subplots(figsize=(7, 7))\n sns.scatterplot(x=y, y=residuals)\n plt.title(\"Residuals vs. Observed\")\n plt.xlabel(\"Obserbed\")\n plt.ylabel(\"Residuals\")\n plt.show()\n\n plt.hist(residuals)\n plt.title(\"Residuals distribution\")\n plt.xlabel(\"Residuals value\")\n plt.ylabel(\"Count\")\n plt.show()\n\n display(\n pd.DataFrame({\n \"explained_variance_score\":\n metrics.explained_variance_score(y, predict),\n \"mean_absolute_error\":\n metrics.mean_absolute_error(y, predict),\n \"mean_squared_log_error\":\n metrics.mean_squared_log_error(y, predict),\n \"median_absolute_error\":\n metrics.median_absolute_error(y, predict),\n \"r2_score\":\n metrics.r2_score(y, predict)\n },\n index=[0]))","def visualize_test(test_data_full, test_data, thetas):\n fig, ax = plt.subplots()\n ax.scatter(test_data_full[\"Weight\"], test_data_full[\"Height\"], color='blue')\n ax.plot(test_data_full[\"Weight\"], predict(test_data, thetas[-1]), color='red', linewidth=2)\n return fig","def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\n\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\n\n # Loop through example sizes and get the training and validation error\n for train_size in train_sizes:\n # Select Subset of Data\n X_train = X_train_all[:train_size]\n X_val = X_val_all[:train_size]\n y_train = y_train_all[:train_size]\n y_val = y_val_all[:train_size]\n\n # Initialize Model\n model = svm.SVC(kernel='linear')\n\n # Fit model\n print(f\"Training {title} using {train_size} examples\")\n model.fit(X_train, y_train)\n\n # Get Predictions \n train_pred = model.predict(X_train)\n val_pred = model.predict(X_val)\n\n # Get Accuracy Score for X_Train and X_Val\n errors = pd.DataFrame({\n 'train_size': [train_size],\n 'train_acc': [accuracy_score(y_train, train_pred)],\n 'val_acc': [accuracy_score(y_val, val_pred)]\n })\n \n # Concatenate Dataframes\n errors_df = pd.concat([errors_df, errors])\n\n # Plot Learning Curve\n fig, ax = plt.subplots()\n\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\n\n ax.set_xlabel(\"Training Size\")\n ax.set_ylabel(\"Accuracy\")\n ax.set_title(title)\n\n # Save Figure\n plt.savefig('figs/' + title + '_learning_curve.png')","def main():\n df = pd.read_csv('data/ch5_q8_simulation.csv')\n\n # Part b\n plt.figure()\n plt.scatter(df['x'], df['y'])\n plt.xlabel('x')\n plt.ylabel('y')\n plt.title('Scatterplot y vs. x')\n plt.savefig('plots/8a.png')\n\n # Part c\n response_var = 'y'\n pred_vars_lin = ['x']\n pred_vars_quad = ['x', 'x2']\n pred_vars_cub = ['x', 'x2', 'x3']\n pred_vars_quar = ['x', 'x2', 'x3', 'x4']\n\n poly_terms = pd.DataFrame({'x2': np.power(df['x'], 2),\n 'x3': np.power(df['x'], 3),\n 'x4': np.power(df['x'], 4)})\n df = pd.concat([df, poly_terms], axis=1)\n\n CV_error_lin = loocv(df, response_var, pred_vars_lin)\n CV_error_quad = loocv(df, response_var, pred_vars_quad)\n CV_error_cub = loocv(df, response_var, pred_vars_cub)\n CV_error_quar = loocv(df, response_var, pred_vars_quar)\n\n print('Part c')\n print('CV error (linear) = {:.3f}'.format(CV_error_lin))\n print('CV error (quadratic) = {:.3f}'.format(CV_error_quad))\n print('CV error (cubic) = {:.3f}'.format(CV_error_cub))\n print('CV error (quartic) = {:.3f}'.format(CV_error_quar))\n\n # Part d\n np.random.seed(801)\n y = np.random.randn(100)\n x = np.random.randn(100)\n y = x - 2 * np.power(x, 2) + np.random.randn(100)\n\n df = pd.DataFrame({'x': x,\n 'x2': np.power(x, 2),\n 'x3': np.power(x, 3),\n 'x4': np.power(x, 4),\n 'y': y})\n\n CV_error_lin = loocv(df, response_var, pred_vars_lin)\n CV_error_quad = loocv(df, response_var, pred_vars_quad)\n CV_error_cub = loocv(df, response_var, pred_vars_cub)\n CV_error_quar = loocv(df, response_var, pred_vars_quar)\n\n print('Part d')\n print('CV error (linear) = {:.3f}'.format(CV_error_lin))\n print('CV error (quadratic) = {:.3f}'.format(CV_error_quad))\n print('CV error (cubic) = {:.3f}'.format(CV_error_cub))\n print('CV error (quartic) = {:.3f}'.format(CV_error_quar))\n\n # Part f\n model = sm.OLS(df.loc[:, response_var], df.loc[:, pred_vars_quar]).fit()\n print(model.summary())","def plot_test(y_test, y_pred, title = None, xlabel = 'Measured $Y = \\log_2(MIC)$', ylabel = 'Predicted $Y = \\log_2(MIC)$', legend = ['Ideal', 'Result'], groups = None):\n \n fig, ax = plt.subplots(1,1)\n fig.set_figheight(5)\n fig.set_figwidth(5)\n if groups is not None:\n groups_obj = pd.concat([y_test,y_pred], axis=1).groupby(np.array(groups))\n cmap=plt.get_cmap('tab10')\n for name, group in groups_obj:\n # Works only for groups with numeric names that are max cmap length:\n ax.plot(group.iloc[:,0], group.iloc[:,1], marker=\"o\", linestyle=\"\", label=int(name), color = cmap.colors[int(name)])\n ax.legend()\n else:\n ax.scatter(y_test,y_pred, color = 'red')\n ax_max = 10\n if np.max(y_test.values)>ax_max:\n ax_max = np.max(y_test).values\n ax_min = 0\n if np.min(y_test.values)<ax_min:\n ax_min = np.min(y_test.values)\n ax.plot([ax_min, ax_max], [ax_min, ax_max], '--', color='black')\n ax.set_aspect('equal', 'box')\n plt.title(title)\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n #plt.savefig(title+'.pdf')\n plt.savefig(title+'.svg')\n #plt.savefig(title+'.png')#, dpi=600)\n #plt.show()","def parity_plot(y_pred, y_act):\n\n fig = plt.figure(figsize=FIG_SIZE)\n plt.scatter(y_act, y_pred)\n plt.plot([y_act.min(), y_act.max()], [y_act.min(), y_act.max()],\n lw=4, color='r')\n plt.xlabel('Actual')\n plt.ylabel('Predicted')\n\n return fig","def custom_scatterplot(ax, x, y, error, xlims, ylims, color='green', markerscale=100):\n\n markersize = error * markerscale\n\n ax.scatter(x, y, color=color, marker='o', s=markersize, alpha=0.5)\n\n ax.set_xlim(xlims)\n ax.set_ylim(ylims)\n\n return ax","def actvspred(modelname, predmodel):\n predscores, actualscores, meanerr, rmsqerr = predmodel\n plt.figure()\n plt.scatter(actualscores,predscores,s=70)\n x = np.array(range(100))\n plt.plot(x,x,'g',label='optimal model')\n # make regression\n rob.globalenv[\"pred\"] = FV(predscores)\n rob.globalenv[\"act\"] = FV(actualscores)\n mult_lm = stats.lm(\"pred ~ act + 1\")\n coeffs = np.array(mult_lm.rx(\"coefficients\")[0])\n rsqrd = base.summary(mult_lm).rx(\"r.squared\")[0][0]\n y = coeffs[1]*x+coeffs[0]\n plt.plot(x,y,'k',label='our model',linewidth=2)\n plt.xlabel(\"actual lsas delta\")\n plt.ylabel(\"predicted lsas delta\")\n plt.title(modelname)\n plt.axis([0,100,0,100])\n axes = plt.axes()\n axes.grid(b=True)\n axes.text(0.05,0.8,\"meanerr: %.2f\\nrmse: %.2f\\nr: %.2f (Rsqrd: %.2f)\"%(meanerr,rmsqerr,np.sqrt(rsqrd),rsqrd),transform=axes.transAxes)\n #plt.legend()\n plt.savefig(os.path.join(outdir,\"%s_crossval.png\"%modelname),dpi=300,format=\"png\")","def regression_plots(regression_results, dependant, independant):\n\n # Scatter of two variables\n ds = xr.Dataset()\n ds['dependant'] = dependant\n ds['independant'] = regression_results[f'prediction_skt']\n ds = ds.transpose(\"y\", \"x\", \"time\")\n\n expected = ds['dependant'].values.flatten()\n predicted = ds['independant'].values.flatten()\n \n plt.style.use('stylesheets/contour.mplstyle')\n fig, ax = plt.subplots(figsize=(5, 5))\n ax.axhline(0, color='k', alpha=0.5)\n ax.axvline(0, color='k', alpha=0.5)\n mask = np.isfinite(expected) * np.isfinite(predicted)\n X = expected[mask]\n Y = predicted[mask]\n counts, xedges, yedges = np.histogram2d(X, Y, bins=100)\n xedges = (xedges[1:] + xedges[:-1]) / 2\n yedges = (yedges[1:] + yedges[:-1]) / 2\n im = ax.contourf(xedges, yedges, counts, norm=LogNorm())\n ax.set_xlabel('Expected values')\n ax.set_ylabel('Predicted values')\n # ax.autoscale(False)\n plt.colorbar(im)\n plt.show()\n\n # gradient_expected = regression[f'{dependant}'].polyfit(\n # dim='time', deg=1, cov=True).sel(degree=1).polyfit_coefficients * 1e9*60*60*24*365\n # gradient_predicted, = regression[f'prediction_{independant}'].polyfit(\n # dim='time', deg=1, cov=True).sel(degree=1).polyfit_coefficients * 1e9*60*60*24*365\n\n\n # max_ = max([gradient_expected.max().max(), gradient_predicted.max().max()])\n # min_ = min([gradient_expected.min().min(), gradient_predicted.min().min()])\n\n # divnorm = TwoSlopeNorm(vmin=min_, vcenter=0, vmax=max_)\n # levels = np.arange(min_, max_, 0.1)\n\n # fig = plt.figure(figsize=(5, 10))\n\n # ax = fig.add_subplot(2, 1, 1, projection=ccrs.SouthPolarStereo())\n # im = ax.contourf(gradient_expected.x, gradient_expected.y, gradient_expected.transpose(\n # ), levels=levels, norm=divnorm, cmap='RdBu_r')\n # ax.coastlines()\n # ax.set_title('Expected Trends')\n # plt.colorbar(im, ax=ax)\n\n # ax = fig.add_subplot(2, 1, 2, projection=ccrs.SouthPolarStereo())\n # im = ax.contourf(gradient_predicted.x, gradient_predicted.y,\n # gradient_predicted.transpose(), levels=levels, norm=divnorm, cmap='RdBu_r')\n # ax.coastlines()\n # ax.set_title('Predicted Trends')\n # plt.colorbar(im, ax=ax)\n pass","def fig5(X_r, Y, TRAIN_SIZE=6000):\n \n # Normalize X_r\n X_n = preprocessing.normalize(X_r)\n \n #kNN weighting and k\n weights = [ \"uniform\", \"distance\" ]\n ks = [2,4,8,16,32,64] \n \n # Little lambda functions to standardize feature extraction\n pca = lambda X,Y: PCA(n_components=128).fit(X).transform(X)\n lda = lambda X,Y: LDA().fit(X, Y).transform(X)\n idn = lambda X,Y: X\n \n # Start the plot\n fig, ax = plt.subplots()\n plt.ylabel(\"Error %\")\n plt.xlabel(\"k\")\n \n \n # Try every combination (product) of weights, feature extraction and normalization\n for weight, feat_reduce, X_ in itertools.product(\n weights, [pca, lda, idn], [X_r, X_n]):\n \n # Reset error rate\n errors = []\n \n #Flags to make things easier\n reduction = \"PCA\" if feat_reduce == pca else \"LDA\"\n normalized = \"n\" if X_ is X_n else \"r\"\n \n #Initialize a black (i.e. key - cmy_K_) line\n linestyle = \"k\"\n \n # Match the point style used in Vailaya\n if weight == \"uniform\":\n if X_ is X_n:\n linestyle += \"x\"\n else:\n linestyle += \"*\"\n if weight == \"distance\":\n if X_ is X_n:\n linestyle += \"o\"\n else:\n linestyle += \"+\"\n \n # As well as the line style\n if feat_reduce is pca:\n linestyle += \":\" # Dotted\n elif feat_reduce is lda:\n linestyle += \"--\" # Solid\n else:\n linestyle += \"-\" # Dashed\n \n # Loop through all k's \n for k in ks:\n #Initialized classifier parameters\n knn = neighbors.KNeighborsClassifier(warn_on_equidistant=False)\n knn.n_neighbors = k\n knn.weights = weight\n \n #Here's where the lambda's come in handy.\n X = feat_reduce(X_,Y)\n \n # Fit the training set\n knn.fit(X[:TRAIN_SIZE], Y[:TRAIN_SIZE])\n \n # Again ugly code for the predictions\n predictions = []\n for i in range(TRAIN_SIZE, len(X)):\n predictions += [ knn.predict(X[i])[0] ] \n \n # Calculate error rate and append it to error rate list\n error = 1.- float(sum(predictions == Y[TRAIN_SIZE:])) / len(predictions)\n errors += [error]\n \n # Print it just for fun. Also in case error rates need to be exported.\n print weight, reduction, normalized, k, error\n \n # Plot the line for all k values \n ax.plot(ks, errors, linestyle)\n \n # Couldn't specify legends properly\n #ax.legend()","def clt_plot(error: pd.Series, n_max=800):\n plt.figure()\n n_values = [n for n in range(20, n_max, 20)]\n error_mean, error_var = do_many_bootstraps(error, n_values, bootstrap_number=50)\n plt.plot(n_values, np.sqrt(error_var), label='Bootstrap estimate')\n plt.plot(n_values, np.divide(np.std(error, ddof=1), np.sqrt(n_values)), label='CLT estimate')\n plt.xlabel('number of samples')\n plt.ylabel('variance of mean square error')\n plt.legend()\n plt.show()","def plot_predictions(self):\n\n plt.title(\"Targets vs. Predictions\")\n plt.plot(self.T, label=\"Targets\")\n plt.plot(self.Y, label=\"Predictions\")\n plt.xlabel(\"Sample number\")\n plt.legend()\n plt.show()","def plot_loss_curves(results):\n loss = results[\"train_loss\"]\n test_loss = results[\"test_loss\"]\n\n accuracy = results[\"train_acc\"]\n test_accuracy = results[\"test_acc\"]\n\n epochs = range(len(results[\"train_loss\"]))\n\n plt.figure(figsize=(15, 7))\n\n # Plot loss\n plt.subplot(1, 2, 1)\n plt.plot(epochs, loss, label=\"train_loss\")\n plt.plot(epochs, test_loss, label=\"test_loss\")\n plt.title(\"Loss\")\n plt.xlabel(\"Epochs\")\n plt.legend()\n\n # Plot accuracy\n plt.subplot(1, 2, 2)\n plt.plot(epochs, accuracy, label=\"train_accuracy\")\n plt.plot(epochs, test_accuracy, label=\"test_accuracy\")\n plt.title(\"Accuracy\")\n plt.xlabel(\"Epochs\")\n plt.legend()","def scatterplot(self, x = \"Predictor\", y = \"Response\", color = None, jitter = False, jitter_sd = .1,\n marg_x = None, marg_y = None, trendline = None, opacity = 1, template = \"ggplot2\",\n has_title = True, title = None):\n x_clean, df_clean = clean_varname(self._df, var = x)\n y_clean, df_clean = clean_varname(df_clean, var = y)\n\n if jitter:\n df_clean[x_clean] = df_clean[x_clean] + np.random.normal(0, jitter_sd, size=len(df))\n df_clean[y_clean] = df_clean[y_clean] + np.random.normal(0, jitter_sd, size=len(df))\n\n if color:\n color_clean, df_clean = clean_varname(df_clean, var = color)\n else:\n color_clean = color \n\n if has_title:\n if not title:\n title = f\"Scatter Plot of {x_clean} and {y_clean}\"\n \n fig = px.scatter(df_clean, x=x_clean, y=y_clean, color=color_clean, title = title,\n marginal_x = marg_x, marginal_y = marg_y, trendline = trendline, template = template, opacity = opacity)\n return fig","def evaluate(y_train,train_preds,y_test,test_preds,model,features):\n \n plt.figure(figsize=(3.5,3))\n train_mae = np.abs(y_train-train_preds).mean()\n test_mae = np.abs(y_test-test_preds).mean()\n print(model, split)\n print('Test MAE: %4.2f'%(test_mae))\n print('Train MAE: %4.2f'%(train_mae))\n plt.plot(y_train,train_preds,'.',c='grey',ms=3,label='Train MAE: %4.2f'%train_mae,alpha=1)\n plt.plot(y_test,test_preds,'.',c=colors[model],ms=3,label='Test MAE: %4.2f'%test_mae,alpha=1)\n #plt.title('%s: Train MAE = %.2f eV; Test MAE = %.2f eV'%(model,np.abs(y_train-train_preds).mean(),np.abs(y_test-test_preds).mean()),fontsize=10)\n\n xlim = plt.gca().get_xlim()\n ylim = plt.gca().get_ylim()\n \n alim = (min(xlim[0],ylim[0]),max(xlim[1],ylim[1]))\n\n plt.plot(alim,alim,'-k',lw=1)\n plt.gca().set_ylim(alim)\n plt.gca().set_xlim(alim)\n\n plt.xlabel('$\\Delta E$ (eV)')\n plt.ylabel('$\\Delta E$ Predicted (eV)')\n\n plt.legend(loc='best')\n\n plt.tight_layout()\n plt.savefig('./parity/'+model+'_'+features+'_'+split+'_parity.pdf')\n \n #Functionality to plot histogram of error if desired\n\n #plt.figure()\n #plt.hist(preds-y,bins=100)\n #plt.xlabel('$\\hat{y} - y$ (eV)')\n #plt.title('%s %s: MAE = %.2f eV'%(model,tt,np.abs(y-preds).mean()))\n\n #xlim = np.array(plt.gca().get_xlim())\n #xmax = np.abs(xlim).max()\n #plt.gca().set_xlim([-xmax,xmax])\n\n #plt.savefig('./output/'+model+'_'+features+'_'+split+'_'+tt+'_hist.pdf')\n\n return","def cross_validation_visualization(lambds, score_tr, score_te):\n plt.semilogx(lambds, score_tr, marker=\".\", color='b', label='train score');\n plt.semilogx(lambds, score_te, marker=\".\", color='r', label='test score');\n plt.xlabel(\"lambda\")\n plt.ylabel(\"score\")\n plt.title(\"cross validation\")\n plt.legend(loc=2)\n plt.grid(True)\n plt.savefig(\"cross_validation_test\")","def plotLoss():\n # ssr\n ssr = np.log(gradientDescent(X, y)[1])\n # number of iterations \n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\n # plot reduction of ssr\n plt.plot(iterations, ssr)\n # xlabel\n plt.xlabel(\"Iteration\")\n # ylabel\n plt.ylabel(\"SSR\")\n # title\n plt.title(\"Reduction of SSR by number of Iterations\")\n # show plot \n plt.show()","def plot_lastreviews_means_and_errors(H_in_HL_mean, H_in_HL_error, L_in_HL_mean, L_in_HL_error,\n H_in_HH_mean, H_in_HH_error, H_in_HM_mean, H_in_HM_error,\n M_in_HM_mean, M_in_HM_error):\n # plot the result in a nice plot\n plt.figure(figsize=(12, 9)) \n\n # create the fig. and axes.\n ax = plt.subplot(111)\n ax.spines[\"top\"].set_visible(False) \n ax.spines[\"right\"].set_visible(False)\n\n # define the color to use\n color_1 = rgb_to_matplot_lib(strong_green)\n color_2 = rgb_to_matplot_lib(light_green)\n color_3 = rgb_to_matplot_lib(strong_red)\n color_4 = rgb_to_matplot_lib(light_green)\n color_5 = rgb_to_matplot_lib(orange)\n\n\n\n # axis \n ax.set_ylabel('Rating', fontsize = 14)\n ax.tick_params(axis='both', labelsize=14)\n\n # plot small dash lines to follow the grading \n for y in np.arange(4.0, 4.6, 0.1): \n ax.plot(range(0, 45), [y] * len(range(0, 45)), \"--\", lw=0.5, color=\"black\", alpha=0.3)\n\n\n # set titles\n ax.set_title('10+ reviews average rating for each case in each group', fontsize = 14)\n\n plt.ylim([1,5.1])\n plt.xlim([0,5.1])\n\n plt.errorbar(1, H_in_HH_mean, H_in_HH_error, lineStyle= None, capsize=5, marker=\"^\", color=color_1)\n plt.errorbar(2, H_in_HL_mean, H_in_HL_error, lineStyle= None, capsize=5, marker=\"^\", color=color_2)\n plt.errorbar(3, L_in_HL_mean, L_in_HL_error, lineStyle= None, capsize=5, marker=\"^\", color=color_3)\n plt.errorbar(4, H_in_HM_mean, H_in_HM_error, lineStyle= None, capsize=5, marker=\"^\", color=color_4)\n plt.errorbar(5, M_in_HM_mean, M_in_HM_error, lineStyle= None, capsize=5, marker=\"^\", color=color_5)\n\n plt.text(0.8, 4.01, \"({:04.3f})\".format(H_in_HH_mean), fontsize=14, color=color_1)\n plt.text(1.8, 4.01, \"({:04.3f})\".format(H_in_HL_mean), fontsize=14, color=color_2) \n plt.text(2.8, 4.01, \"({:04.3f})\".format(L_in_HL_mean), fontsize=14, color=color_3) \n plt.text(3.8, 4.01, \"({:04.3f})\".format(H_in_HM_mean), fontsize=14, color=color_4) \n plt.text(4.8, 4.01, \"({:04.3f})\".format(M_in_HM_mean), fontsize=14, color=color_5) \n\n\n # set ticks label\n ax.set_xticks(range(1,6))\n ax.set_xticklabels(('H in HH', 'H in HL', 'L in HL', 'H in HM', 'M in HM'))\n\n #set ticks color\n colors = [color_1, color_2, color_3, color_4, color_5]\n for xtick, color in zip(ax.get_xticklabels(), colors):\n xtick.set_color(color)\n\n plt.ylim([4,4.6])\n plt.xlim([0.5,5.5])\n plt.show()","def visualize(self):\n\t\tplt.figure(1)\n\t\tax1 = plt.add_suplot(1,2,1)\n\t\t# Plot free energy error\n\t\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\n\t\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\n\t\tplt.legend()\n\n\t\t# Plot density error\n\n\t\t# Plot log-likelihood of test set\n\n\t\t# Plot clustering score\n\n\t\tplt.show()\n\n\t\treturn","def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):\n fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))\n pred1 = net.predict(x_val, batch_size=batch_size)\n # print(\"pred1.shape:\", pred1.shape)\n ax1.plot(idx_val, y_val, label=\"Actual Data\", marker=\"+\")\n ax1.plot(idx_val, pred1, label=\"Prediction\", marker=\"o\")\n # ax1.set_ylim(-0.1, 1.1)\n ax1.set_xlabel(\"Year\")\n ax1.set_ylabel(\"Sunspot Numbers\")\n ax1.legend()\n ax1.set_title(\"Predicted vs Actual Validation Data\")\n\n pred2 = net.predict(x_train, batch_size=batch_size)\n # print(\"pred2.shape:\", pred2.shape)\n ax2.plot(idx_train, y_train, label=\"Actual Data\", marker=\"+\")\n ax2.plot(idx_train, pred2, label=\"Prediction\", marker=\"o\")\n # ax2.set_ylim(-0.1, 1.1)\n ax2.set_xlabel(\"Year\")\n ax2.set_ylabel(\"Sunspot Numbers\")\n ax2.legend()\n ax2.set_title(\"Predicted vs Actual Training Data\")\n\n plt.tight_layout()\n\n filename = \"img/\"\n filename += datetime.now().strftime(\"%y%m%d_%H%M\")\n filename += \"_predicted_vs_actual_data.png\"\n fig.savefig(filename, format=\"png\")","def graph_results(loss, acc):\n N = len(loss)\n x = np.linspace(0, N, N)\n plt.subplot(1,2,1)\n plt.plot(x, loss)\n plt.subplot(1,2,2)\n plt.plot(x,acc)\n plt.show()","def Plot_predict(X,Y,model,X_path): \n labels = {0: 'CNV', 1: 'DME', 2: 'DRUSEN', 3: 'NORMAL'}\n Y_pred_classes = np.argmax(model.predict(X),axis = 1) \n Y_true = np.argmax(Y,axis = 1)\n \n fig = plt.figure(figsize=(40, 40)) \n for i in range(X.shape[0]):\n ax = fig.add_subplot(8, 4, i + 1, xticks=[], yticks=[])\n ax.set_title(\"Groundtruth : {} \\n Prediction : {}\".format(labels[Y_true[i]],labels[Y_pred_classes[i]]), \\\n color=(\"green\" if Y_true[i] == Y_pred_classes[i] else \"red\"),fontsize=20) \n img = image.load_img(X_path[i])\n ax.imshow(img)\n plt.show()\n return","def ploter(self):\n if len(self.dataset[self.first_title]) != 2:\n print('plot is only avilable for two features')\n return\n x_axis = []\n y_axis = []\n for title in self.dataset:\n x_axis.append(self.dataset[title][0])\n y_axis.append(self.dataset[title][1])\n plt.plot(x_axis, y_axis, 'o')\n plt.show()","def plot_data(X, y, X_pred, clf, title):\n \n figsize(10.2, 5.1)\n X2 = [[x] for x in linspace(0, max(X_pred)[0] * 1.15, 50)]\n days = clf.predict(X_pred)\n scatter(X, y, color='black')\n scatter(X_pred, days, color='red')\n plot(X2, clf.predict(X2), color='blue')\n \n i = 0\n len_data = len(X_pred)\n xytext = (5, -10)\n for data in zip(X_pred, days):\n i = i + 1\n dat = purchase_date + timedelta(int(round(data[1], 0)))\n\n annotate(dat.strftime('%b %d %Y'), xy=(data[0][0], data[1]), xycoords='data', xytext=xytext, textcoords='offset points')\n \n pylab.ylim([0, int(clf.predict(X2).max()) + 1])\n pylab.xlim([0, max(X2)[0]])\n ax=pylab.gca()\n ax.yaxis.set_major_formatter(NullFormatter())\n ax.yaxis.set_minor_formatter(NullFormatter())\n pylab.axes().set_xlabel('Miles')\n pylab.axes().set_ylabel('Time')\n pylab.axes().set_title(title)","def _bokeh_confusion_scatter(\n y_true: np.ndarray,\n y_pred: np.ndarray,\n class_names: Sequence[str],\n title_rows: Sequence[str],\n x_label_rotation: Union[str, float] = \"horizontal\",\n y_label_rotation: Union[str, float] = \"vertical\",\n) -> Callable[[], Figure]:\n if len(y_true) != len(y_pred):\n raise ValueError(\"y_true and y_pred must have the same length!\")\n\n def figure() -> Figure:\n\n p = plotting.figure(\n x_range=(-0.5, -0.5 + len(class_names)),\n y_range=(-0.5, -0.5 + len(class_names)),\n plot_height=350,\n plot_width=350,\n tools=TOOLS,\n toolbar_location=TOOLBAR_LOCATION,\n match_aspect=True,\n )\n\n def noise() -> np.ndarray:\n return (np.random.beta(1, 1, size=len(y_true)) - 0.5) * 0.6\n\n p.scatter(\n x=y_true + noise(),\n y=y_pred + noise(),\n size=scatter_plot_circle_size(\n num_points=len(y_true),\n biggest=4.0,\n smallest=1.0,\n use_smallest_when_num_points_at_least=5000,\n ),\n color=DARK_BLUE,\n fill_alpha=SCATTER_CIRCLES_FILL_ALPHA,\n line_alpha=SCATTER_CIRCLES_LINE_ALPHA,\n )\n\n add_title_rows(p, title_rows)\n apply_default_style(p)\n\n p.xaxis.axis_label = \"Ground Truth\"\n p.yaxis.axis_label = \"Prediction\"\n\n arange = np.arange(len(class_names))\n\n p.xaxis.ticker = arange\n p.yaxis.ticker = arange\n\n p.xaxis.major_label_overrides = {i: name for i, name in enumerate(class_names)}\n p.yaxis.major_label_overrides = {i: name for i, name in enumerate(class_names)}\n\n p.xaxis.major_label_orientation = x_label_rotation\n p.yaxis.major_label_orientation = y_label_rotation\n\n # grid between classes, not at classes\n p.xgrid.ticker = arange[0:-1] + 0.5\n p.ygrid.ticker = arange[0:-1] + 0.5\n\n p.xgrid.grid_line_width = 3\n p.ygrid.grid_line_width = 3\n\n # prevent panning to empty regions\n p.x_range.bounds = (-0.5, -0.5 + len(class_names))\n p.y_range.bounds = (-0.5, -0.5 + len(class_names))\n\n return p\n\n return figure","def plot_cv_train_test(test_avg, train_avg, lambdas, path):\n\n plt.plot(lambdas, test_avg, marker = \"o\", color=\"green\", label=\"validating cv error\")\n plt.plot(lambdas, train_avg, marker = \"v\", color=\"blue\", label=\"training cv error\" )\n \n print(train_avg[0])\n print(test_avg[0])\n \n plt.title(\"Cross Validation Error for Different Regularization Parameters\")\n plt.ylabel(\"10f cv RMSE\")\n plt.ylim(0.86 , 0.99)\n plt.xlabel(\"$\\lambda$\")\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\n plt.grid()\n plt.savefig(\"../results/\"+path)\n plt.show()","def plot_results(actual_time_series, predicted_values, len_train_data,\n y_name='Parameter'):\n\n plt.plot(np.arange(0, len(actual_time_series)),\n actual_time_series, label='Actual values', c='green')\n plt.plot(np.arange(len_train_data, len_train_data + len(predicted_values)),\n predicted_values, label='Predicted', c='blue')\n # Plot black line which divide our array into train and test\n plt.plot([len_train_data, len_train_data],\n [min(actual_time_series), max(actual_time_series)], c='black',\n linewidth=1)\n plt.ylabel(y_name, fontsize=15)\n plt.xlabel('Time index', fontsize=15)\n plt.legend(fontsize=15)\n plt.grid()\n plt.show()","def test_plot(arg):\n source_data = data.Biofile(arg)\n sample = source_data.get_header()\n feature = source_data.get_index()\n sample_size, feature_size = 106, 12042\n sample = sample[:sample_size]\n #xshape = (106 12042)\n print(sample, feature)\n X = source_data.get_matrix().T[:sample_size, :feature_size]\n mx = 100\n labs = ['rbf','poly','sigmoid']\n semi_r = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter = mx, parameter = 100) #rbf 0.5\n semi_r_con = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter = mx, kernel='poly', parameter= 0.5)#ploy 2\n semi_r_con1 = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter=mx, kernel='sigmoid', parameter= 0.1) #sigmoid 0.5\n semi_r_con2 = util.convex_non_negative_factorization(X.T, max_iter=mx, n_components=2)\n\n #semi_r = util.semi_non_negative_factorization_with_straint(X.T, max_iter = mx,n_components=2 ,initialization= 'Kmeans',alpha = 0.01, beta = 0.01)\n #semi_r_con = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2 ,initialization= 'Kmeans',alpha= 10, beta = 10)\n #semi_r_con1 = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2, initialization= 'Kmeans',alpha= 0, beta = 10)\n #semi_r_con2 = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2, initialization= 'Kmeans',alpha= 10, beta = 0)\n #convex_r_con = util.convex_non_negative_factorization(X.T, n_components=2, max_iter=mx)\n\n G, G1, G2, G3 = semi_r[1], semi_r_con[1], semi_r_con1[1], semi_r_con2[1]\n result, result1, result2, result3 = semi_r[2], semi_r_con[2], semi_r_con1[2], semi_r_con2[2]\n x = [i for i in range(mx)]\n # plot the losses function\n plt.title(\"losses function of {}\".format(arg[:-4]))\n plt.xlabel(\"iteration times\")\n plt.ylabel(\"losses\")\n\n plt.plot(x, result[:mx], 'r', marker = '.', label = 'kNMF({})'.format(labs[0]))\n plt.plot(x, result1[:mx], 'b', marker ='.' , label = 'kNMF({})'.format(labs[1]))\n plt.plot(x, result2[:mx], 'c', marker ='.', label = 'kNMF({})'.format(labs[2]))\n plt.plot(x, result3[:mx], 'm', marker ='.', label = 'cvxnmf')\n \"\"\"\n plt.plot(x, result[:mx], 'r', marker = '.', label = 'sNMF')\n plt.plot(x, result1[:mx], 'b', marker ='.' , label = 'sNMF(0.5,0.5)')\n plt.plot(x, result2[:mx], 'c', marker ='.', label = 'sNMF(0,0.5)')\n plt.plot(x, result3[:mx], 'm', marker ='.', label = 'sNMF(0.5,1)')\n plt.plot(x, result4[:mx], 'k', marker = '.', label = 'cvx-NMF')\n \"\"\"\n plt.legend(bbox_to_anchor=[1,1])\n plt.grid()\n plt.show()\n\n #plot the clustering result\n plt1 = plt\n plt1.subplot(221)\n plt1.plot(G[:,0], G[:,1], 'ro')\n plt1.title(u'the distribution of items(knmf({}))'.format(labs[0]))\n #items = zip(sample, G)\n #for item in items:\n # item_name, item_data = item[0], item[1]\n # plt1.text(item_data[0], item_data[1], item_name,\n # horizontalalignment='center',\n # verticalalignment='top')\n\n plt1.subplot(222)\n plt1.plot(G1[:,0], G1[:,1], 'bo')\n\n plt1.title(u'the distribution of items(knmf({}))'.format(labs[1]))\n\n #items = zip(sample, G1)\n #for item in items:\n # item_name, item_data = item[0], item[1]\n # plt1.text(item_data[0], item_data[1], item_name,\n # horizontalalignment='center',\n # verticalalignment='top')\n\n plt1.subplot(223)\n plt1.plot(G2[:,0], G2[:,1], 'co')\n plt1.title(u'the distribution of items((knmf({}))'.format(labs[2]))\n #items = zip(sample, G4)\n #for item in items:\n # item_name, item_data = item[0], item[1]\n # plt1.text(item_data[0], item_data[1], item_name,\n # horizontalalignment='center',\n # verticalalignment='top')\n\n plt1.subplot(224)\n plt1.plot(G3[:,0], G3[:,1], 'mo')\n plt1.title(u'the distribution of items(convex-nmf))')\n #items = zip(sample, G2)\n #for item in items:\n # item_name, item_data = item[0], item[1]\n # plt1.text(item_data[0], item_data[1], item_name,\n # horizontalalignment='center',\n # verticalalignment='top')\n\n plt1.show()","def _plot_train_test_experiment(mtrain, mval, metric_name, isState):\n # axes\n f, axes = plt.subplots(2,2,figsize=(12,10))\n ltrain = _plot_experiment(mtrain, axes[:,0], metric_name, isTrain=True)\n lval = _plot_experiment(mval, axes[:,1], metric_name, isTrain=False)\n # title\n target = \"State\" if isState else \"Output\"\n f.suptitle(f\"{target} Errors\")\n f.tight_layout()\n return f, axes","def draw_scatter_plot(x: pd.Series, y: pd.Series, x_label: str, y_label: str):\n\n plt.xlabel(x_label)\n plt.ylabel(y_label)\n plt.scatter(x, y)\n plt.title(\"Scatter plot of '%s' and '%s'\" % (x_label, y_label))\n\n lr_model = linear_regression(x, y)\n plt.plot(x, lr_model.predict(np.array(x).reshape(-1, 1)), color='red')\n\n plt.show()","def plot_T(df, parameters_list, title, point_type):\n slope, intercept, r, p, std_er = stats.linregress(df['T_exp'], df['T_prd'])\n plot = sns.regplot(x='T_exp', y='T_prd', data=df, line_kws={'label':\n \"y={0:.3f}x+{1:.3f}\".format(slope, intercept)})\n plot.legend()\n plot.set(xlabel=\"Experimental Temperature (K)\",\n ylabel=\"Predicted Temperature (K)\")\n plot.set_title(\"Parameters: \" + \", \".join(parameters_list[:-1]))\n plot.figure.suptitle(point_type + \": Experimental Versus Predicted\")\n plot.figure.savefig(title)\n plt.figure()","def plot_results(self):\n\n\n f1, ax1 = plt.subplots()\n h1, = ax1.plot(self.history[\"step\"], self.history[\"trainLoss\"],\\\n \"b-\", label=\"Loss - Train\")\n h2, = ax1.plot(self.history[\"step\"], self.history[\"validLoss\"],\\\n \"b.\", label=\"Loss - Validation\")\n\n ax1.set_ylabel(\"Loss\", color = \"blue\")\n ax1.tick_params(\"y\", color = \"blue\")\n ax1.yaxis.label.set_color(\"blue\")\n ax1.set_xlabel(\"Training Steps [{}]\".format(self.FLAGS.eval_every))\n\n ax2 = ax1.twinx()\n h3, = ax2.plot(self.history[\"step\"], self.history[\"trainAccr\"], \"r-\",\\\n label = \"Accuracy - Train\")\n h4, = ax2.plot(self.history[\"step\"], self.history[\"validAccr\"], \"r.\",\\\n label = \"Accuracy - Validation\")\n\n ax2.set_ylabel(\"Accuracy\", color = \"red\")\n ax2.tick_params(\"y\", color = \"red\")\n ax2.yaxis.label.set_color(\"red\")\n\n hds = [h1,h2,h3,h4]\n lbs = [l.get_label() for l in hds]\n ax1.legend(hds, lbs)\n f1.tight_layout()\n plt.savefig(\"trainingHistory.png\")\n\n plt.close(f1)\n #plt.show()","def plot_sparsification_error(ax, y_true, y_pred, uncert_meas, label,\n num_partitions):\n rel_part_size, sparse_err, sparse_err_oracle = sparsification_error(\n y_true, y_pred, uncert_meas, num_partitions)\n ax.plot(rel_part_size, sparse_err, label=label)\n ax.plot(rel_part_size, sparse_err_oracle, label=\"Oracle\")\n ax.set_xlabel(\"Fraction of removed points\")\n # ax.set_ylabel(\"\\textit{SE}\")\n ax.legend()","def plot_loss(stats):\r\n plt.plot(stats['train_loss_ind'], stats['train_loss'], label='Training loss')\r\n plt.plot(stats['val_loss_ind'], stats['val_loss'], label='Validation loss')\r\n plt.legend()\r\n plt.xlabel('Number of iterations')\r\n plt.ylabel('Loss')\r\n plt.show()","def plot_error_distribution(records, predictions, fig_savepath, figsize=(3.54, 2.0), format='PNG', dpi=300):\n plt.figure(figsize=figsize)\n error = predictions - records\n # plt.hist(error,bins=25)\n # plt.hist(error, 50, density=True,log=True, facecolor='g', alpha=0.75)\n plt.hist(error, 20, density=True, log=True, )\n plt.xlabel('Prediction Error')\n plt.ylabel('count')\n plt.tight_layout()\n plt.savefig(fig_savepath, format=format, dpi=dpi)\n # plt.show()","def plot_results(\n train_data: tuple[Tensor, Tensor],\n test_data: tuple[Tensor, Tensor],\n correct_class: Tensor\n):\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\n ax1.set_title('Training data')\n plot_dataset(train_data, ax1)\n\n ax2.set_title('Test data')\n plot_dataset(test_data, ax2)\n\n ax3.set_title('Test prediction correctness')\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\n \n fig1.savefig('plots/datasets')\n fig2.savefig('plots/predictions')\n plt.show()","def scatterplot(loc: List[CrimeStatistics]) -> None: \n # return None #stub\n #template based on visualization\n \n x = enrollment_list(loc)\n y = crime_list(loc)\n \n \n pyplot.scatter(x,y)\n pyplot.xlabel(\"Enrollment\")\n pyplot.ylabel(\"Total crime per campus\")\n pyplot.title(\"correlation between enrollment and crimes committed\")\n \n \n \n pyplot.show()\n print(linregress(x,y))\n \n \n return None","def scatter_plot(\n xs,\n ys,\n x_errs,\n y_errs,\n model_names=None,\n scaling=\"linear\",\n label=\"\",\n colors=\"blue\",\n fitlabel=\"Linear Fit\",\n fitcolor=\"red\",\n):\n xs = np.array(xs).reshape(-1, 1)\n ys = np.array(ys).reshape(-1, 1)\n x_errs = np.asarray(x_errs)\n y_errs = np.asarray(y_errs)\n\n scaled_xs = rescale(xs, scaling)\n scaled_ys = rescale(ys, scaling)\n\n if x_errs is not None:\n scaled_x_errs = rescale(x_errs, scaling)\n x_delta = np.abs(scaled_xs - scaled_x_errs)\n else:\n x_delta = np.zeros((scaled_xs.shape[0], 2))\n\n if y_errs is not None:\n scaled_y_errs = rescale(y_errs, scaling)\n y_delta = np.abs(scaled_ys - scaled_y_errs)\n else:\n y_delta = np.zeros((scaled_ys.shape[0], 2))\n\n def label_point(i):\n x = xs[i, 0]\n y = ys[i, 0]\n label = f\"{model_names[i]} <br>\" if model_names is not None else \"\"\n if x_errs is not None:\n label += f\"X: {x:.3f} ({x_errs[i, 0]:.3f}, {x_errs[i, 1]:.3f}) <br>\"\n else:\n label += f\"X: {x:.3f} <br>\"\n if y_errs is not None:\n label += f\"Y: {y:.3f} ({y_errs[i, 0]:.3f}, {y_errs[i, 1]:.3f}) <br>\"\n else:\n label += f\"Y: {y:.3f} <br>\"\n return label\n\n traces = []\n traces.append(\n go.Scatter(\n x=scaled_xs.flatten(),\n y=scaled_ys.flatten(),\n hoverinfo=\"text\",\n name=label,\n mode=\"markers\",\n error_x=dict(\n type=\"data\", symmetric=False, arrayminus=x_delta[:, 0], array=x_delta[:, 1], color=\"grey\",\n ),\n error_y=dict(\n type=\"data\", symmetric=False, arrayminus=y_delta[:, 0], array=y_delta[:, 1], color=\"grey\",\n ),\n marker=dict(color=colors, size=6),\n text=[label_point(i) for i in range(len(scaled_xs))],\n showlegend=False,\n )\n )\n\n # Add linear fit\n (bias, slope), r2 = linear_fit(scaled_xs, scaled_ys)\n sample_pts = rescale(np.arange(0.0, 1.0, 0.01), scaling)\n traces.append(\n go.Scatter(\n mode=\"lines\",\n x=sample_pts,\n y=slope * sample_pts + bias,\n name=f\"{fitlabel} (Slope: {slope:.2f}, R2: {r2:.2f})\",\n line=dict(color=fitcolor),\n )\n )\n\n return traces","def loss_plotter(model_history, ax=None):\n \n import matplotlib.pyplot as plt\n import seaborn as sns\n\n training_loss = model_history['loss']\n \n test_loss = model_history['val_loss']\n\n epoch_count = range(1,len(training_loss)+1)\n \n sns.set(font_scale=1.15)\n \n ax = sns.lineplot(\n x=epoch_count,\n y=training_loss,\n ax=ax\n )\n \n ax = sns.lineplot(\n x=epoch_count,\n y=test_loss,\n ax=ax\n )\n\n ax.set_title(\n 'Loss Curves: Pre-Trained VGG-16 with 2 Trained Layers',\n fontsize=19\n )\n ax.set_ylabel(\n 'Loss',\n fontsize=18\n )\n ax.set_xlabel(\n 'Epochs',\n fontsize=18\n )\n\n plt.legend(['Training Loss', 'Validation Loss'])\n plt.show()","def plot_scatter_and_linreg(df, col='b'):\n lr = LinearRegression()\n lr.fit(df['x'].reshape(-1, 1), df['y'])\n df.plot(kind='scatter', x='x', y='y', c=col, s=50)\n x_pred = np.linspace(df['x'].min(), df['x'].max(), 10)\n y_pred = lr.predict(x_pred.reshape(-1, 1))\n plt.plot(x_pred, y_pred, ls=':', c=col)\n\n plt.title(df.name)","def plot_ave(results_list):\n x_range = range(len(results_list[0]))\n err_x, err_y, std_list = [], [], []\n\n for i in x_range:\n if i % 10 == 0:\n #get average for each generation\n column = [] \n for result in results_list:\n column.append(result[i])\n average = np.average(column)\n \n std_dev = np.std(column)\n err_x.append(i)\n err_y.append(average)\n std_list.append(std_dev)\n\n pylab.errorbar(err_x, err_y, yerr=std_list)\n pylab.show()","def display_comparison(self, X_val, y_val):\n import matplotlib.pyplot as plt\n x = []\n y = []\n for model_tuple in self.model_list:\n x.append(model_tuple[1])\n y.append(model_tuple[0].score(X_val, y_val))\n plt.scatter(x, y)\n plt.show()","def plot_stats(x_axis, y_axis, df, highlight=[]):\n a, b = df[x_axis], df[y_axis]\n\n X_train, X_test, y_train, y_test = train_test_split(a, b, test_size=0.33, random_state=42)\n\n X_train = np.array(X_train).reshape(-1, 1)\n X_test = np.array(X_test).reshape(-1, 1)\n y_train = np.array(y_train).reshape(-1, 1)\n y_test = np.array(y_test).reshape(-1, 1)\n\n regr = linear_model.LinearRegression()\n\n regr.fit(X_train, y_train)\n\n df[y_axis + \" STD\"] = df[y_axis].apply(lambda a: round((a-df[y_axis].mean())/df[y_axis].std()))\n df[y_axis + \" rank\"] = df[y_axis].rank(ascending=False)\n df[x_axis + \" rank\"] = df[x_axis].rank(ascending=False)\n \n mapper = linear_cmap(field_name=y_axis + \" STD\", palette=brewer[\"RdBu\"][len(df[y_axis + \" STD\"].unique())], \n low=min(df[y_axis + \" STD\"].unique()), high=max(df[y_axis + \" STD\"].unique()))\n \n source = ColumnDataSource(df)\n source2 = ColumnDataSource(df[df[\"Player\"].isin(highlight)])\n \n p = figure(x_range=(df[x_axis].min() - df[x_axis].std(), df[x_axis].max() + df[x_axis].std()), \n y_range=(df[y_axis].min() - df[y_axis].std(), df[y_axis].max() + df[y_axis].std()))\n \n r1 = p.circle(x=x_axis, y=y_axis,\n source=source, size=10, color=mapper, line_color=\"black\", legend_group= y_axis + \" STD\")\n\n p.title.text = y_axis + \" vs. \" + x_axis\n p.title.align = \"center\"\n p.xaxis.axis_label = x_axis\n p.yaxis.axis_label = y_axis\n p.legend.location = 'top_left'\n p.legend.title = \"St. Dev's from Avg \" + y_axis\n p.background_fill_color = \"#dddddd\"\n p.background_fill_alpha = 0.1\n \n line_x = [df[x_axis].min().item() - df[x_axis].std().item(), df[x_axis].max().item() + df[x_axis].std().item()]\n line_y = [(line_x[0]*regr.coef_.item()) + regr.intercept_.item(), (line_x[1]*regr.coef_.item()) + regr.intercept_.item()]\n r2 = p.line(line_x, line_y, line_width=2, color=\"black\")\n\n p.add_tools(HoverTool(renderers=[r1], tooltips=[\n (\"Player\", \"@Player\"),\n (y_axis, \"@{\" + y_axis +\"}{0.000}\"),\n (y_axis + \" Rank\", \"#@{\" + y_axis + \" rank}\"),\n (x_axis, \"@{\" + x_axis +\"}{0}\"),\n (x_axis + \" Rank\", \"#@{\" + x_axis + \" rank}\")]))\n\n \n p.add_tools(HoverTool(renderers=[r2], \n tooltips=[(x_axis, \"$x{0000}\"),\n (\"Predicted \" + y_axis, \"$y\")]))\n \n labels = LabelSet(x=x_axis, \n y=y_axis, text=\"Player\", y_offset=8,\n text_font_size=\"11px\", text_color=\"#555555\",\n source=source2, text_align='center')\n \n p.add_layout(labels)\n\n st.bokeh_chart(p)","def plot_fit(self, inputs, targets, y_pred, y_std):\n x_context, y_context, x_data = inputs\n y_data = targets\n x_context = np.squeeze(x_context, axis=-1)\n y_context = np.squeeze(y_context, axis=-1)\n x_data = np.squeeze(x_data, axis=-1)\n y_data = np.squeeze(y_data, axis=-1)\n y_pred = np.squeeze(y_pred, axis=-1)\n y_std = np.squeeze(y_std, axis=-1)\n\n plt.figure()\n plt.plot(x_data[-1], y_data[-1], 'k--', label='Ground Truth')\n plt.plot(x_context[-1], y_context[-1], 'ko', label='Context')\n plt.plot(x_data[-1], y_pred[-1], 'b-', label='GP Fit')\n plt.fill_between(x_data[-1], y_pred[-1] - 1.96 * y_std[-1],\n y_pred[-1] + 1.96 * y_std[-1],\n alpha=0.5, color='b')\n # plt.fill_between(x_data[-1], y_pred[-1] - 1 * y_std[-1],\n # y_pred[-1] + 1 * y_std[-1],\n # alpha=0.5, color='b')\n\n # make plots look nice\n plt.xticks(np.arange(-2, 3))\n plt.yticks(np.arange(-2, 3))\n plt.ylabel('y')\n plt.xlabel('x')\n plt.tight_layout()\n plt.show()"],"string":"[\n \"def plot_errors(self):\\n\\n plt.title(\\\"Prediction Error\\\")\\n plt.plot(self.errors)\\n plt.ylabel(\\\"MSE (Mean Squared Error)\\\")\\n plt.xlabel(\\\"Iteration\\\")\\n plt.show()\",\n \"def plotPredictedError():\\n\\tglobal normalized\\n\\n\\twarmthPred = []\\n\\twarmthObserved = []\\n\\tcompPred = []\\n\\tcompObserved = []\\n\\tSStotalWarmth = 0\\n\\tSSresWarmth = 0\\n\\tSStotalComp = 0\\n\\tSSresComp = 0\\n\\tkeys = parser.getMappings(normalized)[0].keys()\\n\\tfor key in keys:\\n\\n\\t\\tif \\\"_\\\" in key:\\n\\t\\t\\twarmthAxis, compAxis = getPlotData(key)\\n\\t\\t\\twarmthPred.append(warmthAxis[3])\\n\\t\\t\\twarmthObserved.append(warmthAxis[2])\\n\\t\\t\\tcompPred.append(compAxis[3])\\n\\t\\t\\tcompObserved.append(compAxis[2])\\n\\n\\tmeanObservedWarmth = np.mean(warmthObserved)\\n\\tmeanObservedComp = np.mean(compObserved)\\n\\tfor i in range(0, len(warmthObserved)):\\n\\t\\tSStotalWarmth += (warmthObserved[i] - meanObservedWarmth)**2\\n\\t\\tSSresWarmth += (warmthObserved[i] - warmthPred[i])**2\\n\\t\\tSStotalComp += (compObserved[i] - meanObservedComp)**2\\n\\t\\tSSresComp += (compObserved[i] - compPred[i])**2\\n\\n\\n\\tplt.axis([0, 100, 0, 100])\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(warmthObserved, warmthPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.title(\\\"Observed vs Predicted Warmth\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(warmthObserved, warmthPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\\n\\n\\tfig = plt.figure(1)\\n\\tax = fig.add_subplot(111)\\n\\tslope, intercept, r_value, p_value, std_err = stats.linregress(compObserved, compPred)\\n\\tprint(r_value**2)\\n\\ttext = ax.text(60, 20, \\\"R^2 value: \\\" + str(r_value**2) , \\\\\\n fontsize = 12, color = 'black')\\n\\tplt.axis([0, 100, 0, 100])\\n\\tplt.title(\\\"Observed vs Predicted Competence\\\")\\n\\tplt.ylabel(\\\"Predicted Value\\\")\\n\\tplt.xlabel(\\\"Observed Value\\\")\\n\\tplt.scatter(compObserved, compPred)\\n\\tplt.plot([0,100], [0,100])\\n\\tplt.show()\",\n \"def _draw_error_scatter(self, p1, p2, var, color='red', marker='*', ax=None, obslabels=None):\\n\\n if ax is None:\\n f = pl.figure()\\n ax = f.add_subplot(111)\\n d1 = self._get_model_error(p1, var) # this gives a dict with (key,value)\\n d2 = self._get_model_error(p2, var)\\n\\n if len(d1) == 0:\\n return None\\n if len(d2) == 0:\\n return None\\n\\n x = []\\n y = []\\n labels = []\\n for k in d1.keys():\\n labels.append(k)\\n x.append(d1[k])\\n #find corresponding model in second observation\\n for l in d2.keys():\\n if l == k:\\n y.append(d2[k])\\n x = np.asarray(x)\\n y = np.asarray(y)\\n\\n if len(x) != len(y):\\n print(d1)\\n print(d2)\\n raise ValueError('The length of the arrays are not the same !')\\n\\n slope, intercept, r_value, p_value, std_err = stats.mstats.linregress(x, y)\\n if r_value is None:\\n return ax\\n else:\\n ax.plot(x, y, marker=marker, color=color, label=self._pos2label(p1, obslabels) + ' vs. ' + self._pos2label(p2, obslabels) + ' ($r$=' + str(round(r_value, 2)) + ')', linestyle='None')\\n return ax\",\n \"def _single_prediction_error_plot(self, scatter_data, color):\\n # figure\\n p = default_figure(\\n {\\n \\\"tools\\\": \\\"pan,wheel_zoom,box_zoom,reset\\\",\\n \\\"toolbar_location\\\": \\\"right\\\"\\n }\\n )\\n\\n # scatter\\n p.scatter(scatter_data[0], scatter_data[1], color=color, size=16, fill_alpha=0.8)\\n\\n # baseline of x=y\\n slope = Slope(\\n gradient=1,\\n y_intercept=0,\\n line_width=1,\\n line_color=self.plot_design.models_dummy_color,\\n line_dash=\\\"dashed\\\"\\n )\\n p.add_layout(slope)\\n\\n # plot specific styling\\n p.xaxis.axis_label = \\\"Actual\\\"\\n p.yaxis.axis_label = \\\"Predicted\\\"\\n\\n formatter = FuncTickFormatter(code=self._formatter_code) # negative numbers are having a wacky formatting\\n # formatters must be created independently, cannot be reused between plots\\n p.xaxis.formatter = formatter\\n p.yaxis.formatter = formatter\\n\\n p.toolbar.autohide = True\\n\\n return p\",\n \"def plotErrors(losses, model_title ='Shallow Network, SGD, Batch Size = 10'):\\n fig, axes = plt.subplots()\\n\\n x = np.arange(len(losses))\\n\\n axes.plot(x, losses)\\n axes.set_ylabel(\\\"Loss (cross entropy)\\\")\\n axes.set_xlabel(\\\"Number of iterations\\\")\\n axes.set_title(model_title) \\n\\n plt.show() \\n\\n return None\",\n \"def plot_errors(loss_train, loss_val, jet):\\n plt.plot(list(range(len(loss_train))), loss_train, 'g', label='Training loss')\\n plt.plot(list(range(len(loss_val))), loss_val, 'b', label='Validation loss')\\n plt.title('Training and Validation loss for jet: {jet}'.format(jet=jet))\\n plt.xlabel('Epochs')\\n plt.ylabel('Loss')\\n plt.legend()\\n plt.show()\",\n \"def plot_train_test_errors(train_errors, test_errors, lambda_str , K , path, rng):\\n plt.plot(range(rng), train_errors, marker='o', label='Training Data');\\n plt.plot(range(rng), test_errors, marker='v', label='Test Data');\\n plt.title('ALS-WR Learning Curve, lambda = %s, K = %d'%(lambda_str, K))\\n plt.xlabel('Number of Epochs');\\n plt.ylabel('RMSE');\\n plt.legend()\\n plt.grid()\\n plt.savefig(\\\"../results/test_train_rmse_\\\"+path)\\n plt.show()\",\n \"def plot_model_error(x_train, x_test, y_train, y_test, model, \\\\\\n save_fig_fname, label):\\n # Assertions\\n assert isinstance(x_train, np.ndarray)\\n assert isinstance(x_test, np.ndarray)\\n assert isinstance(y_train, np.ndarray)\\n assert isinstance(y_test, np.ndarray)\\n assert isinstance(save_fig_fname, (str, type(None))), \\\\\\n 'Wrong Type: desired output file name must be a string'\\n if type(save_fig_fname) is str:\\n assert save_fig_fname.endswith('.png'),\\\\\\n 'output_file string must include the .png extension'\\n\\n # Functionality\\n y_train = y_train.reshape(-1,1)\\n y_test = y_test.reshape(-1,1)\\n plt.figure(figsize=(8, 10), dpi=100)\\n plt.subplot(211)\\n plt.scatter(y_train, model.predict(x_train), color='r', label='train')\\n plt.scatter(y_test, model.predict(x_test), color='blue', label='test')\\n plt.xlabel('Actual %s' % label, fontsize=12)\\n plt.ylabel('Predicted %s' %label, fontsize=12)\\n plt.legend(loc='upper center')\\n\\n plt.subplot(212)\\n plt.scatter(y_train, model.predict(x_train)-y_train, color = 'r', \\\\\\n label = 'train', marker= 'x')\\n plt.scatter(y_test, model.predict(x_test)-y_test, color = 'blue', \\\\\\n label = 'test', marker = 'x')\\n plt.axhline(0, ls='--')\\n plt.xlabel('Actual %s' % label, fontsize=12)\\n plt.ylabel('Prediction error %s' % label, fontsize=12)\\n plt.legend(loc='upper center')\\n\\n if save_fig_fname is not None:\\n plt.savefig(save_fig_fname)\\n else:\\n plt.show()\",\n \"def plot_model_error(self, var, obslabels=None):\\n\\n fig = plt.figure()\\n gs = gridspec.GridSpec(1, 2, wspace=0.05, hspace=0.05, bottom=0.2, width_ratios=[3, 1])\\n ax = fig.add_subplot(gs[0])\\n\\n # 1 vs. 2\\n self._draw_error_scatter(1, 2, var, color='red', marker='o', ax=ax, obslabels=obslabels)\\n\\n # 1 vs. 3\\n self._draw_error_scatter(1, 3, var, color='green', marker='*', ax=ax, obslabels=obslabels)\\n\\n # 1 vs. 4\\n self._draw_error_scatter(1, 4, var, color='blue', marker='^', ax=ax, obslabels=obslabels)\\n\\n # 2 vs. 3\\n self._draw_error_scatter(2, 3, var, color='grey', marker='x', ax=ax, obslabels=obslabels)\\n\\n # 2 vs 4\\n self._draw_error_scatter(2, 4, var, color='m', marker='+', ax=ax, obslabels=obslabels)\\n\\n # 3 vs 4\\n self._draw_error_scatter(3, 4, var, color='c', marker='h', ax=ax, obslabels=obslabels)\\n\\n if ax is not None:\\n ax.legend(prop={'size': 8}, ncol=1, fancybox=True, loc='upper left')\\n ax.set_xlabel('$\\\\epsilon$ (observation X)')\\n ax.set_ylabel('$\\\\epsilon$ (observation Y)')\\n\\n xmi, xma = ax.get_xlim()\\n ymi, yma = ax.get_ylim()\\n\\n ax.set_ylim(min(xmi, ymi), max(xma, yma))\\n ax.set_xlim(min(xmi, ymi), max(xma, yma))\\n ax.grid()\\n ax.set_title('Comparison of model errors: ' + var.upper())\\n ax.plot(ax.get_xlim(), ax.get_xlim(), 'k--') # 1:1 line\\n return fig\",\n \"def error():\\n\\n # Make data set using errors\\n dataset_a = DataSet(oscillating,error_y=oscillating_error,plot='error_bar',label='Data and error')\\n dataset_a.set_error(interval=5,width=1,cap=2)\\n dataset_b = DataSet(oscillating,plot='error_shade',error_y=oscillating_error,order=0,colour='lightgrey',label='Error')\\n dataset_c = DataSet(oscillating,plot='line',order=1,colour='firebrick',label='Data')\\n\\n # Make line graph with error bars\\n plot_bar = Plot()\\n plot_bar.set_legend(legend=True)\\n plot_bar.add_dataset(dataset_a)\\n plot_bar.plot()\\n plot_bar.save(name='./figures/2d_error_bar',fmt='png')\\n plot_bar.display()\\n\\n # Make line graph with shaded errors\\n plot_shade = Plot()\\n plot_shade.set_legend(legend=True,location='upper left')\\n plot_shade.add_dataset(dataset_b)\\n plot_shade.add_dataset(dataset_c)\\n plot_shade.plot()\\n plot_shade.save(name='./figures/2d_error_shade',fmt='png')\\n plot_shade.display()\",\n \"def scatter_plot(x_train, y_train, x_test, y_test, class1, class2):\\n train_c0 = x_train[y_train == 0, :]\\n train_c1 = x_train[y_train == 1, :]\\n test_c0 = x_test[y_test == 0, :]\\n test_c1 = x_test[y_test == 1, :]\\n fig, a = plt.subplots(1, 2)\\n fig.set_size_inches(11, 5)\\n a[0].scatter(train_c0[:, 0], train_c0[:, 1], color='green', label=class1)\\n a[0].scatter(train_c1[:, 0], train_c1[:, 1], color='red', label=class2)\\n a[0].legend()\\n a[0].set_title('Train Set')\\n a[1].scatter(test_c0[:, 0], test_c0[:, 1], color='green', label=class1)\\n a[1].scatter(test_c1[:, 0], test_c1[:, 1], color='red', label=class2)\\n a[1].legend()\\n a[1].set_title('Test Set')\\n plt.show()\",\n \"def plot_failures(features, labels, errors):\\n model = TSNE(n_components=2, random_state=0, init=\\\"pca\\\", metric=\\\"correlation\\\")\\n transformed = model.fit_transform(features)\\n errors = map(lambda x: 30 if x else 10, errors)\\n\\n print(\\\"Data transformed, now plotting...\\\")\\n\\n # Plotting\\n x = transformed[:, 0]\\n y = transformed[:, 1]\\n colors = labels\\n areas = errors\\n\\n plt.scatter(x, y, c=colors, s=areas, edgecolors='none')\\n plt.xlabel(\\\"t-SNE component 1\\\")\\n plt.ylabel(\\\"t-SNE component 2\\\")\\n plt.show()\",\n \"def train_test_error(e_train, e_test, model_params):\\n\\n fig = plt.figure(figsize=FIG_SIZE)\\n plt.plot(model_params, e_train, label='Training Set')\\n plt.plot(model_params, e_train, label='Test Set')\\n plt.xlabel('Model Parameter')\\n plt.ylabel('MSE of model')\\n plt.legend()\\n\\n return fig\",\n \"def error_plot(training_costs, test_costs, learning_rate, accuracy, test_accuracy, val_accuracy, layers, data_size,\\n n_neighbours, dropout_rate):\\n\\n plt.plot(training_costs, label=\\\"Training loss\\\")\\n plt.plot(test_costs, label=\\\"Test loss\\\")\\n plt.xlabel(\\\"Iterations\\\", size='medium')\\n plt.ylabel(\\\"Cost function (%)\\\", size='medium')\\n plt.suptitle(\\\"Cost function while training the neural network\\\", size='medium', ha='center')\\n plt.title(\\\"layers: {} with dropout rate of {}, learning rate: {}\\\".format(layers, dropout_rate, learning_rate),\\n size='small', ha='center')\\n plt.figtext(0.77, 0.35, \\\"Training accuracy\\\\n{0:.2f}%\\\".format(accuracy), size='medium')\\n plt.figtext(0.77, 0.25, \\\"Test accuracy\\\\n{0:.2f}%\\\".format(test_accuracy), size='medium')\\n plt.figtext(0.77, 0.15, \\\"Validation accuracy\\\\n{0:.2f}%\\\".format(val_accuracy), size='medium')\\n if n_neighbours == 0:\\n plt.figtext(0.77, 0.80, \\\"Neighbours\\\\nexcluded\\\", size='medium')\\n else:\\n plt.figtext(0.77, 0.80, \\\"{} neighbours\\\\nincluded\\\".format(n_neighbours), size='medium')\\n plt.figtext(0.77, 0.70, \\\"{}\\\\nsamples\\\".format(data_size))\\n plt.legend(loc='right', bbox_to_anchor=(1.39, 0.5))\\n plt.subplots_adjust(right=0.75)\\n working_dir = os.path.dirname(os.path.abspath(__file__))\\n saving(working_dir + \\\"/output_ANN/error_plots/{}_error_{}\\\".format(n_neighbours, data_size))\",\n \"def classificationError():\\n print('Computing Classification Test Error')\\n\\n dl1, dl2 = CIFAR10TestLoader() \\n err1, err2 = [], []\\n\\n # load every model \\n with open('classification_error.csv','w') as clf:\\n writer = csv.writer(clf)\\n writer.writerow(['Classification Error Dataset 1','Classification Error Dataset 2'])\\n\\n for i in tqdm(range(5,95,2)):\\n mtl = MTL()\\n PATH = os.getcwd() + '/mtl_model_{d1}_vs_{d2}.pth'.format(d1=i, d2=100-i)\\n mtl.load_state_dict(state_dict=torch.load(PATH))\\n\\n e1, e2 = accuracy(dl1, mtl), accuracy(dl2, mtl)\\n err1.append(e1)\\n err2.append(e2)\\n writer.writerow([e1,e2])\\n \\n fig, ax_left = plt.subplots()\\n ax_right = ax_left.twinx()\\n ax_left.plot([0.05 + 0.02* i for i in range(45)], err1, color='black')\\n ax_right.plot([0.05 + 0.02* i for i in range(45)], err2, color='red')\\n ax_right.set_ylabel('Dataset 2 (red) accuracy')\\n ax_left.set_ylabel('Dataset 1 (black) accuracy')\\n ax_left.set_xlabel('Percentage of points from dataset 1 in training set')\\n plt.title('Classification Accuracy over both datasets')\\n plt.savefig('classification_error_plots.pdf')\",\n \"def draw_bonus_error(error):\\n f, ax = plt.subplots()\\n vertices = np.arange(10, 50)\\n ax.plot(vertices, error[10:], 'b', label='Error')\\n plt.xlabel('Rounds')\\n plt.ylabel('Misclassification Error')\\n plt.title('Misclassification Error: l = 10, m = 20, n = 40')\\n plt.legend(loc='upper left')\\n plt.grid(True)\\n plt.show()\",\n \"def actual_pred_plot(preds):\\r\\n actual_pred = pd.DataFrame(columns=['Cost', 'prediction'])\\r\\n actual_pred['Cost'] = all_data['2020':].iloc[:, -1][1:len(preds) + 1]\\r\\n actual_pred['prediction'] = preds[:, -1]\\r\\n\\r\\n from keras.metrics import MeanSquaredError\\r\\n m = MeanSquaredError()\\r\\n m.update_state(np.array(actual_pred['Cost']), np.array(actual_pred['prediction']))\\r\\n\\r\\n return m.result().numpy(), actual_pred.plot()\",\n \"def plot_scatter(self):\\n if Trainer.y_pred is None or Trainer.y_true is None:\\n messagebox.showerror(\\\"Information\\\", \\\"Please train the model first before plotting\\\")\\n return\\n\\n fig = plt.figure(figsize=(8, 4))\\n plt.xlabel(\\\"Prediction\\\")\\n plt.ylabel(\\\"Target\\\")\\n plt.figtext(0, 0, f\\\"RMSE: {self.test_rmse}\\\", fontsize=13)\\n plt.grid()\\n plt.scatter(x=Trainer.y_true, y=Trainer.y_pred, c='b', s=1)\\n\\n win = tk.Toplevel()\\n win.wm_title(\\\"Window\\\")\\n win.geometry(\\\"1000x500\\\")\\n\\n # specify the window as master\\n canvas = FigureCanvasTkAgg(fig, master=win)\\n canvas.draw()\\n canvas.get_tk_widget().grid(row=0, column=0, sticky=tk.W)\\n\\n # navigation toolbar\\n toolbarFrame = tk.Frame(master=win)\\n toolbarFrame.grid(row=1, column=0)\\n toolbar = NavigationToolbar2Tk(canvas, toolbarFrame)\",\n \"def plot_scatter(x_variable, y_variable, df, x_title, y_title):\\n slope, intercept, r_value, p_value, std_err = stats.linregress(\\n df[x_variable], df[y_variable])\\n plot = sns.regplot(x=x_variable, y=y_variable, data=df, line_kws={'label':\\n \\\"y={0:.3f}x+{1:.3f}\\\".format(slope, intercept)})\\n plot.set(xlabel=x_title, ylabel=y_title + ' (K)')\\n title = y_title + ' Versus ' + x_title\\n plot.set_title(title)\\n plot.legend()\\n plot.figure.savefig(title.replace(' ', '_'))\\n plt.figure()\",\n \"def plot_error(k_vals, error):\\n\\n plt.plot(k_vals,error)\\n plt.xlabel('k-value')\\n plt.ylabel('Cost')\\n plt.show()\",\n \"def PlotComparison(result_values, descrete, continuous, jitter=100):\\n df = result_values.copy()\\n np.random.seed(0)\\n df[continuous] = df[continuous] + np.random.randint(low=-jitter, high=jitter, size=len(df))\\n base = alt.Chart(df).transform_calculate(\\n ymin=\\\"datum.mean-2*datum.std\\\",\\n ymax=\\\"datum.mean+2*datum.std\\\",\\n ).properties(\\n title = '[Interactive] Accuracy by Params'\\n )\\n \\n points = base.mark_point(\\n filled=True,\\n size=10\\n ).encode(\\n x=continuous,\\n y=alt.Y('mean:Q'),#, scale=alt.Scale(domain=(0.55, 0.7))),\\n color=descrete,\\n tooltip=['mean','std']\\n )\\n\\n errorbars = base.mark_errorbar().encode(\\n x=continuous,\\n y=alt.Y(\\\"ymin:Q\\\",title='Accuracy'),\\n y2=\\\"ymax:Q\\\",\\n color=descrete,\\n )\\n\\n return(points + errorbars)\",\n \"def plot_error(class_incorreto):\\n epochs = np.arange(1, num_iter + 1)\\n plt.plot(epochs, class_incorreto)\\n plt.xlabel('Iterações')\\n plt.ylabel('Classificados incorretamente')\\n plt.show()\",\n \"def prediction_error_plot(self, prediction_errors):\\n prediction_errors = assess_models_names(prediction_errors)\\n _ = []\\n i = 0\\n for model, scatter_points in prediction_errors:\\n if i == 0:\\n color = self.plot_design.models_color_tuple[0]\\n i += 1\\n else:\\n color = self.plot_design.models_color_tuple[1]\\n plot = self._single_prediction_error_plot(scatter_points, color)\\n _.append(Panel(child=plot, title=model))\\n\\n main_plot = Tabs(tabs=_)\\n return main_plot\",\n \"def plot_loss(training_errors, validation_errors):\\n plt.xscale('Log')\\n plt.xlabel('Epochs')\\n plt.ylabel('Mean Actual Error')\\n plt.plot(training_errors, label = \\\"Training Error\\\", \\\\\\n color = 'blue')\\n plt.plot(validation_errors, label = \\\"Validation Error\\\", \\\\\\n color = 'red')\\n plt.legend()\\n # Saves plot automatically, adjust filename as needed.\\n plt.savefig('reservoir_05whdens_100h_7spec_test_3.png')\\n plt.show()\",\n \"def display_errors(errors_index,img_errors,pred_errors, obs_errors):\\n n = 0\\n nrows = 3\\n ncols = 3\\n fig, ax = plt.subplots(nrows,ncols,sharex=True,sharey=True)\\n for row in range(nrows):\\n for col in range(ncols):\\n error = errors_index[n]\\n ax[row,col].imshow((img_errors[error]).reshape((28,28)))\\n ax[row,col].set_title(\\\"Predicted label :{}\\\\nTrue label :{}\\\".format(pred_errors[error],obs_errors[error]))\\n n += 1\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def plot_result(data, gt_y, pred_y):\\n assert data.shape[0] == gt_y.shape[0]\\n assert data.shape[0] == pred_y.shape[0]\\n\\n plt.figure()\\n\\n plt.subplot(1, 2, 1)\\n plt.title('Ground Truth', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if gt_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.subplot(1, 2, 2)\\n plt.title('Prediction', fontsize=18)\\n\\n for idx in range(data.shape[0]):\\n if pred_y[idx] == 0:\\n plt.plot(data[idx][0], data[idx][1], 'ro')\\n else:\\n plt.plot(data[idx][0], data[idx][1], 'bo')\\n\\n plt.show()\",\n \"def prediction_error(y_true, y_pred, ax=None):\\n _check_parameter_validity(y_true, y_pred)\\n if ax is None:\\n ax = plt.gca()\\n\\n model = LinearRegression()\\n\\n if isinstance(y_true, pd.Series):\\n y_true = y_true.values\\n y_reshaped = y_true.reshape((-1, 1))\\n\\n # it is necessary to fit the model with y_true and y_pred\\n # to get the best fit line representing the error trend\\n model.fit(y_reshaped, y_pred)\\n x = np.linspace(min(min(y_true), min(y_pred)), max(max(y_true), max(y_pred)))\\n y = model.intercept_ + model.coef_ * x\\n ax.plot(x, y, \\\"-b\\\", label=\\\"best fit\\\")\\n\\n # identity line\\n ax.plot(x, x, \\\"--k\\\", label=\\\"identity\\\")\\n\\n # scatter plot\\n ax.scatter(y_true, y_pred)\\n\\n # R2\\n r2 = model.score(y_reshaped, y_pred)\\n plt.plot([], [], \\\" \\\", label=f\\\"R2 = {round(r2,5)}\\\")\\n\\n _set_ax_settings(ax, \\\"y_true\\\", \\\"y_pred\\\", \\\"Prediction Error\\\")\\n ax.legend(loc=\\\"upper left\\\")\\n return ax\",\n \"def analysis_plot(predictions, ys):\\n fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 5))\\n\\n residuals = ys - predictions\\n\\n # Plot 1 - Predicted vs Actual\\n sns.scatterplot(predictions, ys, ax=ax1)\\n ax1.set_title('Predicted vs Actual', fontsize=20)\\n ax1.set(xlabel='Predicted Ys', ylabel='Actual Ys')\\n\\n # Plot 2 - Residuals PLot (predicted vs residuals)\\n sns.scatterplot(predictions, residuals, ax=ax2)\\n ax2.set_title('Residuals Plot', fontsize=20)\\n ax2.set(xlabel='Predicted Ys', ylabel='Residuals')\\n\\n # Plot 3 - QQ Plot\\n sm.qqplot(residuals, ax=ax3, line='s')\\n ax3.set_title('QQ Plot- Distribution of Residuals', fontsize=20)\\n\\n plt.show();\",\n \"def _plot_errors(self):\\n for task_id, loss_type in self.task_ids.iteritems():\\n x = np.arange(len(self.training_errors[task_id]))\\n fig, ax = plt.subplots(1, 1)\\n ax.set_xlabel('Number of epochs of training')\\n if loss_type is LossTypes.mse:\\n ax.set_ylabel('RMSE Error')\\n elif loss_type is LossTypes.cross_entropy:\\n ax.set_xlabel('(1 - accuracy)')\\n plt.plot(x, self.training_errors[task_id], 'r', label='training')\\n plt.plot(x, self.validation_errors[task_id], 'b', label='validation')\\n plt.legend(loc=\\\"best\\\", framealpha=0.3)\\n fig.savefig(\\\"error-curve-task-{}.png\\\".format(task_id))\\n plt.close('all')\",\n \"def plot_cv_errors(errors, lambdas , K , path): \\n colors = cycle([\\\"aqua\\\", \\\"black\\\", \\\"blue\\\", \\\"fuchsia\\\", \\\"gray\\\", \\\"green\\\", \\\"lime\\\", \\\"maroon\\\", \\\"navy\\\", \\\"olive\\\", \\\"purple\\\", \\\"red\\\", \\\"silver\\\", \\\"teal\\\", \\\"yellow\\\"])\\n \\n markers = cycle([ \\\".\\\", \\\",\\\", \\\"o\\\", \\\"v\\\" , \\\"^\\\" , \\\">\\\", \\\"1\\\", \\\"2\\\", \\\"3\\\", \\\"4\\\", \\\"8\\\", \\\"s\\\", \\\"p\\\", \\\"*\\\", \\\"h\\\"])\\n \\n \\n for i, data in enumerate(errors):\\n \\n lambda_str = ('%f' % lambdas[i]).rstrip('0').rstrip('.')\\n plt.plot(range(len(data)), data, marker=next(markers), label='$\\\\lambda$ = %s'%lambda_str);\\n \\n plt.ylim(0.975 , 0.99)\\n #plt.xlim(0 , 50)\\n plt.title('ALS-WR Learning Curve, K = %d'% K)\\n plt.xlabel('Number of Epochs');\\n plt.ylabel('RMSE');\\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\\n plt.grid()\\n plt.savefig(\\\"../results/\\\"+path)\\n plt.show()\",\n \"def plot_error(self, maxstep=20):\\n plt.ion()\\n plt.xlabel(\\\"step\\\")\\n plt.ylabel(\\\"Ave Logloss (bits)\\\")\\n train_errors = []\\n if self.dataset.test:\\n test_errors = []\\n for i in range(maxstep):\\n self.learn(1)\\n train_errors.append( sum(self.logloss(tple) for tple in self.dataset.train)\\n /len(self.dataset.train))\\n if self.dataset.test:\\n test_errors.append( sum(self.logloss(tple) for tple in self.dataset.test)\\n /len(self.dataset.test))\\n plt.plot(range(1,maxstep+1),train_errors,\\n label=str(self.num_classes)+\\\" classes. Training set\\\")\\n if self.dataset.test:\\n plt.plot(range(1,maxstep+1),test_errors,\\n label=str(self.num_classes)+\\\" classes. Test set\\\")\\n plt.legend()\\n plt.draw()\",\n \"def graph_error_over_generation(self, with_scatter=False):\\n mean_errors = []\\n best_individual_errors = []\\n\\n for i in range(len(self.generations)):\\n best_individual_errors.append(\\n self.get_low_fitness_individual(i).fitness)\\n mean_errors.append(\\n np.mean([j.fitness for j in self.generations[i]]))\\n\\n plt.figure(figsize=(10, 5))\\n ax = plt.subplot()\\n if with_scatter:\\n self.plot_error_scatter()\\n mean_error_line, = plt.plot(\\n range(len(self.generations)),\\n mean_errors,\\n label='Mean Error of Individuals',\\n color='b')\\n best_individual_error_line, = plt.plot(\\n range(len(self.generations)),\\n best_individual_errors,\\n label='Lowest Error of an Individual',\\n color='green')\\n plt.xticks(\\n [i for i in range(0, self.config.max_generations, 5)],\\n [i for i in range(0, self.config.max_generations, 5)])\\n hfont = {'fontname': 'Helvetica'}\\n plt.xlabel('Generation', **hfont)\\n plt.ylabel('Error', **hfont)\\n ax.spines['right'].set_visible(False)\\n ax.spines['top'].set_visible(False)\\n\\n plt.legend(\\n handles=[mean_error_line, best_individual_error_line],\\n loc='upper right',\\n bbox_to_anchor=(1, 1.1))\\n plt.savefig('figures/Parameter Tuning Figure/error_over_generation.svg')\",\n \"def plot_scatter(df):\\n fig = px.scatter(df, x=\\\"preds\\\", y=\\\"truth\\\", title=\\\"Predictions vs True Values\\\", color=\\\"mae\\\")\\n wandb.log({f\\\"Predictions vs True Values\\\": fig})\\n\\n # Poor Results\\n df = df.query(\\\"mae > 2\\\")\\n fig = px.scatter(df, x=\\\"preds\\\", y=\\\"truth\\\", title=\\\"Predictions vs True Values\\\", color=\\\"mae\\\")\\n wandb.log({f\\\"Predictions vs True Values [mae > 2]\\\": fig})\",\n \"def scatter_with_err_bar(\\n x: ArrayLike | str,\\n y: ArrayLike | str,\\n df: pd.DataFrame | None = None,\\n xerr: ArrayLike | None = None,\\n yerr: ArrayLike | None = None,\\n ax: plt.Axes | None = None,\\n xlabel: str = \\\"Actual\\\",\\n ylabel: str = \\\"Predicted\\\",\\n title: str | None = None,\\n **kwargs: Any,\\n) -> plt.Axes:\\n x, y = df_to_arrays(df, x, y)\\n ax = ax or plt.gca()\\n\\n styles = dict(markersize=6, fmt=\\\"o\\\", ecolor=\\\"g\\\", capthick=2, elinewidth=2)\\n ax.errorbar(x, y, xerr=xerr, yerr=yerr, **kwargs, **styles)\\n\\n # identity line\\n ax.axline((0, 0), (1, 1), alpha=0.5, zorder=0, linestyle=\\\"dashed\\\", color=\\\"black\\\")\\n\\n annotate_metrics(x, y, ax=ax)\\n\\n ax.set(xlabel=xlabel, ylabel=ylabel, title=title)\\n\\n return ax\",\n \"def plot_results(sgd_train_acc, sgd_train_std, sgd_heldout_acc, sgd_heldout_std, sgd_test_acc,\\n dt_train_acc, dt_train_std, dt_heldout_acc, dt_heldout_std, dt_test_acc,\\n dt4_train_acc, dt4_train_std, dt4_heldout_acc, dt4_heldout_std, dt4_test_acc,\\n stumps_train_acc, stumps_train_std, stumps_heldout_acc, stumps_heldout_std, stumps_test_acc):\\n train_x_pos = [0, 4, 8, 12]\\n cv_x_pos = [1, 5, 9, 13]\\n test_x_pos = [2, 6, 10, 14]\\n ticks = cv_x_pos\\n\\n labels = ['sgd', 'dt', 'dt4', 'stumps (4 x 50)']\\n\\n train_accs = [sgd_train_acc, dt_train_acc, dt4_train_acc, stumps_train_acc]\\n train_errors = [sgd_train_std, dt_train_std, dt4_train_std, stumps_train_std]\\n\\n cv_accs = [sgd_heldout_acc, dt_heldout_acc, dt4_heldout_acc, stumps_heldout_acc]\\n cv_errors = [sgd_heldout_std, dt_heldout_std, dt4_heldout_std, stumps_heldout_std]\\n\\n test_accs = [sgd_test_acc, dt_test_acc, dt4_test_acc, stumps_test_acc]\\n\\n fig, ax = plt.subplots()\\n ax.bar(train_x_pos, train_accs, yerr=train_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='train')\\n ax.bar(cv_x_pos, cv_accs, yerr=cv_errors, align='center', alpha=0.5, ecolor='black', capsize=10, label='held-out')\\n ax.bar(test_x_pos, test_accs, align='center', alpha=0.5, capsize=10, label='test')\\n ax.set_ylabel('Accuracy')\\n ax.set_xticks(ticks)\\n ax.set_xticklabels(labels)\\n ax.set_title('Models')\\n ax.yaxis.grid(True)\\n ax.legend()\\n plt.tight_layout()\",\n \"def plot_data(x_plot, X_train, X_test, y_train, y_test, low, high):\\n s = 15\\n plt.plot(x_plot, ground_truth(x_plot), alpha=0.5, label='ground truth')\\n plt.scatter(X_train, y_train, s=s, alpha=0.2)\\n plt.scatter(X_test, y_test, s=s, alpha=0.2, color='red')\\n plt.xlim((low, high))\\n plt.ylabel('y')\\n plt.xlabel('x')\\n plt.legend(loc='upper left')\\n plt.show()\",\n \"def visualization(epochs, mse_tr, mse_te):\\n plt.semilogx(epochs, mse_tr, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(epochs, mse_te, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"k\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation\\\")\",\n \"def plot_regression_results(ax, y_true, y_pred, title, scores, elapsed_time):\\n ax.plot([y_true.min(), y_true.max()],\\n [y_true.min(), y_true.max()],\\n '--r', linewidth=2)\\n ax.scatter(y_true, y_pred, alpha=0.2)\\n\\n ax.spines['top'].set_visible(False)\\n ax.spines['right'].set_visible(False)\\n ax.get_xaxis().tick_bottom()\\n ax.get_yaxis().tick_left()\\n ax.spines['left'].set_position(('outward', 10))\\n ax.spines['bottom'].set_position(('outward', 10))\\n ax.set_xlim([y_true.min(), y_true.max()])\\n ax.set_ylim([y_true.min(), y_true.max()])\\n ax.set_xlabel('Measured')\\n ax.set_ylabel('Predicted')\\n extra = plt.Rectangle((0, 0), 0, 0, fc=\\\"w\\\", fill=False,\\n edgecolor='none', linewidth=0)\\n ax.legend([extra], [scores], loc='upper left')\\n title = title + '\\\\n Evaluation in {:.2f} seconds'.format(elapsed_time)\\n ax.set_title(title)\",\n \"def reconstruction_errors(identifier, train_errors, vali_errors,\\n generated_errors, random_errors):\\n print(identifier)\\n fig, axarr = plt.subplots(4, 1, sharex=True, figsize=(4, 8))\\n axarr[0].hist(train_errors, normed=1, color='green', bins=50)\\n axarr[0].set_title(\\\"train reconstruction errors\\\")\\n axarr[1].hist(vali_errors, normed=1, color='blue', bins=50)\\n axarr[1].set_title('vali reconstruction errors')\\n axarr[2].hist(generated_errors, normed=1, color='pink', bins=50)\\n axarr[2].set_title('generated reconstruction errors')\\n axarr[3].hist(random_errors, normed=1, color='grey', bins=50)\\n axarr[3].set_title('random reconstruction errors')\\n for ax in axarr:\\n ax.spines[\\\"top\\\"].set_visible(False)\\n ax.spines[\\\"bottom\\\"].set_visible(False)\\n ax.spines[\\\"right\\\"].set_visible(False)\\n ax.spines[\\\"left\\\"].set_visible(False)\\n ax.tick_params(bottom='off', left='off')\\n ax.get_xaxis().set_visible(False)\\n ax.get_yaxis().set_visible(False)\\n axarr[3].set_xlim(0, 0.05)\\n plt.tight_layout()\\n plt.savefig('./experiments/plots/' + identifier + '_reconstruction_errors.png')\\n return True\",\n \"def plot_regression(e_predict, e_true, ax=None, label='', e_max=0.5):\\n ax = ax or plt.gca()\\n ax.scatter(e_true, e_predict, lw=0, alpha=0.5, s=10)\\n ax.set_xlabel('True shear')\\n ax.set_ylabel('Predicted shear')\\n ax.set_xlim(0, e_max)\\n ax.set_ylim(0, e_max)\\n ax.plot([0, e_max], [0, e_max], 'r--')\\n R2 = sklearn.metrics.r2_score(e_true, e_predict)\\n ax.text(0.05, 0.9, f'{label}$R^2 = {R2:.2f}$',\\n transform=ax.transAxes, fontsize=16, color='r')\",\n \"def build_scatterplot(budget):\\n frame = load_frames(budget=budget)\\n X = frame[metrics]\\n Y = frame['y']\\n\\n predicted = cross_val_predict(get_best_models(budget=budget, tool=settings.algo), X, Y, cv=20)\\n\\n fig, ax = plt.subplots()\\n ax.scatter(Y, predicted, edgecolors=(0, 0, 0))\\n ax.plot([Y.min(), Y.max()], [Y.min(), Y.max()], 'k--', lw=4)\\n ax.set_xlabel('Measured')\\n ax.set_ylabel('Predicted')\\n plt.savefig('{}/cv-error-{}-{}.pdf'.format(settings.PLOTS, settings.algo, budget))\",\n \"def visualize_interactive_plot(df, err_param_name, data, scatter_cmap, reduced_data_column, on_click):\\n df = df.groupby(err_param_name).first().reset_index()\\n labels = df[\\\"labels\\\"][0]\\n\\n # plot the data of each error parameter combination\\n for i, _ in enumerate(df[reduced_data_column]):\\n reduced_data = df[reduced_data_column][i]\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.scatter(reduced_data.T[0], reduced_data.T[1], c=labels, cmap=scatter_cmap, marker=\\\".\\\", s=40, picker=True)\\n x_min, x_max, y_min, y_max = get_lims(reduced_data)\\n ax.set_xlim(x_min, x_max)\\n ax.set_ylim(y_min, y_max)\\n err_param_val = round(df[err_param_name][i], 3)\\n ax.set_title(err_param_name + \\\"=\\\" + str(err_param_val))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n\\n reduced_T = reduced_data.T\\n\\n # without creating a class the plots would use wrong values of i\\n class Plot:\\n def __init__(self, i, fig, reduced_T, on_click):\\n self.i = i\\n self.fig = fig\\n self.cid = self.fig.canvas.mpl_connect('pick_event', self)\\n self.reduced_T = reduced_T\\n self.on_click = on_click\\n\\n def __call__(self, event):\\n if len(event.ind) == 0:\\n return False\\n mevent = event.mouseevent\\n closest = event.ind[0]\\n\\n def dist(x0, y0, x1, y1):\\n return (x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1)\\n\\n # find closest data point\\n for elem in event.ind:\\n best_dist = dist(self.reduced_T[0][elem], self.reduced_T[1][elem], mevent.xdata, mevent.ydata)\\n new_dist = dist(self.reduced_T[0][closest], self.reduced_T[1][closest], mevent.xdata, mevent.ydata)\\n if best_dist > new_dist:\\n closest = elem\\n\\n # get original and modified data points\\n original = data[closest]\\n modified = df[\\\"interactive_err_data\\\"][self.i][closest]\\n\\n self.on_click(original, modified)\\n\\n Plot(i, fig, reduced_T, on_click)\",\n \"def cross_validation_visualization(lambdas, loss_train, loss_test):\\n plt.semilogx(lambdas, loss_train, marker=\\\".\\\", color='b', label='train error')\\n plt.semilogx(lambdas, loss_test, marker=\\\".\\\", color='r', label='test error')\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"rmse\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_mse\\\")\",\n \"def plot_rank_sensitivity(\\n dmd_train_error, dmd_test_error, optdmd_train_error, optdmd_test_error\\n):\\n\\n # Generate figure.\\n fig, axes = plt.subplots(\\n 1, 2, figsize=(fig_width, fig_width / 4), sharex=True, sharey=True\\n )\\n\\n # Misc.\\n rank = np.arange(1, dmd_test_error.shape[0] + 1)\\n\\n #####\\n # TRAINING ERROR\\n #####\\n\\n # Plot the vanilla DMD error.\\n axes[0].plot(rank, dmd_train_error)\\n # Plot the OptDMD error.\\n axes[0].plot(rank, optdmd_train_error, ls=\\\"--\\\")\\n # Add decorators.\\n axes[0].set(\\n xlabel=r\\\"Rank of the DMD model\\\",\\n ylabel=r\\\"Normalized error\\\",\\n title=r\\\"Training dataset\\\",\\n )\\n axes[0].grid(True)\\n\\n #####\\n # TESTING ERROR\\n #####\\n\\n # Plot the vanilla DMD error.\\n axes[1].plot(rank, np.mean(dmd_test_error, axis=1), label=r\\\"Regular DMD\\\")\\n axes[1].fill_between(\\n rank,\\n np.mean(dmd_test_error, axis=1) + np.std(dmd_test_error, axis=1),\\n np.mean(dmd_test_error, axis=1) - np.std(dmd_test_error, axis=1),\\n alpha=0.25,\\n )\\n # Plot the OptDMD error.\\n axes[1].plot(\\n rank, np.mean(optdmd_test_error, axis=1), ls=\\\"--\\\", label=r\\\"Optimal DMD\\\"\\n )\\n axes[1].fill_between(\\n rank,\\n np.mean(optdmd_test_error, axis=1) + np.std(optdmd_test_error, axis=1),\\n np.mean(optdmd_test_error, axis=1) - np.std(optdmd_test_error, axis=1),\\n alpha=0.25,\\n )\\n # Add decorators.\\n axes[1].set(\\n xlim=(0, rank.max()),\\n xlabel=r\\\"Rank of the DMD model\\\",\\n ylim=(0, 1),\\n title=r\\\"Testing dataset\\\",\\n )\\n axes[1].grid(True)\\n axes[1].legend(loc=0)\\n\\n return\",\n \"def scatter(target, predictions, threshold=0, ideal_prediction_line=True):\\n\\n plt.plot(target, predictions, linewidth=0, marker='o', zorder=1);\\n if threshold is not None:\\n xlim = plt.xlim()\\n ylim = plt.ylim()\\n plt.hlines(threshold, xlim[0], xlim[1], linestyles='dotted', color='red')\\n plt.vlines(threshold, ylim[0], ylim[1], linestyles='dotted', color='red')\\n plt.xlim(xlim)\\n plt.ylim(ylim)\\n if ideal_prediction_line:\\n plt.plot([target.min(), target.max()], [target.min(), target.max()], label='Ideal prediction')\\n plt.legend()\\n plt.title('Predicted returns VS actual returns')\\n plt.xlabel('Actual return')\\n plt.ylabel('Predicted return');\",\n \"def visualizePredictions(testData,knn_predictions):\\r\\n testData.visualize.scatterPlot('Petal length','Petal width')\\r\\n testData.dataDict[testData.reference] = knn_predictions\\r\\n testData.visualize.scatterPlot('Petal length','Petal width')\\r\\n\\r\\n pass\",\n \"def display_convergence_error(train_losses, valid_losses):\\n if len(valid_losses) > 0:\\n plt.plot(len(train_losses), train_losses, color=\\\"red\\\")\\n plt.plot(len(valid_losses), valid_losses, color=\\\"blue\\\")\\n plt.legend([\\\"Train\\\", \\\"Valid\\\"])\\n else:\\n plt.plot(len(train_losses), train_losses, color=\\\"red\\\")\\n plt.legend([\\\"Train\\\"])\\n plt.xlabel('Epoch')\\n plt.ylabel('Loss')\\n plt.show()\",\n \"def plot_loss():\\n df = pd.read_csv('data/loss.csv', encoding='utf-8')\\n loss = df['loss'].values\\n val_loss = df['val_loss'].values\\n x = [i for i in range(1, len(loss) + 1)]\\n\\n plt.plot(x, loss, label='Train loss')\\n plt.plot(x, val_loss, label='Val loss')\\n\\n plt.xlabel('Epochs')\\n plt.ylabel('Contrastive Loss')\\n plt.title('Train and test loss')\\n plt.grid(True)\\n plt.legend(shadow=True, fontsize='x-large')\\n\\n plt.show()\",\n \"def plot_predictions(\\n train_data, train_labels, test_data, test_labels, predictions=None\\n):\\n plt.figure(figsize=(10, 7))\\n\\n # Plot training data in blue\\n plt.scatter(train_data, train_labels, c=\\\"b\\\", s=4, label=\\\"Training data\\\")\\n\\n # Plot test data in green\\n plt.scatter(test_data, test_labels, c=\\\"g\\\", s=4, label=\\\"Testing data\\\")\\n\\n if predictions is not None:\\n # Plot the predictions in red (predictions were made on the test data)\\n plt.scatter(test_data, predictions, c=\\\"r\\\", s=4, label=\\\"Predictions\\\")\\n\\n # Show the legend\\n plt.legend(prop={\\\"size\\\": 14})\",\n \"def validate(self, input_data):\\n self.assert_data_shape(input_data)\\n\\n y = input_data[1]\\n hat_y, variance = self.predict(input_data[0])\\n\\n # plt.scatter(hat_y, input_data[1], s=1)\\n # plt.show()\\n\\n return self.stat(y, hat_y)\",\n \"def plot_error_curve(ax,\\n y_true,\\n y_pred,\\n uncert_meas,\\n label,\\n every_nth,\\n window_size=10):\\n error = (y_true[::every_nth] - y_pred[::every_nth])**2\\n error, uncert_meas = np.array(error), np.array(uncert_meas[::every_nth])\\n sorted_inds = generate_order(uncert_meas)\\n sorted_error = error[sorted_inds]\\n smooth_error = moving_average(sorted_error, window_size)\\n ax.plot(np.arange(len(smooth_error)), smooth_error, label=label)\",\n \"def regression_analysis(cls, y_true, y_pred, path=None):\\n residual = y_true - y_pred\\n print(\\\"Histogram\\\")\\n cls.histogram(residual, \\\"Residual\\\")\\n print(\\\"Scatter\\\")\\n cls.scatter_plot(y_pred, residual, \\\"pred\\\", \\\"residual\\\", path=path)\\n print(\\\"Scatter\\\")\\n cls.scatter_plot( y_true, y_pred, \\\"y_test\\\", \\\"pred\\\", path=path)\",\n \"def plot(model, samples):\\n # compute responsiblity values\\n resp = model.predict_proba(samples)\\n\\n # plot\\n plt.axis('equal')\\n plt.scatter(samples[:,0], samples[:,1], c=resp)\\n plt.show()\",\n \"def ScatterPlot_LWR(X_train, y_train, X_test, y_test, reg, tau, degree):\\r\\n\\r\\n # Set model instances\\r\\n y_pred = reg.predict(X_train, y_train, X_test)\\r\\n theta = reg.theta\\r\\n\\r\\n # R-squared\\r\\n rsq = r2_score(y_test, y_pred)\\r\\n\\r\\n # Set figure object\\r\\n fig = plt.figure(figsize=(20, 10))\\r\\n\\r\\n # Create x_axis values\\r\\n x_tmp = np.arange(0, 1.1, 0.01)\\r\\n x_limit = np.arange(0, 1.1, 0.01)\\r\\n x_limit = x_limit.reshape((x_limit.shape[0], 1))\\r\\n\\r\\n # Transform x_axis values\\r\\n poly = PolynomialFeatures(degree)\\r\\n x_limit = poly.fit_transform(x_limit)\\r\\n\\r\\n # Predictions\\r\\n hypothesis = np.dot(x_limit, theta)\\r\\n\\r\\n # Scatter plots\\r\\n plt.scatter(X_train, y_train, color='green', label='Training Set', s = 150)\\r\\n plt.scatter(X_test, y_test, color='blue', label='Testing Set', s = 150)\\r\\n plt.scatter(X_test, y_pred, color='red', label='Prediction Points', s = 150)\\r\\n plt.plot(x_tmp, hypothesis, color='purple', label='Predictions')\\r\\n\\r\\n # Set figure parameters\\r\\n plt.xlabel(\\\"$x_1$\\\", fontsize=18)\\r\\n plt.ylabel(\\\"$x_1$\\\", fontsize=18)\\r\\n plt.title('Locally Weighted Regression, Degree = {}, $r^2$ = {:.2f} '.format(\\r\\n degree, rsq), fontsize=18)\\r\\n plt.tick_params(axis='x', labelsize=15)\\r\\n plt.tick_params(axis='y', labelsize=15)\\r\\n\\r\\n # Legend Patches\\r\\n green_patch = mpatches.Patch(color='green', label='Training Set')\\r\\n blue_patch = mpatches.Patch(color='blue', label='Testing Set')\\r\\n red_patch = mpatches.Patch(color='red', label='Predictions')\\r\\n purple_patch = mpatches.Patch(\\r\\n color='purple', label='Locally Weighted Regressor')\\r\\n\\r\\n patches = [green_patch, blue_patch, red_patch, purple_patch]\\r\\n\\r\\n legend = plt.legend(handles=patches, loc='upper right',\\r\\n borderaxespad=0., fontsize=14)\\r\\n\\r\\n return fig\",\n \"def visualize_train(train_data_full, train_labels, train_data, thetas, losses, niter):\\n fig1, ax1 = plt.subplots()\\n ax1.scatter(train_data_full[\\\"Weight\\\"], train_data_full[\\\"Height\\\"], color = 'blue')\\n\\n # De-standarize\\n train_mean = train_data_full[\\\"Weight\\\"].mean()\\n train_std = train_data_full[\\\"Weight\\\"].std()\\n train_data_for_plot = train_mean + train_data[\\\"Weight\\\"] * train_std\\n\\n ax1.plot(train_data_for_plot, predict(train_data, thetas[niter - 1]), color = 'red', linewidth = 2)\\n ax1.set_xlabel(\\\"Height\\\")\\n ax1.set_ylabel(\\\"Weight\\\")\\n\\n fig2, ax2 = plt.subplots()\\n ax2.plot(range(len(losses)), losses, color = 'blue', linewidth = 2)\\n ax2.set_xlabel(\\\"Iteration\\\")\\n ax2.set_ylabel(\\\"MSE\\\")\\n\\n fig3, ax3 = plt.subplots()\\n np_gradient_ws = np.array(thetas)\\n\\n w = np.linspace(min(np_gradient_ws[:, 0]), max(np_gradient_ws[:, 0]), len(np_gradient_ws[:, 0]))\\n b = np.linspace(min(np_gradient_ws[:, 1]), max(np_gradient_ws[:, 1]), len(np_gradient_ws[:, 1]))\\n x, y = np.meshgrid(w, b)\\n z = compute_z_loss(train_labels, train_data, np.stack((w,b)).T)\\n cp = ax3.contourf(x, y, z, cmap = plt.cm.jet)\\n fig3.colorbar(cp, ax = ax3)\\n ax3.plot(3.54794951, 66.63949115837143, color = 'red', marker = '*', markersize = 20)\\n if niter > 0:\\n thetas_to_plot = np_gradient_ws[:niter]\\n ax3.plot(thetas_to_plot[:, 0], thetas_to_plot[:, 1], marker = 'o', color = 'w', markersize = 10)\\n ax3.set_xlabel(r'$w$')\\n ax3.set_ylabel(r'$b$')\\n return fig1, fig2, fig3\",\n \"def report(self, X, y):\\n predict = self.model.predict(X)\\n\\n skplt.estimators.plot_feature_importances(\\n self.model, x_tick_rotation=90)\\n plt.show()\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=predict)\\n lims = [\\n np.min([ax.get_xlim(), ax.get_ylim()]), # min of both axes\\n np.max([ax.get_xlim(), ax.get_ylim()]), # max of both axes\\n ]\\n ax.plot(lims, lims, 'k-', alpha=0.75, zorder=0)\\n ax.set_aspect('equal')\\n ax.set_xlim(lims)\\n ax.set_ylim(lims)\\n ax.set_xlabel(\\\"Observed\\\")\\n ax.set_ylabel(\\\"Predict\\\")\\n ax.set_title(\\\"Predict vs. Observed\\\")\\n plt.show()\\n\\n residuals = y - predict\\n\\n fig, ax = plt.subplots(figsize=(7, 7))\\n sns.scatterplot(x=y, y=residuals)\\n plt.title(\\\"Residuals vs. Observed\\\")\\n plt.xlabel(\\\"Obserbed\\\")\\n plt.ylabel(\\\"Residuals\\\")\\n plt.show()\\n\\n plt.hist(residuals)\\n plt.title(\\\"Residuals distribution\\\")\\n plt.xlabel(\\\"Residuals value\\\")\\n plt.ylabel(\\\"Count\\\")\\n plt.show()\\n\\n display(\\n pd.DataFrame({\\n \\\"explained_variance_score\\\":\\n metrics.explained_variance_score(y, predict),\\n \\\"mean_absolute_error\\\":\\n metrics.mean_absolute_error(y, predict),\\n \\\"mean_squared_log_error\\\":\\n metrics.mean_squared_log_error(y, predict),\\n \\\"median_absolute_error\\\":\\n metrics.median_absolute_error(y, predict),\\n \\\"r2_score\\\":\\n metrics.r2_score(y, predict)\\n },\\n index=[0]))\",\n \"def visualize_test(test_data_full, test_data, thetas):\\n fig, ax = plt.subplots()\\n ax.scatter(test_data_full[\\\"Weight\\\"], test_data_full[\\\"Height\\\"], color='blue')\\n ax.plot(test_data_full[\\\"Weight\\\"], predict(test_data, thetas[-1]), color='red', linewidth=2)\\n return fig\",\n \"def plot_learning_curve(X_train_all, X_val_all, y_train_all, y_val_all, train_sizes, title):\\n\\n errors_df = pd.DataFrame(columns = ['train_size', 'train_acc', 'val_acc'])\\n\\n # Loop through example sizes and get the training and validation error\\n for train_size in train_sizes:\\n # Select Subset of Data\\n X_train = X_train_all[:train_size]\\n X_val = X_val_all[:train_size]\\n y_train = y_train_all[:train_size]\\n y_val = y_val_all[:train_size]\\n\\n # Initialize Model\\n model = svm.SVC(kernel='linear')\\n\\n # Fit model\\n print(f\\\"Training {title} using {train_size} examples\\\")\\n model.fit(X_train, y_train)\\n\\n # Get Predictions \\n train_pred = model.predict(X_train)\\n val_pred = model.predict(X_val)\\n\\n # Get Accuracy Score for X_Train and X_Val\\n errors = pd.DataFrame({\\n 'train_size': [train_size],\\n 'train_acc': [accuracy_score(y_train, train_pred)],\\n 'val_acc': [accuracy_score(y_val, val_pred)]\\n })\\n \\n # Concatenate Dataframes\\n errors_df = pd.concat([errors_df, errors])\\n\\n # Plot Learning Curve\\n fig, ax = plt.subplots()\\n\\n errors_df.plot(x='train_size', y='train_acc',kind='line', ax=ax)\\n errors_df.plot(x='train_size', y='val_acc',kind='line', color='red', ax=ax)\\n\\n ax.set_xlabel(\\\"Training Size\\\")\\n ax.set_ylabel(\\\"Accuracy\\\")\\n ax.set_title(title)\\n\\n # Save Figure\\n plt.savefig('figs/' + title + '_learning_curve.png')\",\n \"def main():\\n df = pd.read_csv('data/ch5_q8_simulation.csv')\\n\\n # Part b\\n plt.figure()\\n plt.scatter(df['x'], df['y'])\\n plt.xlabel('x')\\n plt.ylabel('y')\\n plt.title('Scatterplot y vs. x')\\n plt.savefig('plots/8a.png')\\n\\n # Part c\\n response_var = 'y'\\n pred_vars_lin = ['x']\\n pred_vars_quad = ['x', 'x2']\\n pred_vars_cub = ['x', 'x2', 'x3']\\n pred_vars_quar = ['x', 'x2', 'x3', 'x4']\\n\\n poly_terms = pd.DataFrame({'x2': np.power(df['x'], 2),\\n 'x3': np.power(df['x'], 3),\\n 'x4': np.power(df['x'], 4)})\\n df = pd.concat([df, poly_terms], axis=1)\\n\\n CV_error_lin = loocv(df, response_var, pred_vars_lin)\\n CV_error_quad = loocv(df, response_var, pred_vars_quad)\\n CV_error_cub = loocv(df, response_var, pred_vars_cub)\\n CV_error_quar = loocv(df, response_var, pred_vars_quar)\\n\\n print('Part c')\\n print('CV error (linear) = {:.3f}'.format(CV_error_lin))\\n print('CV error (quadratic) = {:.3f}'.format(CV_error_quad))\\n print('CV error (cubic) = {:.3f}'.format(CV_error_cub))\\n print('CV error (quartic) = {:.3f}'.format(CV_error_quar))\\n\\n # Part d\\n np.random.seed(801)\\n y = np.random.randn(100)\\n x = np.random.randn(100)\\n y = x - 2 * np.power(x, 2) + np.random.randn(100)\\n\\n df = pd.DataFrame({'x': x,\\n 'x2': np.power(x, 2),\\n 'x3': np.power(x, 3),\\n 'x4': np.power(x, 4),\\n 'y': y})\\n\\n CV_error_lin = loocv(df, response_var, pred_vars_lin)\\n CV_error_quad = loocv(df, response_var, pred_vars_quad)\\n CV_error_cub = loocv(df, response_var, pred_vars_cub)\\n CV_error_quar = loocv(df, response_var, pred_vars_quar)\\n\\n print('Part d')\\n print('CV error (linear) = {:.3f}'.format(CV_error_lin))\\n print('CV error (quadratic) = {:.3f}'.format(CV_error_quad))\\n print('CV error (cubic) = {:.3f}'.format(CV_error_cub))\\n print('CV error (quartic) = {:.3f}'.format(CV_error_quar))\\n\\n # Part f\\n model = sm.OLS(df.loc[:, response_var], df.loc[:, pred_vars_quar]).fit()\\n print(model.summary())\",\n \"def plot_test(y_test, y_pred, title = None, xlabel = 'Measured $Y = \\\\log_2(MIC)$', ylabel = 'Predicted $Y = \\\\log_2(MIC)$', legend = ['Ideal', 'Result'], groups = None):\\n \\n fig, ax = plt.subplots(1,1)\\n fig.set_figheight(5)\\n fig.set_figwidth(5)\\n if groups is not None:\\n groups_obj = pd.concat([y_test,y_pred], axis=1).groupby(np.array(groups))\\n cmap=plt.get_cmap('tab10')\\n for name, group in groups_obj:\\n # Works only for groups with numeric names that are max cmap length:\\n ax.plot(group.iloc[:,0], group.iloc[:,1], marker=\\\"o\\\", linestyle=\\\"\\\", label=int(name), color = cmap.colors[int(name)])\\n ax.legend()\\n else:\\n ax.scatter(y_test,y_pred, color = 'red')\\n ax_max = 10\\n if np.max(y_test.values)>ax_max:\\n ax_max = np.max(y_test).values\\n ax_min = 0\\n if np.min(y_test.values)<ax_min:\\n ax_min = np.min(y_test.values)\\n ax.plot([ax_min, ax_max], [ax_min, ax_max], '--', color='black')\\n ax.set_aspect('equal', 'box')\\n plt.title(title)\\n plt.xlabel(xlabel)\\n plt.ylabel(ylabel)\\n #plt.savefig(title+'.pdf')\\n plt.savefig(title+'.svg')\\n #plt.savefig(title+'.png')#, dpi=600)\\n #plt.show()\",\n \"def parity_plot(y_pred, y_act):\\n\\n fig = plt.figure(figsize=FIG_SIZE)\\n plt.scatter(y_act, y_pred)\\n plt.plot([y_act.min(), y_act.max()], [y_act.min(), y_act.max()],\\n lw=4, color='r')\\n plt.xlabel('Actual')\\n plt.ylabel('Predicted')\\n\\n return fig\",\n \"def custom_scatterplot(ax, x, y, error, xlims, ylims, color='green', markerscale=100):\\n\\n markersize = error * markerscale\\n\\n ax.scatter(x, y, color=color, marker='o', s=markersize, alpha=0.5)\\n\\n ax.set_xlim(xlims)\\n ax.set_ylim(ylims)\\n\\n return ax\",\n \"def actvspred(modelname, predmodel):\\n predscores, actualscores, meanerr, rmsqerr = predmodel\\n plt.figure()\\n plt.scatter(actualscores,predscores,s=70)\\n x = np.array(range(100))\\n plt.plot(x,x,'g',label='optimal model')\\n # make regression\\n rob.globalenv[\\\"pred\\\"] = FV(predscores)\\n rob.globalenv[\\\"act\\\"] = FV(actualscores)\\n mult_lm = stats.lm(\\\"pred ~ act + 1\\\")\\n coeffs = np.array(mult_lm.rx(\\\"coefficients\\\")[0])\\n rsqrd = base.summary(mult_lm).rx(\\\"r.squared\\\")[0][0]\\n y = coeffs[1]*x+coeffs[0]\\n plt.plot(x,y,'k',label='our model',linewidth=2)\\n plt.xlabel(\\\"actual lsas delta\\\")\\n plt.ylabel(\\\"predicted lsas delta\\\")\\n plt.title(modelname)\\n plt.axis([0,100,0,100])\\n axes = plt.axes()\\n axes.grid(b=True)\\n axes.text(0.05,0.8,\\\"meanerr: %.2f\\\\nrmse: %.2f\\\\nr: %.2f (Rsqrd: %.2f)\\\"%(meanerr,rmsqerr,np.sqrt(rsqrd),rsqrd),transform=axes.transAxes)\\n #plt.legend()\\n plt.savefig(os.path.join(outdir,\\\"%s_crossval.png\\\"%modelname),dpi=300,format=\\\"png\\\")\",\n \"def regression_plots(regression_results, dependant, independant):\\n\\n # Scatter of two variables\\n ds = xr.Dataset()\\n ds['dependant'] = dependant\\n ds['independant'] = regression_results[f'prediction_skt']\\n ds = ds.transpose(\\\"y\\\", \\\"x\\\", \\\"time\\\")\\n\\n expected = ds['dependant'].values.flatten()\\n predicted = ds['independant'].values.flatten()\\n \\n plt.style.use('stylesheets/contour.mplstyle')\\n fig, ax = plt.subplots(figsize=(5, 5))\\n ax.axhline(0, color='k', alpha=0.5)\\n ax.axvline(0, color='k', alpha=0.5)\\n mask = np.isfinite(expected) * np.isfinite(predicted)\\n X = expected[mask]\\n Y = predicted[mask]\\n counts, xedges, yedges = np.histogram2d(X, Y, bins=100)\\n xedges = (xedges[1:] + xedges[:-1]) / 2\\n yedges = (yedges[1:] + yedges[:-1]) / 2\\n im = ax.contourf(xedges, yedges, counts, norm=LogNorm())\\n ax.set_xlabel('Expected values')\\n ax.set_ylabel('Predicted values')\\n # ax.autoscale(False)\\n plt.colorbar(im)\\n plt.show()\\n\\n # gradient_expected = regression[f'{dependant}'].polyfit(\\n # dim='time', deg=1, cov=True).sel(degree=1).polyfit_coefficients * 1e9*60*60*24*365\\n # gradient_predicted, = regression[f'prediction_{independant}'].polyfit(\\n # dim='time', deg=1, cov=True).sel(degree=1).polyfit_coefficients * 1e9*60*60*24*365\\n\\n\\n # max_ = max([gradient_expected.max().max(), gradient_predicted.max().max()])\\n # min_ = min([gradient_expected.min().min(), gradient_predicted.min().min()])\\n\\n # divnorm = TwoSlopeNorm(vmin=min_, vcenter=0, vmax=max_)\\n # levels = np.arange(min_, max_, 0.1)\\n\\n # fig = plt.figure(figsize=(5, 10))\\n\\n # ax = fig.add_subplot(2, 1, 1, projection=ccrs.SouthPolarStereo())\\n # im = ax.contourf(gradient_expected.x, gradient_expected.y, gradient_expected.transpose(\\n # ), levels=levels, norm=divnorm, cmap='RdBu_r')\\n # ax.coastlines()\\n # ax.set_title('Expected Trends')\\n # plt.colorbar(im, ax=ax)\\n\\n # ax = fig.add_subplot(2, 1, 2, projection=ccrs.SouthPolarStereo())\\n # im = ax.contourf(gradient_predicted.x, gradient_predicted.y,\\n # gradient_predicted.transpose(), levels=levels, norm=divnorm, cmap='RdBu_r')\\n # ax.coastlines()\\n # ax.set_title('Predicted Trends')\\n # plt.colorbar(im, ax=ax)\\n pass\",\n \"def fig5(X_r, Y, TRAIN_SIZE=6000):\\n \\n # Normalize X_r\\n X_n = preprocessing.normalize(X_r)\\n \\n #kNN weighting and k\\n weights = [ \\\"uniform\\\", \\\"distance\\\" ]\\n ks = [2,4,8,16,32,64] \\n \\n # Little lambda functions to standardize feature extraction\\n pca = lambda X,Y: PCA(n_components=128).fit(X).transform(X)\\n lda = lambda X,Y: LDA().fit(X, Y).transform(X)\\n idn = lambda X,Y: X\\n \\n # Start the plot\\n fig, ax = plt.subplots()\\n plt.ylabel(\\\"Error %\\\")\\n plt.xlabel(\\\"k\\\")\\n \\n \\n # Try every combination (product) of weights, feature extraction and normalization\\n for weight, feat_reduce, X_ in itertools.product(\\n weights, [pca, lda, idn], [X_r, X_n]):\\n \\n # Reset error rate\\n errors = []\\n \\n #Flags to make things easier\\n reduction = \\\"PCA\\\" if feat_reduce == pca else \\\"LDA\\\"\\n normalized = \\\"n\\\" if X_ is X_n else \\\"r\\\"\\n \\n #Initialize a black (i.e. key - cmy_K_) line\\n linestyle = \\\"k\\\"\\n \\n # Match the point style used in Vailaya\\n if weight == \\\"uniform\\\":\\n if X_ is X_n:\\n linestyle += \\\"x\\\"\\n else:\\n linestyle += \\\"*\\\"\\n if weight == \\\"distance\\\":\\n if X_ is X_n:\\n linestyle += \\\"o\\\"\\n else:\\n linestyle += \\\"+\\\"\\n \\n # As well as the line style\\n if feat_reduce is pca:\\n linestyle += \\\":\\\" # Dotted\\n elif feat_reduce is lda:\\n linestyle += \\\"--\\\" # Solid\\n else:\\n linestyle += \\\"-\\\" # Dashed\\n \\n # Loop through all k's \\n for k in ks:\\n #Initialized classifier parameters\\n knn = neighbors.KNeighborsClassifier(warn_on_equidistant=False)\\n knn.n_neighbors = k\\n knn.weights = weight\\n \\n #Here's where the lambda's come in handy.\\n X = feat_reduce(X_,Y)\\n \\n # Fit the training set\\n knn.fit(X[:TRAIN_SIZE], Y[:TRAIN_SIZE])\\n \\n # Again ugly code for the predictions\\n predictions = []\\n for i in range(TRAIN_SIZE, len(X)):\\n predictions += [ knn.predict(X[i])[0] ] \\n \\n # Calculate error rate and append it to error rate list\\n error = 1.- float(sum(predictions == Y[TRAIN_SIZE:])) / len(predictions)\\n errors += [error]\\n \\n # Print it just for fun. Also in case error rates need to be exported.\\n print weight, reduction, normalized, k, error\\n \\n # Plot the line for all k values \\n ax.plot(ks, errors, linestyle)\\n \\n # Couldn't specify legends properly\\n #ax.legend()\",\n \"def clt_plot(error: pd.Series, n_max=800):\\n plt.figure()\\n n_values = [n for n in range(20, n_max, 20)]\\n error_mean, error_var = do_many_bootstraps(error, n_values, bootstrap_number=50)\\n plt.plot(n_values, np.sqrt(error_var), label='Bootstrap estimate')\\n plt.plot(n_values, np.divide(np.std(error, ddof=1), np.sqrt(n_values)), label='CLT estimate')\\n plt.xlabel('number of samples')\\n plt.ylabel('variance of mean square error')\\n plt.legend()\\n plt.show()\",\n \"def plot_predictions(self):\\n\\n plt.title(\\\"Targets vs. Predictions\\\")\\n plt.plot(self.T, label=\\\"Targets\\\")\\n plt.plot(self.Y, label=\\\"Predictions\\\")\\n plt.xlabel(\\\"Sample number\\\")\\n plt.legend()\\n plt.show()\",\n \"def plot_loss_curves(results):\\n loss = results[\\\"train_loss\\\"]\\n test_loss = results[\\\"test_loss\\\"]\\n\\n accuracy = results[\\\"train_acc\\\"]\\n test_accuracy = results[\\\"test_acc\\\"]\\n\\n epochs = range(len(results[\\\"train_loss\\\"]))\\n\\n plt.figure(figsize=(15, 7))\\n\\n # Plot loss\\n plt.subplot(1, 2, 1)\\n plt.plot(epochs, loss, label=\\\"train_loss\\\")\\n plt.plot(epochs, test_loss, label=\\\"test_loss\\\")\\n plt.title(\\\"Loss\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\\n\\n # Plot accuracy\\n plt.subplot(1, 2, 2)\\n plt.plot(epochs, accuracy, label=\\\"train_accuracy\\\")\\n plt.plot(epochs, test_accuracy, label=\\\"test_accuracy\\\")\\n plt.title(\\\"Accuracy\\\")\\n plt.xlabel(\\\"Epochs\\\")\\n plt.legend()\",\n \"def scatterplot(self, x = \\\"Predictor\\\", y = \\\"Response\\\", color = None, jitter = False, jitter_sd = .1,\\n marg_x = None, marg_y = None, trendline = None, opacity = 1, template = \\\"ggplot2\\\",\\n has_title = True, title = None):\\n x_clean, df_clean = clean_varname(self._df, var = x)\\n y_clean, df_clean = clean_varname(df_clean, var = y)\\n\\n if jitter:\\n df_clean[x_clean] = df_clean[x_clean] + np.random.normal(0, jitter_sd, size=len(df))\\n df_clean[y_clean] = df_clean[y_clean] + np.random.normal(0, jitter_sd, size=len(df))\\n\\n if color:\\n color_clean, df_clean = clean_varname(df_clean, var = color)\\n else:\\n color_clean = color \\n\\n if has_title:\\n if not title:\\n title = f\\\"Scatter Plot of {x_clean} and {y_clean}\\\"\\n \\n fig = px.scatter(df_clean, x=x_clean, y=y_clean, color=color_clean, title = title,\\n marginal_x = marg_x, marginal_y = marg_y, trendline = trendline, template = template, opacity = opacity)\\n return fig\",\n \"def evaluate(y_train,train_preds,y_test,test_preds,model,features):\\n \\n plt.figure(figsize=(3.5,3))\\n train_mae = np.abs(y_train-train_preds).mean()\\n test_mae = np.abs(y_test-test_preds).mean()\\n print(model, split)\\n print('Test MAE: %4.2f'%(test_mae))\\n print('Train MAE: %4.2f'%(train_mae))\\n plt.plot(y_train,train_preds,'.',c='grey',ms=3,label='Train MAE: %4.2f'%train_mae,alpha=1)\\n plt.plot(y_test,test_preds,'.',c=colors[model],ms=3,label='Test MAE: %4.2f'%test_mae,alpha=1)\\n #plt.title('%s: Train MAE = %.2f eV; Test MAE = %.2f eV'%(model,np.abs(y_train-train_preds).mean(),np.abs(y_test-test_preds).mean()),fontsize=10)\\n\\n xlim = plt.gca().get_xlim()\\n ylim = plt.gca().get_ylim()\\n \\n alim = (min(xlim[0],ylim[0]),max(xlim[1],ylim[1]))\\n\\n plt.plot(alim,alim,'-k',lw=1)\\n plt.gca().set_ylim(alim)\\n plt.gca().set_xlim(alim)\\n\\n plt.xlabel('$\\\\Delta E$ (eV)')\\n plt.ylabel('$\\\\Delta E$ Predicted (eV)')\\n\\n plt.legend(loc='best')\\n\\n plt.tight_layout()\\n plt.savefig('./parity/'+model+'_'+features+'_'+split+'_parity.pdf')\\n \\n #Functionality to plot histogram of error if desired\\n\\n #plt.figure()\\n #plt.hist(preds-y,bins=100)\\n #plt.xlabel('$\\\\hat{y} - y$ (eV)')\\n #plt.title('%s %s: MAE = %.2f eV'%(model,tt,np.abs(y-preds).mean()))\\n\\n #xlim = np.array(plt.gca().get_xlim())\\n #xmax = np.abs(xlim).max()\\n #plt.gca().set_xlim([-xmax,xmax])\\n\\n #plt.savefig('./output/'+model+'_'+features+'_'+split+'_'+tt+'_hist.pdf')\\n\\n return\",\n \"def cross_validation_visualization(lambds, score_tr, score_te):\\n plt.semilogx(lambds, score_tr, marker=\\\".\\\", color='b', label='train score');\\n plt.semilogx(lambds, score_te, marker=\\\".\\\", color='r', label='test score');\\n plt.xlabel(\\\"lambda\\\")\\n plt.ylabel(\\\"score\\\")\\n plt.title(\\\"cross validation\\\")\\n plt.legend(loc=2)\\n plt.grid(True)\\n plt.savefig(\\\"cross_validation_test\\\")\",\n \"def plotLoss():\\n # ssr\\n ssr = np.log(gradientDescent(X, y)[1])\\n # number of iterations \\n iterations = np.log(np.arange(1, len(ssr) + 1, 1))\\n # plot reduction of ssr\\n plt.plot(iterations, ssr)\\n # xlabel\\n plt.xlabel(\\\"Iteration\\\")\\n # ylabel\\n plt.ylabel(\\\"SSR\\\")\\n # title\\n plt.title(\\\"Reduction of SSR by number of Iterations\\\")\\n # show plot \\n plt.show()\",\n \"def plot_lastreviews_means_and_errors(H_in_HL_mean, H_in_HL_error, L_in_HL_mean, L_in_HL_error,\\n H_in_HH_mean, H_in_HH_error, H_in_HM_mean, H_in_HM_error,\\n M_in_HM_mean, M_in_HM_error):\\n # plot the result in a nice plot\\n plt.figure(figsize=(12, 9)) \\n\\n # create the fig. and axes.\\n ax = plt.subplot(111)\\n ax.spines[\\\"top\\\"].set_visible(False) \\n ax.spines[\\\"right\\\"].set_visible(False)\\n\\n # define the color to use\\n color_1 = rgb_to_matplot_lib(strong_green)\\n color_2 = rgb_to_matplot_lib(light_green)\\n color_3 = rgb_to_matplot_lib(strong_red)\\n color_4 = rgb_to_matplot_lib(light_green)\\n color_5 = rgb_to_matplot_lib(orange)\\n\\n\\n\\n # axis \\n ax.set_ylabel('Rating', fontsize = 14)\\n ax.tick_params(axis='both', labelsize=14)\\n\\n # plot small dash lines to follow the grading \\n for y in np.arange(4.0, 4.6, 0.1): \\n ax.plot(range(0, 45), [y] * len(range(0, 45)), \\\"--\\\", lw=0.5, color=\\\"black\\\", alpha=0.3)\\n\\n\\n # set titles\\n ax.set_title('10+ reviews average rating for each case in each group', fontsize = 14)\\n\\n plt.ylim([1,5.1])\\n plt.xlim([0,5.1])\\n\\n plt.errorbar(1, H_in_HH_mean, H_in_HH_error, lineStyle= None, capsize=5, marker=\\\"^\\\", color=color_1)\\n plt.errorbar(2, H_in_HL_mean, H_in_HL_error, lineStyle= None, capsize=5, marker=\\\"^\\\", color=color_2)\\n plt.errorbar(3, L_in_HL_mean, L_in_HL_error, lineStyle= None, capsize=5, marker=\\\"^\\\", color=color_3)\\n plt.errorbar(4, H_in_HM_mean, H_in_HM_error, lineStyle= None, capsize=5, marker=\\\"^\\\", color=color_4)\\n plt.errorbar(5, M_in_HM_mean, M_in_HM_error, lineStyle= None, capsize=5, marker=\\\"^\\\", color=color_5)\\n\\n plt.text(0.8, 4.01, \\\"({:04.3f})\\\".format(H_in_HH_mean), fontsize=14, color=color_1)\\n plt.text(1.8, 4.01, \\\"({:04.3f})\\\".format(H_in_HL_mean), fontsize=14, color=color_2) \\n plt.text(2.8, 4.01, \\\"({:04.3f})\\\".format(L_in_HL_mean), fontsize=14, color=color_3) \\n plt.text(3.8, 4.01, \\\"({:04.3f})\\\".format(H_in_HM_mean), fontsize=14, color=color_4) \\n plt.text(4.8, 4.01, \\\"({:04.3f})\\\".format(M_in_HM_mean), fontsize=14, color=color_5) \\n\\n\\n # set ticks label\\n ax.set_xticks(range(1,6))\\n ax.set_xticklabels(('H in HH', 'H in HL', 'L in HL', 'H in HM', 'M in HM'))\\n\\n #set ticks color\\n colors = [color_1, color_2, color_3, color_4, color_5]\\n for xtick, color in zip(ax.get_xticklabels(), colors):\\n xtick.set_color(color)\\n\\n plt.ylim([4,4.6])\\n plt.xlim([0.5,5.5])\\n plt.show()\",\n \"def visualize(self):\\n\\t\\tplt.figure(1)\\n\\t\\tax1 = plt.add_suplot(1,2,1)\\n\\t\\t# Plot free energy error\\n\\t\\tax1.plot(self.FE_errors_GMM_CV_, linewidth=4, label='GMM with cross-validation')\\n\\t\\tax1.plot(self.FE_errors_GMM_mix_models_, linewidth=4, label='GMM with mixture of models')\\n\\t\\tplt.legend()\\n\\n\\t\\t# Plot density error\\n\\n\\t\\t# Plot log-likelihood of test set\\n\\n\\t\\t# Plot clustering score\\n\\n\\t\\tplt.show()\\n\\n\\t\\treturn\",\n \"def plot_predictions(net, x_train, y_train, idx_train, x_val, y_val, idx_val):\\n fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(20, 30))\\n pred1 = net.predict(x_val, batch_size=batch_size)\\n # print(\\\"pred1.shape:\\\", pred1.shape)\\n ax1.plot(idx_val, y_val, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax1.plot(idx_val, pred1, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax1.set_ylim(-0.1, 1.1)\\n ax1.set_xlabel(\\\"Year\\\")\\n ax1.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax1.legend()\\n ax1.set_title(\\\"Predicted vs Actual Validation Data\\\")\\n\\n pred2 = net.predict(x_train, batch_size=batch_size)\\n # print(\\\"pred2.shape:\\\", pred2.shape)\\n ax2.plot(idx_train, y_train, label=\\\"Actual Data\\\", marker=\\\"+\\\")\\n ax2.plot(idx_train, pred2, label=\\\"Prediction\\\", marker=\\\"o\\\")\\n # ax2.set_ylim(-0.1, 1.1)\\n ax2.set_xlabel(\\\"Year\\\")\\n ax2.set_ylabel(\\\"Sunspot Numbers\\\")\\n ax2.legend()\\n ax2.set_title(\\\"Predicted vs Actual Training Data\\\")\\n\\n plt.tight_layout()\\n\\n filename = \\\"img/\\\"\\n filename += datetime.now().strftime(\\\"%y%m%d_%H%M\\\")\\n filename += \\\"_predicted_vs_actual_data.png\\\"\\n fig.savefig(filename, format=\\\"png\\\")\",\n \"def graph_results(loss, acc):\\n N = len(loss)\\n x = np.linspace(0, N, N)\\n plt.subplot(1,2,1)\\n plt.plot(x, loss)\\n plt.subplot(1,2,2)\\n plt.plot(x,acc)\\n plt.show()\",\n \"def Plot_predict(X,Y,model,X_path): \\n labels = {0: 'CNV', 1: 'DME', 2: 'DRUSEN', 3: 'NORMAL'}\\n Y_pred_classes = np.argmax(model.predict(X),axis = 1) \\n Y_true = np.argmax(Y,axis = 1)\\n \\n fig = plt.figure(figsize=(40, 40)) \\n for i in range(X.shape[0]):\\n ax = fig.add_subplot(8, 4, i + 1, xticks=[], yticks=[])\\n ax.set_title(\\\"Groundtruth : {} \\\\n Prediction : {}\\\".format(labels[Y_true[i]],labels[Y_pred_classes[i]]), \\\\\\n color=(\\\"green\\\" if Y_true[i] == Y_pred_classes[i] else \\\"red\\\"),fontsize=20) \\n img = image.load_img(X_path[i])\\n ax.imshow(img)\\n plt.show()\\n return\",\n \"def ploter(self):\\n if len(self.dataset[self.first_title]) != 2:\\n print('plot is only avilable for two features')\\n return\\n x_axis = []\\n y_axis = []\\n for title in self.dataset:\\n x_axis.append(self.dataset[title][0])\\n y_axis.append(self.dataset[title][1])\\n plt.plot(x_axis, y_axis, 'o')\\n plt.show()\",\n \"def plot_data(X, y, X_pred, clf, title):\\n \\n figsize(10.2, 5.1)\\n X2 = [[x] for x in linspace(0, max(X_pred)[0] * 1.15, 50)]\\n days = clf.predict(X_pred)\\n scatter(X, y, color='black')\\n scatter(X_pred, days, color='red')\\n plot(X2, clf.predict(X2), color='blue')\\n \\n i = 0\\n len_data = len(X_pred)\\n xytext = (5, -10)\\n for data in zip(X_pred, days):\\n i = i + 1\\n dat = purchase_date + timedelta(int(round(data[1], 0)))\\n\\n annotate(dat.strftime('%b %d %Y'), xy=(data[0][0], data[1]), xycoords='data', xytext=xytext, textcoords='offset points')\\n \\n pylab.ylim([0, int(clf.predict(X2).max()) + 1])\\n pylab.xlim([0, max(X2)[0]])\\n ax=pylab.gca()\\n ax.yaxis.set_major_formatter(NullFormatter())\\n ax.yaxis.set_minor_formatter(NullFormatter())\\n pylab.axes().set_xlabel('Miles')\\n pylab.axes().set_ylabel('Time')\\n pylab.axes().set_title(title)\",\n \"def _bokeh_confusion_scatter(\\n y_true: np.ndarray,\\n y_pred: np.ndarray,\\n class_names: Sequence[str],\\n title_rows: Sequence[str],\\n x_label_rotation: Union[str, float] = \\\"horizontal\\\",\\n y_label_rotation: Union[str, float] = \\\"vertical\\\",\\n) -> Callable[[], Figure]:\\n if len(y_true) != len(y_pred):\\n raise ValueError(\\\"y_true and y_pred must have the same length!\\\")\\n\\n def figure() -> Figure:\\n\\n p = plotting.figure(\\n x_range=(-0.5, -0.5 + len(class_names)),\\n y_range=(-0.5, -0.5 + len(class_names)),\\n plot_height=350,\\n plot_width=350,\\n tools=TOOLS,\\n toolbar_location=TOOLBAR_LOCATION,\\n match_aspect=True,\\n )\\n\\n def noise() -> np.ndarray:\\n return (np.random.beta(1, 1, size=len(y_true)) - 0.5) * 0.6\\n\\n p.scatter(\\n x=y_true + noise(),\\n y=y_pred + noise(),\\n size=scatter_plot_circle_size(\\n num_points=len(y_true),\\n biggest=4.0,\\n smallest=1.0,\\n use_smallest_when_num_points_at_least=5000,\\n ),\\n color=DARK_BLUE,\\n fill_alpha=SCATTER_CIRCLES_FILL_ALPHA,\\n line_alpha=SCATTER_CIRCLES_LINE_ALPHA,\\n )\\n\\n add_title_rows(p, title_rows)\\n apply_default_style(p)\\n\\n p.xaxis.axis_label = \\\"Ground Truth\\\"\\n p.yaxis.axis_label = \\\"Prediction\\\"\\n\\n arange = np.arange(len(class_names))\\n\\n p.xaxis.ticker = arange\\n p.yaxis.ticker = arange\\n\\n p.xaxis.major_label_overrides = {i: name for i, name in enumerate(class_names)}\\n p.yaxis.major_label_overrides = {i: name for i, name in enumerate(class_names)}\\n\\n p.xaxis.major_label_orientation = x_label_rotation\\n p.yaxis.major_label_orientation = y_label_rotation\\n\\n # grid between classes, not at classes\\n p.xgrid.ticker = arange[0:-1] + 0.5\\n p.ygrid.ticker = arange[0:-1] + 0.5\\n\\n p.xgrid.grid_line_width = 3\\n p.ygrid.grid_line_width = 3\\n\\n # prevent panning to empty regions\\n p.x_range.bounds = (-0.5, -0.5 + len(class_names))\\n p.y_range.bounds = (-0.5, -0.5 + len(class_names))\\n\\n return p\\n\\n return figure\",\n \"def plot_cv_train_test(test_avg, train_avg, lambdas, path):\\n\\n plt.plot(lambdas, test_avg, marker = \\\"o\\\", color=\\\"green\\\", label=\\\"validating cv error\\\")\\n plt.plot(lambdas, train_avg, marker = \\\"v\\\", color=\\\"blue\\\", label=\\\"training cv error\\\" )\\n \\n print(train_avg[0])\\n print(test_avg[0])\\n \\n plt.title(\\\"Cross Validation Error for Different Regularization Parameters\\\")\\n plt.ylabel(\\\"10f cv RMSE\\\")\\n plt.ylim(0.86 , 0.99)\\n plt.xlabel(\\\"$\\\\lambda$\\\")\\n plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)\\n plt.grid()\\n plt.savefig(\\\"../results/\\\"+path)\\n plt.show()\",\n \"def plot_results(actual_time_series, predicted_values, len_train_data,\\n y_name='Parameter'):\\n\\n plt.plot(np.arange(0, len(actual_time_series)),\\n actual_time_series, label='Actual values', c='green')\\n plt.plot(np.arange(len_train_data, len_train_data + len(predicted_values)),\\n predicted_values, label='Predicted', c='blue')\\n # Plot black line which divide our array into train and test\\n plt.plot([len_train_data, len_train_data],\\n [min(actual_time_series), max(actual_time_series)], c='black',\\n linewidth=1)\\n plt.ylabel(y_name, fontsize=15)\\n plt.xlabel('Time index', fontsize=15)\\n plt.legend(fontsize=15)\\n plt.grid()\\n plt.show()\",\n \"def test_plot(arg):\\n source_data = data.Biofile(arg)\\n sample = source_data.get_header()\\n feature = source_data.get_index()\\n sample_size, feature_size = 106, 12042\\n sample = sample[:sample_size]\\n #xshape = (106 12042)\\n print(sample, feature)\\n X = source_data.get_matrix().T[:sample_size, :feature_size]\\n mx = 100\\n labs = ['rbf','poly','sigmoid']\\n semi_r = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter = mx, parameter = 100) #rbf 0.5\\n semi_r_con = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter = mx, kernel='poly', parameter= 0.5)#ploy 2\\n semi_r_con1 = util.kernel_non_negative_factorization(X.T,n_components=2, max_iter=mx, kernel='sigmoid', parameter= 0.1) #sigmoid 0.5\\n semi_r_con2 = util.convex_non_negative_factorization(X.T, max_iter=mx, n_components=2)\\n\\n #semi_r = util.semi_non_negative_factorization_with_straint(X.T, max_iter = mx,n_components=2 ,initialization= 'Kmeans',alpha = 0.01, beta = 0.01)\\n #semi_r_con = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2 ,initialization= 'Kmeans',alpha= 10, beta = 10)\\n #semi_r_con1 = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2, initialization= 'Kmeans',alpha= 0, beta = 10)\\n #semi_r_con2 = util.semi_non_negative_factorization_with_straint(X.T, max_iter=mx,n_components=2, initialization= 'Kmeans',alpha= 10, beta = 0)\\n #convex_r_con = util.convex_non_negative_factorization(X.T, n_components=2, max_iter=mx)\\n\\n G, G1, G2, G3 = semi_r[1], semi_r_con[1], semi_r_con1[1], semi_r_con2[1]\\n result, result1, result2, result3 = semi_r[2], semi_r_con[2], semi_r_con1[2], semi_r_con2[2]\\n x = [i for i in range(mx)]\\n # plot the losses function\\n plt.title(\\\"losses function of {}\\\".format(arg[:-4]))\\n plt.xlabel(\\\"iteration times\\\")\\n plt.ylabel(\\\"losses\\\")\\n\\n plt.plot(x, result[:mx], 'r', marker = '.', label = 'kNMF({})'.format(labs[0]))\\n plt.plot(x, result1[:mx], 'b', marker ='.' , label = 'kNMF({})'.format(labs[1]))\\n plt.plot(x, result2[:mx], 'c', marker ='.', label = 'kNMF({})'.format(labs[2]))\\n plt.plot(x, result3[:mx], 'm', marker ='.', label = 'cvxnmf')\\n \\\"\\\"\\\"\\n plt.plot(x, result[:mx], 'r', marker = '.', label = 'sNMF')\\n plt.plot(x, result1[:mx], 'b', marker ='.' , label = 'sNMF(0.5,0.5)')\\n plt.plot(x, result2[:mx], 'c', marker ='.', label = 'sNMF(0,0.5)')\\n plt.plot(x, result3[:mx], 'm', marker ='.', label = 'sNMF(0.5,1)')\\n plt.plot(x, result4[:mx], 'k', marker = '.', label = 'cvx-NMF')\\n \\\"\\\"\\\"\\n plt.legend(bbox_to_anchor=[1,1])\\n plt.grid()\\n plt.show()\\n\\n #plot the clustering result\\n plt1 = plt\\n plt1.subplot(221)\\n plt1.plot(G[:,0], G[:,1], 'ro')\\n plt1.title(u'the distribution of items(knmf({}))'.format(labs[0]))\\n #items = zip(sample, G)\\n #for item in items:\\n # item_name, item_data = item[0], item[1]\\n # plt1.text(item_data[0], item_data[1], item_name,\\n # horizontalalignment='center',\\n # verticalalignment='top')\\n\\n plt1.subplot(222)\\n plt1.plot(G1[:,0], G1[:,1], 'bo')\\n\\n plt1.title(u'the distribution of items(knmf({}))'.format(labs[1]))\\n\\n #items = zip(sample, G1)\\n #for item in items:\\n # item_name, item_data = item[0], item[1]\\n # plt1.text(item_data[0], item_data[1], item_name,\\n # horizontalalignment='center',\\n # verticalalignment='top')\\n\\n plt1.subplot(223)\\n plt1.plot(G2[:,0], G2[:,1], 'co')\\n plt1.title(u'the distribution of items((knmf({}))'.format(labs[2]))\\n #items = zip(sample, G4)\\n #for item in items:\\n # item_name, item_data = item[0], item[1]\\n # plt1.text(item_data[0], item_data[1], item_name,\\n # horizontalalignment='center',\\n # verticalalignment='top')\\n\\n plt1.subplot(224)\\n plt1.plot(G3[:,0], G3[:,1], 'mo')\\n plt1.title(u'the distribution of items(convex-nmf))')\\n #items = zip(sample, G2)\\n #for item in items:\\n # item_name, item_data = item[0], item[1]\\n # plt1.text(item_data[0], item_data[1], item_name,\\n # horizontalalignment='center',\\n # verticalalignment='top')\\n\\n plt1.show()\",\n \"def _plot_train_test_experiment(mtrain, mval, metric_name, isState):\\n # axes\\n f, axes = plt.subplots(2,2,figsize=(12,10))\\n ltrain = _plot_experiment(mtrain, axes[:,0], metric_name, isTrain=True)\\n lval = _plot_experiment(mval, axes[:,1], metric_name, isTrain=False)\\n # title\\n target = \\\"State\\\" if isState else \\\"Output\\\"\\n f.suptitle(f\\\"{target} Errors\\\")\\n f.tight_layout()\\n return f, axes\",\n \"def draw_scatter_plot(x: pd.Series, y: pd.Series, x_label: str, y_label: str):\\n\\n plt.xlabel(x_label)\\n plt.ylabel(y_label)\\n plt.scatter(x, y)\\n plt.title(\\\"Scatter plot of '%s' and '%s'\\\" % (x_label, y_label))\\n\\n lr_model = linear_regression(x, y)\\n plt.plot(x, lr_model.predict(np.array(x).reshape(-1, 1)), color='red')\\n\\n plt.show()\",\n \"def plot_T(df, parameters_list, title, point_type):\\n slope, intercept, r, p, std_er = stats.linregress(df['T_exp'], df['T_prd'])\\n plot = sns.regplot(x='T_exp', y='T_prd', data=df, line_kws={'label':\\n \\\"y={0:.3f}x+{1:.3f}\\\".format(slope, intercept)})\\n plot.legend()\\n plot.set(xlabel=\\\"Experimental Temperature (K)\\\",\\n ylabel=\\\"Predicted Temperature (K)\\\")\\n plot.set_title(\\\"Parameters: \\\" + \\\", \\\".join(parameters_list[:-1]))\\n plot.figure.suptitle(point_type + \\\": Experimental Versus Predicted\\\")\\n plot.figure.savefig(title)\\n plt.figure()\",\n \"def plot_results(self):\\n\\n\\n f1, ax1 = plt.subplots()\\n h1, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"trainLoss\\\"],\\\\\\n \\\"b-\\\", label=\\\"Loss - Train\\\")\\n h2, = ax1.plot(self.history[\\\"step\\\"], self.history[\\\"validLoss\\\"],\\\\\\n \\\"b.\\\", label=\\\"Loss - Validation\\\")\\n\\n ax1.set_ylabel(\\\"Loss\\\", color = \\\"blue\\\")\\n ax1.tick_params(\\\"y\\\", color = \\\"blue\\\")\\n ax1.yaxis.label.set_color(\\\"blue\\\")\\n ax1.set_xlabel(\\\"Training Steps [{}]\\\".format(self.FLAGS.eval_every))\\n\\n ax2 = ax1.twinx()\\n h3, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"trainAccr\\\"], \\\"r-\\\",\\\\\\n label = \\\"Accuracy - Train\\\")\\n h4, = ax2.plot(self.history[\\\"step\\\"], self.history[\\\"validAccr\\\"], \\\"r.\\\",\\\\\\n label = \\\"Accuracy - Validation\\\")\\n\\n ax2.set_ylabel(\\\"Accuracy\\\", color = \\\"red\\\")\\n ax2.tick_params(\\\"y\\\", color = \\\"red\\\")\\n ax2.yaxis.label.set_color(\\\"red\\\")\\n\\n hds = [h1,h2,h3,h4]\\n lbs = [l.get_label() for l in hds]\\n ax1.legend(hds, lbs)\\n f1.tight_layout()\\n plt.savefig(\\\"trainingHistory.png\\\")\\n\\n plt.close(f1)\\n #plt.show()\",\n \"def plot_sparsification_error(ax, y_true, y_pred, uncert_meas, label,\\n num_partitions):\\n rel_part_size, sparse_err, sparse_err_oracle = sparsification_error(\\n y_true, y_pred, uncert_meas, num_partitions)\\n ax.plot(rel_part_size, sparse_err, label=label)\\n ax.plot(rel_part_size, sparse_err_oracle, label=\\\"Oracle\\\")\\n ax.set_xlabel(\\\"Fraction of removed points\\\")\\n # ax.set_ylabel(\\\"\\\\textit{SE}\\\")\\n ax.legend()\",\n \"def plot_loss(stats):\\r\\n plt.plot(stats['train_loss_ind'], stats['train_loss'], label='Training loss')\\r\\n plt.plot(stats['val_loss_ind'], stats['val_loss'], label='Validation loss')\\r\\n plt.legend()\\r\\n plt.xlabel('Number of iterations')\\r\\n plt.ylabel('Loss')\\r\\n plt.show()\",\n \"def plot_error_distribution(records, predictions, fig_savepath, figsize=(3.54, 2.0), format='PNG', dpi=300):\\n plt.figure(figsize=figsize)\\n error = predictions - records\\n # plt.hist(error,bins=25)\\n # plt.hist(error, 50, density=True,log=True, facecolor='g', alpha=0.75)\\n plt.hist(error, 20, density=True, log=True, )\\n plt.xlabel('Prediction Error')\\n plt.ylabel('count')\\n plt.tight_layout()\\n plt.savefig(fig_savepath, format=format, dpi=dpi)\\n # plt.show()\",\n \"def plot_results(\\n train_data: tuple[Tensor, Tensor],\\n test_data: tuple[Tensor, Tensor],\\n correct_class: Tensor\\n):\\n #fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(21,7), subplot_kw=dict(box_aspect=1))\\n fig1, (ax1, ax2) = plt.subplots(1, 2, figsize=(14,7), subplot_kw=dict(box_aspect=1))\\n fig2, ax3 = plt.subplots(figsize=(7,7), subplot_kw=dict(box_aspect=1))\\n ax1.set_title('Training data')\\n plot_dataset(train_data, ax1)\\n\\n ax2.set_title('Test data')\\n plot_dataset(test_data, ax2)\\n\\n ax3.set_title('Test prediction correctness')\\n plot_dataset((test_data[0], correct_class.int()), ax3, cmap={0: '#ff0000', 1: '#00ff00'})\\n \\n fig1.savefig('plots/datasets')\\n fig2.savefig('plots/predictions')\\n plt.show()\",\n \"def scatterplot(loc: List[CrimeStatistics]) -> None: \\n # return None #stub\\n #template based on visualization\\n \\n x = enrollment_list(loc)\\n y = crime_list(loc)\\n \\n \\n pyplot.scatter(x,y)\\n pyplot.xlabel(\\\"Enrollment\\\")\\n pyplot.ylabel(\\\"Total crime per campus\\\")\\n pyplot.title(\\\"correlation between enrollment and crimes committed\\\")\\n \\n \\n \\n pyplot.show()\\n print(linregress(x,y))\\n \\n \\n return None\",\n \"def scatter_plot(\\n xs,\\n ys,\\n x_errs,\\n y_errs,\\n model_names=None,\\n scaling=\\\"linear\\\",\\n label=\\\"\\\",\\n colors=\\\"blue\\\",\\n fitlabel=\\\"Linear Fit\\\",\\n fitcolor=\\\"red\\\",\\n):\\n xs = np.array(xs).reshape(-1, 1)\\n ys = np.array(ys).reshape(-1, 1)\\n x_errs = np.asarray(x_errs)\\n y_errs = np.asarray(y_errs)\\n\\n scaled_xs = rescale(xs, scaling)\\n scaled_ys = rescale(ys, scaling)\\n\\n if x_errs is not None:\\n scaled_x_errs = rescale(x_errs, scaling)\\n x_delta = np.abs(scaled_xs - scaled_x_errs)\\n else:\\n x_delta = np.zeros((scaled_xs.shape[0], 2))\\n\\n if y_errs is not None:\\n scaled_y_errs = rescale(y_errs, scaling)\\n y_delta = np.abs(scaled_ys - scaled_y_errs)\\n else:\\n y_delta = np.zeros((scaled_ys.shape[0], 2))\\n\\n def label_point(i):\\n x = xs[i, 0]\\n y = ys[i, 0]\\n label = f\\\"{model_names[i]} <br>\\\" if model_names is not None else \\\"\\\"\\n if x_errs is not None:\\n label += f\\\"X: {x:.3f} ({x_errs[i, 0]:.3f}, {x_errs[i, 1]:.3f}) <br>\\\"\\n else:\\n label += f\\\"X: {x:.3f} <br>\\\"\\n if y_errs is not None:\\n label += f\\\"Y: {y:.3f} ({y_errs[i, 0]:.3f}, {y_errs[i, 1]:.3f}) <br>\\\"\\n else:\\n label += f\\\"Y: {y:.3f} <br>\\\"\\n return label\\n\\n traces = []\\n traces.append(\\n go.Scatter(\\n x=scaled_xs.flatten(),\\n y=scaled_ys.flatten(),\\n hoverinfo=\\\"text\\\",\\n name=label,\\n mode=\\\"markers\\\",\\n error_x=dict(\\n type=\\\"data\\\", symmetric=False, arrayminus=x_delta[:, 0], array=x_delta[:, 1], color=\\\"grey\\\",\\n ),\\n error_y=dict(\\n type=\\\"data\\\", symmetric=False, arrayminus=y_delta[:, 0], array=y_delta[:, 1], color=\\\"grey\\\",\\n ),\\n marker=dict(color=colors, size=6),\\n text=[label_point(i) for i in range(len(scaled_xs))],\\n showlegend=False,\\n )\\n )\\n\\n # Add linear fit\\n (bias, slope), r2 = linear_fit(scaled_xs, scaled_ys)\\n sample_pts = rescale(np.arange(0.0, 1.0, 0.01), scaling)\\n traces.append(\\n go.Scatter(\\n mode=\\\"lines\\\",\\n x=sample_pts,\\n y=slope * sample_pts + bias,\\n name=f\\\"{fitlabel} (Slope: {slope:.2f}, R2: {r2:.2f})\\\",\\n line=dict(color=fitcolor),\\n )\\n )\\n\\n return traces\",\n \"def loss_plotter(model_history, ax=None):\\n \\n import matplotlib.pyplot as plt\\n import seaborn as sns\\n\\n training_loss = model_history['loss']\\n \\n test_loss = model_history['val_loss']\\n\\n epoch_count = range(1,len(training_loss)+1)\\n \\n sns.set(font_scale=1.15)\\n \\n ax = sns.lineplot(\\n x=epoch_count,\\n y=training_loss,\\n ax=ax\\n )\\n \\n ax = sns.lineplot(\\n x=epoch_count,\\n y=test_loss,\\n ax=ax\\n )\\n\\n ax.set_title(\\n 'Loss Curves: Pre-Trained VGG-16 with 2 Trained Layers',\\n fontsize=19\\n )\\n ax.set_ylabel(\\n 'Loss',\\n fontsize=18\\n )\\n ax.set_xlabel(\\n 'Epochs',\\n fontsize=18\\n )\\n\\n plt.legend(['Training Loss', 'Validation Loss'])\\n plt.show()\",\n \"def plot_scatter_and_linreg(df, col='b'):\\n lr = LinearRegression()\\n lr.fit(df['x'].reshape(-1, 1), df['y'])\\n df.plot(kind='scatter', x='x', y='y', c=col, s=50)\\n x_pred = np.linspace(df['x'].min(), df['x'].max(), 10)\\n y_pred = lr.predict(x_pred.reshape(-1, 1))\\n plt.plot(x_pred, y_pred, ls=':', c=col)\\n\\n plt.title(df.name)\",\n \"def plot_ave(results_list):\\n x_range = range(len(results_list[0]))\\n err_x, err_y, std_list = [], [], []\\n\\n for i in x_range:\\n if i % 10 == 0:\\n #get average for each generation\\n column = [] \\n for result in results_list:\\n column.append(result[i])\\n average = np.average(column)\\n \\n std_dev = np.std(column)\\n err_x.append(i)\\n err_y.append(average)\\n std_list.append(std_dev)\\n\\n pylab.errorbar(err_x, err_y, yerr=std_list)\\n pylab.show()\",\n \"def display_comparison(self, X_val, y_val):\\n import matplotlib.pyplot as plt\\n x = []\\n y = []\\n for model_tuple in self.model_list:\\n x.append(model_tuple[1])\\n y.append(model_tuple[0].score(X_val, y_val))\\n plt.scatter(x, y)\\n plt.show()\",\n \"def plot_stats(x_axis, y_axis, df, highlight=[]):\\n a, b = df[x_axis], df[y_axis]\\n\\n X_train, X_test, y_train, y_test = train_test_split(a, b, test_size=0.33, random_state=42)\\n\\n X_train = np.array(X_train).reshape(-1, 1)\\n X_test = np.array(X_test).reshape(-1, 1)\\n y_train = np.array(y_train).reshape(-1, 1)\\n y_test = np.array(y_test).reshape(-1, 1)\\n\\n regr = linear_model.LinearRegression()\\n\\n regr.fit(X_train, y_train)\\n\\n df[y_axis + \\\" STD\\\"] = df[y_axis].apply(lambda a: round((a-df[y_axis].mean())/df[y_axis].std()))\\n df[y_axis + \\\" rank\\\"] = df[y_axis].rank(ascending=False)\\n df[x_axis + \\\" rank\\\"] = df[x_axis].rank(ascending=False)\\n \\n mapper = linear_cmap(field_name=y_axis + \\\" STD\\\", palette=brewer[\\\"RdBu\\\"][len(df[y_axis + \\\" STD\\\"].unique())], \\n low=min(df[y_axis + \\\" STD\\\"].unique()), high=max(df[y_axis + \\\" STD\\\"].unique()))\\n \\n source = ColumnDataSource(df)\\n source2 = ColumnDataSource(df[df[\\\"Player\\\"].isin(highlight)])\\n \\n p = figure(x_range=(df[x_axis].min() - df[x_axis].std(), df[x_axis].max() + df[x_axis].std()), \\n y_range=(df[y_axis].min() - df[y_axis].std(), df[y_axis].max() + df[y_axis].std()))\\n \\n r1 = p.circle(x=x_axis, y=y_axis,\\n source=source, size=10, color=mapper, line_color=\\\"black\\\", legend_group= y_axis + \\\" STD\\\")\\n\\n p.title.text = y_axis + \\\" vs. \\\" + x_axis\\n p.title.align = \\\"center\\\"\\n p.xaxis.axis_label = x_axis\\n p.yaxis.axis_label = y_axis\\n p.legend.location = 'top_left'\\n p.legend.title = \\\"St. Dev's from Avg \\\" + y_axis\\n p.background_fill_color = \\\"#dddddd\\\"\\n p.background_fill_alpha = 0.1\\n \\n line_x = [df[x_axis].min().item() - df[x_axis].std().item(), df[x_axis].max().item() + df[x_axis].std().item()]\\n line_y = [(line_x[0]*regr.coef_.item()) + regr.intercept_.item(), (line_x[1]*regr.coef_.item()) + regr.intercept_.item()]\\n r2 = p.line(line_x, line_y, line_width=2, color=\\\"black\\\")\\n\\n p.add_tools(HoverTool(renderers=[r1], tooltips=[\\n (\\\"Player\\\", \\\"@Player\\\"),\\n (y_axis, \\\"@{\\\" + y_axis +\\\"}{0.000}\\\"),\\n (y_axis + \\\" Rank\\\", \\\"#@{\\\" + y_axis + \\\" rank}\\\"),\\n (x_axis, \\\"@{\\\" + x_axis +\\\"}{0}\\\"),\\n (x_axis + \\\" Rank\\\", \\\"#@{\\\" + x_axis + \\\" rank}\\\")]))\\n\\n \\n p.add_tools(HoverTool(renderers=[r2], \\n tooltips=[(x_axis, \\\"$x{0000}\\\"),\\n (\\\"Predicted \\\" + y_axis, \\\"$y\\\")]))\\n \\n labels = LabelSet(x=x_axis, \\n y=y_axis, text=\\\"Player\\\", y_offset=8,\\n text_font_size=\\\"11px\\\", text_color=\\\"#555555\\\",\\n source=source2, text_align='center')\\n \\n p.add_layout(labels)\\n\\n st.bokeh_chart(p)\",\n \"def plot_fit(self, inputs, targets, y_pred, y_std):\\n x_context, y_context, x_data = inputs\\n y_data = targets\\n x_context = np.squeeze(x_context, axis=-1)\\n y_context = np.squeeze(y_context, axis=-1)\\n x_data = np.squeeze(x_data, axis=-1)\\n y_data = np.squeeze(y_data, axis=-1)\\n y_pred = np.squeeze(y_pred, axis=-1)\\n y_std = np.squeeze(y_std, axis=-1)\\n\\n plt.figure()\\n plt.plot(x_data[-1], y_data[-1], 'k--', label='Ground Truth')\\n plt.plot(x_context[-1], y_context[-1], 'ko', label='Context')\\n plt.plot(x_data[-1], y_pred[-1], 'b-', label='GP Fit')\\n plt.fill_between(x_data[-1], y_pred[-1] - 1.96 * y_std[-1],\\n y_pred[-1] + 1.96 * y_std[-1],\\n alpha=0.5, color='b')\\n # plt.fill_between(x_data[-1], y_pred[-1] - 1 * y_std[-1],\\n # y_pred[-1] + 1 * y_std[-1],\\n # alpha=0.5, color='b')\\n\\n # make plots look nice\\n plt.xticks(np.arange(-2, 3))\\n plt.yticks(np.arange(-2, 3))\\n plt.ylabel('y')\\n plt.xlabel('x')\\n plt.tight_layout()\\n plt.show()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74629337","0.73333055","0.7297354","0.72578835","0.71555036","0.69879824","0.6962361","0.6863958","0.68618965","0.6843908","0.68003273","0.67923915","0.6791393","0.6774523","0.6764563","0.6723646","0.67137504","0.6705686","0.66826","0.664954","0.65584993","0.6554893","0.655036","0.65356827","0.6505592","0.6482037","0.6482037","0.64780825","0.64474297","0.64137644","0.63994294","0.6396782","0.6390069","0.6384972","0.6375536","0.6371211","0.63704807","0.63647234","0.6331177","0.63178027","0.63173723","0.6301722","0.6261904","0.6261711","0.6250047","0.62499416","0.62495023","0.624932","0.6243629","0.62302995","0.62232083","0.6218862","0.62175673","0.6214082","0.62052673","0.6201922","0.6200937","0.6197131","0.6194712","0.6193161","0.61927503","0.61739933","0.617329","0.6154091","0.6134054","0.613294","0.61321014","0.6125587","0.61238486","0.6122654","0.6113789","0.6108905","0.61049867","0.6104365","0.61001706","0.6091152","0.6090655","0.60839474","0.60785705","0.6077479","0.6067583","0.6065185","0.60551953","0.60459733","0.6036276","0.6034438","0.6030255","0.6026524","0.6021394","0.599772","0.59963053","0.5988951","0.5987779","0.5977036","0.59736955","0.5972074","0.59607875","0.5955645","0.59530354","0.5947361"],"string":"[\n \"0.74629337\",\n \"0.73333055\",\n \"0.7297354\",\n \"0.72578835\",\n \"0.71555036\",\n \"0.69879824\",\n \"0.6962361\",\n \"0.6863958\",\n \"0.68618965\",\n \"0.6843908\",\n \"0.68003273\",\n \"0.67923915\",\n \"0.6791393\",\n \"0.6774523\",\n \"0.6764563\",\n \"0.6723646\",\n \"0.67137504\",\n \"0.6705686\",\n \"0.66826\",\n \"0.664954\",\n \"0.65584993\",\n \"0.6554893\",\n \"0.655036\",\n \"0.65356827\",\n \"0.6505592\",\n \"0.6482037\",\n \"0.6482037\",\n \"0.64780825\",\n \"0.64474297\",\n \"0.64137644\",\n \"0.63994294\",\n \"0.6396782\",\n \"0.6390069\",\n \"0.6384972\",\n \"0.6375536\",\n \"0.6371211\",\n \"0.63704807\",\n \"0.63647234\",\n \"0.6331177\",\n \"0.63178027\",\n \"0.63173723\",\n \"0.6301722\",\n \"0.6261904\",\n \"0.6261711\",\n \"0.6250047\",\n \"0.62499416\",\n \"0.62495023\",\n \"0.624932\",\n \"0.6243629\",\n \"0.62302995\",\n \"0.62232083\",\n \"0.6218862\",\n \"0.62175673\",\n \"0.6214082\",\n \"0.62052673\",\n \"0.6201922\",\n \"0.6200937\",\n \"0.6197131\",\n \"0.6194712\",\n \"0.6193161\",\n \"0.61927503\",\n \"0.61739933\",\n \"0.617329\",\n \"0.6154091\",\n \"0.6134054\",\n \"0.613294\",\n \"0.61321014\",\n \"0.6125587\",\n \"0.61238486\",\n \"0.6122654\",\n \"0.6113789\",\n \"0.6108905\",\n \"0.61049867\",\n \"0.6104365\",\n \"0.61001706\",\n \"0.6091152\",\n \"0.6090655\",\n \"0.60839474\",\n \"0.60785705\",\n \"0.6077479\",\n \"0.6067583\",\n \"0.6065185\",\n \"0.60551953\",\n \"0.60459733\",\n \"0.6036276\",\n \"0.6034438\",\n \"0.6030255\",\n \"0.6026524\",\n \"0.6021394\",\n \"0.599772\",\n \"0.59963053\",\n \"0.5988951\",\n \"0.5987779\",\n \"0.5977036\",\n \"0.59736955\",\n \"0.5972074\",\n \"0.59607875\",\n \"0.5955645\",\n \"0.59530354\",\n \"0.5947361\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72337556"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":85194,"cells":{"query":{"kind":"string","value":"Function that plots a Calendar Map"},"document":{"kind":"string","value":"def plot_calmap(df_serie, title='Calendar 2018'):\n \n \n plt.style.use('seaborn')\n\n fig = plt.figure(figsize=(15,6))\n ax = fig.add_subplot(111)\n cax = calmap.yearplot(df_serie, ax=ax )#, cmap='YlGn')\n cb=fig.colorbar(cax.get_children()[1], ax=cax, orientation='horizontal')\n \n plt.title(title)\n \n \n #increase all text\n ax=plt.gca()\n for item in ([ ax.xaxis.label, ax.yaxis.label] +\n ax.get_xticklabels() + ax.get_yticklabels() ):\n item.set_fontsize(16)\n \n cb.ax.tick_params(labelsize=14) \n ax.title.set_fontsize(22)\n \n \n return fig"},"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_calmap(df, yr, s3_resource_bucket):\n calmap_data = pd.Series(df['Miles'].values, index=df['Date'])\n plt.figure(figsize=(15, 5))\n plt.title(f'CALENDAR HEATMAP')\n calmap.yearplot(calmap_data,\n year=int(yr),\n fillcolor='lightgrey')\n plt.savefig(f'yr_calmap.png')\n s3_resource_bucket.upload_file('yr_calmap.png', 'yr_calmap.png',\n ExtraArgs={'ContentType': 'image/png'})\n # remove local file\n os.remove('yr_calmap.png')","def draw_observation(data, date_obj, map_region):\n\n # set mapbox token\n px.set_mapbox_access_token(CONFIG.CONFIG['MAPBOX']['token'])\n\n # create figures\n map_center = {'lat':(map_region[2] + map_region[3]) * 0.5,\n 'lon':(map_region[0] + map_region[1]) * 0.5}\n figs = collections.OrderedDict()\n\n # draw precipitation\n bins = [0.1, 10, 25, 50, 100, 250, 1200]\n keys = ['0.1~10', '10~25', '25~50', '50~100', '100~250', '>=250']\n cols = ['lightgreen', 'yellow', 'lightskyblue', 'blue', 'magenta','maroon']\n cols_map = dict(zip(keys, cols))\n data['rain'] = pd.cut(data['PRE_Time_0808'], bins=bins, labels=keys)\n data['Rainfall'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\n data['PRE_Time_0808'].astype(str)\n data['rain_size'] = data['PRE_Time_0808'] + data['PRE_Time_0808'].mean()\n df = data[data['rain'].notna()]\n if df.shape[0] >= 2:\n figs['Rainfall'] = px.scatter_mapbox(\n df, lat=\"Lat\", lon=\"Lon\", color=\"rain\", category_orders={'rain': keys}, color_discrete_map = cols_map,\n hover_data={'Rainfall':True, 'Lon':False, 'Lat':False, 'rain':False, 'rain_size':False},\n mapbox_style='satellite-streets', size=\"rain_size\", center=map_center, size_max=10, zoom=4,\n title = 'Accumulated precipitation ({})'.format(date_obj.strftime(\"%Y%m%d 08-08\")),\n width=900, height=700)\n\n # draw maximum temperature\n bins = [35, 37, 40, 60]\n keys = ['35~37', '37~40', '>=40']\n cols = ['rgb(255,191,187)', 'rgb(250,89,0)', 'rgb(230,0,8)']\n cols_map = dict(zip(keys, cols))\n data['max_temp_warning'] = pd.cut(data['TEM_Max'], bins=bins, labels=keys)\n data['max_temp'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\n data['TEM_Max'].astype(str)\n df = data[data['max_temp_warning'].notna()]\n if df.shape[0] >= 2:\n figs['Max_temperature'] = px.scatter_mapbox(\n df, lat=\"Lat\", lon=\"Lon\", color=\"max_temp_warning\", category_orders={'max_temp_warning': keys}, \n color_discrete_map = cols_map,\n hover_data={'max_temp':True, 'Lon':False, 'Lat':False, 'max_temp_warning':False, 'TEM_Max':False},\n mapbox_style='satellite-streets', size=\"TEM_Max\", center=map_center, size_max=10, zoom=4,\n title = 'Maximum temperature ({})'.format(date_obj.strftime(\"%Y%m%d 08-08\")),\n width=900, height=700)\n\n # draw minimum temperature\n bins = [-120, -40, -30, -20, -10, 0]\n keys = ['<=-40','-40~-30', '-30~-20', '-20~-10', '-10~0']\n cols = ['rgb(178,1,223)', 'rgb(8,7,249)', 'rgb(5,71,162)', 'rgb(5,109,250)', 'rgb(111,176,248)']\n cols_map = dict(zip(keys, cols))\n data['min_temp_warning'] = pd.cut(data['TEM_Min'], bins=bins, labels=keys)\n data['min_temp'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\n data['TEM_Min'].astype(str)\n df = data[data['min_temp_warning'].notna()]\n if df.shape[0] >= 2:\n figs['Min_temprature'] = px.scatter_mapbox(\n df, lat=\"Lat\", lon=\"Lon\", color=\"min_temp_warning\", category_orders={'min_temp_warning': keys}, \n color_discrete_map = cols_map,\n hover_data={'min_temp':True, 'Lon':False, 'Lat':False, 'min_temp_warning':False, 'TEM_Min':False},\n mapbox_style='satellite-streets', size=-1.0*df[\"TEM_Min\"], center=map_center, size_max=10, zoom=4,\n title = 'Minimum temperature ({})'.format(date_obj.strftime(\"%Y%m%d 08-08\")),\n width=900, height=700)\n\n # draw low visibility\n data['VIS_Min'] /= 1000.0\n bins = [0, 0.05, 0.2, 0.5, 1]\n keys = ['<=0.05','0.05~0.2', '0.2~0.5', '0.5~1']\n cols = ['rgb(0,82,77)', 'rgb(0,153,160)', 'rgb(0,210,204)', 'rgb(95,255,252)']\n cols_map = dict(zip(keys, cols))\n data['min_vis_warning'] = pd.cut(data['VIS_Min'], bins=bins, labels=keys)\n data['VIS_Min_size'] = 2.0-data[\"VIS_Min\"]\n data['min_vis'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\n data['VIS_Min'].astype(str)\n df = data[data['min_vis_warning'].notna()]\n if df.shape[0] >= 2:\n figs['Low_visibility'] = px.scatter_mapbox(\n df, lat=\"Lat\", lon=\"Lon\", color=\"min_vis_warning\", category_orders={'min_vis_warning': keys}, \n color_discrete_map = cols_map,\n hover_data={'min_vis':True, 'Lon':False, 'Lat':False, 'min_vis_warning':False, 'VIS_Min_size':False},\n mapbox_style='satellite-streets', size=\"VIS_Min_size\", center=map_center, size_max=10, zoom=4,\n title = 'Low visibility ({})'.format(date_obj.strftime(\"%Y%m%d 08-08\")),\n width=900, height=700)\n\n # draw high wind\n bins = [10.8, 13.9, 17.2, 20.8, 24.5, 28.5, 32.7, 37.0, 120]\n keys = ['10.8~13.8','13.9~17.1', '17.2~20.7', '20.8~24.4', '24.5~28.4', '28.5~32.6', '32.7~36.9', '>=37.0']\n cols = ['rgb(0,210,244)', 'rgb(0,125,255)', 'rgb(253,255,0)', 'rgb(247,213,0)',\n 'rgb(255,141,0)', 'rgb(251,89,91)', 'rgb(255,3,0)', 'rgb(178,1,223)']\n cols_map = dict(zip(keys, cols))\n data['max_win_warning'] = pd.cut(data['WIN_S_Max'], bins=bins, labels=keys)\n data['max_win'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\n data['WIN_S_Max'].astype(str)\n df = data[data['max_win_warning'].notna()]\n if df.shape[0] >= 2:\n figs['High_wind'] = px.scatter_mapbox(\n df, lat=\"Lat\", lon=\"Lon\", color=\"max_win_warning\", category_orders={'max_win_warning': keys}, \n color_discrete_map = cols_map,\n hover_data={'max_win':True, 'Lon':False, 'Lat':False, 'max_win_warning':False, 'WIN_S_Max':False},\n mapbox_style='satellite-streets', size=\"WIN_S_Max\", center=map_center, size_max=10, zoom=4,\n title = 'Maximum wind speed ({})'.format(date_obj.strftime(\"%Y%m%d 08-08\")),\n width=1000, height=800)\n\n return figs","def plot_date(date, source, scene_map, ax, aois=(), valid_area=full_study_area,\n show_scalebar=True, show_legend=True, show_xticks=True, show_yticks=True,\n show_title=True, legend_font_size=10, font_size=10, continent_color=\"#b2b2b2\",\n line_color='#AAAAAA',\n scene_legend_offset=(130.45, 37.83),\n detection_legend_size=6):\n\n if show_legend == 'minimal':\n llcrnrlon, urcrnrlon = 129, 135\n llcrnrlat, urcrnrlat = 36.9, 42.4\n else:\n llcrnrlon, urcrnrlon = 129, 135\n llcrnrlat, urcrnrlat = 38.45, 42\n projection = Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat,\n urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, \n lat_ts=0, projection='mill', resolution=\"l\", ax=ax)\n \n df = source[date]\n valid_mask = create_valid_area_mask(df.longitude, df.latitude, valid_area)\n aoi_mask = create_aoi_mask(df, aois)\n scene_counts = create_scene_counts(df, scene_map)\n aoi_pts, aoi_pairs = compute_detection_counts(df.kind, valid_mask, aoi_mask, scene_counts)\n\n # 1. plot all scenes that intersect the valid_area\n scene_count = 0\n for scene_id in scene_map:\n if scene_id.startswith(date):\n scene = scene_map[scene_id]\n bounds = json.loads(scene.boundary)\n lons = [y['lon'] for y in bounds]\n lats = [y['lat'] for y in bounds]\n is_valid = any(create_valid_area_mask(lons, lats, valid_area))\n if is_valid:\n scene_count += 1\n lons, lats = projection(lons, lats)\n ax.fill(lons, lats, color='#DDDDDD', alpha=0.25)[0]\n if show_legend:\n lons = np.array(lons)\n lats = np.array(lats)\n dx, dy = projection(scene_legend_offset[0], scene_legend_offset[1])\n lons = lons - lons.mean() + dx\n lats = lats - lats.mean() + dy\n scene_hndl = patches.Polygon(list(zip(lons, lats)), color='#DDDDDD', alpha=0.5)\n scene_hndl.set_clip_on(False)\n ax.add_patch(scene_hndl)\n\n # 2. Plot the NK EEZ, valid region, and the map \n lons, lats = projection(plotting_nk_eez[:, 0], \n plotting_nk_eez[:, 1])\n eez_hndl = ax.plot(lons, lats, '--', color=line_color, linewidth=1)[0]\n lons, lats = projection(valid_area[:, 0], \n valid_area[:, 1])\n valid_hndl = ax.plot(lons, lats, '-', color=line_color, linewidth=1)[0]\n projection.fillcontinents(color=continent_color,lake_color=continent_color, zorder=2.5)\n\n # 3. Plot the AOIs\n aoi_hndl = None\n for aoi in aois:\n lons, lats = projection([x[0] for x in aoi], [x[1] for x in aoi])\n aoi_hndl = ax.fill(lons, lats, color='#0000FF', alpha=0.15)[0]\n\n # 4. Plot the detections\n lons, lats = projection(df[valid_mask].longitude.values, \n df[valid_mask].latitude.values)\n dtct_hndl = ax.plot(lons, lats, '.', markersize=2, \n color='#bd0026', label='detection', alpha=0.125)[0]\n \n # 5. Title\n title_dict = {'fontsize': font_size,}\n datestr = \"{}-{}-{}\".format(date[:4], date[4:6], date[6:8])\n if show_title:\n if len(aois):\n ax.set_title(\"{} ({} trawlers in AOI)\".format(datestr, \n int(round(aoi_pts))), fontdict=title_dict)\n else:\n ax.set_title(\"{} (no fleet found)\".format(datestr), \n fontdict=title_dict)\n\n # 6. Legend\n if show_legend:\n dummy = lines.Line2D([0],[0],color=\"w\", alpha=0)\n if show_legend == 'minimal':\n title = \"{} PlanetScope detections\".format(datestr)\n handles = [dtct_hndl, dummy, aoi_hndl]\n labels = ['Pair trawler CNN detection',\n \"PlanetScope scene (1 of {})\".format(scene_count),\n 'Location of pair trawler fleet',\n ]\n borderpad = 0.5\n labelspacing = 0.1\n detect_index = 0\n else:\n title = None\n handles = [eez_hndl, valid_hndl, aoi_hndl, dummy, dtct_hndl]\n labels = [ 'EEZ claimed by N. Korea', 'Study area', 'Location of pair trawler fleet', \n \"PlanetScope scene\", 'Pair trawler CNN detection']\n borderpad = 0\n labelspacing = 0\n detect_index = -1\n\n if len(aois) == 0:\n index = labels.index(\"Location of pair trawler fleet\")\n handles.pop(index)\n labels.pop(index)\n \n if show_legend == 'inside':\n loc = \"upper right\" \n bbox_to_anchor = None\n elif show_legend == 'minimal':\n loc = 'lower center'\n bbox_to_anchor = None\n else:\n loc = \"upper left\"\n bbox_to_anchor = (1, 1)\n\n lgnd = ax.legend(handles, labels, \n title=title,\n loc=loc, \n bbox_to_anchor=bbox_to_anchor, \n frameon=False,\n fontsize=legend_font_size, \n borderpad=borderpad,\n labelspacing=labelspacing,\n framealpha=0)\n if title:\n lgnd._legend_box.sep = 5\n\n lgnd.legendHandles[detect_index]._legmarker.set_markersize(detection_legend_size)\n\n \n # 7. Scalebar\n if show_scalebar:\n font_props = {'size': font_size,}\n lon = 0.5 * (llcrnrlon + urcrnrlon)\n lat = 0.5 * (llcrnrlat + urcrnrlat)\n ([lon0, lon1], [lat0, lat1]) = projection([lon - 0.05, lon + 0.05], [lat, lat])\n scale = (lon0 - lon1) / 0.1\n scalebar = ScaleBar(111000 / scale * np.cos(np.radians(lat)), frameon=False, \n fixed_value=100, fixed_units='km',\n border_pad=0.4,\n location=1,\n font_properties=font_props) # 111 km / degree\n ax.add_artist(scalebar)\n \n \n # 8. Set limits and turn on/off ticks\n ax.xaxis.set_tick_params(width=0.5, color='0.5')\n ax.yaxis.set_tick_params(width=0.5, color='0.5')\n [i.set_linewidth(0.5) for i in ax.spines.values()]\n [i.set_color('0.5') for i in ax.spines.values()]\n if show_legend == 'minimal':\n raw_xticklocs = [130, 134]\n raw_yticklocs = [38, 41]\n else:\n raw_xticklocs = [130, 132, 134]\n raw_yticklocs = [39, 41]\n xticklocs, _ = projection(raw_xticklocs, raw_yticklocs[:1] * len(raw_xticklocs))\n _, yticklocs = projection(raw_xticklocs[-1:] * len(raw_yticklocs), raw_yticklocs)\n\n if show_xticks:\n ax.set_xticks(xticklocs)\n ax.set_xticklabels(['{}$\\\\degree$E'.format(x) for x in raw_xticklocs], title_dict)\n else:\n ax.set_xticks([])\n if show_yticks:\n ax.set_yticks(yticklocs)\n ax.set_yticklabels(['{}$\\\\degree$N'.format(x) for x in raw_yticklocs], title_dict)\n else:\n ax.set_yticks([])\n \n return aoi_pts, aoi_pairs","def maplot(pdata, colormax=1, colormin=-999, mask='no', title='', precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\n import numpy as np\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n if colormin == -999:\n colormin = -colormax\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \n plt.figure()\n if mask == 'yes':\n lsm = ncread('/home/bakerh/Documents/DPhil/CPDN/\\\nWeather-at-Home_ancilmaker-master/lsm_n96_add.nc', 'lsm')[0, 0, :]\n pdata = np.ma.masked_array(pdata, mask=np.logical_not(lsm))\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\n pdata, lon = addcyclic(pdata, lon)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\n mycmap1 = plt.cm.Blues_r(np.arange(256))\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\n my_cmap[230:282, :] = 1\n if precip == 'yes':\n my_cmap = my_cmap[::-1]\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\"newjet\", my_cmap)\n ctrs = np.linspace(colormin, colormax, 17)\n plot = m.contourf(x, y, pdata, ctrs,\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\n extend='both')\n b = plt.colorbar(plot, orientation='horizontal',\n aspect=50, shrink=0.75, spacing='proportional')\n b.set_label(label=r'pr (mm day$^{-1}$)')\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\n m.drawparallels(parallels, labels=[True, True, True, True])\n m.drawmeridians(meridians, labels=[True, True, True, True])\n plt.title(title, y=1.08)\n plt.show()","def draw_map_m(data, month, data_name):\r\n print(str(month))\r\n waste = []\r\n for i in range(len(data)):\r\n d = data.iloc[i]\r\n if d['Date'].split('-')[1] == '0' + str(month) and d['Description'] == data_name:\r\n waste.append({\r\n 'date':d['Date'],\r\n 'category' : d['Category'],\r\n 'longitude' : d['Location'].split(' ')[1][1:],\r\n 'latitude' : d['Location'].split(' ')[2][:-1]\r\n })\r\n coordinates = []\r\n for i in waste:\r\n coordinates.append([i['latitude'], i['longitude']])\r\n \r\n latitude = 37.77\r\n longitude = -122.42\r\n # Create map and display it\r\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\r\n # Display the map of San Francisco\r\n # add incidents to map\r\n HeatMap(coordinates, radius = 14).add_to(san_map)\r\n san_map.save(str(month) + '_' + str(data_name) + '.html')","def draw_map_y(data, year, data_name):\r\n print(str(year))\r\n waste = []\r\n for i in range(len(data)):\r\n d = data.iloc[i]\r\n if d['Date'].split('-')[0] == str(year) and d['Description'] == data_name:\r\n waste.append({\r\n 'date':d['Date'],\r\n 'category' : d['Category'],\r\n 'longitude' : d['Location'].split(' ')[1][1:],\r\n 'latitude' : d['Location'].split(' ')[2][:-1]\r\n })\r\n coordinates = []\r\n for i in waste:\r\n coordinates.append([i['latitude'], i['longitude']])\r\n \r\n latitude = 37.77\r\n longitude = -122.42\r\n # Create map and display it\r\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\r\n # Display the map of San Francisco\r\n # add incidents to map\r\n HeatMap(coordinates, radius = 14).add_to(san_map)\r\n san_map.save(str(year) + '_' + str(data_name) + '.html')","def makePlot(timeStamp):\n\n #-------------------------------------------------------------------------\n # Create figure and axes\n #-------------------------------------------------------------------------\n\n width = 12 # inches\n height = 8 # inches\n fig = plt.figure(figsize=(width, height))\n\n # We'll use gridspec to create axes in rectangular 6-by-5 lattice\n import matplotlib.gridspec as gridspec\n nrows = 6\n ncols = 5\n Grid = gridspec.GridSpec(nrows, ncols)\n\n # axis for elevation time series\n axElev = fig.add_subplot(Grid[:2, :2]) # first 2 rows, first 2 columns\n # axis for slab\n axSlab = fig.add_subplot(Grid[:2, 2:]) # first 2 rows, columns > 2\n # and the transects\n axTran1 = fig.add_subplot(Grid[2:4, :]) # rows 2,3,4, all columns\n # rows 5,6,7, all columns, share x/y axis with previous (sets same ticks\n # etc)\n axTran2 = fig.add_subplot(Grid[4:6, :], sharex=axTran1, sharey=axTran1)\n\n # gridspec allows to tune the spacing between plots (unit is fraction of\n # font size)\n boundary_pad = 3.5\n horizontal_pad = 0.2\n vertical_pad = 1.0\n # figure area left,bottom,right,top in normalized coordinates [0,1]\n bounds = [0, 0, 1, 1]\n Grid.tight_layout(\n fig,\n pad=boundary_pad,\n w_pad=horizontal_pad,\n h_pad=vertical_pad,\n rect=bounds)\n\n #-------------------------------------------------------------------------\n # Create plots\n #-------------------------------------------------------------------------\n\n # for all avaiable colormaps see ( '_r' reverses the colormap )\n # http://matplotlib.org/examples/color/colormaps_reference.html\n colormap = plt.get_cmap('Spectral_r')\n colormap_kine = plt.get_cmap('gist_heat')\n\n # slab\n salt_clim = [0, 32]\n ncontours = 16\n # bouding box for slab [xmin,xmax,ymin,ymax] in model x,y coordinates\n estuarybbox = [330000, 360000, 284500, 297500]\n dia = slabSnapshotDC(\n clabel='Salinity',\n unit='psu',\n clim=salt_clim,\n cmap=colormap)\n dia.setAxes(axSlab)\n dia.addSample(slabDC, timeStamp=timeStamp, plotType='contourf',\n bbox=estuarybbox, N=ncontours)\n # overrides default format for colorbar floats\n dia.showColorBar(format='%.2g')\n #dia.addTitle('in case you want a custom title')\n # get transect (x,y) coordinates from the transectDC\n transectXYCoords = generateTransectFromDataContainer(transectDC_salt, 0)[4]\n # plot transect on the map (thin black on thick white)\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\n color='w', linewidth=2.0)\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\n color='k', linewidth=1.0)\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(\n staX,\n staY,\n label=station,\n printLabel=True,\n marker='*')\n # add text to plot. x,y are in normalized axis coordinates [0,1]\n dia.ax.text(0.05, 0.98, 'custom text', fontsize=fontsize,\n verticalalignment='top', horizontalalignment='left',\n transform=dia.ax.transAxes)\n\n # elevation time series\n # define the time range to plot\n elevStartTime = datetime.datetime(2012, 5, 4, 0, 0)\n elevEndTime = datetime.datetime(2012, 5, 5, 0, 15)\n elevMeanTime = elevStartTime + (elevEndTime - elevStartTime) / 2\n elevLim = [-1.5, 2.5]\n dia = timeSeriesPlotDC2(\n xlabel=elevMeanTime.strftime('%Y %b %d'),\n ylim=elevLim)\n dia.setAxes(axElev)\n #dia.addShadedRange( timeStamp, timeStamp+datetime.timedelta(seconds=30), facecolor='IndianRed')\n dia.addShadedRange(\n timeStamp,\n timeStamp,\n edgecolor='IndianRed',\n facecolor='none',\n linewidth=2)\n tag = elevDC.getMetaData('tag')\n dia.addSample(\n elevDC.timeWindow(\n elevStartTime,\n elevEndTime),\n label=tag,\n color='k')\n dia.addTitle('Elevation ({0:s}) [m]'.format(\n elevDC.getMetaData('location').upper()))\n # adjust the number of ticks in x/y axis\n dia.updateXAxis(maxticks=5)\n dia.updateYAxis(maxticks=3, prune='lower')\n\n # transects\n dia = transectSnapshotDC(\n clabel='Salinity',\n unit='psu',\n cmap=colormap,\n clim=salt_clim)\n dia.setAxes(axTran1)\n #transectDC_salt.data *= 1e-3\n dia.addSample(transectDC_salt, timeStamp, N=ncontours)\n dia.addTitle('')\n dia.showColorBar()\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(staX, staY, label=station, color='k',\n linewidth=1.5, linestyle='dashed')\n # do not show x axis ticks and label for this plot\n dia.hideXTicks()\n\n dia = transectSnapshotDC(clabel='TKE', unit='m2s-1', logScale=True,\n clim=[-7, -2], climIsLog=True, cmap=colormap_kine)\n dia.setAxes(axTran2)\n dia.addSample(transectDC_kine, timeStamp, N=ncontours)\n # plot station markers\n for station in stationsToPlot:\n staX = staFileObj.getX(station)\n staY = staFileObj.getY(station)\n dia.addStationMarker(staX, staY, label=station, color='k',\n linewidth=1.5, linestyle='dashed')\n dia.addTitle('')\n dia.showColorBar()\n dia.updateXAxis(maxticks=15)\n dia.updateYAxis(maxticks=6)\n\n #-------------------------------------------------------------------------\n # Save to disk\n #-------------------------------------------------------------------------\n dateStr = timeStamp.strftime('%Y-%m-%d_%H-%M')\n filename = '_'.join([imgPrefix, dateStr])\n saveFigure(\n imgDir,\n filename,\n imgFiletype,\n verbose=True,\n dpi=200,\n bbox_tight=True)\n plt.close()","def draw_map_m_2(data, month, data_name):\r\n print(str(month))\r\n waste = []\r\n for i in range(len(data)):\r\n d = data.iloc[i]\r\n if d['Date'].split('-')[1] == str(month) and d['Description'] == data_name:\r\n waste.append({\r\n 'date':d['Date'],\r\n 'category' : d['Category'],\r\n 'longitude' : d['Location'].split(' ')[1][1:],\r\n 'latitude' : d['Location'].split(' ')[2][:-1]\r\n })\r\n coordinates = []\r\n for i in waste:\r\n coordinates.append([i['latitude'], i['longitude']])\r\n \r\n latitude = 37.77\r\n longitude = -122.42\r\n # Create map and display it\r\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\r\n # Display the map of San Francisco\r\n # add incidents to map\r\n HeatMap(coordinates, radius = 14).add_to(san_map)\r\n san_map.save(str(month) + '_' + str(data_name) + '.html')","def render_map(map,\nlat=None,\nlon=None,\ntitle=None,\nsave=True,\nshow=True,\nschedule=None,\nschedule_bbox=(-0.03,0,1,0.91),\nimg_filename=None,\nimg_dir=\"\",\nimg_size=[20,15],\nimg_dpi=300,\nimg_filetype=\"png\",\nbrdr_nation=True,\nbrdr_nation_rgba=[0,0,0,1],\nbrdr_state=True,\nbrdr_state_rgba=[0,0,0,0.75],\ncmap=\"gist_ncar\",\ncmap_limits=None,\ncbar=True,\ncbar_limits=None,\ncbar_label=None,\ncountry_focus=\"CHE\",\ngridlines=True,\ngridlines_dms=False,\nmch_logo=True) :\n\n # TODO: Add custom sizing and resolution specifications\n fig = plt.figure(figsize=(img_size[0]/2.54,img_size[1]/2.54))\n\n # TODO: Accept custom projections\n # proj = ccrs.Mercator()\n proj = ccrs.Orthographic(central_longitude=(lon[0]+lon[-1])/2, central_latitude=(lat[0]+lat[-1])/2)\n\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\n ax = fig.add_subplot(1,1,1,projection = proj)\n\n # TODO: Increase flexibility of borders consideration\n if brdr_state :\n state_brdrs = cfeat.NaturalEarthFeature(\n category='cultural',\n name='admin_1_states_provinces_lines',\n scale='10m',\n facecolor='none')\n ax.add_feature(state_brdrs,linestyle=\"--\",edgecolor=tuple(brdr_state_rgba),linewidth=0.5)\n if brdr_nation :\n ax.add_feature(cfeat.BORDERS,edgecolor=tuple(brdr_nation_rgba))\n\n if country_focus is not None :\n shpfilename = shapereader.natural_earth(resolution='10m',\n category='cultural',name='admin_0_countries')\n reader = shapereader.Reader(shpfilename)\n countries = reader.records() \n # this is a very janky search for Switzerland, but it's ultimately simpler than\n # making geopandas a requirement for the library\n for country in countries :\n if country.attributes['ADM0_A3'] == country_focus :\n break\n assert country.attributes['ADM0_A3'] == country_focus, \"country_focus input not recognised\"\n poly = country.geometry\n\n msk_proj = proj.project_geometry (poly, ccrs.Geodetic()) # project geometry to the projection used by stamen\n\n # plot the mask using semi-transparency (alpha=0.65) on the masked-out portion\n ax.add_geometries( msk_proj, proj, facecolor='white', edgecolor='none', alpha=0.8)\n\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\n extents=[lon[0],lon[-1],lat[0],lat[-1]]\n ax.set_extent(extents,crs=ccrs.Geodetic())\n\n # this code correctly translate the lat/lon limits into the projected coordinates\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\n extents_proj = extents_proj[:,:2].flatten(order='F')\n\n if gridlines :\n ax.gridlines(draw_labels=True, dms=gridlines_dms, x_inline=False, y_inline=False,linewidth=0.25,\n ylocs=[46,46.5,47,47.5])\n\n # TODO: Custom colormaps, interpolation, cropping\n\n # Upscale matrix for better reprojection\n # f = interp2d(lon, lat, map, kind='linear')\n # latnew = np.linspace(lat[0], lat[-1], (len(lat)-1)*3+1)\n # lonnew = np.linspace(lon[0], lon[-1], (len(lon)-1)*3+1)\n # mapnew = f(lonnew, latnew)\n\n # Upscale matrix for better reprojection\n mapnew = zoom(map,3)\n\n # show map with given cmap and set cmap limits\n im = ax.imshow(mapnew,extent=extents,transform=ccrs.PlateCarree(),\n origin='lower',cmap=cmap)\n if cmap_limits is not None :\n im.set_clim(cmap_limits[0],cmap_limits[1])\n\n # colorbar\n # TODO: Add support for horizontal vertical option\n if cbar :\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\n cb.ax.set_xlabel(cbar_label)\n\n # show schedule diagram\n if schedule is not None :\n ax2 = inset_axes(ax, width=\"25%\", height=\"25%\", loc=2,\n axes_class = get_projection_class('polar'),\n bbox_to_anchor=tuple(schedule_bbox),\n bbox_transform=ax.transAxes)\n schedule_clock(ax2,schedule,title=\"Exposure schedule\")\n\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\n if title is not None :\n ax.set_title(title)\n\n if mch_logo :\n ex = ax.get_extent()\n mch_logo_img = plt.imread('python_tamer/mch_logo.png')\n mch_logo_width = 0.15\n mch_logo_pad = 0\n # some maths to work out position, note image aspect ratio 5:1\n mch_extents = [ex[1]-(ex[1]-ex[0])*mch_logo_width-(ex[1]-ex[0])*mch_logo_pad,\n ex[1]-(ex[1]-ex[0])*mch_logo_pad,\n ex[2]+(ex[3]-ex[2])*mch_logo_pad,\n ex[2]+0.2*(ex[1]-ex[0])*mch_logo_width+(ex[3]-ex[2])*mch_logo_pad]\n # zorder puts image on top (behind mask otherwise for some reason)\n ax.imshow(mch_logo_img,extent=mch_extents,zorder=12)\n\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\n if save :\n # Generate timestamp filename if relying on default\n if img_filename is None :\n if title is not None :\n img_filename = format_filename(title)\n else :\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\n elif img_filename == \"timestamp\" :\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\n\n plt.savefig(img_dir+img_filename+\".\"+img_filetype,\n bbox_inches=\"tight\",dpi=img_dpi)\n\n if show :\n plt.show()","def ts_map(self, vmin=0, vmax=25, pixelsize=0.25):\n self.tsmap.plot(ait_kw=dict(pixelsize=pixelsize), vmin=vmin, vmax=vmax)\n fig=plt.gcf()\n fig.set_facecolor('white')\n return fig","def draw_composite_map(date_obj, t850, u200, v200, u500, v500, mslp, gh500, u850, v850, pwat):\n \n #Get lat and lon arrays for this dataset:\n lat = t850.lat.values\n lon = t850.lon.values\n\n #========================================================================================================\n # Create a Basemap plotting figure and add geography\n #========================================================================================================\n\n #Create a Plate Carree projection object\n proj_ccrs = ccrs.Miller(central_longitude=0.0)\n\n #Create figure and axes for main plot and colorbars\n fig = plt.figure(figsize=(18,12),dpi=125)\n gs = gridspec.GridSpec(12, 36, figure=fig) #[ytop:ybot, xleft:xright]\n ax = plt.subplot(gs[:, :-1],projection=proj_ccrs) #main plot\n ax.set_xticklabels([])\n ax.set_yticklabels([])\n ax2 = plt.subplot(gs[:4, -1]) #top plot\n ax2.set_xticklabels([])\n ax2.set_yticklabels([])\n ax3 = plt.subplot(gs[4:8, -1]) #bottom plot\n ax3.set_xticklabels([])\n ax3.set_yticklabels([])\n ax4 = plt.subplot(gs[8:, -1]) #bottom plot\n ax4.set_xticklabels([])\n ax4.set_yticklabels([])\n\n #Add political boundaries and coastlines\n ax.add_feature(cfeature.COASTLINE.with_scale('50m'), linewidths=1.2)\n ax.add_feature(cfeature.BORDERS.with_scale('50m'), linewidths=1.2)\n ax.add_feature(cfeature.STATES.with_scale('50m'), linewidths=0.5)\n\n #Add land/lake/ocean masking\n land_mask = cfeature.NaturalEarthFeature('physical', 'land', '50m',\n edgecolor='face', facecolor='#e6e6e6')\n sea_mask = cfeature.NaturalEarthFeature('physical', 'ocean', '50m',\n edgecolor='face', facecolor='#ffffff')\n lake_mask = cfeature.NaturalEarthFeature('physical', 'lakes', '50m',\n edgecolor='face', facecolor='#ffffff')\n ax.add_feature(sea_mask,zorder=0)\n ax.add_feature(land_mask,zorder=0)\n ax.add_feature(lake_mask,zorder=0)\n\n #========================================================================================================\n # Fill contours\n #========================================================================================================\n\n #--------------------------------------------------------------------------------------------------------\n # 850-hPa temperature\n #--------------------------------------------------------------------------------------------------------\n\n #Specify contour settings\n clevs = np.arange(-40,40,1)\n cmap = plt.get_cmap('jet')\n extend = \"both\"\n\n #Contour fill this variable\n norm = col.BoundaryNorm(clevs,cmap.N)\n cs = ax.contourf(lon,lat,t850,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.1)\n\n #--------------------------------------------------------------------------------------------------------\n # PWAT\n #--------------------------------------------------------------------------------------------------------\n\n #Specify contour settings\n clevs = np.arange(20,71,0.5)\n\n #Define a color gradient for PWAT\n pwat_colors = gradient([[(255,255,255),0.0],[(255,255,255),20.0]],\n [[(205,255,205),20.0],[(0,255,0),34.0]],\n [[(0,255,0),34.0],[(0,115,0),67.0]])\n cmap = pwat_colors.get_cmap(clevs)\n extend = \"max\"\n\n #Contour fill this variable\n norm = col.BoundaryNorm(clevs,cmap.N)\n cs = ax.contourf(lon,lat,pwat,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.9)\n\n #Add a color bar\n _ = plt.colorbar(cs,cax=ax2,shrink=0.75,pad=0.01,ticks=[20,30,40,50,60,70])\n\n #--------------------------------------------------------------------------------------------------------\n # 250-hPa wind\n #--------------------------------------------------------------------------------------------------------\n\n #Get the data for this variable\n wind = calc.wind_speed(u200, v200)\n\n #Specify contour settings\n clevs = [40,50,60,70,80,90,100,110]\n cmap = col.ListedColormap(['#99E3FB','#47B6FB','#0F77F7','#AC97F5','#A267F4','#9126F5','#E118F3','#E118F3'])\n extend = \"max\"\n\n #Contour fill this variable\n norm = col.BoundaryNorm(clevs,cmap.N)\n cs = ax.contourf(lon,lat,wind,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs)\n\n #Add a color bar\n _ = plt.colorbar(cs,cax=ax3,shrink=0.75,pad=0.01,ticks=clevs)\n\n #--------------------------------------------------------------------------------------------------------\n # 500-hPa smoothed vorticity\n #--------------------------------------------------------------------------------------------------------\n\n #Get the data for this variable\n dx,dy = calc.lat_lon_grid_deltas(lon,lat)\n vort = calc.vorticity(u500, v500, dx=dx, dy=dy)\n smooth_vort = smooth(vort, 5.0) * 10**5\n\n #Specify contour settings\n clevs = np.arange(2,20,1)\n cmap = plt.get_cmap('autumn_r')\n extend = \"max\"\n\n #Contour fill this variable\n norm = col.BoundaryNorm(clevs,cmap.N)\n cs = ax.contourf(lon,lat,smooth_vort,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.3)\n\n #Add a color bar\n _ = plt.colorbar(cs,cax=ax4,shrink=0.75,pad=0.01,ticks=clevs[::2])\n \n #========================================================================================================\n # Contours\n #========================================================================================================\n\n #--------------------------------------------------------------------------------------------------------\n # MSLP\n #--------------------------------------------------------------------------------------------------------\n\n #Specify contour settings\n clevs = np.arange(960,1040+4,4)\n style = 'solid' #Plot solid lines\n color = 'red' #Plot lines as gray\n width = 0.8 #Width of contours 0.25\n\n #Contour this variable\n cs = ax.contour(lon,lat,mslp,clevs,colors=color,linewidths=width,linestyles=style,transform=proj_ccrs,alpha=0.9)\n\n #Include value labels\n ax.clabel(cs, inline=1, fontsize=9, fmt='%d')\n\n #--------------------------------------------------------------------------------------------------------\n # Geopotential heights\n #--------------------------------------------------------------------------------------------------------\n\n #Get the data for this variable\n gh500 = gh500 / 10.0\n\n #Specify contour settings\n clevs = np.arange(480,612,4)\n style = 'solid' #Plot solid lines\n color = 'black' #Plot lines as gray\n width = 2.0 #Width of contours\n\n #Contour this variable\n cs = ax.contour(lon,lat,gh500,clevs,colors=color,linewidths=width,linestyles=style,transform=proj_ccrs)\n\n #Include value labels\n ax.clabel(cs, inline=1, fontsize=12, fmt='%d')\n\n #--------------------------------------------------------------------------------------------------------\n # Surface barbs\n #--------------------------------------------------------------------------------------------------------\n\n #Plot wind barbs\n _ = ax.quiver(lon, lat, u850.values, v850.values, transform=proj_ccrs, regrid_shape=(38,30), scale=820, alpha=0.5)\n\n #--------------------------------------------------------------------------------------------------------\n # Label highs & lows\n #--------------------------------------------------------------------------------------------------------\n\n #Label highs and lows\n add_mslp_label(ax, proj_ccrs, mslp, lat, lon)\n\n #========================================================================================================\n # Step 6. Add map boundary, legend, plot title, then save image and close\n #========================================================================================================\n\n #Add china province boundary\n add_china_map_2cartopy(ax, name='province')\n\n #Add custom legend\n from matplotlib.lines import Line2D\n custom_lines = [Line2D([0], [0], color='#00A123', lw=5),\n Line2D([0], [0], color='#0F77F7', lw=5),\n Line2D([0], [0], color='#FFC000', lw=5),\n Line2D([0], [0], color='k', lw=2),\n Line2D([0], [0], color='k', lw=0.1, marker=r'$\\rightarrow$', ms=20),\n Line2D([0], [0], color='r', lw=0.8),]\n\n ax.legend(custom_lines, ['PWAT (mm)', '200-hPa Wind (m/s)', '500-hPa Vorticity', '500-hPa Height (dam)', '850-hPa Wind (m/s)', 'MSLP (hPa)'], loc=2, prop={'size':12})\n\n #Format plot title\n title = \"Synoptic Composite \\nValid: \" + dt.datetime.strftime(date_obj,'%Y-%m-%d %H%M UTC')\n st = plt.suptitle(title,fontweight='bold',fontsize=16)\n st.set_y(0.92)\n\n #Return figuration\n return(fig)","def DT(time_lvl = 0, date = 160924 ):\n \n #-------Customised color in RGB ------------\n C = [[232,232,230],#grey\n [203,203,203], #grey\n [161,161,161], #grey\n [130,130,130], #grey\n [149,53,229], #lillac, 39\t64\t197\t149,53,229\n [39,64,197], #blue dark,7,67,194\n [15,110,229], #blue\n [80,149,240], #blue\n [74,192,243], #blue\n [152,219,248], #blue\n [183,237,247], #blue\n [251,217,198], #redish\n [255,197,166], #redish\n [255,172,164], #redish\n [253,139,142], #redish\n [253,101,105], #redish\n [255,66,74], #redish\n [238,13,28], #red\n [214,78,166], #pink\n [214,102,201], \n [217,155,210],\n [216,181,211]]\n C = np.array( C )\n C = np.divide( C, 255. ) # RGB has to be between 0 and 1 in python\n #-----------------------------------------------------------\n \n fig = plt.figure()\n \n \n #-----Setting our map area and projection of interest-------\n m = Basemap( llcrnrlon = -90., llcrnrlat = 0., urcrnrlon = 50., urcrnrlat=70.,\\\n resolution = 'l', area_thresh = 10000., projection = 'merc' )\n #m = Basemap(width=11500000,height=8500000,resolution='l',projection='eqdc',\\\n # lat_1=07.,lat_2=40,lat_0=44,lon_0=-30.)\n #m = Basemap(width=190000,height=2200000,resolution='l', projection='tmerc',lon_0=-30,lat_0=44)\n \n map_area( m ) # ploting background\n path = \"gribs/\"\n file = path +\"DT_var.grib\"\n obj = pygrib.open( file )\n \n #-FETCHING ALL THE VALUES----------------------------------------\n #-----Potential temperature---------------------------------------\n lat, lon, data = get_data( obj,'Potential temperature', 2000, date, timelevel = time_lvl )\n contour_val = np.linspace( 264, 384, 22 ) #contours for potential tempeature\n plot_contourf( m, lat, lon, data, C, contour_val )\n \n #-----Relative vorticity, diff level------------------------------\n contour=[ 2.8E-4, 3.5E-4, 4.5E-4, 6.5E-4, 7.E-4, 7.5E-4, 8.E-4 ] #1.5E-4,2.5E-4]#\n lat, lon, data925 = get_data( obj, 'Vorticity (relative)', 925, date, timelevel = time_lvl )\n lat, lon, data900 = get_data( obj, 'Vorticity (relative)', 900, date, timelevel = time_lvl )\n lat, lon, data850 = get_data( obj, 'Vorticity (relative)', 850, date, timelevel = time_lvl )\n \n #->--->---->--mean value over height and filtering----------------\n data = np.sqrt( data900**2 + 2*data850**2 + data925**2 ) #Vertical \"average\", weightet values at 850hpa double.\n footprint = np.array([[0,0,0,1,1,1,1,0,0,0], #footprint=np.ones((3,10))\n [0,0,1,1,1,2,1,1,0,0],\n [1,1,1,2,2,1,2,1,1,1],\n [0,1,1,1,1,2,1,1,1,0],\n [0,0,1,1,1,1,1,1,0,0]])\n \n data = ndimage.generic_filter( data, np.mean, footprint = footprint, mode='wrap' )\n plot_contour( m, lat,lon, data,contour, clr = 'k' )\n \n #-----Wind barbs----------------------------------------------------\n lat, lon, data_u = get_data( obj , 'U component of wind', 2000, date, timelevel = time_lvl )\n lat, lon, data_v = get_data( obj , 'V component of wind', 2000, date, timelevel = time_lvl )\n plot_wind_bar( m, lat, lon, data_u, data_v )\n #-----------------------------------------------\n #-----------------------------------------------\n \n \n \n #-SAVE AND CLOSE----------------------------------------------------\n #------------------------------------------------------------------\n obj.close()\n if time_lvl == 0:\n t = \"0000\"\n elif time_lvl == 1:\n t = \"1200\"\n elif time_lvl == 2:\n t = \"1800\"\n else: \n t = \"t_not_set\"\n \n fig_name = \"DT/DT_\" + str( date ) + \"_\" + str( t )+ \".TIFF\" \n \n ax = plt.gca( )\n plt.rc( 'font', size = 6 )\n fig.set_size_inches( 12.80, 7.15 )\n \n fig.savefig( fig_name, dpi = 600 )\n plt.close( )\n #plt.show()\n #--------------------------\n #----------------------------","def get_ax(self, data):\n timezone = list([x for x in data if 'UTC' in x])\n\n timezone_start = tuple((x/255 for x in (0, 255, 0, 100)))\n country_start = tuple((x/255 for x in (0, 100, 0)))\n # We ignore some countries, as they are too big and need a higher\n # resolution for precise timezone assignment.\n ignored_countries = ['United States', 'Australia', 'Brazil', 'Canada']\n\n ax = plt.axes(projection=ccrs.PlateCarree())\n\n # Print countries and state borders\n ax.add_feature(cartopy.feature.LAND)\n ax.add_feature(cartopy.feature.OCEAN)\n ax.add_feature(cartopy.feature.COASTLINE)\n ax.add_feature(cartopy.feature.BORDERS)\n for state in self.states:\n ax.add_geometries(\n state.geometry,\n ccrs.PlateCarree(),\n facecolor=np.array((240, 240, 220)) / 256,\n edgecolor='black',\n label=state.attributes['name'],\n )\n\n collected_countries = []\n collected_timezones = []\n collected_states = []\n\n timezones_to_draw = []\n countries_to_draw = []\n states_to_draw = []\n for name in data:\n # Color the timezone if we find one\n name = map_timezone_to_utc(name)\n if name in self.timezones_by_name:\n timezone = self.timezones_by_name[name]\n\n # Prevent timezone from being applied multiple times.\n utc_name = timezone.attributes['utc_format']\n if utc_name not in collected_timezones:\n collected_timezones.append(utc_name)\n timezones_to_draw.append(timezone)\n\n # Check if we find a country for this timezone and draw it\n if name in timezone_country:\n # Check if we have a country code for this timezone\n country_code = timezone_country[name]\n\n # We have no country for this code.\n # Unfortunately the natural earth database is a little inconsistent.\n # Try to get the full name of the country by using pycountry\n # and resolve the country by this name.\n if country_code not in self.countries_by_iso_a2:\n try:\n name = pycountries.get(alpha_2=country_code).name\n except KeyError:\n continue\n\n # We found a full name for this code.\n # Check if we have a country for this name.\n if name not in self.countries_by_name:\n continue\n\n # We found a country for this name. Proceed\n country = self.countries_by_name[name]\n\n else:\n country = self.countries_by_iso_a2[country_code]\n\n # This country is too big and has many timezones it it.\n # Try to get the state name and to color only the interesting states.\n if country.attributes['NAME_LONG'] in ignored_countries:\n state = map_timezone_to_state(name)\n\n # We couldn't find a state for this timezone\n if state is None:\n continue\n\n # We don't have this state name in our world data\n if state not in self.states_by_name:\n continue\n\n # We already have this state\n if state in collected_states:\n continue\n\n # Found a state\n collected_states.append(state)\n state = self.states_by_name[state]\n states_to_draw.append(state)\n\n continue\n\n # Avoid to draw the same country multiple times\n country_name = country.attributes['NAME_LONG']\n if country_name in collected_countries:\n continue\n\n collected_countries.append(country_name)\n countries_to_draw.append(country)\n\n # Draw everything at the end.\n # Otherwise timezones might draw over countries and fuck up the image.\n for timezone in timezones_to_draw:\n ax.add_geometries(\n timezone.geometry,\n ccrs.PlateCarree(),\n facecolor=timezone_start,\n label=name,\n )\n\n for country in countries_to_draw:\n ax.add_geometries(\n country.geometry,\n ccrs.PlateCarree(),\n facecolor=country_start,\n edgecolor='black',\n label=country_name,\n )\n\n for state in states_to_draw:\n ax.add_geometries(\n state.geometry,\n ccrs.PlateCarree(),\n facecolor=country_start,\n edgecolor='black',\n label=state.attributes['name'],\n )\n\n return ax","def generateStationPlot(dir_path, traj_list, color_scheme='light'):\n\n\n # Choose the color scheme\n cs = MapColorScheme()\n \n if color_scheme == 'light':\n cs.light()\n\n else:\n cs.dark()\n\n\n plt.figure(figsize=(19.2, 10.8))\n\n # Init the map\n m = Basemap(projection='cyl', resolution='i')\n\n # Draw the coast boundary and fill the oceans with the given color\n m.drawmapboundary(fill_color=cs.map_background)\n\n # Fill continents, set lake color same as ocean color\n m.fillcontinents(color=cs.continents, lake_color=cs.lakes, zorder=1)\n\n # Draw country borders\n m.drawcountries(color=cs.countries)\n m.drawstates(color=cs.states, linestyle='--')\n\n\n\n ### PLOT WORLD MAP ###\n\n # Group stations into countries\n country_dict = {}\n for traj in traj_list:\n\n for obs in traj.observations:\n\n # Extract country code\n country_code = obs.station_id[:2]\n\n if country_code not in country_dict:\n country_dict[country_code] = {}\n \n\n if obs.station_id not in country_dict[country_code]:\n country_dict[country_code][obs.station_id] = [obs.lat, obs.lon]\n\n\n\n # Plot stations in all countries\n for country_code in country_dict:\n\n station_dict = country_dict[country_code]\n\n # Extract lat/lon\n lat = np.degrees([station_dict[station_id][0] for station_id in station_dict])\n lon = np.degrees([station_dict[station_id][1] for station_id in station_dict])\n\n # Convert lat/lon to x/y\n x, y = m(lon, lat)\n\n plt.scatter(x, y, s=0.75, zorder=5, label=\"{:s}: {:d}\".format(country_code, len(lat)))\n\n\n plt.legend(loc='lower left')\n\n plt.tight_layout()\n\n plt.savefig(os.path.join(dir_path, \"world_map.png\"), dpi=100)\n\n plt.close()\n\n ### ###","def plotOceanParcelsAccumulatedResults(input_data_folder, output_folder, start_year, end_year, dt=1):\n # Only for\n tot_days = (end_year-start_year)*365\n start_date = datetime.strptime(str(start_year),'%Y')\n\n open_files = []\n for c_day in np.arange(0, tot_days, dt):\n print(F\"------- {c_day}---------\")\n # Released months\n c_date = start_date + timedelta(days=int(c_day))\n months = (c_date.year - start_date.year)*12 + c_date.month - start_date.month\n\n # Iterate over all the files that should contribute to the image\n fig = plt.figure(figsize=(20,10))\n ax = plt.subplot(1, 1, 1, projection=ccrs.PlateCarree())\n for c_month in range(0, months + 1):\n c_file_year = (start_date + relativedelta(months=int(c_month))).year\n c_file_month = (start_date + relativedelta(months=int(c_month))).month\n skip_days = c_day - (c_date - datetime.strptime(F\"{c_file_year}-{c_file_month}\",'%Y-%m')).days\n\n if len(open_files) <= c_month:\n file_name = F\"TenYears_YesWinds_YesDiffusion_NoUnbeaching_{c_file_year}_{(c_file_month):02d}.nc\"\n print(F\"Reading new file: {file_name}\")\n open_files.append(Dataset(join(input_data_folder, file_name), \"r\", format=\"NETCDF4\"))\n\n c_time_step = c_day - skip_days\n # lats = open_files[c_month].variables['lat'][:,c_time_step]\n # lons = open_files[c_month].variables['lon'][:,c_time_step]\n ax.scatter(open_files[c_month].variables['lon'][:,c_time_step], open_files[c_month].variables['lat'][:,c_time_step], color='c', s=1)\n\n title = F\"{start_date.strftime('%Y-%m-%d')} - {c_date.strftime('%Y-%m-%d')}\"\n ax.coastlines()\n ax.set_title(title, fontsize=30)\n\n # plt.show()\n plt.savefig(F\"{output_folder}/{start_date.strftime('%Y_%m')}_{c_day:04d}.png\")\n plt.close()","def plot_mult_locations(sf, df, data, dcounts, geoid, all_geoids, l, b, w_map = 2.5, w_time = 3, h=3, \n colors = ['orange','palevioletred','steelblue','olive'], \n markers = ['o','^','s','P']):\n #plot timeseries\n ax = None\n ax = plot_mult_timetrends(data, geoid, cols = [i for i in data.columns if (i.endswith('21day_avg') and\n i[:12] in geoid)],\n area = [l + w_map + 0.3,b + h/2, w_time, h/2], colors = colors,\n markers = markers, sharex = ax, ylim_bottom = -50, ylim_top = 50,\n xlabels=[''] * 6)\n \n # plot dcount timeseries\n ax = None\n ax = plot_mult_timetrends(dcounts, geoid, cols = [i for i in data.columns if (i.endswith('21day_avg') and\n i[:12] in geoid)],\n area = [l + w_map + 0.3,b,w_time,h/2], colors = colors, markers = markers, sharex = ax,\n ylim_bottom = 0, ylim_top = 200, ylabel = 'Device count',\n xlabels=data.index[np.arange(0,data.shape[0],28)].tolist())\n \n #plot map\n plt.axes([l,b,w_map,h])\n for i in df_edges[df_edges.ZIPR.isin(['98105','98195','98115','98102','98112'])].index:\n shape_ex = sf_edges.shape(i)\n x_lon = np.zeros((len(shape_ex.points),1))\n y_lat = np.zeros((len(shape_ex.points),1))\n for ip in range(len(shape_ex.points)):\n x_lon[ip] = shape_ex.points[ip][0]\n y_lat[ip] = shape_ex.points[ip][1]\n plt.plot(x_lon,y_lat, color = 'black')\n \n outline_geoids(sf = sf, df = df, geoids = all_geoids, include_labels=False)\n fill_blockgroups(sf = sf, df = df, geoids = geoid, colors=colors)\n \n \n plt.xlim(-122.325,-122.25)\n plt.ylim(47.645,47.68)\n plt.axis('off')","def plot_events_grid(self, scale, distrib=True, dataname='', timeres=0):\n\n def plot_notimeres():\n \"\"\"\n All time colapsed\n @return:\n \"\"\"\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n\n if distrib:\n cont = cont / np.max(cont)\n plt.imshow(cont, interpolation='bicubic', cmap=cm.gist_yarg)\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color='#000000',\n fill_color='#110000')\n # mymap.addradpoint(minLat+(((scale - i)+0.5)/normLat), minLon+((j+0.5)/normLon),\n # cont[i,j]*(circlesize/scale), \"#FF0000\")\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n plt.plot(j, scale - i, 'k.')\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color='#000000',\n fill_color='#110000')\n # mymap.addradpoint(minLat+(((scale - i )+0.5)/normLat),\n # minLon+((j+0.5)/normLon), 30, \"#FF0000\")\n\n def plot_timeres(timeres):\n \"\"\"\n Geo points separated by the time resolution zones\n @return:\n \"\"\"\n tint = 24 / timeres\n step = 255 / (tint + 1)\n\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n mxcont = np.max(cont)\n\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\n # cont[i,j]*(circlesize/scale), \"#FF0000\")\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color='#000000',\n fill_color='#110000', fill_opacity=0.3)\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\n # minLon+((j+1.5)/normLon), 30, \"#FF0000\")\n for t in range(tint):\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\n cont = np.zeros((scale, scale))\n for i in range(self.dataset.shape[0]):\n posy = int(((self.dataset[i][0] - minLat) * normLat))\n posx = int(((self.dataset[i][1] - minLon) * normLon))\n stime = time.localtime(np.int32(self.dataset[i][2]))\n evtime = stime[3]\n if (evtime / timeres) == t:\n if distrib:\n cont[scale - posy - 1, posx - 1] += 1\n else:\n cont[scale - posy - 1, posx - 1] = 1\n if distrib:\n cont = cont / mxcont\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=cont[i, j] * (circlesize / scale),\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)\n else:\n for i in range(cont.shape[0]):\n for j in range(cont.shape[1]):\n if cont[i, j] > 0.01:\n mymap.circle_marker(\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\n radius=30,\n line_color=color,\n fill_color='#110000', fill_opacity=0.2)\n\n print 'Generating the events plot ...'\n circlesize = 15000\n\n # if timeres == 0:\n # fig = plt.figure()\n # ax = fig.add_subplot(111)\n\n minLat, maxLat, minLon, maxLon = self.city[1]\n normLat = scale / (maxLat - minLat)\n normLon = scale / (maxLon - minLon)\n mymap = folium.Map(location=[(minLat + maxLat) / 2.0, (minLon + maxLon) / 2.0], zoom_start=12, width=1200,\n height=1000)\n\n # mymap = pygmaps.maps((minLat+maxLat)/2,(minLon + maxLon)/2.0, 10)\n # mymap.setgrids(minLat, maxLat, 0.01, minLon, maxLon, 0.01)\n if timeres is None:\n plot_notimeres()\n else:\n plot_timeres(timeres)\n\n # today = time.strftime('%Y%m%d%H%M%S', time.localtime())\n nfile = self.application + '-' + dataname + '-Grid'\n if self.mnhh is not None and self.mnhh is not None:\n nfile += '-nusr' + str(self.mxhh) + '#' + str(self.mnhh)\n if timeres is not None:\n nfile += '-tr' + str(timeres.interval)\n\n nfile += '-s' + str(scale)\n\n # if timeres == 0:\n # fig.savefig(homepath + 'Results/' + self.city[2] + '-' +\n # nfile + '.pdf', orientation='landscape', format='pdf')\n # plt.close()\n mymap.create_map(path=homepath + 'Results/' + self.city[2] + nfile + '.html')\n # mymap.draw(homepath + 'Results/' + self.city[2] + nfile + '.html')","def plot(lats, lons, year):\r\n\thtml_file = \"html_files/ufo_sightings_\" + str(year) + \".html\"\r\n\r\n\tgmap = gmplot.GoogleMapPlotter(40, -100, 4)\r\n\tgmap.heatmap(lats, lons)\r\n\tgmap.draw(html_file)\r\n\r\n\tget_screenshot(html_file, year)","def main_date_plot(full_date, start_date, end_date):\n fig, ax = plt.subplots()\n loc = dts.MonthLocator()\n if end_date - start_date < dt.timedelta(days=90):\n myFmt = dts.DateFormatter('%m-%d')\n else:\n myFmt = dts.DateFormatter('%m')\n \n # check if full data is a list of lists\n this_event = [(date, data) for date, data in full_data if\n date >= prev_date and date <= final_date]\n\n date, rank = zip(*this_event)\n\n ax.plot(date, rank, 'k-')\n\n ax.set_xlabel('Month')\n ax.set_ylabel('Rank')\n ax.invert_yaxis()\n ax.xaxis.set_major_formatter(myFmt)\n ax.set_title('Rank plot for {} in {}'.format(WORD, YEAR))\n fig.savefig('plots/{}-{}-shock-event.jpg'.format(WORD, YEAR))\n plt.close(fig)","def maplot_c(pdata, pdata1, title='', precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid\n import numpy as np\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n plt.figure()\n\n pdata, lon1 = shiftgrid(180., pdata, lon, start=False)\n pdata1, lon = shiftgrid(180., pdata1, lon, start=False)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n plot = m.contour(x, y, pdata, [4, 5, 6], colors='k')\n plt.clabel(plot, inline=1, fontsize=10)\n plot1 = m.contour(x, y, pdata1, [4, 5, 6], colors='r', linestyles='--')\n plt.clabel(plot, inline=1, fontsize=10)\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\n m.drawparallels(parallels, labels=[True, True, True, True])\n m.drawmeridians(meridians, labels=[True, True, True, True])\n plt.title(title, y=1.08)\n plt.show()","def make_map(data,LatLonBox):\n\n proj = ccrs.LambertConformal(central_longitude=data.StationLongitude,\n central_latitude=data.StationLatitude)\n\n fig = plt.figure(figsize=(17,11))\n ax = plt.subplot(111,projection=proj)\n \n ax.coastlines('50m', 'black', linewidth=2, zorder=2)\n\n reader = shpreader.Reader('/Users/chowdahead/Documents/shapefiles/countyl010g_shp_nt00964/countyl010g.shp')\n counties = list(reader.geometries())\n COUNTIES = cfeature.ShapelyFeature(counties,ccrs.PlateCarree())\n ax.add_feature(COUNTIES, facecolor='none',edgecolor='w')\n # Grab state borders\n state_borders = cfeature.NaturalEarthFeature(\n category='cultural', name='admin_1_states_provinces_lines',\n scale='50m', facecolor='none')\n ax.add_feature(state_borders, edgecolor='w', linewidth=1, zorder=3)\n \n ocean = cfeature.NaturalEarthFeature('physical', 'ocean', scale='50m',\n edgecolor='face',\n facecolor=cfeature.COLORS['water'])\n land = cfeature.NaturalEarthFeature('physical', 'land', scale='50m',\n edgecolor='face',\n facecolor=\"k\")\n\n ax.add_feature(ocean, zorder=-1)\n ax.add_feature(land, zorder=-1)\n ax.set_facecolor('black')\n \n ax.set_extent(LatLonBox,ccrs.PlateCarree())\n \n return fig,ax,proj","def generate_geo_map(start_date, end_date):\n start_time = dt.datetime.now()\n\n start_date = dt.datetime.strptime(start_date.split('T')[0], '%Y-%m-%d') # Convert strings to datetime objects\n end_date = dt.datetime.strptime(end_date.split('T')[0], '%Y-%m-%d')\n\n filtered_data = filter_dataframe(df, start_date, end_date)\n dff = filtered_data\n\n traces = []\n\n data = [ dict(\n type = 'scattermapbox',\n lon = dff['lat'],\n lat = dff['lon'],\n text = dff['timestamp'],\n mode = 'markers',\n marker = dict(\n size = 8,\n opacity = 0.8,\n color = 'orange'\n ))]\n\n # relayoutData is None by default, and {'autosize': True} without relayout action\n # if main_graph_layout is not None and selector is not None and \"locked\" in selector:\n # if \"mapbox.center\" in main_graph_layout.keys():\n # lon = float(main_graph_layout[\"mapbox.center\"][\"lon\"])\n # lat = float(main_graph_layout[\"mapbox.center\"][\"lat\"])\n # zoom = float(main_graph_layout[\"mapbox.zoom\"])\n # layout[\"mapbox\"][\"center\"][\"lon\"] = lon\n # layout[\"mapbox\"][\"center\"][\"lat\"] = lat\n # layout[\"mapbox\"][\"zoom\"] = zoom\n\n print('generate_geo_map:', (dt.datetime.now()-start_time).total_seconds())\n\n figure = dict(data=data, layout=layout)\n return figure","def do_month(ts, routes=\"m\"):\n pgconn = get_dbconn(\"coop\", user=\"nobody\")\n ccursor = pgconn.cursor(cursor_factory=psycopg2.extras.DictCursor)\n nt = NetworkTable(\"IACLIMATE\")\n sql = \"\"\"SELECT station, sum(precip) as total, max(day) as lastday\n from alldata_ia WHERE year = %s and month = %s\n and station != 'IA0000' and substr(station,2,1) != 'C'\n GROUP by station\"\"\" % (\n ts.year,\n ts.month,\n )\n\n lats = []\n lons = []\n vals = []\n lastday = None\n ccursor.execute(sql)\n for row in ccursor:\n if row[\"station\"] not in nt.sts:\n continue\n if lastday is None:\n lastday = row[\"lastday\"]\n lats.append(nt.sts[row[\"station\"]][\"lat\"])\n lons.append(nt.sts[row[\"station\"]][\"lon\"])\n vals.append(row[\"total\"])\n\n mp = MapPlot(\n title=\"%s - %s\"\n % (ts.strftime(\"%d %B %Y\"), lastday.strftime(\"%d %B %Y\")),\n subtitle=\"%s Total Precipitation [inch]\" % (ts.strftime(\"%B %Y\"),),\n )\n mp.contourf(\n lons, lats, vals, [0, 0.1, 0.25, 0.5, 0.75, 1, 2, 3, 4, 5, 6, 7]\n )\n mp.plot_values(lons, lats, vals, fmt=\"%.2f\")\n\n pqstr = (\n \"plot %s %s summary/iemre_iowa_total_precip.png \"\n \"%s/summary/iemre_iowa_total_precip.png png\"\n ) % (routes, ts.strftime(\"%Y%m%d%H%M\"), ts.strftime(\"%Y/%m\"))\n mp.postprocess(pqstr=pqstr)","def pcolorDays(DIVA_results, arg):\n \n # use maximum or minimum value:\n max_min = arg[0]\n \n # define what data should be plotted:\n X = DIVA_results[arg[1]]\n \n # define rotation axis:\n rotation_axis = arg[2]\n \n # assign angles and angle_locations: \n x_angle_location = DIVA_results['angles']['x_angle_location']\n y_angle_location = DIVA_results['angles']['y_angle_location']\n allAngles = DIVA_results['angles']['allAngles']\n \n if len(arg)==0:\n max_min = 'min'\n else:\n max_min = arg[0]\n \n axis_ind =[]\n \n if max_min == 'min':\n ind=np.argmin(X,axis=0)\n elif max_min == 'max':\n ind=np.argmax(X,axis=0)\n\n\n z_min=0\n if rotation_axis == 'x':\n for i in range(len(ind)):\n axis_ind.append(x_angle_location[ind[i]])\n z_max=max(x_angle_location)\n elif rotation_axis == 'y':\n for i in range(len(ind)):\n axis_ind.append(y_angle_location[ind[i]])\n z_max=max(y_angle_location)\n elif rotation_axis == 'xy':\n axis_ind = ind\n z_max=len(allAngles[0])-1\n else:\n print 'axis not available'\n dx, dy = 1, 1\n \n # generate 2 2d grids for the x & y bounds\n y, x = np.mgrid[slice(0, 24 + dy, dy),\n slice(0, 365 + dx, dx)]\n z=[]\n for i in range(24):\n z.append([])\n for j in range(365):\n z[i].append(axis_ind[24*j + i])\n z = np.asarray(z)\n \n # z_min, z_max = 0, len()\n #print z_min, z_max\n \n #plt.pcolor(x, y, z, cmap='jet', vmin=z_min, vmax=z_max)\n plt.pcolor(x, y, z, cmap='cubehelix', vmin=z_min, vmax=z_max, rasterized=True)\n# plt.pcolor(x, y, z, cmap='PRGn', vmin=z_min, vmax=z_max)\n #plt.pcolor(x, y, z, cmap='nipy_spectral', vmin=z_min, vmax=z_max)\n\n #plt.title('pcolor')\n# plt.xlabel(\"Day of the Year\")\n# plt.ylabel(\"Hour of the Day\")\n # set the limits of the plot to the limits of the data\n plt.axis([x.min(), x.max(), y.min(), y.max()])","def plot_events(ax, MD):\n\n coord_vars = ['CT_at_HB', 'CT_out_HB']\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\n all_vars = coord_vars + ingestion_vars\n\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\n \n names = ['M', 'M', 'F', 'F', 'W', 'W']\n idx = [2, 0, 0, 1, 0, 1]\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\n\n offsets = [-3, -5, -9, -11, -14, -16]\n height = 1.\n \n print \"plotting events..\"\n\n\n for c, name in enumerate(all_vars):\n\n # load\n if not hasattr(MD, name):\n MD.load(name)\n\n events = getattr(MD, name) / 3600. - 7 \n\n offset = offsets[c]\n color = colors[c]\n label = str(events.shape[0]) + ' ' + labels[c]\n\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\n label += ' events'\n\n if name in coord_vars:\n \n ax.scatter(\n events, offset * np.ones(events.shape[0]),\n c=color,\n marker='|',\n linewidths=1,\n edgecolors=None\n )\n \n\n elif name in ingestion_vars:\n\n for x in events: \n event_patch = patches.Rectangle(\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\n linewidth=0.001,\n fc=color, \n ec=color\n ) \n ax.add_patch(event_patch) \n\n # event descritpion\n ax.text(31, offset, label, color=color, \n fontsize=7, ha='left', va='bottom'\n )","def calendar_plot_by_year(series_to_plot, normalize_each_year=False):\n\n # calculate number of years\n start_year = series_to_plot.sort_index().index[0].year\n end_year = series_to_plot.sort_index().index[-1].year\n num_years = end_year - start_year + 1\n\n # send directly to function if we want to few heatmap across full time period\n if not normalize_each_year:\n calmap.calendarplot(series_to_plot, cmap='YlGn', fillcolor='grey', \\\n linewidth=.05, daylabels=['M', 'T', 'W', 'T', 'F', 'S', 'S'], \\\n fig_kws=dict(figsize=(12, 2*num_years)))\n return\n\n # plot each year and build figure\n fig = plt.figure(figsize=(12, 2*num_years))\n for i, year in enumerate(range(start_year, end_year + 1), 1):\n year_to_plot = series_to_plot[series_to_plot.index.year == year]\n\n # plot\n axes = fig.add_subplot(num_years, 1, i)\n calmap.yearplot(year_to_plot, year=year, cmap='YlGn', fillcolor='grey', linewidth=.05, \\\n daylabels=['M', 'T', 'W', 'T', 'F', 'S', 'S'], ax=axes)\n axes.set_ylabel(year)","def visualizations():\r\n raise NotImplementedError\r\n # df = pandas.read_csv('accidents_by_hour.csv', index_col=0, header=0)\r\n # plt.plot(0, 0, data=df)\r\n # plt.show()\r","def plot_using_a_map(self, map, legend_name: str):\n x_axis, y_axis = zip(*sorted(map.items()))\n plt.plot(x_axis,\n y_axis,\n label=legend_name)","def drawMap(self, M):\n\n for i in range(M.shape[1]):\n self.ax.plot (M[1, i], M[2, i], 'gx')\n\n self.fig.canvas.draw()","def one_period_plot():\n file = \"Data/matfiles/20131221.mat\"\n object = MatReader(file)\n\n NeA = object.NeA\n latA = object.latA\n times = object.secondsA\n mlt = object.mltA\n ind1 = 2606 #lat inds\n ind2 = 13940 #lat inds\n \n ind1 = 3197 #mlat inds\n ind2 = 14390 #mlat inds\n \n T = ind2 - ind1\n ind1 += int(T/2)\n ind2 += int(T/2)\n\n latA = latA[ind1:ind2]\n NeA = NeA[ind1:ind2]\n # NeA = object.meanie(NeA, 5)\n times = times[ind1:ind2]\n mlt = mlt[ind1:ind2]\n mlt = hour_round(mlt)\n\n lats = np.zeros_like(latA)\n lats[0] = latA[0]\n for i in range(len(latA)-1):\n dlat = latA[i+1] - latA[i]\n if dlat < 0:\n lats[i+1] = lats[i] - dlat\n else:\n lats[i+1] = lats[i] + dlat\n\n lats += 90\n\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\n # plt.plot(lats, NeA, \".\", markersize = 1)\n # plt.plot([0, 0], [0, np.max(NeA)], \"k\")\n # plt.plot([30, 30], [0, np.max(NeA)], \"k\")\n # plt.plot([60, 60], [0, np.max(NeA)], \"k\")\n # plt.plot([120, 120],[0, np.max(NeA)], \"k\")\n # plt.plot([150, 150], [0, np.max(NeA)], \"k\")\n # plt.plot([167, 167], [0, np.max(NeA)], \"k\")\n # plt.plot([193, 193], [0, np.max(NeA)], \"k\")\n # plt.plot([210, 210], [0, np.max(NeA)], \"k\")\n # plt.plot([240, 244], [0, np.max(NeA)], \"k\")\n # plt.plot([300, 300], [0, np.max(NeA)], \"k\")\n # plt.plot([330, 330], [0, np.max(NeA)], \"k\")\n # plt.plot([360, 360], [0, np.max(NeA)], \"k\")\n # plt.xticks(xticks)\n # plt.xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n # plt.ylabel(\"Electron density [cm$^{-1}$]\")\n # plt.title(\"One SWARM satellite period\")\n # plt.grid(\"on\", axis = \"x\", xdata = gridticks)\n #adding letters\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\n y = np.zeros_like(x) - np.max(NeA)/40\n s = [\"S\", \"B\", \"A\", \"B\", \"C\", \"D\", \"C\", \"B\", \"A\", \"B\", \"S\"]\n # for i in range(len(x)):\n # plt.text(x[i], y[i], s[i], fontsize = 10)\n # plt.savefig(\"Figures/swarm_period.pdf\")\n # plt.show()\n\n # plt.plot(times, latA)\n # plt.plot(times, mlt)\n # plt.show()\n print(lats[0])\n print(lats[-1])\n \n fig, ax = plt.subplots()\n ax.plot(lats, NeA, \".\", markersize = 1)\n ax.set_xticks(xticks, minor=False)\n ax.set_xticks([167, 193], minor=True)\n ax.xaxis.grid(True, which = \"major\")\n ax.xaxis.grid(True, which = \"minor\")\n for i in range(len(x)):\n ax.text(x[i], y[i], s[i], fontsize = 10)\n ax.set_xlabel(\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\")\n ax.set_ylabel(\"Electron density [cm$^{-1}$]\")\n ax.set_title(\"One Swarm satellite period\")\n # plt.savefig(\"Figures/swarm_period.pdf\")\n plt.show()\n plt.plot(mlt, NeA)\n plt.show()\n plt.plot(mlt, lats)\n plt.show()","def showGlobalPlot(self,fsize=[14,14],cmap='jet',m=None,figname='fig'):\n\n fig=plt.figure(figsize=(14,14))\n # read in data to use for plotted points\n\n A=[]\n for key,value in self._ts_dict.iteritems():\n A.append(np.array([i.replace(\"#\",\" \")\n .split()[0:4] for i in value.index])\n .astype(float))\n\n B=np.array(A[0]).reshape(len(A[0]),4)\n\n lat = (B[:,0]+B[:,1])/2\n lon = (B[:,2]+B[:,3])/2\n A=[]\n for key,value in self._ts_dict.iteritems():\n A.append(value.sum(axis=1).values)\n\n val = np.array(A)\n\n\n # determine range to print based on min, max lat and lon of the data\n margin = 2 # buffer to add to the range\n lat_min = min(lat) - margin\n lat_max = max(lat) + margin\n lon_min = min(lon) - margin\n lon_max = max(lon) + margin\n\n # create map using BASEMAP\n if m is None:\n m = Basemap(llcrnrlon=lon_min,\n llcrnrlat=lat_min,\n urcrnrlon=lon_max,\n urcrnrlat=lat_max,\n lat_0=(lat_max - lat_min)/2,\n lon_0=(lon_max-lon_min)/2,\n projection='merc',\n resolution = 'h',\n area_thresh=10000.,\n )\n m.drawcoastlines()\n m.drawcountries()\n m.drawstates()\n m.drawmapboundary(fill_color='#acbcec')\n m.fillcontinents(color = 'k',lake_color='#acbcec')\n\n # convert lat and lon to map projection coordinates\n lons, lats = m(lon, lat)\n # plot points as red dots\n m.scatter(lons, lats,s=val+1, c=val, cmap=cmap,\n norm=colors.LogNorm(vmin=np.min(val)+1, vmax=np.max(val)+1),\n zorder=5)\n\n plt.savefig(figname+'.pdf',dpi=300,bbox_inches='tight',transparent=True)\n\n return m","def _plot_map(self):\n\n # Plot points if they exist\n\n if len(self._laserX) > 0:\n self._plot_laser()\n\n if len(self._goalX) > 0:\n self._plot_goal()\n\n if len(self._summitX) > 0:\n self._plot_summit()\n\n self._plot_objects()\n\n # Update Plot\n self._fig.canvas.draw_idle()\n\n plt.pause(0.01)","def plot_landings(df):\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ax.set_position(default_timeseries_position) \n\n Fn = df['CatchMT'].groupby([df.Year, df.Reg, df.Sreg]).mean()\n\n all_data = Fn.loc[:, 'All', 'All']\n ma_data = Fn.loc[:, '1', 'All']\n gb_data = Fn.loc[:, '2', 'All']\n\n # Don't plot the first year. Also, the data is shifted by one year.\n # For some reason, restricting the year range above results in a series\n # that still have a multi-index. This seems like the cleanest way to do\n # that.\n all_data = all_data.iloc[2:]\n ma_data = ma_data.iloc[2:]\n gb_data = gb_data.iloc[2:]\n all_data.index = all_data.index - 1\n ma_data.index = ma_data.index - 1\n gb_data.index = gb_data.index - 1\n\n all_data.plot(ax=ax, label='All') \n ma_data.plot(ax=ax, label='Mid Atlantic')\n gb_data.plot(ax=ax, label='Georges Bank')\n\n ax.legend(loc='best')\n\n content = io.BytesIO()\n plt.savefig(content, format='png')\n content.seek(0)\n image_cache['landings']['landings'] = content\n\n plt.close()","def plotmap(self):\n if self.plotfigure is None: return\n\n self.plotfigure.clf()\n collist = [\"#%.2x%.2x%.2x\" % (i, i, i) for i in self.currentshades]\n cmap = colors.ListedColormap(collist)\n if self.gs.isfixed:\n crange = [self.minvalue] + self.currentvalues\n elif self.gs.isperc:\n crange = np.percentile(self.imagearray, [0.0] + self.currentpercents)\n else:\n crange = np.array([self.minstdd] + self.currentnsigs) * self.stdvalue + self.meanvalue\n norm = colors.BoundaryNorm(crange, cmap.N)\n img = plt.imshow(self.imagearray, cmap=cmap, norm=norm, origin='lower')\n plt.colorbar(img, norm=norm, cmap=cmap, boundaries=crange, ticks=crange)\n if self.imagetitle is not None:\n plt.title(self.imagetitle)","def maplot_cgt(pdata, colormax=1, mask='no', title='', precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\n import numpy as np\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n plt.figure()\n if mask == 'yes':\n lsm = ncread('/home/bakerh/Documents/DPhil/CPDN/\\\nWeather-at-Home_ancilmaker-master/lsm_n96_add.nc', 'lsm')[0, 0, :]\n pdata = np.ma.masked_array(pdata, mask=np.logical_not(lsm))\n pdata, lon = shiftgrid(250., pdata, lon, start=False)\n pdata, lon = addcyclic(pdata, lon)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=0, urcrnrlat=70,\n llcrnrlon=-110, urcrnrlon=250, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\n mycmap1 = plt.cm.Blues_r(np.arange(256))\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\n my_cmap[230:282, :] = 1\n if precip == 'yes':\n my_cmap = my_cmap[::-1]\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\"newjet\", my_cmap)\n ctrs = np.linspace(-colormax, colormax, 17)\n plot = m.contourf(x, y, pdata, ctrs,\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\n extend='both')\n plt.colorbar(plot, orientation='horizontal',\n shrink=0.5, spacing='proportional', label='Difference (m)')\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\n m.drawparallels(parallels, labels=[True, True, True, True])\n m.drawmeridians(meridians, labels=[True, True, True, True])\n plt.title(title, y=1.08)\n plt.show()","def calender(self, month, year):\n\n day = ['S', ' M', ' T', ' W', ' Th', 'F', ' S']\n\n days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n\n values = 1\n d = 1\n\n m = month\n y = year\n y0 = y - (14 - m) // 12\n x = y0 + y0 // 4 - y0 // 100 + y0 // 400\n m0 = m + 12 * ((14 - m) // 12) - 2\n d0 = (d + x + 31 * m0 // 12) % 7\n\n if utility_obj.isleap_year(str(year)):\n days[1] = 29\n row = 6\n column = 7\n two_d_array = [[0 for j in range(column)] for i in range(row)]\n\n print('Your Calender is Ready\\n')\n\n for i in range(0, 6 + 1):\n print(day[i], end=' ')\n print()\n for i in range(row):\n\n for j in range(column):\n\n if values <= days[m - 1]:\n if i == 0 and j < d0:\n two_d_array[i][j] = ' '\n continue\n\n two_d_array[i][j] = values\n values += 1\n\n for i in range(row):\n\n for j in range(column):\n if two_d_array[i][j] != 0:\n x = two_d_array[i][j]\n x1 = str(x).ljust(2)\n print(x1, end=\" \")\n\n print()","def map_season(x, figsize=(8, 6), **kwargs):\n\n from pycmbs.mapping import map_plot\n\n nvals = len(x.data)\n if nvals == 12:\n year = True\n elif nvals == 4:\n year = False\n else:\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\n\n #/// checks ///\n if x.data.ndim != 3:\n print x.data.ndim\n raise ValueError('only 3D data supported')\n\n if 'vmin' not in kwargs.keys():\n raise ValueError('vmin argument is obligatory for map_seasons()')\n if 'vmax' not in kwargs.keys():\n raise ValueError('vmax argument is obligatory for map_seasons()')\n\n if kwargs['vmin'] is None:\n raise ValueError('vmin MUST NOT be None!')\n if kwargs['vmax'] is None:\n raise ValueError('vmax MUST NOT be None!')\n\n #/// figure and axes\n if 'figure' in kwargs:\n f = kwargs['figure']\n else:\n f = plt.figure(figsize=figsize)\n\n if 'title' in kwargs:\n tit = kwargs.pop('title')\n else:\n tit = x.label\n\n if 'drawparallels' in kwargs:\n drawparallels = kwargs.pop('drawparallels')\n else:\n drawparallels = False\n\n if 'savefile' in kwargs:\n savefile = kwargs.pop('savefile')\n if '.nc' in savefile:\n savefile = savefile[:-3]\n else:\n savefile = None\n\n # plot\n if year:\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\n else:\n labels = ['DJF', 'MAM', 'JJA', 'SON']\n\n # check dates\n if year:\n mo = 1\n for t in x.time:\n if x.num2date(t).month != mo:\n print x.num2date(t), mo\n raise ValueError('Invalid monthly sequence! Can not plot results!')\n mo += 1\n\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\n if 'overlay' in kwargs.keys():\n overlays = kwargs.pop('overlay')\n else:\n overlays = None\n\n for i in range(nvals):\n if year:\n ax = f.add_subplot(4, 3, i + 1)\n #if i % 3 == 2:\n if i > 8:\n show_colorbar = True\n else:\n show_colorbar = False\n else:\n ax = f.add_subplot(2, 2, i + 1)\n if 'show_colorbar' in kwargs:\n show_colorbar = kwargs.pop('show_colorbar')\n else:\n show_colorbar = True\n\n d = x.copy()\n d.data = x.data[i, :, :]\n d.label = labels[i]\n\n if overlays is None:\n overlay = None\n else:\n overlay = overlays[i, :, :]\n\n if savefile is not None:\n tmpoutname = savefile + '_' + labels[i]\n else:\n tmpoutname = None\n\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\n savefile=tmpoutname, colorbar_orientation='horizontal',\n drawparallels=drawparallels, **kwargs)\n del d\n f.suptitle(tit, size=16)\n return f","def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\n import numpy as np\n import matplotlib as mpl\n import matplotlib.pyplot as plt\n from netcdfread import ncread\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\n\n def plotter(pdata, colormax=1, colormin=-999, title=''):\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \n if colormin == -999:\n colormin = -colormax\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\n pdata, lon = addcyclic(pdata, lon)\n meshlon, meshlat = np.meshgrid(lon, lat)\n\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\n m.drawcoastlines()\n m.drawmapboundary()\n x, y = m(meshlon, meshlat)\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\n mycmap1 = plt.cm.Blues_r(np.arange(256))\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\n my_cmap[230:282, :] = 1\n if precip == 'yes':\n my_cmap = my_cmap[::-1]\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\"newjet\", my_cmap)\n ctrs = np.linspace(colormin, colormax, 17)\n plot = m.contourf(x, y, pdata, ctrs,\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\n extend='both')\n\n plt.title(title, y=1)\n plt.show()\n return plot\n\n ax1 = fig.add_subplot(3, 3, 1)\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\n ax2 = fig.add_subplot(3, 3, 2)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\n ax3 = fig.add_subplot(3, 3, 3)\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\n ax4 = fig.add_subplot(3, 3, 4)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\n ax5 = fig.add_subplot(3, 3, 5)\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\n ax6 = fig.add_subplot(3, 3, 6)\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\n ax7 = fig.add_subplot(3, 3, 7)\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\n ax8 = fig.add_subplot(3, 3, 9)\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\n ax9 = fig.add_subplot(3, 3, 8)\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\n\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\n orientation='horizontal', extend='max')\n \n b.set_label(label='t200 difference ($^\\circ$C)', size=20, fontsize=20, fontname='Arial')\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\n right=.95)","def plotCurrentTimeAnticipatory(s, ne,nc, gs):\n fig, ax = plt.subplots()\n ax.set_title('time: {0}'.format(s.time))\n for c in range(nc):\n carTemp = s.cars.getObject(c)\n ax.scatter(carTemp.position[0], carTemp.position[1], c='k', alpha=0.5)\n ax.scatter([], [], c='b', marker='*', label='Opened not commited')\n ax.scatter([], [], c='b', label='Opened commited')\n ax.scatter([], [], c='r', label='Canceled')\n ax.scatter([], [], c='g', label='Closed')\n for i in range(ne):\n eventTemp = s.events.getObject(i)\n if eventTemp.status == Status.OPENED_COMMITED:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', alpha=0.7)\n elif eventTemp.status == Status.OPENED_NOT_COMMITED:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', marker='*', alpha=0.7)\n elif (eventTemp.status == Status.CLOSED):\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='g', alpha=0.2)\n elif (eventTemp.status == Status.CANCELED):\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='r', alpha=0.2)\n else:\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='y', alpha=0.2)\n ax.set_xlim([-1, gs + 1])\n ax.set_ylim([-1, gs + 1])\n ax.grid(True)\n plt.legend()\n # Used to return the plot as an image rray\n fig.canvas.draw() # draw the canvas, cache the renderer\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\n image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n return image","def plot_all(self, highlight_desert=False, highlight_steppe=False,\n area=None, highlight=None):\n if area is None:\n area = Rectangle.entire_map(self.world)\n for era in self.date_ranges:\n self.plot(era, highlight_desert, highlight_steppe, area, highlight)","def draw_map(fig, ax, coll, bgcolor=\"white\", lims=40):\r\n ax.set_axis_bgcolor(bgcolor)\r\n ax.set_aspect(\"equal\")\r\n ax.add_collection(coll)\r\n ax.minorticks_on()\r\n ax.set_xlim([lims, -lims])\r\n ax.set_ylim([-lims, lims])\r\n return","def plot_map(self,map_options=None) :\n\n if map_options is not None :\n self.map_options.update(map_options)\n\n # TODO: Add custom sizing and resolution specifications\n fig = plt.figure(figsize=(self.map_options['img_size'][0]/2.54,\n self.map_options['img_size'][1]/2.54))\n\n # TODO: Accept custom projections\n proj = ccrs.Mercator()\n\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\n ax = fig.add_subplot(1,1,1,projection = proj)\n\n # TODO: Increase flexibility of borders consideration\n if self.map_options['brdr_nation'] :\n ax.add_feature(cfeat.BORDERS)\n\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\n extents=[self.lon[0],self.lon[-1],self.lat[0],self.lat[-1]]\n ax.set_extent(extents)\n\n # Confusingly, this code correctly translate the lat/lon limits into the projected coordinates\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\n extents_proj = extents_proj[:,:2].flatten(order='F')\n\n # TODO: Custom colormaps, interpolation, cropping\n im = ax.imshow(self.map,extent=extents_proj,transform=proj,origin='lower',\n cmap=self.map_options['cmap'],interpolation='bicubic')\n\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\n if self.map_options['title'] is not None :\n ax.set_title(self.map_options['title'])\n\n # TODO: Add support for horizontal\n if self.map_options['cbar'] :\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\n cb.ax.set_xlabel(self.units)\n\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\n if self.map_options['save'] :\n # Generate timestamp filename if relying on default\n if self.map_options['img_filename'] == \"timestamp\" :\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\n\n plt.savefig(self.map_options['img_dir']+img_filename+\".\"+self.map_options['img_filetype'],\n bbox_inches=\"tight\",dpi=self.map_options['img_dpi'])\n\n plt.show()\n\n return self","def draw_map(data, title, output):\n import cartopy.crs as ccrs\n\n coords = get_lat_lon(data).values()\n\n lat = [coord[0] for coord in coords]\n lon = [coord[1] for coord in coords]\n\n ax = plt.axes(projection=ccrs.PlateCarree())\n ax.stock_img()\n ax.coastlines()\n ax.scatter(lon, lat, marker='o', s=50, alpha=0.8)\n ax.set_extent([-75, -20, -35, 5], crs=ccrs.PlateCarree())\n ax.set_title(title)\n plt.savefig(output)","def plotGlobal(metric):\n #set plotting details for each metric\n if metric == 'corr':\n dat = starter()[0]\n varToPlot = 'Correlation'\n title = 'Pearson\\'s Correlation - 1980-2010'\n bubbleSizeMultiplier = 200\n elif metric == 'nse':\n dat = starter()[2]\n# <<<<<<< HEAD\n# varToPlot = 'NSE(%)'\n# title = 'NSE(%) - 1980-2010' \n# bubbleSizeMultiplier = 3\n# =======\n varToPlot = 'NNSE'\n title = 'NNSE - 1980-2010' \n bubbleSizeMultiplier = 200\n# >>>>>>> kiko-stuff\n else:\n dat = starter()[1]\n varToPlot = 'RMSE(cm)'\n title = 'RMSE(cm) - 1980-2010'\n bubbleSizeMultiplier = 10\n\n #increase plot font size\n sns.set_context('notebook', font_scale = 1.5)\n \n plt.figure(figsize=(20, 10))\n m=Basemap(projection='cyl', lat_ts=20, llcrnrlon=-180, \n urcrnrlon=180,llcrnrlat=-90,urcrnrlat=90, resolution='c')\n x,y = m(dat['lon'].tolist(), dat['lat'].tolist())\n m.drawcoastlines()\n\n #get degree signs \n parallels = np.arange(-80,81,20.)\n meridians = np.arange(-180.,180.,40.)\n #labels = [left,right,top,bottom]\n m.drawparallels(parallels,labels=[True,True,False,False], linewidth = 0.5)\n m.drawmeridians(meridians,labels=[False,False,False,True], linewidth = 0.5)\n\n m.bluemarble(alpha = 0.8) \n \n #define markers -use same for all for now\n markers = {\"20CR\": \"o\", \"ERA-20C\": \"o\", \"ERA-Interim\":'o', \"MERRA\":'o', \"ERA-FIVE\":'o'}\n #define palette\n color_dict = dict({'20CR':'green',\n 'ERA-20C':'magenta',\n 'ERA-Interim': 'black',\n 'MERRA': 'red',\n 'ERA-FIVE':'aqua'\n })\n #define bubble sizes\n minSize = min(dat[varToPlot])*bubbleSizeMultiplier\n if minSize < 0:\n minSize = 0\n maxSize = max(dat[varToPlot])*bubbleSizeMultiplier\n \n sns.scatterplot(x = x, y = y, markers = markers, style = 'Reanalysis',\\\n size = varToPlot, sizes=(minSize, maxSize),\\\n hue = 'Reanalysis', palette = color_dict, data = dat)\n plt.legend(loc = 'lower left', ncol = 12)\n plt.title(title)\n os.chdir('G:\\\\data\\\\allReconstructions\\\\validation\\\\commonPeriodValidation\\\\plotFiles')\n saveName = 'allReanalyses'+metric+'.svg'\n plt.savefig(saveName, dpi = 400)","def oneplot(moviedict, toplotdict, figw, figh, figdpi, fontsz, border, ylabel, ylim, time, ymin, \n lw):\n print(toplotdict.keys())\n \n fontv = mpl.font_manager.FontProperties()\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \n # similar (just slightly narrower).\n fontv = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\n fontv.set_size(fontsz)\n \n fonti = mpl.font_manager.FontProperties()\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \n #similar (just slightly narrower).\n fonti = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/ariali.ttf')\n fonti.set_size(fontsz)\n \n fig1 = plt.figure(figsize=(figw, figh), dpi=figdpi, facecolor='w', edgecolor='k')\n \n #Plots data on one graph with parameters specified in the moviedict directory.\n for k, v in moviedict.iteritems():\n print(k)\n cond1, offset, color, inum = v\n xvals = toplotdict[k][0]\n data = toplotdict[k][1] + offset\n condition = cond1\n \n\n plt.plot(xvals, data, color, linewidth=0.75, label=condition)\n print(condition)\n #if k == 'mov_20110113_180524':\n #plt.text(0.5, offset+7, inum+condition, horizontalalignment='left', \n #fontproperties=fontv)\n #else:\n #plt.text(0.5, offset+9, inum+condition, horizontalalignment='left', \n #fontproperties=fontv)\n \n # Plots text labels\n \n if k == 'mov_20101130_200030':\n plt.text(0.03, offset+6, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.11, offset+6.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n if k == 'mov_20101130_201605':\n plt.text(0.03, offset+5, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.125, offset+5.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n if k == 'mov_20101213_193258':\n plt.text(0.03, offset+3, inum, horizontalalignment='left', fontproperties=fontv)\n plt.text(0.137, offset+3.5, condition, horizontalalignment='left', \n fontproperties=fonti)\n\n ax = plt.gca()\n\n ## Plots legend.\n #legend = plt.legend()\n ### Manipulates order of the legend entries.\n ##handles, labels = ax.get_legend_handles_labels()\n ##handles2 = handles[0], handles[2], handles[1], handles[3]\n ##labels2 = labels[0], labels[2], labels[1], labels[3]\n ##legend = ax.legend(handles2, labels2, bbox_to_anchor=(0, 0, 1, 1), \n ##transform=plt.gcf().transFigure)\n ### Changes legend font to fontsz.\n #ltext = legend.get_texts()\n #plt.setp(ltext, fontsize=fontsz)\n ### Removes border around the legend.\n #legend.draw_frame(False)\n \n \n #Uncomment lines below to display without top and right borders.\n if border == 'no':\n for loc, spine in ax.spines.iteritems():\n if loc in ['left','bottom']:\n pass\n elif loc in ['right','top']:\n spine.set_color('none') # don't draw spine\n else:\n raise ValueError('unknown spine location: %s'%loc)\n \n #Uncomment lines below to display ticks only where there are borders.\n ax.xaxis.set_ticks_position('bottom')\n ax.yaxis.set_ticks_position('left')\n ## Removes tick labels and ticks from yaxis.\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\n \n # Specifies axis labels and axis tick label sizes.\n plt.xlabel(XLABEL, fontproperties=fontv, labelpad=4)\n plt.ylabel(ylabel, fontproperties=fontv, labelpad=4)\n plt.xticks(fontproperties=fontv)\n plt.yticks(fontproperties=fontv)\n \n # Specifies axis limits.\n plt.axis( [0, time, ymin, ylim])\n \n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower lefthand corner of the figure.\n fig1.subplots_adjust(top=0.95)\n fig1.subplots_adjust(left=0.15)\n #fig1.subplots_adjust(right=0.95)\n fig1.subplots_adjust(bottom=0.15)","def plot_map(priors):\n sns.set_style(\"white\")\n\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\n fig = plt.figure(figsize=(10*len(priors),10))\n figs=[]\n for i in range(0,len(priors)):\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\n\n for i in range(0,len(priors)):\n vmin=np.min(priors[i].sim)\n vmax=np.max(priors[i].sim)\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\n marker='o', s=20, alpha=0.5)\n figs[i].tick_labels.set_xformat('dd.dd')\n figs[i].tick_labels.set_yformat('dd.dd')\n figs[i].add_colorbar()\n figs[i].colorbar.set_location('top')\n return figs,fig","def draw_map(gdf_wrf_all, gdf_wrf_rw, gdf_rw):\n fig = plt.figure(figsize=(6, 6))\n ax = plt.axes(projection=ccrs.PlateCarree())\n ax.coastlines(resolution='10m')\n states_provinces = cfeature.NaturalEarthFeature(\n category='cultural',\n name='admin_1_states_provinces_lines',\n scale='10m',\n facecolor='none')\n ax.add_feature(states_provinces, edgecolor='black')\n ax.add_geometries(geoms=gdf_wrf_rw.geometry, crs=ccrs.Mercator.GOOGLE,\n facecolor='#1b9e77', edgecolor='black', alpha=0.5,\n label='Redwood range')\n ax.add_geometries(geoms=gdf_wrf_all.geometry, crs=ccrs.Mercator.GOOGLE,\n facecolor='white', edgecolor='black', alpha=0.3,\n\n label='WRF cells with redwoods')\n ax.add_geometries(geoms=gdf_rw.geometry, crs=ccrs.Mercator.GOOGLE,\n facecolor='#d95f02', edgecolor='black', alpha=0.5,\n label='WRF cells with redwoods')\n bounds = gdf_wrf.total_bounds\n ax.set_extent(bounds[(0, 2, 1, 3), ], crs=ccrs.Mercator.GOOGLE)\n\n # make proxy artists for a legend\n redwoods = mpatches.Rectangle((0, 0), 1, 1, facecolor='#d95f02')\n wrf_cells = mpatches.Rectangle((0, 0), 1, 1, facecolor='white',\n edgecolor='black', alpha=0.3)\n wrf_redwoods = mpatches.Rectangle((0, 0), 1, 1, facecolor='#1b9e77',\n edgecolor='black', alpha=0.5)\n labels = ['Redwoods range',\n 'WRF grid',\n 'WRF cells with redwoods']\n plt.legend([redwoods, wrf_cells, wrf_redwoods], labels,\n loc='lower left', bbox_to_anchor=(0.025, -0.1), fancybox=True)\n\n plt.show()","def makePlot(ra, dec, date=None, name=None, figsize=(6.,6.), dpi=80, s=50, center=None, airmass=True, moon=True, des=True):\n #figsize=(10.5,8.5)\n if date is None: date = ephem.now()\n if type(date) != ephem.Date:\n date = ephem.Date(date)\n\n observatory = utils.ctio()\n observatory.date = date\n \n #fig, ax = plt.subplots(fig='ortho', figsize=FIGSIZE, dpi=DPI)\n #fig = plt.figure('ortho')\n #ax = plt.subplots(figure=fig, figsize=FIGSIZE, dpi=DPI)\n fig = plt.figure(name, figsize=figsize, dpi=dpi)\n\n ra_zenith, dec_zenith = observatory.radec_of(0, '90') # RA and Dec of zenith\n ra_zenith = np.degrees(ra_zenith)\n dec_zenith = np.degrees(dec_zenith)\n\n # Zenith position\n #lon_zen = LMC_RA; lat_zen = LMC_DEC\n lon_zen = ra_zenith; lat_zen = dec_zenith\n\n # Create the basemap\n proj_kwargs = dict(projection='ortho', celestial=True)\n if center is None:\n lon_0, lat_0 = -lon_zen, lat_zen # Center position\n else:\n lon_0, lat_0 = center[0], center[1]\n\n proj_kwargs.update(lon_0=lon_0, lat_0=lat_0)\n #print proj_kwargs\n print(proj_kwargs)\n basemap = DECamBasemap(**proj_kwargs)\n\n parallels = np.arange(-90.,120.,30.)\n basemap.drawparallels(parallels)\n meridians = np.arange(0.,420.,60.)\n basemap.drawmeridians(meridians)\n\n if des: drawDES(basemap)\n if airmass: drawAirmassContour(basemap, observatory, 2., s=s)\n if moon: drawMoon(basemap, date)\n plt.title('%s UTC'%(datestring(date)))\n \n drawTarget(basemap, ra, dec)\n\n #return fig, ax, basemap\n return fig, basemap","def draw_weather_analysis(date_obj, data, map_region, return_dict):\n\n # image dictionary\n images = collections.OrderedDict()\n return_dict[0] = None\n\n # draw 2PVU surface pressure\n image = pv.draw_pres_pv2(\n data['pres_pv2'].values, data['pres_pv2']['lon'].values, data['pres_pv2']['lat'].values,\n map_region=map_region, title_kwargs={'name':'CFSR', 'time': date_obj})\n images['2PVU_Surface_Pressure'] = image\n\n # draw 200hPa wind field\n image = dynamics.draw_wind_upper(\n data['u200'].values, data['v200'].values, \n data['u200']['lon'].values, data['u200']['lat'].values,\n gh=data['gh200'].values, map_region=map_region, \n title_kwargs={'name':'CFSR', 'head': \"200hPa Wind | GH\", 'time': date_obj})\n images['200hPa_Wind'] = image\n\n # draw 500hPa height and temperature\n image = dynamics.draw_height_temp(\n data['gh500'].values, data['t500'].values, \n data['gh500']['lon'].values, data['gh500']['lat'].values, map_region=map_region, \n title_kwargs={'name':'CFSR', 'head': \"500hPa GH | T\", 'time': date_obj})\n images['500hPa_Height'] = image\n\n # draw 500hPa vorticity\n image = dynamics.draw_vort_high(\n data['u500'].values, data['v500'].values, \n data['u500']['lon'].values, data['u500']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"500hPa Wind | Vorticity | GH\", 'time': date_obj})\n images['500hPa_Vorticity'] = image\n\n # draw 700hPa vertical velocity\n image = dynamics.draw_vvel_high(\n data['u700'].values, data['v700'].values, data['w700'].values, \n data['w700']['lon'].values, data['w700']['lat'].values,\n gh=data['gh700'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"700hPa Vertical Velocity | Wind | GH\", 'time': date_obj})\n images['700hPa_Vertical_Velocity'] = image\n\n # draw 700hPa wind field\n image = dynamics.draw_wind_high(\n data['u700'].values, data['v700'].values, \n data['u700']['lon'].values, data['u700']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"700hPa Wind | 500hPa GH\", 'time': date_obj})\n images['700hPa_Wind'] = image\n\n # draw 700hPa temperature field\n image = thermal.draw_temp_high(\n data['t700'].values, data['t700']['lon'].values, data['t700']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"700hPa T | 500hPa GH\", 'time': date_obj})\n images['700hPa_Temperature'] = image\n\n # draw 700hPa relative humidity\n rh = calc.relative_humidity_from_specific_humidity(700 * units.hPa, data['t700'], data['q700']) * 100\n image = moisture.draw_rh_high(\n data['u700'].values, data['v700'].values, rh.values,\n data['u700']['lon'].values, data['u700']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"700hPa RH | Wind | 500hPa GH\", 'time': date_obj})\n images['700hPa_Relative_Humidity'] = image\n\n # draw 850hPa wind field\n image = dynamics.draw_wind_high(\n data['u850'].values, data['v850'].values, \n data['u850']['lon'].values, data['u850']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"850hPa Wind | 500hPa GH\", 'time': date_obj})\n images['850hPa_Wind'] = image\n\n # draw 850hPa temperature field\n image = thermal.draw_temp_high(\n data['t850'].values, data['t850']['lon'].values, data['t850']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"850hPa T | 500hPa GH\", 'time': date_obj})\n images['850hPa_Temperature'] = image\n\n # draw 850hPa relative humidity\n rh = calc.relative_humidity_from_specific_humidity(850 * units.hPa, data['t850'], data['q850']) * 100\n image = moisture.draw_rh_high(\n data['u850'].values, data['v850'].values, rh.values,\n data['u850']['lon'].values, data['u850']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"850hPa RH | Wind | 500hPa GH\", 'time': date_obj})\n images['850hPa_Relative_Humidity'] = image\n\n # draw 850hPa specific field\n image = moisture.draw_sp_high(\n data['u850'].values, data['v850'].values, data['q850'].values*1000.,\n data['q850']['lon'].values, data['q850']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"850hPa SP | Wind | 500hPa GH\", 'time': date_obj})\n images['850hPa_Specific_Humidity'] = image\n\n # draw 925hPa temperature field\n image = thermal.draw_temp_high(\n data['t925'].values, data['t925']['lon'].values, data['t925']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"925hPa T | 500hPa GH\", 'time': date_obj})\n images['925hPa_Temperature'] = image\n\n # draw 925hPa wind field\n image = dynamics.draw_wind_high(\n data['u925'].values, data['v925'].values, \n data['u925']['lon'].values, data['u925']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"925hPa Wind | 500hPa GH\", 'time': date_obj})\n images['925hPa_Wind'] = image\n\n # draw 925hPa relative humidity\n rh = calc.relative_humidity_from_specific_humidity(925 * units.hPa, data['t925'], data['q925']) * 100\n image = moisture.draw_rh_high(\n data['u925'].values, data['v925'].values, rh.values,\n data['u925']['lon'].values, data['u925']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"925hPa RH | Wind | 500hPa GH\", 'time': date_obj})\n images['925hPa_Relative_Humdity'] = image\n\n # draw 925hPa specific field\n image = moisture.draw_sp_high(\n data['u925'].values, data['v925'].values, data['q925'].values*1000.,\n data['q925']['lon'].values, data['q925']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"925hPa SP | Wind | 500hPa GH\", 'time': date_obj})\n images['925hPa_Specific_Humidity'] = image\n\n # draw precipitable water field\n image = moisture.draw_pwat(\n data['pwat'].values, data['pwat']['lon'].values, data['pwat']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"Precipitable Water | 500hPa GH\", 'time': date_obj})\n images['Precipitable_Water'] = image\n\n # draw mean sea level pressure field\n image = dynamics.draw_mslp(\n data['mslp'].values, data['mslp']['lon'].values, data['mslp']['lat'].values,\n gh=data['gh500'].values, map_region=map_region,\n title_kwargs={'name':'CFSR', 'head': \"MSLP | 500hPa GH\", 'time': date_obj})\n images['Mean_Sea_Level_Pressure'] = image\n\n return_dict[0] = images","def display_calendar(daze, month, year):\n log = daze.dateDict\n if not year:\n year = date.today().year # defaults to this year\n if month:\n first = date(year, month, 1)\n last = max([day for day in cal.itermonthdates(year, month) if day.month == month])\n s, ndates, firstdate, lastdate = daze.summarize(firstdate=first, lastdate=last)\n else:\n s, ndates, firstdate, lastdate = daze.summarize()\n places = sorted(s, key=s.get, reverse=True)\n colors = ['green', 'magenta', 'white', 'cyan', 'blue', 'red', 'yellow']\n months = calendar.month_name[1:]\n dates = [firstdate + timedelta(days=i) for i in range((lastdate - firstdate).days + 1)]\n\n matches = {p: c for (p, c) in zip(places, colors)}\n\n for (p, c) in matches.items():\n click.secho(\" %s \" % p, bg=c, fg='black', bold=True)\n\n for _date in dates:\n if _date.day == 1 or _date == firstdate:\n click.echo('')\n click.echo(\"\\n\" + months[_date.month - 1])\n if (_date.isoweekday() != 7):\n click.echo(\" \" * 3 * _date.isoweekday(), nl=False)\n if _date in log:\n p = log[_date]\n click.secho(\"%s\" % str(_date.day).rjust(3),\n fg='black',\n bg=matches[p],\n nl=(_date.isoweekday() == 6))\n else:\n click.secho(\"%s\" % str(_date.day).rjust(3),\n fg='black', nl=(_date.isoweekday() == 6))\n\n click.echo('\\n\\n\\n')","def createMap(title_in, file_in, fig_file_in, N, vmin, vmax, lon_in,\n lat_in, sss_in, colors, label='SSS [PSS]'):\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.set_title(title_in)\n plt.figtext(1, 0, file_in, ha='right', va='bottom', fontsize=6)\n\n map = Basemap(projection='moll', resolution='l', lon_0=-50, ellps='WGS84', anchor='S')\n map.drawcoastlines(linewidth=0.01, antialiased=False)\n map.drawmapboundary(fill_color='white', linewidth=0.01)\n map.drawmeridians(np.arange(-180,181,60), labels=[0,0,0,0], linewidth=0.01, labelstyle=None)\n map.drawparallels(np.arange(-90,91,30), labels=[1,0,0,0], linewidth=0.01, labelstyle=None) \n map.fillcontinents(color='grey')\n\n ticks = np.linspace(vmin, vmax, N+1)\n \n lonout, z = map.shiftdata(lon_in, sss_in, lon_0=-50)\n lon, lat = np.meshgrid(lonout, lat_in)\n x, y = map(lon, lat)\n\n cmap = cm.get_cmap(colors, N)\n cmap.set_bad('1.0')\n cmap.set_under((0.0, 0.0, 0.25, 1.0))\n cmap.set_over((0.25, 0.0, 0.0, 1.0))\n\n pc = map.pcolormesh(x, y, z, vmin=vmin, vmax=vmax, cmap=cmap)\n cb = plt.colorbar(pc, shrink=0.8, orientation='horizontal', fraction=0.04, extend ='both', ticks=ticks)\n cb.set_label(label)\n plt.savefig(fig_file_in)\n logging.debug(fig_file_in +' .... created!' )\n plt.close()\n\n return None","def three_moment0_maps(gal_indices,lines,**kwargs):\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n fig = plt.figure(figsize=(17,14),constrained_layout=False)\n gs1 = fig.add_gridspec(nrows=3, ncols=3, wspace=0.05, hspace=0.02)\n\n if not p.R_max: p.R_max = [60.]*3\n\n rotate = False\n for row_i,gal_index in enumerate(gal_indices):\n line_i = 0\n for quant in lines:\n legend = True\n label = False\n if quant == lines[-1]: label = True\n #if line_i == len(lines)-1: legend = True\n ax1 = fig.add_subplot(gs1[row_i,line_i])\n moment0_map(gal_index=gal_index,cmap=p.cmap,quant=quant,add=True,ax=ax1,R_max=p.R_max[row_i],legend=legend,label=label)\n # Make a size indicator\n ax1.set_xlim([-p.R_max[row_i],p.R_max[row_i]]); ax1.set_ylim([-p.R_max[row_i],p.R_max[row_i]])\n ax1.plot([p.R_max[row_i]*(1-0.35),p.R_max[row_i]*(1-0.35)+10],[p.R_max[row_i]*(-1+0.15),p.R_max[row_i]*(-1+0.15)],lw=4,color='white')\n ax1.text(p.R_max[row_i]*(1-0.45),p.R_max[row_i]*(-1+0.25),'10 kpc',color='white',fontsize=14)\n # Remove axes ticks\n ax1.tick_params(axis='x',which='both',labelbottom=False,bottom=False,top=False)\n ax1.tick_params(axis='y',which='both',labelleft=False,bottom=False,top=False) \n line_i += 1\n ax1.text(p.R_max[row_i]*(-1+0.15),p.R_max[row_i]*(1-0.2),quant.replace('L_',''),color='white',fontsize=18)\n # s = segs\n\n gs1.update(top=0.98,bottom=0.02,left=0.02,right=0.93)\n #fig.text(0.97,0.5, 'log surface brightness density (Jy${\\cdot}$km/s / kpc$^2$)', va='center', ha='center', fontsize=22, rotation='vertical')\n plt.tight_layout()\n\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'pretty/'): os.mkdir(p.d_plot + 'pretty/')\n plt.savefig('plots/pretty/moment0_maps.png',format='png',dpi=200)","def display_map(grid):\n fig, ax = plt.subplots(figsize=(7, 7))\n\n major_ticks_x = np.arange(0, LENGTH_case + 1, 5)\n minor_ticks_x = np.arange(0, LENGTH_case + 1, 1)\n major_ticks_y = np.arange(0, WIDTH_case + 1, 5)\n minor_ticks_y = np.arange(0, WIDTH_case + 1, 1)\n ax.set_xticks(major_ticks_x)\n ax.set_xticks(minor_ticks_x, minor=True)\n ax.set_yticks(major_ticks_y)\n ax.set_yticks(minor_ticks_y, minor=True)\n ax.grid(which='minor', alpha=0.2)\n ax.grid(which='major', alpha=0.5)\n ax.set_ylim([0, WIDTH_case])\n ax.set_xlim([0, LENGTH_case])\n ax.grid(True)\n\n # Select the colors with which to display obstacles and free cells\n cmap = colors.ListedColormap(['white', 'red'])\n\n # Displaying the map\n ax.imshow(grid, cmap=cmap)\n plt.title(\"Map : free cells in white, occupied cells in red\");\n\n return fig, ax","def _bokeh_visualization(\n calendar: \"Calendar\",\n n_years: int,\n relative_dates: bool,\n add_yticklabels: bool = True,\n **kwargs,\n) -> plotting.figure:\n if add_yticklabels:\n tooltips = [\n (\"Interval\", \"@desc\"),\n (\"Size\", \"@width_days days\"),\n (\"Type\", \"@type\"),\n ]\n else:\n # Do not show the actual intervals, as the calendar is not mapped.\n tooltips = [(\"Size\", \"@width_days days\"), (\"Type\", \"@type\")]\n\n if \"width\" not in kwargs:\n kwargs[\"width\"] = 500\n if \"height\" not in kwargs:\n kwargs[\"height\"] = 300\n if \"tooltips\" not in kwargs:\n kwargs[\"tooltips\"] = tooltips\n if \"x_axis_type\" not in kwargs:\n kwargs[\"x_axis_type\"] = \"linear\" if relative_dates else \"datetime\"\n\n figure = plotting.figure(\n **kwargs,\n )\n\n intervals = calendar.get_intervals()[:n_years]\n\n for year, year_intervals in intervals.iterrows():\n data = generate_plot_data(\n calendar=calendar,\n relative_dates=relative_dates,\n year=year,\n year_intervals=year_intervals,\n )\n _generate_rectangle(figure, plotting.ColumnDataSource(data))\n\n figure.xaxis.axis_label = (\n \"Days relative to anchor date\" if relative_dates else \"Date\"\n )\n figure.yaxis.axis_label = \"Anchor year\"\n\n if relative_dates:\n figure.x_range.start = ( # type: ignore\n np.min(data[\"x\"]) - data[\"width\"][np.argmin(data[\"x\"])] / 2 - 14\n )\n figure.x_range.end = ( # type: ignore\n np.max(data[\"x\"]) + data[\"width\"][np.argmax(data[\"x\"])] / 2 + 14\n )\n\n if add_yticklabels:\n figure.yaxis.ticker = [int(x) for x in intervals.index.to_list()]\n else:\n figure.yaxis.ticker = []\n\n return figure","def plot_current_map(inputs):\n # plot it each epoch\n mp = construct_map_with_sliders(inputs, extvar=extvar)\n # to make it clearer, add the start pos\n npa = np.concatenate([[np.concatenate(\n [extvar[\"start_pos\"] / np.array([512, 384]), [0, 0]])], tf.stack(mp).numpy().squeeze()])\n fig, ax = plt.subplots()\n x, y = np.transpose(npa)[0:2]\n #x, y = np.random.rand(2, 20)\n line = MyLine(x, y, mfc='red', ms=12)\n line.text.set_color('red')\n line.text.set_fontsize(16)\n ax.add_line(line)\n plt.show()","def mapa(player):\n mapita = pd.read_csv(\"./data/database_shots.csv\")\n mapita[\"coord_x\"] = pd.to_numeric(mapita[\"coord_x\"], downcast=\"float\")\n mapita[\"coord_y\"] = pd.to_numeric(mapita[\"coord_y\"], downcast=\"float\")\n mapita[\"coord_y\"] = mapita[\"coord_y\"] * (-1)\n listita = mapita[mapita[\"name\"] == player]\n listita_1 = pd.DataFrame(listita, columns = ['name', \"shot\", 'coord_x','coord_y'])\n listita_1.shot = listita_1.shot.apply(lambda x: 'in' if 'in' in x else x)\n listita_1.shot = listita_1.shot.apply(lambda x: 'in' if 'dunk' in x else x)\n listita_1.shot = listita_1.shot.apply(lambda x: 'out' if 'out' in x else x)\n plt.figure(figsize=(18,20))\n pl.draw_court(outer_lines=True)\n plt.axis('off')\n plt.xlim(0,260)\n plt.ylim(-283,0)\n markers = {\"#local-in\": \"s\", \"#local-out\": \"x\"}\n sns.scatterplot(data = listita_1, x = \"coord_x\", y = \"coord_y\", s = 300, hue = \"shot\", style = \"shot\")\n plt.legend(loc = 4,bbox_to_anchor=(0.95,0.05), fontsize=6, title='Shots attempted',title_fontsize=8, mode = \"expand\")\n plt.savefig(\"./images/map.png\",dpi = 600)","def plot(self,ax=None,return_ax=False,cartopy_proj=None,prop={},map_prop={}):\n \n #Create instance of plot object\n self.plot_obj = TrackPlot()\n \n if self.basin in ['east_pacific','west_pacific','south_pacific','australia','all']:\n self.plot_obj.create_cartopy(proj='PlateCarree',central_longitude=180.0)\n else:\n self.plot_obj.create_cartopy(proj='PlateCarree',central_longitude=0.0)\n \n \n #Plot storm\n return_ax = self.plot_obj.plot_season(self,ax=ax,return_ax=return_ax,prop=prop,map_prop=map_prop)\n \n #Return axis\n if ax != None or return_ax == True: return return_ax","def VisualizeSunTrackingAngles(SunTrackingData, rotation_axis):\n \n dx, dy = 1, 1\n \n # generate 2 2d grids for the x & y bounds\n y, x = np.mgrid[slice(0, 24 + dy, dy),\n slice(0, 12 + dx, dx)]\n\n z = np.empty((24,12))*np.nan\n \n if rotation_axis == 'x':\n for i in range(len(SunTrackingData['HOY'])):\n z[SunTrackingData['HoursInMonthTracking'][i],SunTrackingData['MonthTracking'][i]-1]= SunTrackingData['Xangles'][i]\n z_min = 0\n z_max = 90\n elif rotation_axis == 'y':\n for i in range(len(SunTrackingData['HOY'])):\n z[SunTrackingData['HoursInMonthTracking'][i],SunTrackingData['MonthTracking'][i]-1]= SunTrackingData['Yangles'][i] \n z_min = -45\n z_max = 45\n else:\n print 'axis not available'\n \n z_mask = np.isnan(z)\n masked_array = np.ma.array(z, mask=z_mask)\n cmap = plt.cm.cubehelix\n cmap = plt.cm.RdBu\n cmap.set_bad('grey',1.)\n\n \n #plt.pcolor(x, y, z, cmap='jet', vmin=z_min, vmax=z_max)\n plt.pcolormesh(x, y, masked_array, cmap=cmap, vmin=z_min, vmax=z_max)\n\n # set the limits of the plot to the limits of the data\n plt.axis([x.min(), x.max(), 3, 22])\n plt.colorbar()\n plt.tick_params(axis=u'both',labelsize=14)","def plot(self):\n\n self.map.plot(ax=self.ax,\n color='white',\n edgecolor='gray')\n\n plt.axis('off')","def __init__(self, event_dict=None):\n self.X = None\n self.y = None\n self.event_dict = event_dict\n\n defualt_events = {\n \"Pride Parade\": [\n \"6/30/2019\",\n \"6/24/2018\",\n \"6/25/2017\",\n \"6/26/2016\",\n \"6/28/2015\",\n \"6/29/2014\",\n \"6/30/2013\",\n \"6/24/2012\",\n \"6/26/2011\",\n \"6/27/2010\",\n ],\n \"Seafair\": [\n \"8/2/2019\",\n \"8/3/2019\",\n \"8/4/2019\",\n \"8/3/2018\",\n \"8/4/2018\",\n \"8/5/2018\",\n \"8/4/2017\",\n \"8/5/2017\",\n \"8/6/2017\",\n \"8/5/2016\",\n \"8/6/2016\",\n \"8/7/2016\",\n \"7/31/2015\",\n \"8/1/2015\",\n \"8/2/2015\",\n \"8/1/2014\",\n \"8/2/2014\",\n \"8/3/2014\",\n \"8/2/2013\",\n \"8/3/2013\",\n \"8/4/2013\",\n \"8/3/2012\",\n \"8/4/2012\",\n \"8/5/2012\",\n \"8/5/2011\",\n \"8/6/2011\",\n \"8/7/2011\",\n \"8/6/2010\",\n \"8/7/2010\",\n \"8/8/2010\",\n ],\n \"Soltice Parade\": [\n \"6/30/2019\",\n \"6/16/2018\",\n \"6/17/2017\",\n \"6/18/2016\",\n \"6/20/2015\",\n \"6/21/2014\",\n \"6/22/2013\",\n \"6/16/2012\",\n \"6/18/2011\",\n \"6/19/2010\",\n ],\n \"Womens March\": [\"1/19/2019\", \"1/20/2018\", \"1/21/2017\"],\n }\n\n if self.event_dict == None:\n self.event_dict = defualt_events","def plot_2018_board():\n top_left_corner_border = plt.Polygon([[0,823], [91,823], [0,747]], fill='k', edgecolor='k')\n bottom_left_corner_border = plt.Polygon([[0,0], [0,76], [91,0]], fill='k', edgecolor='k')\n plt.gca().add_line(top_left_corner_border)\n plt.gca().add_line(bottom_left_corner_border)\n\n # Auto Line\n auto_line = plt.Line2D((305, 305), (0, 823), lw=2.5)\n plt.gca().add_line(auto_line)\n\n # Exchange Zone\n exchange_zone = plt.Rectangle((0, 442), 91, 122, fc='r')\n plt.gca().add_patch(exchange_zone)\n\n # Power Cube Zone\n power_cube_zone = plt.Rectangle((249, 354), 107, 114, fc='r')\n plt.gca().add_patch(power_cube_zone)\n\n # Switch Zone\n switch_zone = plt.Rectangle((356, 216), 142, 390, fc='grey')\n plt.gca().add_patch(switch_zone)\n\n # Power Cubes next to Switch Zone\n for i in range(0,6,1):\n cube = plt.Rectangle((498, 216+i*(33+38.4)), 33, 33, fc='yellow')\n plt.gca().add_patch(cube)\n\n # Null territory\n null_territory_top = plt.Polygon([[731.5, 581], [731.5, 823], [823, 823], [823, 581]], fill=None, edgecolor='k')\n null_territory_bottom = plt.Polygon([[731.5, 0], [731.5, 242], [823, 242], [823, 0]], fill=None, edgecolor='k')\n plt.gca().add_line(null_territory_top)\n plt.gca().add_line(null_territory_bottom)\n\n # Scale\n scale = plt.Rectangle((653.5, 242), 823-653.5, 581-242, fc='black')\n plt.gca().add_patch(scale)","def __plot( dict1, title):\n plt.title(title)\n plt.xlabel(\"Run Time (microsecondsS)\")\n plt.ylabel(\"Number of Items Retreived\")\n plt.ylim(0, max(dict1.values()))\n plt.xlim(min(dict1.keys()), max(dict1.keys()) )\n x1, y1 = zip(*dict1.items())\n\n plt.scatter(x1, y1)\n plt.show()","def visualize_days():\n\n # grab our parsed data that we parsed earlier\n data_file = parse(MY_FILE, \",\")\n\n counter = Counter(item['DayOfWeek'] for item in data_file)\n\n data_list = [\n counter['Monday'],\n counter['Tuesday'],\n counter['Wednesday'],\n counter['Thursday'],\n counter['Friday'],\n counter['Saturday'],\n counter['Sunday']\n ]\n\n day_tuple = tuple(['Mon','Tues','Wed','Thurs','Fri','Sat','Sun'])\n\n plt.plot(data_list)\n\n # num of ticks needed for our x-axis & assign labels\n plt.xticks(range(len(day_tuple)),day_tuple)\n \n plt.savefig(\"Days.png\")\n plt.clf()","def plot(self, view='section', **kwargs):\n if view=='section':\n ax = self.data.plot('d','z',**kwargs)\n elif view=='map':\n ax = self.location.plot('x','y',**kwargs)\n else:\n logger.warning('{0} is not a valid view option'.format(view))\n ax=None\n return ax","def generate_line_plot():\n df = pd.read_csv(\"/Users/maxwell/Documents/workspace/CoronaScan/results.csv\",\n names=[i for i in subreddits])\n\n dates = df.loc['2020-04-28']","def plot_heatmap(self, blur=False, area=None, highlight=None):\n if area is None:\n area = Rectangle.entire_map(self.world)\n xmin, xmax, ymin, ymax = area.bounds()\n\n for era in self.date_ranges:\n fig, ax, colour_map = _init_world_plot()\n\n plot_data = self.data[era][xmin:xmax, ymin:ymax]\n\n if blur:\n plot_data = ndimage.gaussian_filter(plot_data, sigma=blur)\n # Normalise\n vmax = np.max(plot_data)\n plot_data = plot_data/vmax\n\n # Create rgb data\n plot_data = colour_map(plot_data)\n plot_data = _colour_special_tiles(plot_data, self.world, area=area)\n if highlight:\n plot_data = _highlight(plot_data, area, highlight)\n\n im = ax.imshow(np.rot90(plot_data), cmap=colour_map, vmax=vmax,\n vmin=0)\n fig.colorbar(im)\n fig.savefig('{}_{}.pdf'.format(self._prefix, era))","def plot_all_dates_by_ar(ipcc_counts_dates, meta, cmap):\r\n ipcc_counts_dates = rp_da.scale_counts(ipcc_counts_dates.copy())\r\n # prep for plotting\r\n counts_meta = rp_da.merge_counts_meta(ipcc_counts_dates, meta)\r\n dates = list({str(year):0 for year in range(2000,2105,10)}.keys())\r\n # Plot the seperate temps\r\n means = counts_meta.groupby(\"AR\").mean().iloc[:,3:]\r\n ax = means.plot(kind=\"bar\", stacked=True, cmap=cmap) \r\n handles, labels = ax.get_legend_handles_labels()\r\n ax.legend(handles[::-1], labels[::-1],loc='upper right', bbox_to_anchor=(1.12, 0.962),labelspacing=1.4, frameon=False)\r\n # Make pretty\r\n ax.set_ylabel(\"% Mentions\")\r\n plot_nicer(ax)\r\n fig = plt.gcf()\r\n fig.set_size_inches(8,8)\r\n fig.tight_layout()\r\n plt.savefig(\"Figures\"+ os.sep + \"Supplementary\" + os.sep + \"AR_all_dates_grouped.png\", dpi=200)\r\n plt.close()","def plot_days_at_sea(days_at_sea_series):\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n\n ax.set_position(default_timeseries_position) \n\n days_at_sea_series.plot(ax=ax)\n ax.set_ylabel('Days at Sea')\n\n content = io.BytesIO()\n plt.savefig(content, format='png')\n content.seek(0)\n image_cache['days_at_sea']['days_at_sea'] = content\n\n plt.close()","def plot_map(fig=None,\n coast='110m',\n figsize=(10, 10),\n bounds=None,\n cp=None,\n grid_linewidth=1,\n **kwargs,\n ):\n crs = ccrs.PlateCarree()\n #\n if fig is None:\n fig = plt.figure(figsize=figsize)\n else:\n fig.clf()\n\n if bounds is None:\n if cp is not None:\n bounds = cp.bounds\n else:\n bounds = _bounds_default\n\n ax = fig.add_subplot(111, projection=crs)\n ax.set_extent(bounds, crs=crs)\n gl = ax.gridlines(crs=crs,\n draw_labels=True,\n linewidth=grid_linewidth,\n color='k',\n alpha=0.5, linestyle='--',\n )\n gl.xlabels_top = False\n #\n if coast in ['10m', '50m', '110m']:\n ax.coastlines(resolution=coast, color='k')\n elif coast in ['auto', 'coarse', 'low', 'intermediate', 'high', 'full']:\n shpfile = shapereader.gshhs('h')\n shp = shapereader.Reader(shpfile)\n ax.add_geometries(\n shp.geometries(), crs, edgecolor='black', facecolor='none')\n elif coast=='med':\n # conda install -c conda-forge gdal\n # ogr2ogr -f \"ESRI Shapefile\" med_coast.shp /Users/aponte/.local/share/cartopy/shapefiles/gshhs/h/GSHHS_h_L1.shp -clipsrc 5 42. 7 44.\n shp = shapereader.Reader(os.getenv('HOME')+'/data/OSM/med/med_coast.shp')\n for record, geometry in zip(shp.records(), shp.geometries()):\n ax.add_geometries([geometry], crs, facecolor='None', edgecolor='black')\n elif coast=='med_high':\n # conda install -c conda-forge gdal\n # ogr2ogr -f \"ESRI Shapefile\" med_high_coast.shp ../coastlines/lines.shp -clipsrc 6 7 42.5 43.5\n shp = shapereader.Reader(os.getenv('HOME')+'/data/OSM/med/med_high_coast.shp')\n for record, geometry in zip(shp.records(), shp.geometries()):\n ax.add_geometries([geometry], crs, facecolor='None', edgecolor='black')\n\n return [fig, ax, crs]","def basic_map(proj):\n fig = plt.figure(figsize=(15, 10))\n add_metpy_logo(fig, 0, 80, size='large')\n view = fig.add_axes([0, 0, 1, 1], projection=proj)\n view.set_extent([-120, -70, 20, 50])\n view.add_feature(cfeature.STATES.with_scale('50m'))\n view.add_feature(cfeature.OCEAN)\n view.add_feature(cfeature.COASTLINE)\n view.add_feature(cfeature.BORDERS, linestyle=':')\n return fig, view","def station_map(data, station_counter):\n r = 6373.0\n\n phi = np.cos(55.943894)\n\n stations = list(set(data['start_station_name'].tolist() + data['end_station_name'].tolist()))\n dict = {name: () for name in stations}\n for index, row in data.iterrows():\n dict[row['start_station_name']] = (row['start_station_latitude'], row['start_station_longitude'])\n dict[row['end_station_name']] = (row['end_station_latitude'], row['end_station_longitude'])\n # number of stations\n n = len(dict.keys())\n\n # Convert to XY coordinates\n dict_xy = {ids: (station_counter[ids], (r * dict[ids][1] * phi, r * dict[ids][0])) for ids in dict.keys()}\n\n journeys, loc = zip(*list(dict_xy.values()))\n x, y = zip(*list(loc))\n journeys = [i for i in journeys]\n\n fig, ax = plt.subplots(figsize=(13, 8))\n plt.scatter(x, y, s=journeys)\n\n for ii in dict_xy.keys():\n ax.annotate(ii, dict_xy[ii][1], dict_xy[ii][1])\n\n plt.show()","def plot_vals(df, colors, events):\n #to do: take df.Datum.loc[0] und df.Datum.loc[-1], datetime.strftime() back to str, set as start&end\n fig, ax = plt.subplots(figsize=(16,5))\n ax.axis([0, 1440, 0, 5])\n start, end = ax.get_xlim()\n formatter = FuncFormatter(my_ticks)\n plt.xticks(rotation=70)\n ax.xaxis.set_major_locator(ticker.MultipleLocator(60.00))\n ax.xaxis.set_major_formatter(formatter)\n plt.yticks((1,2,3,4), events)\n ax.set_title(\"Jakobs Tag\") # to do: add dates (siehe oben)\n for ind, ev in enumerate(events):\n (xs,ys,dotsizes) = create_scatter_vals(df, ev, (ind+1))\n plt.scatter(xs, ys, s=dotsizes, marker=\"o\", alpha=0.5, color=colors[ind])\n plt.savefig(\"test1.pdf\")\n return fig,ax","def filter_plot(mode, country, continent, start_date, end_date, options):\n # Default is World mode\n chart_data = world_daywise_df\n map_data = countries_daywise_df\n print(country, continent)\n if mode == SelectionMode.Continents.value:\n #Continents mode\n if not isinstance(continent, list):\n continent = [continent]\n\n chart_data = continents_daywise_df[continents_daywise_df['WHO Region'].isin(continent)]\n map_data = map_data[map_data['WHO Region'].isin(continent)]\n elif mode == SelectionMode.Countries.value:\n # Countries mode\n if not isinstance(country, list):\n country = [country]\n\n chart_data = countries_daywise_df[countries_daywise_df['Country/Region'].isin(country)]\n map_data = chart_data\n\n chart_data = chart_data.query('Date >= @start_date & Date <= @end_date')\n map_data = map_data.query('Date >= @start_date & Date <= @end_date')\n\n # fix error when groupby geometry or put it in the aggregate column\n temp = map_data.drop(['geometry', 'country_code', 'Date'], axis=1).groupby(['Country/Region']).agg(metrics).reset_index()\n map_data = join_country_code_data(temp, country_code_data)\n\n if is_perCapita(options):\n for metric in ['Confirmed', 'Deaths', 'Recovered']:\n chart_data[metric + '_per_capita'] = chart_data[metric] / chart_data['Population']\n map_data[metric + '_per_capita'] = map_data[metric] / map_data['Population']\n \n if is_perCapita(options):\n return plot(chart_data, 'Confirmed_per_capita', 'Confirmed Cases Per Capita'), \\\n plot(chart_data, 'Deaths_per_capita', 'Confirmed Deaths Per Capita'), \\\n plot(chart_data, 'Recovered_per_capita', 'Confirmed Recoveries Per Capita'), \\\n generate_map(map_data)\n\n return plot(chart_data, 'Confirmed', 'Confirmed Cases'), \\\n plot(chart_data, 'Deaths', 'Confirmed Deaths'), \\\n plot(chart_data, 'Recovered', 'Confirmed Recoveries'), \\\n generate_map(map_data)","def visualizemap(dna, map_view=\"linear\", feature_list=None, start=0, end=None,label_location=None, display_label=2, display_title=True, display_axis=True, fontsize=None, fontsize_nucl=None, \n tick_interval=\"auto\", labelcolor=\"k\", title=None, width_scale=\"auto\", height_scale=1.0, linebreak=None, seq=False, rcseq=False, diamater_scale=1.0, fig= None):\n\n if fontsize is None and map_view == \"linear\":\n fontsize = 12\n elif fontsize is None and map_view == \"circular\":\n fontsize = 10\n else:\n pass \n\n if title is None or title == \"\":\n display_titlee = False\n\n #if map_view == \"circular\":\n #feature_list.sort(key=lambda x:len(dna.printsequence(x.start, x.end)))\n \n standard_scale = 4000\n if map_view == \"circular\":\n figo, ax1, ax2= vc.visualize(dna, format=0, feature_list=feature_list, bottom=400 * diamater_scale, label_visible=display_label, fontsize=fontsize, \n title_visible=display_title, axis_visible=display_axis, tick_space=tick_interval, labelcolor=labelcolor, \n titlename=title, fig=fig)\n try:\n import patchworklib \n _patchworklib = True\n except:\n _patchworklib = False\n \n if _patchworklib == True:\n ax1 = patchworklib.cBrick(ax=ax1)\n ax2 = patchworklib.Brick(ax=ax2)\n if fig == patchworklib.Brick._figure or fig is None:\n return patchworklib.Bricks({ax1.get_label():ax1, ax2.get_label():ax2}) \n else:\n return figo\n else:\n return figo\n else:\n if feature_list is None:\n feature_list = dna.dnafeatures\n figo, ax = vl.visualize(dna, start=start, end=end, feature_list=feature_list, wrap_width=linebreak, annotation_loc=label_location, unvisible_types=[\"source\"], \n visible_types=[], enlarge_w=width_scale, enlarge_h=height_scale, fontsize=fontsize, fontsize_nucl=fontsize_nucl, with_seq=seq, with_seqr=rcseq, nucl_char=None, nucl_color_dict=None, \n label_visible=display_label, scale=\"fix\", title_visible=display_title, axis_visible=display_axis, tick_space=tick_interval, \n labelcolor=labelcolor, titlename=title, fig=fig)\n try:\n import patchworklib \n _patchworklib = True\n except:\n _patchworklib = False\n \n if _patchworklib == True:\n if fig == patchworklib.Brick._figure or fig is None:\n return ax\n else:\n return figo \n else:\n return figo","def make_map(\n shape_df,\n df,\n dates,\n adm_key,\n cols,\n output_dir,\n title_prefix=None,\n log_scale=True,\n colormap=\"Reds\",\n outline_df=None,\n):\n # Maps are joined one level down from the map-level\n # National maps color by state, state maps color by county\n join_key = \"adm2\" if adm_key == \"adm1\" else \"adm1\"\n\n # For colorbar scaling\n data_ranges = []\n\n # If log, use a different colormap and scale columns\n if log_scale:\n # formatter = LogFormatter(10, labelOnlyBase=False)\n\n # Log scale columns and save\n for col in cols:\n\n col_name = \"log_\" + col\n df = pd.concat([df, np.log10(1.0 + df[col]).rename(col_name)], axis=1)\n\n # Save min and max\n data_ranges.append([df[col_name].min(), df[col_name].max()])\n\n else:\n # formatter = ScalarFormatter()\n\n for col in cols:\n data_ranges.append([df[col].min(), df[col].max()])\n\n # Index by date\n df[\"date\"] = pd.to_datetime(df[\"date\"])\n df = df.set_index([\"date\", join_key])\n\n # Make maps for each requested data\n for date in dates:\n\n # Get data for this date and merge with shape data\n date_df = shape_df.merge(df.xs(date, level=0), on=join_key)\n\n for i, column in enumerate(cols):\n\n # Create title\n map_title = readable_col_names[column] + \" \" + str(date.date())\n\n if title_prefix is not None:\n map_title = title_prefix + \" \" + map_title\n val_range = data_ranges[i]\n\n # Determine column to plot\n if log_scale:\n column = \"log_\" + column\n\n # date_df = date_df.to_crs(epsg=2163)\n\n # Plot\n ax = date_df.plot(\n column=column,\n cmap=colormap,\n vmin=val_range[0],\n vmax=val_range[1],\n legend=True,\n legend_kwds={\n \"orientation\": \"horizontal\",\n \"shrink\": 0.8,\n \"aspect\": 50,\n \"label\": \"Log10-scaled (10 ^ x)\",\n },\n edgecolor=\"black\",\n linewidth=0.1,\n figsize=(16, 9),\n )\n\n if outline_df is not None:\n outline_df.boundary.plot(ax=ax, edgecolor=\"black\", linewidth=0.5)\n\n plt.title(map_title)\n plt.tight_layout()\n plt.axis(\"off\")\n axes = plt.gca()\n axes.set_aspect(\"equal\")\n\n # Create filename\n filename = os.path.join(output_dir, adm_key + \"_\" + map_title.replace(\" \", \"\") + \".png\")\n\n # print(filename)\n # plt.show()\n df.xs(date, level=0).to_csv(os.path.join(output_dir, adm_key + \"_\" + map_title.replace(\" \", \"\") + \".csv\"))\n plt.savefig(filename)\n plt.close()","def pcolorMonths(monthlyData, arg):\n # use maximum or minimum value:\n max_min = arg[0]\n \n # define what data should be plotted:\n X = monthlyData[arg[1]]\n \n # define rotation axis:\n rotation_axis = arg[2]\n \n # define mask:\n if arg[3]=='DIVA':\n sunMask = monthlyData['DIVAmask']\n elif arg[3]=='LB':\n sunMask = monthlyData['LBmask']\n else:\n raise ValueError('mask does not exist')\n \n # assign angles and angle_locations: \n x_angle_location = monthlyData['angles']['x_angle_location']\n y_angle_location = monthlyData['angles']['y_angle_location']\n allAngles = monthlyData['angles']['allAngles']\n \n # find index of max/min from data according to the given option:\n if max_min == 'min':\n ind=np.argmin(X,axis=0)\n elif max_min == 'max':\n ind=np.argmax(X,axis=0)\n else:\n print \"somehow max min is not working\"\n\n # define axis index list: \n axis_ind =[]\n \n # assign indices according to option:\n z_min=0\n if rotation_axis == 'x':\n for i in range(len(ind)):\n axis_ind.append(x_angle_location[ind[i]])\n z_max=max(x_angle_location)\n elif rotation_axis == 'y':\n for i in range(len(ind)):\n axis_ind.append(y_angle_location[ind[i]])\n z_max=max(y_angle_location)\n elif rotation_axis == 'xy':\n axis_ind = ind\n z_max=len(allAngles[0])-1\n else:\n print 'axis not available'\n dx, dy = 1, 1\n \n # generate 2 2d grids for the x & y bounds:\n y, x = np.mgrid[slice(0, 24 + dy, dy),\n slice(0, 12 + dx, dx)]\n \n # create array with data that will be plotted:\n z=[]\n for i in range(24):\n z.append([])\n for j in range(12):\n z[i].append(axis_ind[24*j + i])\n z = np.asarray(z)\n \n # create masked array from sunMask:\n masked_array = np.ma.array(z, mask=sunMask)\n \n # define colormap:\n# cmap = plt.cm.cubehelix\n #cmap = plt.cm.PRGn\n# cmap = plt.cm.RdBu$\n cmap = plt.cm.CMRmap\n cmap = plt.cm.gnuplot\n cmap = plt.cm.afmhot\n \n # define what happens to bad data (i.e. data outside the mask):\n cmap.set_bad('grey',1.)\n \n # create the carpet plot:\n plt.pcolormesh(x, y, masked_array, cmap=cmap, vmin=z_min, vmax=z_max, rasterized=True)\n\n # set the limits of the plot to the limits of the data\n plt.axis([x.min(), x.max(), 3, 22])\n plt.tick_params(axis=u'both',labelsize=14)","def map_plot(self, iter_no):\n \n m = self._m\n n = self._n\n plt.figure()\n label=np.zeros(m*n)\n self._trained = True\n mapped = self.map_vects(datanorm)\n mapped=tuple(map(tuple, mapped))\n c=Counter(mapped)\n \n c= sorted(c.items(), key=itemgetter(1))\n a=[m*n]\n for i in range(0,len(c)):\n x=(((c[i])[0])[0])\n y=(((c[i])[0])[1])\n z=((c[i])[1])\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \n plt.savefig('exoplanet{}.png'.format(iter_no))\n p=plt.imread('exoplanet{}.png'.format(iter_no))\n imgs.append(p)\n plt.show()\n plt.close()\n print(c)\n self._trained = False","def bokeh_visualization(\n calendar,\n n_years: int,\n relative_dates: bool,\n add_yticklabels: bool = True,\n **kwargs,\n) -> None:\n bokeh_fig = _bokeh_visualization(\n calendar, n_years, relative_dates, add_yticklabels, **kwargs\n )\n if \"pytest\" in sys.modules: # Do not open browser if we are testing.\n plotting.save(bokeh_fig)\n else:\n plotting.show(bokeh_fig)","def raster(self, event_times_list, color='k'):\n ax = plt.gca()\n for ith, trial in enumerate(event_times_list):\n plt.vlines(trial, ith + .5, ith + 1.5, color=color)\n plt.ylim(.5, len(event_times_list) + .5)\n return ax","def plot_maps(self, astrometry, gs=None, plotmaps=['broad', 'core', 'wing'], savefig=False):\n\n extent = np.array([-astrometry.par.ncrop / 2, astrometry.par.ncrop / 2,\n -astrometry.par.ncrop / 2, astrometry.par.ncrop / 2]\n )\n\n # extent *= astrometry.par.sampling * 1e3 # implement cellsize in cube!\n\n if gs == None:\n fig = plt.figure(figsize=(9, 2 + 1.5 * len(astrometry.fluxmap.__dict__)), dpi=150)\n gs = gridspec.GridSpec(3, len(plotmaps) + 1, wspace=.07, hspace=.06)\n\n # Top row: flux maps\n cmap = mpl.cm.get_cmap('gist_earth_r')\n for idx, component in enumerate(plotmaps):\n fluxmap = astrometry.basis.components[component].fluxmap\n ax = plt.subplot(gs[0, idx])\n im = ax.imshow(fluxmap / np.nanmax(fluxmap), origin='lower', cmap=cmap, # extent=extent,\n norm=LogNorm(vmin=2e-2, vmax=1))\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\n\n # annotations\n ax.annotate(component, xy=(0.9, 0.85), fontsize=14, ha='right', xycoords='axes fraction')\n ax.annotate('(' + chr(0 * len(plotmaps) + idx + 97) + ')',\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\n if idx == 0: ax.annotate(r'Data', xy=(0.9, .7), fontsize=14, ha='right', xycoords='axes fraction')\n\n # axes labels and ticks\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n ax.tick_params(axis='both', labelbottom=False)\n if idx == 0:\n ax.set_ylabel(r'$\\Delta \\, \\delta \\,[{\\rm px}]$')\n else:\n ax.tick_params(axis='both', labelleft=False)\n\n # colorbar\n if idx == len(plotmaps) - 1:\n ax = plt.subplot(gs[0, idx + 1])\n cbarlabel = r'$ \\Sigma$'\n colorbar(ax, im, label=cbarlabel)\n\n # Row 2: Model light distribution\n for idx, component in enumerate(plotmaps):\n fluxmap = astrometry.basis.components[component].fluxmap\n ax = plt.subplot(gs[1, idx])\n im = ax.imshow(fluxmap / np.nanmax(fluxmap), origin='lower', cmap=cmap, # extent=extent\n norm=LogNorm(vmin=2e-2, vmax=1))\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\n\n # annotations\n if idx == 0: ax.annotate('Model', ha='right', xy=(0.9, 0.85), fontsize=14, xycoords='axes fraction')\n ax.annotate('(' + chr(1 * len(plotmaps) + idx + 97) + ')',\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\n\n # centroid location\n # add the location of the component, which is measured in coordinates of the minicube pixels\n\n ax.scatter(astrometry.basis.components['broad'].centroid[0], # + extent[0],\n astrometry.basis.components['broad'].centroid[1], # + extent[2],\n marker='x', c='firebrick', s=40, label='AGN')\n if idx > 0:\n ax.scatter(astrometry.basis.components[component].centroid[0], # + extent[0],\n astrometry.basis.components[component].centroid[1], # + extent[2],\n marker='x', c='gold', s=40, label='centroid')\n\n # add legend\n if idx == len(plotmaps) - 1:\n legend = ax.legend(fontsize=8, bbox_to_anchor=(0.98, 0.98), loc='upper right', framealpha=.5)\n # legend.get_frame()._alpha(.4)\n\n # axes labels and ticks\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n ax.tick_params(axis='both', labelbottom=False)\n if idx == 0:\n ax.set_ylabel(r'$\\Delta \\, \\delta \\,[{\\rm px}]$')\n else:\n ax.tick_params(axis='both', labelleft=False)\n\n # colorbar\n if idx == len(plotmaps) - 1:\n ax = plt.subplot(gs[1, idx + 1])\n cbarlabel = r'$ \\Sigma$'\n colorbar(ax, im, label=cbarlabel)\n\n # Row 3: Residual maps\n cmap = mpl.cm.get_cmap('seismic')\n for idx, component in enumerate(plotmaps):\n\n # combine systematic error from PSF with statistical error from data cube noise\n # compute systematic error from the normalized map, scaled to the component flux map\n residuals = astrometry.basis.components[component].fluxmap - astrometry.basis.components[component].fluxmodel\n error = np.sqrt(astrometry.basis.components[component].errmap**2 +\n (astrometry.sysmap * astrometry.basis.components[component].fluxmap)**2\n )\n\n ax = plt.subplot(gs[2, idx])\n im = ax.imshow(residuals/error, origin='lower', cmap=cmap, vmin=-1, vmax=1) # , extent=extent)\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\n\n # annotations\n if idx == 0: ax.annotate('Residual', ha='right', xy=(0.9, 0.85), fontsize=14, xycoords='axes fraction')\n ax.annotate('(' + chr(2 * len(plotmaps) + idx + 97) + ')',\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\n\n # labels and ticks\n ax.xaxis.set_minor_locator(AutoMinorLocator())\n ax.yaxis.set_minor_locator(AutoMinorLocator())\n ax.set_xlabel(r'$\\Delta \\, \\alpha \\,[{\\rm px}]$')\n if idx == 0:\n ax.set_ylabel(r'$\\Delta \\, \\delta \\,[{\\rm px}]$')\n else:\n ax.tick_params(axis='both', labelleft=False)\n\n # colorbar\n if idx == len(plotmaps) - 1:\n ax = plt.subplot(gs[2, idx + 1])\n cbarlabel = 'residual/error'\n colorbar(ax, im, label=cbarlabel)\n\n # *** interactive plot ***\n self.boxes = np.full([astrometry.par.ncrop, astrometry.par.ncrop], mpl.lines.Line2D)\n for i in range(astrometry.par.ncrop):\n for j in range(astrometry.par.ncrop):\n # plot all boxes\n xbox = np.array([i, i, i + 1, i + 1, i]) - .5\n ybox = np.array([j, j + 1, j + 1, j, j]) - .5\n self.boxes[i, j] = self.fig.axes[3].plot(xbox, ybox, color='r', linewidth=2)[0]\n self.boxes[i, j].set_visible(False)\n\n if savefig:\n plt.savefig(astrometry.par.output_dir + '/' + astrometry.par.obj +\n '.spectroastrometry_maps.png', bbox_inches='tight')","def plot_typical_day(bdf):\n\n bdf[\"time\"] = bdf.index.time\n bdf[\"weekday\"] = bdf.index.weekday < 5\n week_profile = bdf[bdf.weekday].pivot_table(\n index=\"time\", values=\"load\", aggfunc=[\"mean\", \"max\", \"min\"]\n )\n week_profile.columns = [\"week_mean\", \"week_max\", \"week_min\"]\n weekend_profile = bdf[~bdf.weekday].pivot_table(\n index=\"time\", values=\"load\", aggfunc=[\"mean\", \"max\", \"min\"]\n )\n weekend_profile.columns = [\"weekend_mean\", \"weekend_max\", \"weekend_min\"]\n profile = week_profile.merge(weekend_profile, left_index=True, right_index=True)\n fig = profile.iplot(\n asFigure=True,\n layout=dict(\n title=\"Typisch week/weekend profiel\",\n xaxis=dict(title=\"Tijd vd dag [-]\"),\n yaxis=dict(title=\"Belasting [MW]\"),\n ),\n )\n\n # Update traces based on name\n for trace in fig.data:\n if \"week\" in trace[\"name\"]:\n trace.update(line=dict(color=\"blue\"))\n if \"weekend\" in trace[\"name\"]:\n trace.update(line=dict(color=\"green\"))\n if \"min\" in trace[\"name\"] or \"max\" in trace[\"name\"]:\n trace.update(line=dict(dash=\"dot\"))\n\n return fig","def plot(self):\n fig, ax = plt.subplots()\n ticklabels = [item.strftime('%b %d') for item in self.series.index]\n ax.xaxis.set_major_formatter(ticker.FixedFormatter(ticklabels))\n\n plt.ylabel('#Cases')\n i = 0\n for y in self.countries:\n plt.plot(ticklabels, self.series[y], GRAPH_FORMATS[i], label=y)\n i += 1\n ax.set_xticklabels(ticklabels, rotation='vertical', fontsize=10)\n plt.legend()\n plt.grid()\n if self.log:\n plt.yscale(\"log\")\n plt.show()","def worldplot(data):\n \n plt.rcParams['font.size'] = 18\n world_df= geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'));\n\n world_df = world_df[world_df[\"iso_a3\"].isin(data[\"recipient_iso3\"])];\n\n #world_2df.[\"OFa_all_con\"] = np.nan;\n #world_2df.sort_values(by=\"iso_a3\").head()\n for i in world_df.index:\n for j in data.index:\n if world_df.loc[i,\"iso_a3\"] == data.loc[j,\"recipient_iso3\"]:\n world_df.loc[i,\"OFa_all_con\"] = data.loc[j, \"OFa_all_con\"];\n\n\n fig, ax = plt.subplots(1,1, figsize=(22,14))\n ax.axis('off')\n fig.suptitle('Chinese Development Finance', fontsize=25)\n \n world_df.plot(column='OFa_all_con', ax = ax, legend=True, legend_kwds={\"label\":\"\\n Chinese Development Finance in $10 bln.\",\n \"orientation\": \"horizontal\"}, \n missing_kwds={\"color\": \"lightgrey\",\n \"edgecolor\": \"red\",\n \"hatch\": \"///\",\n \"label\": \"Missing values\"});","def map_plot(iso3_codes, countries_organisations_amount,countries_list):\n d = {'ISO-3': iso3_codes, 'spending': countries_organisations_amount, 'countries': countries_list}\n df = pd.DataFrame(data=d)\n fig = px.choropleth(df,\n locations='ISO-3',\n color=\"spending\",\n scope=\"world\",\n labels={'spending': 'Amount of organisations'},\n height=500,\n hover_name=df['countries'],\n hover_data=['spending'],\n custom_data=['spending','countries']\n )\n\n fig.update_layout(\n title_text='Number of organisations lobbying in the EU',\n geo=dict(\n showframe=False,\n showcoastlines=False,\n projection_type='equirectangular'))\n fig.update_traces(hovertemplate=\"<b> %{customdata[1]} </b> : Number of organisations: %{customdata[0]}\")\n return fig","def worldplot_2(data, cc, pc):\n # define the columns of input\n # cc = data.columns[checkcol]\n #pc = data.columns[plotcol]\n \n plt.rcParams['font.size'] = 18\n # generate standart geopandas dataframe\n world_df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'));\n #check indicies of the input dataframe and modify standart geopandas df\n world_df = world_df[world_df[\"iso_a3\"].isin(data[cc])];\n\n #world_2df.[\"OFa_all_con\"] = np.nan;\n #world_2df.sort_values(by=\"iso_a3\").head()\n for i in world_df.index:\n for j in data.index:\n if world_df.loc[i,\"iso_a3\"] == data.loc[j, cc]:\n try:\n world_df.loc[i,pc] = data.loc[j, pc];\n except: \n print(\"\\nError! Invalid Input. Example for input: OFa_all_con\")\n return\n \n\n fig, ax = plt.subplots(1,1, figsize=(22,12))\n ax.axis('off')\n \n \n if pc == \"OFa_all_con\":\n fig.suptitle('Chinese Development Finance (financial amount)', fontsize=25)\n world_df.plot(column=pc, ax = ax, legend=True, cmap='jet', legend_kwds={\"label\":\"\\n Chinese Development Finance in $10 bln (2000-2014)\",\n \"orientation\": \"horizontal\"}, \n missing_kwds={\"color\": \"lightgrey\",\n \"edgecolor\": \"red\",\n \"hatch\": \"///\",\n \"label\": \"Missing values\"});\n else:\n fig.suptitle('Chinese Development Finance (probability)', fontsize=25)\n world_df.plot(column=pc, ax = ax, legend=True, cmap='jet', legend_kwds={\"label\":\"\\n Probability of receiving Chinese Development Finance (2000-2014)\",###ADDDDJUST!!!!!\n \"orientation\": \"horizontal\"}, \n missing_kwds={\"color\": \"lightgrey\",\n \"edgecolor\": \"red\",\n \"hatch\": \"///\",\n \"label\": \"Missing values\"});","def plot_pc(*args, x='date', y='pc_new_positives', days=0):\r\n # unpack args (stored in tuple) to list form\r\n a = []\r\n a.append(x)\r\n a.append(y)\r\n for arg in args:\r\n a.append(arg)\r\n # format dates\r\n if (days > 0) & (days < 32):\r\n locator = mdates.DayLocator()\r\n formatter = mdates.DateFormatter('%d')\r\n else:\r\n locator = mdates.MonthLocator()\r\n formatter = mdates.DateFormatter('%m-%d')\r\n # set up axes for subplots\r\n fig, ax = plt.subplots(figsize=(8, 8))\r\n # format dates on x-axis\r\n ax.xaxis.set_major_locator(locator)\r\n ax.xaxis.set_major_formatter(formatter)\r\n for state in args:\r\n # subset df for our plots. dropna() ensures same date range for all plots\r\n plot_data = df[df['State'] == state]\r\n # subset for number of days\r\n if days > 0:\r\n plot_data = plot_data[:days+1]\r\n # make plot\r\n ax.plot(plot_data[x], plot_data[y][plot_data['State'] == state], linestyle='-', label=state)\r\n # set titles\r\n ax.set_title(\"{} per 100,000 people\".format(y))\r\n #show legend\r\n ax.legend()","def __init__(self, gdf_map):\n\n self.fig = plt.figure(figsize=(13,13))\n self.ax = self.fig.add_subplot(1,1,1)\n self.fontsize = 18\n\n self.city_markersize = 6\n self.city_marker = 'o'\n self.city_markercolor = 'k'\n self.cmap = 'Reds'\n\n self.map = gdf_map","def heatmap_drawer(fname, month_or_year, waste_or_encamp):\r\n assert isinstance(fname, str)\r\n assert isinstance(month_or_year, str)\r\n assert isinstance(waste_or_encamp, str)\r\n assert fname[-4:] == '.csv'\r\n assert month_or_year == 'M' or month_or_year == 'Y'\r\n assert waste_or_encamp == 'W' or waste_or_encamp == 'E'\r\n \r\n data = pd.read_csv(fname)\r\n \r\n if month_or_year == 'Y':\r\n if waste_or_encamp == 'E':\r\n for i in range(2008, 2020):\r\n draw_map_y(data, i, 'Encampment Reports')\r\n elif waste_or_encamp == 'W':\r\n for i in range(2008, 2020):\r\n draw_map_y(data, i, 'Human or Animal Waste')\r\n elif month_or_year == 'M':\r\n if waste_or_encamp == 'E':\r\n for i in range(1, 10):\r\n draw_map_m(data, i, 'Encampment Reports')\r\n for i in range(10, 13):\r\n draw_map_m_2(data, i, 'Encampment Reports')\r\n elif waste_or_encamp == 'W':\r\n for i in range(1, 10):\r\n draw_map_m(data, i, 'Human or Animal Waste')\r\n for i in range(10, 13):\r\n draw_map_m_2(data, i, 'Human or Animal Waste')","def display_calendar_redo(daze, year, month):\n log = daze.dateDict\n\n # Set first and last dates\n if year is None:\n year = date.today().year\n if month is None:\n first = date(year, 1, 1)\n if year == date.today().year:\n last = date.today()\n else:\n last = date(year, 12, 31)\n else:\n first = date(year, month, 1)\n last = date(2016, month, calendar.monthrange(2016, month)[1])\n\n # Get summarized data\n s, ndates, firstdate, lastdate = daze.summarize()\n places = sorted(s, key=s.get, reverse=True)\n colors = ['green', 'magenta', 'white', 'cyan', 'blue', 'red', 'yellow']","def show_MAP_frequencies(self, figure_name):\n if not self.get('MAP_done'): return\n\n modes = self.get('modes') \n obs_freq = np.array([mode.freq for mode in modes]) # unit: per day\n d_freq = obs_freq[1:] - obs_freq[:-1]\n\n # MAP_names = self.get('feature_names')\n # MAP_features = self.get('MAP_feature')\n MAP_freq = self.get('MAP_frequencies')\n\n fig, ax = plt.subplots(1, figsize=(4,3), tight_layout=True)\n\n for k, freq in enumerate(obs_freq):\n ax.axvline(x=freq, ymin=0, ymax=1, linestyle='solid', color='r', lw=2)\n ax.axvline(x=MAP_freq[k], ymin=0, ymax=0.8, linestyle='dashed', color='k', lw=1)\n\n # Axis cosmetics\n ax.set_ylim(0, 1.2)\n ax.set_yticklabels(())\n ax.set_xlabel(r'Frequency (per day)')\n # Legend\n ax.plot([], [], linestyle='solid', lw=4, color='r', label='Observed')\n ax.plot([], [], linestyle='dashed', lw=2, color='k', label='Model')\n leg = ax.legend(loc=1)\n\n plt.savefig(figure_name)\n logger.info('show_MAP_frequencies: saved {0}'.format(figure_name))\n plt.close()","def visualize_days():\n\t\n\t#grab our parsed data that we parsed earlier\n\tdata_file = parse(MY_FILE, \",\")\n\t\n\t#make a new variable, counter, from iterating through each line of\n\t#data in the parsed data, and count how many incidents happen on each\n\t#day of the week\n\tcounter = Counter(item[\"DayOfWeek\"] for item in data_file)\n\t\n\t#separate the x-axis data (days of the week) from the counter variable\n\t#from the y-axis (number of incidents each day)\n\tdata_list = [\n\t\t\t\tcounter[\"Monday\"],\n\t\t\t\tcounter[\"Tuesday\"],\n\t\t\t\tcounter[\"Wednesday\"],\n\t\t\t\tcounter[\"Thursday\"],\n\t\t\t\tcounter[\"Friday\"],\n\t\t\t\tcounter[\"Saturday\"],\n\t\t\t\tcounter[\"Sunday\"]\n\t\t\t\t]\n\tday_tuple = tuple([\"Mon\", \"Tues\", \"Wed\", \"Thurs\", \"Fri\", \"Sat\", \"Sun\"])\n\t\n\t#with y-axis data, assign it to a matplotlib plot instance\n\tplt.plot(data_list)\n\t\n\t#create amount of ticks need for x and y axes and assign labels\n\tplt.xticks(range(len(day_tuple)), day_tuple)\n\t\n\t#save the plot\n\tplt.savefig(\"Days.png\")\n\t\n\t#close plot file\n\tplt.clf()","def plot_map(data, pixlist, nside, runconf, title, unit):\n hpmap = np.repeat(np.nan, hp.pixelfunc.nside2npix(nside))\n hpmap[pixlist] = data\n plot_lon_cen, plot_lat_cen = runconf['ra'], runconf['dec']\n if plot_lon_cen > 180:\n plot_lon_cen -= 360\n plot_bounds = (1.0 + 1.1 * runconf['radius']) * np.array([-1.0, 1.0])\n \n hp.cartview(hpmap, rot=(plot_lon_cen, plot_lat_cen, 0), \n lonra=plot_bounds, latra=plot_bounds,\n notext=True, unit=unit, title=title, \n min=min(data), max=max(data), coord='C', flip='astro')\n\n dec0 = np.round(runconf['dec'])\n dec_spacing = runconf['radius']/2.0\n decs = dec0 + np.arange(-2*runconf['radius'], 2.1*runconf['radius'], dec_spacing)\n decs_min, decs_max = min(decs), max(decs)\n\n ra0 = np.round(runconf['ra'])\n cosdelt =np.cos(np.deg2rad(dec0)) \n ra_spacing = runconf['radius']/cosdelt / 2.0\n ras = ra0 + np.arange(-2.0*runconf['radius']/cosdelt, 2.1*runconf['radius']/cosdelt, ra_spacing)\n ras_min, ras_max = min(ras), max(ras)\n #num_ras = np.ceil(1.0 * runconf['radius'] / grid_spacing / np.cos(np.deg2rad(min(decs))) )\n\n line_dec = np.linspace(decs_min, decs_max, 100)\n line_ra = np.linspace(ras_min, ras_max, 100)\n for ra in ras:\n hp.projplot(np.repeat(ra, 100), line_dec, lonlat=True, ls='dashed', color='black')\n hp.projtext(ra, dec0, r\"{ra:0.1f}$^\\circ$\".format(ra=ra), lonlat=True, clip_on=True)\n for dec in decs:\n hp.projplot(line_ra, np.repeat(dec, 100), lonlat=True, ls='dashed', color='black')\n hp.projtext(ra0, dec, r\"{dec:0.1f}$^\\circ$\".format(dec=dec), lonlat=True, clip_on=True, rotation=90)\n return","def draw_galaxies(fig, ax):\r\n table = os.path.join(tables_dir, \"misgeld_et_al_2008.tsv\")\r\n ra, dec, diam = np.loadtxt(table, usecols=(0, 1, 15), delimiter=\"|\").T\r\n ################################################\r\n # Center is set in NGC 3311 according to catalog\r\n x = canvas.arcsec2kpc(3600. * (ra - canvas.ra0))\r\n y = canvas.arcsec2kpc(3600. * (dec - canvas.dec0))\r\n #################################################\r\n ax.plot(x, y, \"og\", ms=16, markerfacecolor='none', mec=\"y\")\r\n return","def plot_dep(self,period=6.,projection='lambert',geopolygons=None, showfig=True, vmin=None, vmax=None, hillshade=False):\n\t\tif hillshade:\n\t\t\talpha = 0.5\n\t\telse:\n\t\t\talpha =1.\n\t\tm = self._get_basemap(projection=projection, geopolygons=geopolygons,hillshade=hillshade)\n\t\tgroup = self['%g_sec'%( period )]\n\t\tx, y = m(group['lonArr'].value, group['latArr'].value)\n\t\tmy_cmap = pycpt.load.gmtColormap('/work3/wang/code_bkup/ToolKit/Models/ETOPO1/ETOPO1.cpt')\n\t\tdep_Arr = group['dep_Arr'].value\n\t\tif vmin == None:\n\t\t\tvmin = np.nanmin(dep_Arr)\n\t\t\tvmin = np.floor(vmin/100.)*100.\n\t\tif vmax == None:\n\t\t\tvmax = np.nanmax(dep_Arr)\n\t\t\tvmax = np.ceil(vmax/100.)*100.\n\t\tim = m.pcolormesh(x, y, dep_Arr, cmap=my_cmap, shading='gouraud', vmin=vmin, vmax=vmax, alpha=alpha)\n\t\tcb = m.colorbar(im, \"bottom\", size=\"3%\", pad='2%', format='%d')\n\t\tcb.set_label('Topography (m)', fontsize=12, rotation=0)\n\t\tcb.set_alpha(1)\n\t\tcb.draw_all()\n\t\tax = plt.gca() # only plot the oceanic part for JdF\n\t\t# ax.set_xlim(right=x_max)\n\t\tif showfig:\n\t\t\tplt.show()\n\t\treturn","def plot_timeline_overview(logs):\n\tfig, ax = plt.subplots(figsize=(11,6))\n\tfig.autofmt_xdate()\n\tc = 0\n\tline2D_array = []\n\tplot_data_dict = {}\n\tfor l in logs:\n\t\tplot_data, _, dates, _ = l.give_plot_data()\n\t\ttmp, = ax.plot(dates, [c]*len(dates), label=l.name, picker=10, marker='.', linestyle='-', linewidth=0.05, ms=5)\n\t\tplot_data_dict[tmp.get_c()] = plot_data\n\t\tline2D_array.append(tmp)\n\t\tc += 1\n\tmyFmt = DateFormatter(\"%Y %d.%b %H:%M\")\n\tax.xaxis.set_major_formatter(myFmt)\n\tax.set_yticks(range(0,len(logs)))\n\tax.set_yticklabels([x.name for x in logs])\n\tnames = ' and '.join([x.name for x in logs])\n\tplt.title('Analysis of the files ' + names)\n\tt = 0.15+(0.1)*len(logs)\n\tplt.subplots_adjust(left=0.23, bottom=0.2, right=0.9, top=t)\n\n\tannot = ax.annotate(\"\", xy=(0,0), xytext=(0.01,0.01) ,textcoords='figure fraction', bbox=dict(boxstyle=\"round\", fc=\"cyan\"), arrowprops=dict(arrowstyle=\"->\"))\n\tannot.set_visible(False)\n\tax.set_xlabel('timestamps in UTC')\n\tax.set_ylabel('log files')\n\n\tdef update_annot(l,ind):\n\t\tplot_data = plot_data_dict[l.get_c()]\n\t\tx,y = l.get_data()\n\t\tannot.xy = (x[ind[\"ind\"][0]], y[ind[\"ind\"][0]])\n\t\ttext = plot_data[ind[\"ind\"][0]]\n\t\tannot.set_text(text)\n\t\tannot.get_bbox_patch().set_alpha(0.4)\n\n\tdef hover(event):\n\t\tvis = annot.get_visible()\n\t\tif event.inaxes == ax:\n\t\t\tfor l in line2D_array:\n\t\t\t\tcont, ind = l.contains(event)\n\t\t\t\tif cont:\n\t\t\t\t\tupdate_annot(l,ind)\n\t\t\t\t\tannot.set_visible(True)\n\t\t\t\t\tfig.canvas.draw_idle()\n\t\t\t\telse:\n\t\t\t\t\tif vis:\n\t\t\t\t\t\tannot.set_visible(False)\n\t\t\t\t\t\tfig.canvas.draw_idle()\n\n\tfig.canvas.mpl_connect(\"motion_notify_event\", hover)\n\tfig.canvas.mpl_connect('key_press_event', _quit_figure)","def test_render_world_map():\n gdpinfo = {\n \"gdpfile\": \"isp_gdp.csv\",\n \"separator\": \",\",\n \"quote\": '\"',\n \"min_year\": 1960,\n \"max_year\": 2015,\n \"country_name\": \"Country Name\",\n \"country_code\": \"Country Code\"\n }\n\n # Get pygal country code map\n pygal_countries = pygal.maps.world.COUNTRIES\n #pygal_countries = {'KEN':'Kenya', 'IDN':'Indonesia', 'IND':'India', \\\n #'USA':'United States of America'}\n\n # 1960\n #render_world_map(gdpinfo, pygal_countries, \"1960\", \"isp_gdp_world_name_1960.svg\")\n\n # 1980\n #render_world_map(gdpinfo, pygal_countries, \"1980\", \"isp_gdp_world_name_1980.svg\")\n\n # 2000\n #render_world_map(gdpinfo, pygal_countries, \"2000\", \"isp_gdp_world_name_2000.svg\")\n\n # 2010\n render_world_map(gdpinfo, pygal_countries, \"2010\", \"isp_gdp_world_name_2010.svg\")","def world_map_template():\n fig, ax = plt.subplots(figsize=(20, 10))\n ax.plot(\n laea_x(np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(-np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(-np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(-np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(-np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(-2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(-2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(0, np.linspace(-np.pi / 2, np.pi / 2)),\n laea_y(0, np.linspace(-np.pi / 2, np.pi / 2)),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.linspace(-np.pi, np.pi), 0),\n laea_y(np.linspace(-np.pi, np.pi), 0),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.linspace(-np.pi, np.pi), np.pi / 6),\n laea_y(np.linspace(-np.pi, np.pi), np.pi / 6),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.linspace(-np.pi, np.pi), -np.pi / 6),\n laea_y(np.linspace(-np.pi, np.pi), -np.pi / 6),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.linspace(-np.pi, np.pi), np.pi / 3),\n laea_y(np.linspace(-np.pi, np.pi), np.pi / 3),\n color=\"k\",\n zorder=10,\n )\n ax.plot(\n laea_x(np.linspace(-np.pi, np.pi), -np.pi / 3),\n laea_y(np.linspace(-np.pi, np.pi), -np.pi / 3),\n color=\"k\",\n zorder=10,\n )\n ax.text(0, 1.47, r\"$|0\\rangle$\", fontsize=20)\n ax.text(0, -1.53, r\"$|1\\rangle$\", fontsize=20)\n ax.text(0.05, 0.05, r\"$|+\\rangle$\", fontsize=20)\n ax.text(2.9, 0, r\"$|-\\rangle$\", fontsize=20)\n ax.text(-3.2, 0, r\"$|-\\rangle$\", fontsize=20)\n\n return fig, ax","def map_area( m ):\n \n \n m.drawcoastlines( linewidth = 1.5, linestyle = 'solid', color = [ 75./255., 75/255., 75/255. ] )\t\n # ------draw parallels----------------\n circles = np.arange( -90., 90. + 30, 30. ) #delat = 30.\n m.drawparallels( circles, labels = [ 1, 0, 0, 0 ] )\n \n # -------draw meridians---------------\n meridians = np.arange( 0., 360, 60. ) #delon = 60.\n m.drawmeridians( meridians, labels = [ 0, 0, 0, 1 ] )","def experimental_report(environment, species, time_series,path=None,events=None):\n\n\n M = len(environment)+1\n L = int(np.ceil(1 + len(time_series)/2))\n fig = plt.figure(figsize=(5*M,5*L))\n \n colormaps = [\"Greens\",\"bwr\",\"Blues\",\"Oranges\",\"RdPu\",\"Reds\"]\n for i,(k,v) in enumerate(environment):\n plt.subplot(L,M,i+1)\n plt.imshow(v,\n interpolation='None',\n cmap=colormaps[i%len(colormaps)],\n vmin=0,vmax=1,\n aspect=\"equal\")\n plt.xticks([])\n plt.yticks([])\n plt.title(k)\n plt.colorbar(orientation=\"horizontal\", fraction=0.045)\n plt.subplot(L,M,M)\n niches(species,path=path)\n\n colors = [\"blue\",\"green\",\"brown\",\"purple\",\"red\"]\n host = [host_subplot(L*100+10+2+j, axes_class=AA.Axes) for j in range(L-1)]\n\n\n for i,(k,v) in enumerate(time_series):\n #if False and i%2 != 0:\n # ax = host[int(i/2)].twinx()\n #else:\n ax = host[int(i/2)]\n ax.set_ylabel(k)\n if len(v) == 2:\n T = len(v[0])\n ax.plot(v[0],\n label=k,\n color=colors[i%len(colors)],\n linewidth=2)\n ax.fill_between(range(len(v[0])),\n v[0]-v[1], v[0]+v[1],\n alpha=0.3,\n color=colors[i%len(colors)])\n else:\n T = len(v)\n ax.plot(range(len(v)),v, color=colors[i%len(colors)], label=k)\n \n \n for h in host:\n h.set_xlim((0,T-1))\n h.legend()\n h.set_xlabel(\"Time\")\n \n h.set_ymargin(0.05)\n h.autoscale(enable=True, axis=u'both', tight=False)\n\n if events is not None:\n h.vlines(events,*h.get_ylim(),alpha=0.1)","def drawHeatMap(xdat, name=None, colors=pylab.cm.Reds, dendro=False, protColors=None, cIndex=None, km=None, \r\n nameDict={}, scale=None, saveName=None, colorBar=False, figSize=(6,6), topDendro=False, fig=None, axData=None):\r\n\r\n data = xdat['data']\r\n if nameDict is None:\r\n nameList = [i for i in xdat['fractions']]\r\n else:\r\n nameList = [nameDict[i] for i in xdat['fractions']]\r\n\r\n proteins = [i for i in xdat['proteins']]\r\n if fig is None:\r\n fig = pylab.figure(figsize=figSize)\r\n if not (name is None):\r\n fig.suptitle(name)\r\n ##Draw heatmap\r\n xOffset = 0.05\r\n if colorBar:\r\n xLess = 0.10\r\n else:\r\n xLess = 0.00\r\n if dendro:\r\n xStart = 0.375\r\n xLength = 0.55-xLess\r\n else:\r\n xStart = 0.125\r\n xLength = 0.85-xLess\r\n if (km is None) and (topDendro is False):\r\n yStart = 0.05\r\n yLength = 0.9\r\n else:\r\n yStart = 0.05\r\n yLength = 0.8\r\n figAxes = heatMapAxes(data, dims = [xStart, yStart, xLength, yLength], columns=nameList, rows=proteins, protColors=protColors, cIndex=cIndex, fig=fig, colors=colors, axData=axData)\r\n ##Draw colorbar\r\n if colorBar:\r\n fig.colorbar(figAxes)\r\n\r\n if dendro:\r\n ax2Data = fig.add_axes([xOffset, yStart, xLength-0.3, yLength])\r\n sch.dendrogram(xdat['rightDendro'], orientation='right', color_threshold=0.0)\r\n ax2Data.set_xticks([])\r\n ax2Data.set_yticks([])\r\n \r\n if topDendro:\r\n ax4Data = fig.add_axes([xStart, yStart+yLength, xLength, 0.1])\r\n sch.dendrogram(xdat['topDendro'], orientation='down', color_threshold=0.0)\r\n ax4Data.set_xticks([])\r\n ax4Data.set_yticks([])\r\n \r\n if not km is None:\r\n small = data.min()\r\n big = data.max()\r\n if math.fabs(small) > math.fabs(big):\r\n big = 0-small\r\n else:\r\n small = 0-big\r\n offset=0.0\r\n ax3Data = fig.add_axes([xStart, yLength+offset, xLength-0.1, 0.1])\r\n ax3Data.matshow(km, aspect='auto', origin='lower', cmap=colors, vmin=small, vmax=big)\r\n for i in range(len(km)):\r\n ax3Data.text(-0.75, i, 'clus'+str(i), verticalalignment=\"center\", horizontalalignment=\"right\", fontsize=10, color=cIndex(float(i)/(protColors.max()+1)))\r\n ax3Data.set_xticks([])\r\n ax3Data.set_yticks([])\r\n #fig.tight_layout()\r\n if not (saveName is None):\r\n pylab.savefig(saveName)\r\n \r\n return fig"],"string":"[\n \"def create_calmap(df, yr, s3_resource_bucket):\\n calmap_data = pd.Series(df['Miles'].values, index=df['Date'])\\n plt.figure(figsize=(15, 5))\\n plt.title(f'CALENDAR HEATMAP')\\n calmap.yearplot(calmap_data,\\n year=int(yr),\\n fillcolor='lightgrey')\\n plt.savefig(f'yr_calmap.png')\\n s3_resource_bucket.upload_file('yr_calmap.png', 'yr_calmap.png',\\n ExtraArgs={'ContentType': 'image/png'})\\n # remove local file\\n os.remove('yr_calmap.png')\",\n \"def draw_observation(data, date_obj, map_region):\\n\\n # set mapbox token\\n px.set_mapbox_access_token(CONFIG.CONFIG['MAPBOX']['token'])\\n\\n # create figures\\n map_center = {'lat':(map_region[2] + map_region[3]) * 0.5,\\n 'lon':(map_region[0] + map_region[1]) * 0.5}\\n figs = collections.OrderedDict()\\n\\n # draw precipitation\\n bins = [0.1, 10, 25, 50, 100, 250, 1200]\\n keys = ['0.1~10', '10~25', '25~50', '50~100', '100~250', '>=250']\\n cols = ['lightgreen', 'yellow', 'lightskyblue', 'blue', 'magenta','maroon']\\n cols_map = dict(zip(keys, cols))\\n data['rain'] = pd.cut(data['PRE_Time_0808'], bins=bins, labels=keys)\\n data['Rainfall'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\\\\n data['PRE_Time_0808'].astype(str)\\n data['rain_size'] = data['PRE_Time_0808'] + data['PRE_Time_0808'].mean()\\n df = data[data['rain'].notna()]\\n if df.shape[0] >= 2:\\n figs['Rainfall'] = px.scatter_mapbox(\\n df, lat=\\\"Lat\\\", lon=\\\"Lon\\\", color=\\\"rain\\\", category_orders={'rain': keys}, color_discrete_map = cols_map,\\n hover_data={'Rainfall':True, 'Lon':False, 'Lat':False, 'rain':False, 'rain_size':False},\\n mapbox_style='satellite-streets', size=\\\"rain_size\\\", center=map_center, size_max=10, zoom=4,\\n title = 'Accumulated precipitation ({})'.format(date_obj.strftime(\\\"%Y%m%d 08-08\\\")),\\n width=900, height=700)\\n\\n # draw maximum temperature\\n bins = [35, 37, 40, 60]\\n keys = ['35~37', '37~40', '>=40']\\n cols = ['rgb(255,191,187)', 'rgb(250,89,0)', 'rgb(230,0,8)']\\n cols_map = dict(zip(keys, cols))\\n data['max_temp_warning'] = pd.cut(data['TEM_Max'], bins=bins, labels=keys)\\n data['max_temp'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\\\\n data['TEM_Max'].astype(str)\\n df = data[data['max_temp_warning'].notna()]\\n if df.shape[0] >= 2:\\n figs['Max_temperature'] = px.scatter_mapbox(\\n df, lat=\\\"Lat\\\", lon=\\\"Lon\\\", color=\\\"max_temp_warning\\\", category_orders={'max_temp_warning': keys}, \\n color_discrete_map = cols_map,\\n hover_data={'max_temp':True, 'Lon':False, 'Lat':False, 'max_temp_warning':False, 'TEM_Max':False},\\n mapbox_style='satellite-streets', size=\\\"TEM_Max\\\", center=map_center, size_max=10, zoom=4,\\n title = 'Maximum temperature ({})'.format(date_obj.strftime(\\\"%Y%m%d 08-08\\\")),\\n width=900, height=700)\\n\\n # draw minimum temperature\\n bins = [-120, -40, -30, -20, -10, 0]\\n keys = ['<=-40','-40~-30', '-30~-20', '-20~-10', '-10~0']\\n cols = ['rgb(178,1,223)', 'rgb(8,7,249)', 'rgb(5,71,162)', 'rgb(5,109,250)', 'rgb(111,176,248)']\\n cols_map = dict(zip(keys, cols))\\n data['min_temp_warning'] = pd.cut(data['TEM_Min'], bins=bins, labels=keys)\\n data['min_temp'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\\\\n data['TEM_Min'].astype(str)\\n df = data[data['min_temp_warning'].notna()]\\n if df.shape[0] >= 2:\\n figs['Min_temprature'] = px.scatter_mapbox(\\n df, lat=\\\"Lat\\\", lon=\\\"Lon\\\", color=\\\"min_temp_warning\\\", category_orders={'min_temp_warning': keys}, \\n color_discrete_map = cols_map,\\n hover_data={'min_temp':True, 'Lon':False, 'Lat':False, 'min_temp_warning':False, 'TEM_Min':False},\\n mapbox_style='satellite-streets', size=-1.0*df[\\\"TEM_Min\\\"], center=map_center, size_max=10, zoom=4,\\n title = 'Minimum temperature ({})'.format(date_obj.strftime(\\\"%Y%m%d 08-08\\\")),\\n width=900, height=700)\\n\\n # draw low visibility\\n data['VIS_Min'] /= 1000.0\\n bins = [0, 0.05, 0.2, 0.5, 1]\\n keys = ['<=0.05','0.05~0.2', '0.2~0.5', '0.5~1']\\n cols = ['rgb(0,82,77)', 'rgb(0,153,160)', 'rgb(0,210,204)', 'rgb(95,255,252)']\\n cols_map = dict(zip(keys, cols))\\n data['min_vis_warning'] = pd.cut(data['VIS_Min'], bins=bins, labels=keys)\\n data['VIS_Min_size'] = 2.0-data[\\\"VIS_Min\\\"]\\n data['min_vis'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\\\\n data['VIS_Min'].astype(str)\\n df = data[data['min_vis_warning'].notna()]\\n if df.shape[0] >= 2:\\n figs['Low_visibility'] = px.scatter_mapbox(\\n df, lat=\\\"Lat\\\", lon=\\\"Lon\\\", color=\\\"min_vis_warning\\\", category_orders={'min_vis_warning': keys}, \\n color_discrete_map = cols_map,\\n hover_data={'min_vis':True, 'Lon':False, 'Lat':False, 'min_vis_warning':False, 'VIS_Min_size':False},\\n mapbox_style='satellite-streets', size=\\\"VIS_Min_size\\\", center=map_center, size_max=10, zoom=4,\\n title = 'Low visibility ({})'.format(date_obj.strftime(\\\"%Y%m%d 08-08\\\")),\\n width=900, height=700)\\n\\n # draw high wind\\n bins = [10.8, 13.9, 17.2, 20.8, 24.5, 28.5, 32.7, 37.0, 120]\\n keys = ['10.8~13.8','13.9~17.1', '17.2~20.7', '20.8~24.4', '24.5~28.4', '28.5~32.6', '32.7~36.9', '>=37.0']\\n cols = ['rgb(0,210,244)', 'rgb(0,125,255)', 'rgb(253,255,0)', 'rgb(247,213,0)',\\n 'rgb(255,141,0)', 'rgb(251,89,91)', 'rgb(255,3,0)', 'rgb(178,1,223)']\\n cols_map = dict(zip(keys, cols))\\n data['max_win_warning'] = pd.cut(data['WIN_S_Max'], bins=bins, labels=keys)\\n data['max_win'] = '['+data['Lon'].round(2).astype(str) + ',' + data['Lat'].round(2).astype(str) + ']: ' + \\\\\\n data['WIN_S_Max'].astype(str)\\n df = data[data['max_win_warning'].notna()]\\n if df.shape[0] >= 2:\\n figs['High_wind'] = px.scatter_mapbox(\\n df, lat=\\\"Lat\\\", lon=\\\"Lon\\\", color=\\\"max_win_warning\\\", category_orders={'max_win_warning': keys}, \\n color_discrete_map = cols_map,\\n hover_data={'max_win':True, 'Lon':False, 'Lat':False, 'max_win_warning':False, 'WIN_S_Max':False},\\n mapbox_style='satellite-streets', size=\\\"WIN_S_Max\\\", center=map_center, size_max=10, zoom=4,\\n title = 'Maximum wind speed ({})'.format(date_obj.strftime(\\\"%Y%m%d 08-08\\\")),\\n width=1000, height=800)\\n\\n return figs\",\n \"def plot_date(date, source, scene_map, ax, aois=(), valid_area=full_study_area,\\n show_scalebar=True, show_legend=True, show_xticks=True, show_yticks=True,\\n show_title=True, legend_font_size=10, font_size=10, continent_color=\\\"#b2b2b2\\\",\\n line_color='#AAAAAA',\\n scene_legend_offset=(130.45, 37.83),\\n detection_legend_size=6):\\n\\n if show_legend == 'minimal':\\n llcrnrlon, urcrnrlon = 129, 135\\n llcrnrlat, urcrnrlat = 36.9, 42.4\\n else:\\n llcrnrlon, urcrnrlon = 129, 135\\n llcrnrlat, urcrnrlat = 38.45, 42\\n projection = Basemap(llcrnrlon=llcrnrlon, llcrnrlat=llcrnrlat,\\n urcrnrlon=urcrnrlon, urcrnrlat=urcrnrlat, \\n lat_ts=0, projection='mill', resolution=\\\"l\\\", ax=ax)\\n \\n df = source[date]\\n valid_mask = create_valid_area_mask(df.longitude, df.latitude, valid_area)\\n aoi_mask = create_aoi_mask(df, aois)\\n scene_counts = create_scene_counts(df, scene_map)\\n aoi_pts, aoi_pairs = compute_detection_counts(df.kind, valid_mask, aoi_mask, scene_counts)\\n\\n # 1. plot all scenes that intersect the valid_area\\n scene_count = 0\\n for scene_id in scene_map:\\n if scene_id.startswith(date):\\n scene = scene_map[scene_id]\\n bounds = json.loads(scene.boundary)\\n lons = [y['lon'] for y in bounds]\\n lats = [y['lat'] for y in bounds]\\n is_valid = any(create_valid_area_mask(lons, lats, valid_area))\\n if is_valid:\\n scene_count += 1\\n lons, lats = projection(lons, lats)\\n ax.fill(lons, lats, color='#DDDDDD', alpha=0.25)[0]\\n if show_legend:\\n lons = np.array(lons)\\n lats = np.array(lats)\\n dx, dy = projection(scene_legend_offset[0], scene_legend_offset[1])\\n lons = lons - lons.mean() + dx\\n lats = lats - lats.mean() + dy\\n scene_hndl = patches.Polygon(list(zip(lons, lats)), color='#DDDDDD', alpha=0.5)\\n scene_hndl.set_clip_on(False)\\n ax.add_patch(scene_hndl)\\n\\n # 2. Plot the NK EEZ, valid region, and the map \\n lons, lats = projection(plotting_nk_eez[:, 0], \\n plotting_nk_eez[:, 1])\\n eez_hndl = ax.plot(lons, lats, '--', color=line_color, linewidth=1)[0]\\n lons, lats = projection(valid_area[:, 0], \\n valid_area[:, 1])\\n valid_hndl = ax.plot(lons, lats, '-', color=line_color, linewidth=1)[0]\\n projection.fillcontinents(color=continent_color,lake_color=continent_color, zorder=2.5)\\n\\n # 3. Plot the AOIs\\n aoi_hndl = None\\n for aoi in aois:\\n lons, lats = projection([x[0] for x in aoi], [x[1] for x in aoi])\\n aoi_hndl = ax.fill(lons, lats, color='#0000FF', alpha=0.15)[0]\\n\\n # 4. Plot the detections\\n lons, lats = projection(df[valid_mask].longitude.values, \\n df[valid_mask].latitude.values)\\n dtct_hndl = ax.plot(lons, lats, '.', markersize=2, \\n color='#bd0026', label='detection', alpha=0.125)[0]\\n \\n # 5. Title\\n title_dict = {'fontsize': font_size,}\\n datestr = \\\"{}-{}-{}\\\".format(date[:4], date[4:6], date[6:8])\\n if show_title:\\n if len(aois):\\n ax.set_title(\\\"{} ({} trawlers in AOI)\\\".format(datestr, \\n int(round(aoi_pts))), fontdict=title_dict)\\n else:\\n ax.set_title(\\\"{} (no fleet found)\\\".format(datestr), \\n fontdict=title_dict)\\n\\n # 6. Legend\\n if show_legend:\\n dummy = lines.Line2D([0],[0],color=\\\"w\\\", alpha=0)\\n if show_legend == 'minimal':\\n title = \\\"{} PlanetScope detections\\\".format(datestr)\\n handles = [dtct_hndl, dummy, aoi_hndl]\\n labels = ['Pair trawler CNN detection',\\n \\\"PlanetScope scene (1 of {})\\\".format(scene_count),\\n 'Location of pair trawler fleet',\\n ]\\n borderpad = 0.5\\n labelspacing = 0.1\\n detect_index = 0\\n else:\\n title = None\\n handles = [eez_hndl, valid_hndl, aoi_hndl, dummy, dtct_hndl]\\n labels = [ 'EEZ claimed by N. Korea', 'Study area', 'Location of pair trawler fleet', \\n \\\"PlanetScope scene\\\", 'Pair trawler CNN detection']\\n borderpad = 0\\n labelspacing = 0\\n detect_index = -1\\n\\n if len(aois) == 0:\\n index = labels.index(\\\"Location of pair trawler fleet\\\")\\n handles.pop(index)\\n labels.pop(index)\\n \\n if show_legend == 'inside':\\n loc = \\\"upper right\\\" \\n bbox_to_anchor = None\\n elif show_legend == 'minimal':\\n loc = 'lower center'\\n bbox_to_anchor = None\\n else:\\n loc = \\\"upper left\\\"\\n bbox_to_anchor = (1, 1)\\n\\n lgnd = ax.legend(handles, labels, \\n title=title,\\n loc=loc, \\n bbox_to_anchor=bbox_to_anchor, \\n frameon=False,\\n fontsize=legend_font_size, \\n borderpad=borderpad,\\n labelspacing=labelspacing,\\n framealpha=0)\\n if title:\\n lgnd._legend_box.sep = 5\\n\\n lgnd.legendHandles[detect_index]._legmarker.set_markersize(detection_legend_size)\\n\\n \\n # 7. Scalebar\\n if show_scalebar:\\n font_props = {'size': font_size,}\\n lon = 0.5 * (llcrnrlon + urcrnrlon)\\n lat = 0.5 * (llcrnrlat + urcrnrlat)\\n ([lon0, lon1], [lat0, lat1]) = projection([lon - 0.05, lon + 0.05], [lat, lat])\\n scale = (lon0 - lon1) / 0.1\\n scalebar = ScaleBar(111000 / scale * np.cos(np.radians(lat)), frameon=False, \\n fixed_value=100, fixed_units='km',\\n border_pad=0.4,\\n location=1,\\n font_properties=font_props) # 111 km / degree\\n ax.add_artist(scalebar)\\n \\n \\n # 8. Set limits and turn on/off ticks\\n ax.xaxis.set_tick_params(width=0.5, color='0.5')\\n ax.yaxis.set_tick_params(width=0.5, color='0.5')\\n [i.set_linewidth(0.5) for i in ax.spines.values()]\\n [i.set_color('0.5') for i in ax.spines.values()]\\n if show_legend == 'minimal':\\n raw_xticklocs = [130, 134]\\n raw_yticklocs = [38, 41]\\n else:\\n raw_xticklocs = [130, 132, 134]\\n raw_yticklocs = [39, 41]\\n xticklocs, _ = projection(raw_xticklocs, raw_yticklocs[:1] * len(raw_xticklocs))\\n _, yticklocs = projection(raw_xticklocs[-1:] * len(raw_yticklocs), raw_yticklocs)\\n\\n if show_xticks:\\n ax.set_xticks(xticklocs)\\n ax.set_xticklabels(['{}$\\\\\\\\degree$E'.format(x) for x in raw_xticklocs], title_dict)\\n else:\\n ax.set_xticks([])\\n if show_yticks:\\n ax.set_yticks(yticklocs)\\n ax.set_yticklabels(['{}$\\\\\\\\degree$N'.format(x) for x in raw_yticklocs], title_dict)\\n else:\\n ax.set_yticks([])\\n \\n return aoi_pts, aoi_pairs\",\n \"def maplot(pdata, colormax=1, colormin=-999, mask='no', title='', precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\\n import numpy as np\\n import matplotlib as mpl\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n if colormin == -999:\\n colormin = -colormax\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \\n plt.figure()\\n if mask == 'yes':\\n lsm = ncread('/home/bakerh/Documents/DPhil/CPDN/\\\\\\nWeather-at-Home_ancilmaker-master/lsm_n96_add.nc', 'lsm')[0, 0, :]\\n pdata = np.ma.masked_array(pdata, mask=np.logical_not(lsm))\\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\\n pdata, lon = addcyclic(pdata, lon)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\\n mycmap1 = plt.cm.Blues_r(np.arange(256))\\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\\n my_cmap[230:282, :] = 1\\n if precip == 'yes':\\n my_cmap = my_cmap[::-1]\\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\\\"newjet\\\", my_cmap)\\n ctrs = np.linspace(colormin, colormax, 17)\\n plot = m.contourf(x, y, pdata, ctrs,\\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\\n extend='both')\\n b = plt.colorbar(plot, orientation='horizontal',\\n aspect=50, shrink=0.75, spacing='proportional')\\n b.set_label(label=r'pr (mm day$^{-1}$)')\\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\\n m.drawparallels(parallels, labels=[True, True, True, True])\\n m.drawmeridians(meridians, labels=[True, True, True, True])\\n plt.title(title, y=1.08)\\n plt.show()\",\n \"def draw_map_m(data, month, data_name):\\r\\n print(str(month))\\r\\n waste = []\\r\\n for i in range(len(data)):\\r\\n d = data.iloc[i]\\r\\n if d['Date'].split('-')[1] == '0' + str(month) and d['Description'] == data_name:\\r\\n waste.append({\\r\\n 'date':d['Date'],\\r\\n 'category' : d['Category'],\\r\\n 'longitude' : d['Location'].split(' ')[1][1:],\\r\\n 'latitude' : d['Location'].split(' ')[2][:-1]\\r\\n })\\r\\n coordinates = []\\r\\n for i in waste:\\r\\n coordinates.append([i['latitude'], i['longitude']])\\r\\n \\r\\n latitude = 37.77\\r\\n longitude = -122.42\\r\\n # Create map and display it\\r\\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\\r\\n # Display the map of San Francisco\\r\\n # add incidents to map\\r\\n HeatMap(coordinates, radius = 14).add_to(san_map)\\r\\n san_map.save(str(month) + '_' + str(data_name) + '.html')\",\n \"def draw_map_y(data, year, data_name):\\r\\n print(str(year))\\r\\n waste = []\\r\\n for i in range(len(data)):\\r\\n d = data.iloc[i]\\r\\n if d['Date'].split('-')[0] == str(year) and d['Description'] == data_name:\\r\\n waste.append({\\r\\n 'date':d['Date'],\\r\\n 'category' : d['Category'],\\r\\n 'longitude' : d['Location'].split(' ')[1][1:],\\r\\n 'latitude' : d['Location'].split(' ')[2][:-1]\\r\\n })\\r\\n coordinates = []\\r\\n for i in waste:\\r\\n coordinates.append([i['latitude'], i['longitude']])\\r\\n \\r\\n latitude = 37.77\\r\\n longitude = -122.42\\r\\n # Create map and display it\\r\\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\\r\\n # Display the map of San Francisco\\r\\n # add incidents to map\\r\\n HeatMap(coordinates, radius = 14).add_to(san_map)\\r\\n san_map.save(str(year) + '_' + str(data_name) + '.html')\",\n \"def makePlot(timeStamp):\\n\\n #-------------------------------------------------------------------------\\n # Create figure and axes\\n #-------------------------------------------------------------------------\\n\\n width = 12 # inches\\n height = 8 # inches\\n fig = plt.figure(figsize=(width, height))\\n\\n # We'll use gridspec to create axes in rectangular 6-by-5 lattice\\n import matplotlib.gridspec as gridspec\\n nrows = 6\\n ncols = 5\\n Grid = gridspec.GridSpec(nrows, ncols)\\n\\n # axis for elevation time series\\n axElev = fig.add_subplot(Grid[:2, :2]) # first 2 rows, first 2 columns\\n # axis for slab\\n axSlab = fig.add_subplot(Grid[:2, 2:]) # first 2 rows, columns > 2\\n # and the transects\\n axTran1 = fig.add_subplot(Grid[2:4, :]) # rows 2,3,4, all columns\\n # rows 5,6,7, all columns, share x/y axis with previous (sets same ticks\\n # etc)\\n axTran2 = fig.add_subplot(Grid[4:6, :], sharex=axTran1, sharey=axTran1)\\n\\n # gridspec allows to tune the spacing between plots (unit is fraction of\\n # font size)\\n boundary_pad = 3.5\\n horizontal_pad = 0.2\\n vertical_pad = 1.0\\n # figure area left,bottom,right,top in normalized coordinates [0,1]\\n bounds = [0, 0, 1, 1]\\n Grid.tight_layout(\\n fig,\\n pad=boundary_pad,\\n w_pad=horizontal_pad,\\n h_pad=vertical_pad,\\n rect=bounds)\\n\\n #-------------------------------------------------------------------------\\n # Create plots\\n #-------------------------------------------------------------------------\\n\\n # for all avaiable colormaps see ( '_r' reverses the colormap )\\n # http://matplotlib.org/examples/color/colormaps_reference.html\\n colormap = plt.get_cmap('Spectral_r')\\n colormap_kine = plt.get_cmap('gist_heat')\\n\\n # slab\\n salt_clim = [0, 32]\\n ncontours = 16\\n # bouding box for slab [xmin,xmax,ymin,ymax] in model x,y coordinates\\n estuarybbox = [330000, 360000, 284500, 297500]\\n dia = slabSnapshotDC(\\n clabel='Salinity',\\n unit='psu',\\n clim=salt_clim,\\n cmap=colormap)\\n dia.setAxes(axSlab)\\n dia.addSample(slabDC, timeStamp=timeStamp, plotType='contourf',\\n bbox=estuarybbox, N=ncontours)\\n # overrides default format for colorbar floats\\n dia.showColorBar(format='%.2g')\\n #dia.addTitle('in case you want a custom title')\\n # get transect (x,y) coordinates from the transectDC\\n transectXYCoords = generateTransectFromDataContainer(transectDC_salt, 0)[4]\\n # plot transect on the map (thin black on thick white)\\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\\n color='w', linewidth=2.0)\\n dia.addTransectMarker(transectXYCoords[:, 0], transectXYCoords[:, 1],\\n color='k', linewidth=1.0)\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(\\n staX,\\n staY,\\n label=station,\\n printLabel=True,\\n marker='*')\\n # add text to plot. x,y are in normalized axis coordinates [0,1]\\n dia.ax.text(0.05, 0.98, 'custom text', fontsize=fontsize,\\n verticalalignment='top', horizontalalignment='left',\\n transform=dia.ax.transAxes)\\n\\n # elevation time series\\n # define the time range to plot\\n elevStartTime = datetime.datetime(2012, 5, 4, 0, 0)\\n elevEndTime = datetime.datetime(2012, 5, 5, 0, 15)\\n elevMeanTime = elevStartTime + (elevEndTime - elevStartTime) / 2\\n elevLim = [-1.5, 2.5]\\n dia = timeSeriesPlotDC2(\\n xlabel=elevMeanTime.strftime('%Y %b %d'),\\n ylim=elevLim)\\n dia.setAxes(axElev)\\n #dia.addShadedRange( timeStamp, timeStamp+datetime.timedelta(seconds=30), facecolor='IndianRed')\\n dia.addShadedRange(\\n timeStamp,\\n timeStamp,\\n edgecolor='IndianRed',\\n facecolor='none',\\n linewidth=2)\\n tag = elevDC.getMetaData('tag')\\n dia.addSample(\\n elevDC.timeWindow(\\n elevStartTime,\\n elevEndTime),\\n label=tag,\\n color='k')\\n dia.addTitle('Elevation ({0:s}) [m]'.format(\\n elevDC.getMetaData('location').upper()))\\n # adjust the number of ticks in x/y axis\\n dia.updateXAxis(maxticks=5)\\n dia.updateYAxis(maxticks=3, prune='lower')\\n\\n # transects\\n dia = transectSnapshotDC(\\n clabel='Salinity',\\n unit='psu',\\n cmap=colormap,\\n clim=salt_clim)\\n dia.setAxes(axTran1)\\n #transectDC_salt.data *= 1e-3\\n dia.addSample(transectDC_salt, timeStamp, N=ncontours)\\n dia.addTitle('')\\n dia.showColorBar()\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(staX, staY, label=station, color='k',\\n linewidth=1.5, linestyle='dashed')\\n # do not show x axis ticks and label for this plot\\n dia.hideXTicks()\\n\\n dia = transectSnapshotDC(clabel='TKE', unit='m2s-1', logScale=True,\\n clim=[-7, -2], climIsLog=True, cmap=colormap_kine)\\n dia.setAxes(axTran2)\\n dia.addSample(transectDC_kine, timeStamp, N=ncontours)\\n # plot station markers\\n for station in stationsToPlot:\\n staX = staFileObj.getX(station)\\n staY = staFileObj.getY(station)\\n dia.addStationMarker(staX, staY, label=station, color='k',\\n linewidth=1.5, linestyle='dashed')\\n dia.addTitle('')\\n dia.showColorBar()\\n dia.updateXAxis(maxticks=15)\\n dia.updateYAxis(maxticks=6)\\n\\n #-------------------------------------------------------------------------\\n # Save to disk\\n #-------------------------------------------------------------------------\\n dateStr = timeStamp.strftime('%Y-%m-%d_%H-%M')\\n filename = '_'.join([imgPrefix, dateStr])\\n saveFigure(\\n imgDir,\\n filename,\\n imgFiletype,\\n verbose=True,\\n dpi=200,\\n bbox_tight=True)\\n plt.close()\",\n \"def draw_map_m_2(data, month, data_name):\\r\\n print(str(month))\\r\\n waste = []\\r\\n for i in range(len(data)):\\r\\n d = data.iloc[i]\\r\\n if d['Date'].split('-')[1] == str(month) and d['Description'] == data_name:\\r\\n waste.append({\\r\\n 'date':d['Date'],\\r\\n 'category' : d['Category'],\\r\\n 'longitude' : d['Location'].split(' ')[1][1:],\\r\\n 'latitude' : d['Location'].split(' ')[2][:-1]\\r\\n })\\r\\n coordinates = []\\r\\n for i in waste:\\r\\n coordinates.append([i['latitude'], i['longitude']])\\r\\n \\r\\n latitude = 37.77\\r\\n longitude = -122.42\\r\\n # Create map and display it\\r\\n san_map = folium.Map(location=[latitude, longitude],tiles='Stamen Toner', zoom_start=13)\\r\\n # Display the map of San Francisco\\r\\n # add incidents to map\\r\\n HeatMap(coordinates, radius = 14).add_to(san_map)\\r\\n san_map.save(str(month) + '_' + str(data_name) + '.html')\",\n \"def render_map(map,\\nlat=None,\\nlon=None,\\ntitle=None,\\nsave=True,\\nshow=True,\\nschedule=None,\\nschedule_bbox=(-0.03,0,1,0.91),\\nimg_filename=None,\\nimg_dir=\\\"\\\",\\nimg_size=[20,15],\\nimg_dpi=300,\\nimg_filetype=\\\"png\\\",\\nbrdr_nation=True,\\nbrdr_nation_rgba=[0,0,0,1],\\nbrdr_state=True,\\nbrdr_state_rgba=[0,0,0,0.75],\\ncmap=\\\"gist_ncar\\\",\\ncmap_limits=None,\\ncbar=True,\\ncbar_limits=None,\\ncbar_label=None,\\ncountry_focus=\\\"CHE\\\",\\ngridlines=True,\\ngridlines_dms=False,\\nmch_logo=True) :\\n\\n # TODO: Add custom sizing and resolution specifications\\n fig = plt.figure(figsize=(img_size[0]/2.54,img_size[1]/2.54))\\n\\n # TODO: Accept custom projections\\n # proj = ccrs.Mercator()\\n proj = ccrs.Orthographic(central_longitude=(lon[0]+lon[-1])/2, central_latitude=(lat[0]+lat[-1])/2)\\n\\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\\n ax = fig.add_subplot(1,1,1,projection = proj)\\n\\n # TODO: Increase flexibility of borders consideration\\n if brdr_state :\\n state_brdrs = cfeat.NaturalEarthFeature(\\n category='cultural',\\n name='admin_1_states_provinces_lines',\\n scale='10m',\\n facecolor='none')\\n ax.add_feature(state_brdrs,linestyle=\\\"--\\\",edgecolor=tuple(brdr_state_rgba),linewidth=0.5)\\n if brdr_nation :\\n ax.add_feature(cfeat.BORDERS,edgecolor=tuple(brdr_nation_rgba))\\n\\n if country_focus is not None :\\n shpfilename = shapereader.natural_earth(resolution='10m',\\n category='cultural',name='admin_0_countries')\\n reader = shapereader.Reader(shpfilename)\\n countries = reader.records() \\n # this is a very janky search for Switzerland, but it's ultimately simpler than\\n # making geopandas a requirement for the library\\n for country in countries :\\n if country.attributes['ADM0_A3'] == country_focus :\\n break\\n assert country.attributes['ADM0_A3'] == country_focus, \\\"country_focus input not recognised\\\"\\n poly = country.geometry\\n\\n msk_proj = proj.project_geometry (poly, ccrs.Geodetic()) # project geometry to the projection used by stamen\\n\\n # plot the mask using semi-transparency (alpha=0.65) on the masked-out portion\\n ax.add_geometries( msk_proj, proj, facecolor='white', edgecolor='none', alpha=0.8)\\n\\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\\n extents=[lon[0],lon[-1],lat[0],lat[-1]]\\n ax.set_extent(extents,crs=ccrs.Geodetic())\\n\\n # this code correctly translate the lat/lon limits into the projected coordinates\\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\\n extents_proj = extents_proj[:,:2].flatten(order='F')\\n\\n if gridlines :\\n ax.gridlines(draw_labels=True, dms=gridlines_dms, x_inline=False, y_inline=False,linewidth=0.25,\\n ylocs=[46,46.5,47,47.5])\\n\\n # TODO: Custom colormaps, interpolation, cropping\\n\\n # Upscale matrix for better reprojection\\n # f = interp2d(lon, lat, map, kind='linear')\\n # latnew = np.linspace(lat[0], lat[-1], (len(lat)-1)*3+1)\\n # lonnew = np.linspace(lon[0], lon[-1], (len(lon)-1)*3+1)\\n # mapnew = f(lonnew, latnew)\\n\\n # Upscale matrix for better reprojection\\n mapnew = zoom(map,3)\\n\\n # show map with given cmap and set cmap limits\\n im = ax.imshow(mapnew,extent=extents,transform=ccrs.PlateCarree(),\\n origin='lower',cmap=cmap)\\n if cmap_limits is not None :\\n im.set_clim(cmap_limits[0],cmap_limits[1])\\n\\n # colorbar\\n # TODO: Add support for horizontal vertical option\\n if cbar :\\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\\n cb.ax.set_xlabel(cbar_label)\\n\\n # show schedule diagram\\n if schedule is not None :\\n ax2 = inset_axes(ax, width=\\\"25%\\\", height=\\\"25%\\\", loc=2,\\n axes_class = get_projection_class('polar'),\\n bbox_to_anchor=tuple(schedule_bbox),\\n bbox_transform=ax.transAxes)\\n schedule_clock(ax2,schedule,title=\\\"Exposure schedule\\\")\\n\\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\\n if title is not None :\\n ax.set_title(title)\\n\\n if mch_logo :\\n ex = ax.get_extent()\\n mch_logo_img = plt.imread('python_tamer/mch_logo.png')\\n mch_logo_width = 0.15\\n mch_logo_pad = 0\\n # some maths to work out position, note image aspect ratio 5:1\\n mch_extents = [ex[1]-(ex[1]-ex[0])*mch_logo_width-(ex[1]-ex[0])*mch_logo_pad,\\n ex[1]-(ex[1]-ex[0])*mch_logo_pad,\\n ex[2]+(ex[3]-ex[2])*mch_logo_pad,\\n ex[2]+0.2*(ex[1]-ex[0])*mch_logo_width+(ex[3]-ex[2])*mch_logo_pad]\\n # zorder puts image on top (behind mask otherwise for some reason)\\n ax.imshow(mch_logo_img,extent=mch_extents,zorder=12)\\n\\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\\n if save :\\n # Generate timestamp filename if relying on default\\n if img_filename is None :\\n if title is not None :\\n img_filename = format_filename(title)\\n else :\\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\\n elif img_filename == \\\"timestamp\\\" :\\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\\n\\n plt.savefig(img_dir+img_filename+\\\".\\\"+img_filetype,\\n bbox_inches=\\\"tight\\\",dpi=img_dpi)\\n\\n if show :\\n plt.show()\",\n \"def ts_map(self, vmin=0, vmax=25, pixelsize=0.25):\\n self.tsmap.plot(ait_kw=dict(pixelsize=pixelsize), vmin=vmin, vmax=vmax)\\n fig=plt.gcf()\\n fig.set_facecolor('white')\\n return fig\",\n \"def draw_composite_map(date_obj, t850, u200, v200, u500, v500, mslp, gh500, u850, v850, pwat):\\n \\n #Get lat and lon arrays for this dataset:\\n lat = t850.lat.values\\n lon = t850.lon.values\\n\\n #========================================================================================================\\n # Create a Basemap plotting figure and add geography\\n #========================================================================================================\\n\\n #Create a Plate Carree projection object\\n proj_ccrs = ccrs.Miller(central_longitude=0.0)\\n\\n #Create figure and axes for main plot and colorbars\\n fig = plt.figure(figsize=(18,12),dpi=125)\\n gs = gridspec.GridSpec(12, 36, figure=fig) #[ytop:ybot, xleft:xright]\\n ax = plt.subplot(gs[:, :-1],projection=proj_ccrs) #main plot\\n ax.set_xticklabels([])\\n ax.set_yticklabels([])\\n ax2 = plt.subplot(gs[:4, -1]) #top plot\\n ax2.set_xticklabels([])\\n ax2.set_yticklabels([])\\n ax3 = plt.subplot(gs[4:8, -1]) #bottom plot\\n ax3.set_xticklabels([])\\n ax3.set_yticklabels([])\\n ax4 = plt.subplot(gs[8:, -1]) #bottom plot\\n ax4.set_xticklabels([])\\n ax4.set_yticklabels([])\\n\\n #Add political boundaries and coastlines\\n ax.add_feature(cfeature.COASTLINE.with_scale('50m'), linewidths=1.2)\\n ax.add_feature(cfeature.BORDERS.with_scale('50m'), linewidths=1.2)\\n ax.add_feature(cfeature.STATES.with_scale('50m'), linewidths=0.5)\\n\\n #Add land/lake/ocean masking\\n land_mask = cfeature.NaturalEarthFeature('physical', 'land', '50m',\\n edgecolor='face', facecolor='#e6e6e6')\\n sea_mask = cfeature.NaturalEarthFeature('physical', 'ocean', '50m',\\n edgecolor='face', facecolor='#ffffff')\\n lake_mask = cfeature.NaturalEarthFeature('physical', 'lakes', '50m',\\n edgecolor='face', facecolor='#ffffff')\\n ax.add_feature(sea_mask,zorder=0)\\n ax.add_feature(land_mask,zorder=0)\\n ax.add_feature(lake_mask,zorder=0)\\n\\n #========================================================================================================\\n # Fill contours\\n #========================================================================================================\\n\\n #--------------------------------------------------------------------------------------------------------\\n # 850-hPa temperature\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Specify contour settings\\n clevs = np.arange(-40,40,1)\\n cmap = plt.get_cmap('jet')\\n extend = \\\"both\\\"\\n\\n #Contour fill this variable\\n norm = col.BoundaryNorm(clevs,cmap.N)\\n cs = ax.contourf(lon,lat,t850,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.1)\\n\\n #--------------------------------------------------------------------------------------------------------\\n # PWAT\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Specify contour settings\\n clevs = np.arange(20,71,0.5)\\n\\n #Define a color gradient for PWAT\\n pwat_colors = gradient([[(255,255,255),0.0],[(255,255,255),20.0]],\\n [[(205,255,205),20.0],[(0,255,0),34.0]],\\n [[(0,255,0),34.0],[(0,115,0),67.0]])\\n cmap = pwat_colors.get_cmap(clevs)\\n extend = \\\"max\\\"\\n\\n #Contour fill this variable\\n norm = col.BoundaryNorm(clevs,cmap.N)\\n cs = ax.contourf(lon,lat,pwat,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.9)\\n\\n #Add a color bar\\n _ = plt.colorbar(cs,cax=ax2,shrink=0.75,pad=0.01,ticks=[20,30,40,50,60,70])\\n\\n #--------------------------------------------------------------------------------------------------------\\n # 250-hPa wind\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Get the data for this variable\\n wind = calc.wind_speed(u200, v200)\\n\\n #Specify contour settings\\n clevs = [40,50,60,70,80,90,100,110]\\n cmap = col.ListedColormap(['#99E3FB','#47B6FB','#0F77F7','#AC97F5','#A267F4','#9126F5','#E118F3','#E118F3'])\\n extend = \\\"max\\\"\\n\\n #Contour fill this variable\\n norm = col.BoundaryNorm(clevs,cmap.N)\\n cs = ax.contourf(lon,lat,wind,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs)\\n\\n #Add a color bar\\n _ = plt.colorbar(cs,cax=ax3,shrink=0.75,pad=0.01,ticks=clevs)\\n\\n #--------------------------------------------------------------------------------------------------------\\n # 500-hPa smoothed vorticity\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Get the data for this variable\\n dx,dy = calc.lat_lon_grid_deltas(lon,lat)\\n vort = calc.vorticity(u500, v500, dx=dx, dy=dy)\\n smooth_vort = smooth(vort, 5.0) * 10**5\\n\\n #Specify contour settings\\n clevs = np.arange(2,20,1)\\n cmap = plt.get_cmap('autumn_r')\\n extend = \\\"max\\\"\\n\\n #Contour fill this variable\\n norm = col.BoundaryNorm(clevs,cmap.N)\\n cs = ax.contourf(lon,lat,smooth_vort,clevs,cmap=cmap,norm=norm,extend=extend,transform=proj_ccrs,alpha=0.3)\\n\\n #Add a color bar\\n _ = plt.colorbar(cs,cax=ax4,shrink=0.75,pad=0.01,ticks=clevs[::2])\\n \\n #========================================================================================================\\n # Contours\\n #========================================================================================================\\n\\n #--------------------------------------------------------------------------------------------------------\\n # MSLP\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Specify contour settings\\n clevs = np.arange(960,1040+4,4)\\n style = 'solid' #Plot solid lines\\n color = 'red' #Plot lines as gray\\n width = 0.8 #Width of contours 0.25\\n\\n #Contour this variable\\n cs = ax.contour(lon,lat,mslp,clevs,colors=color,linewidths=width,linestyles=style,transform=proj_ccrs,alpha=0.9)\\n\\n #Include value labels\\n ax.clabel(cs, inline=1, fontsize=9, fmt='%d')\\n\\n #--------------------------------------------------------------------------------------------------------\\n # Geopotential heights\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Get the data for this variable\\n gh500 = gh500 / 10.0\\n\\n #Specify contour settings\\n clevs = np.arange(480,612,4)\\n style = 'solid' #Plot solid lines\\n color = 'black' #Plot lines as gray\\n width = 2.0 #Width of contours\\n\\n #Contour this variable\\n cs = ax.contour(lon,lat,gh500,clevs,colors=color,linewidths=width,linestyles=style,transform=proj_ccrs)\\n\\n #Include value labels\\n ax.clabel(cs, inline=1, fontsize=12, fmt='%d')\\n\\n #--------------------------------------------------------------------------------------------------------\\n # Surface barbs\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Plot wind barbs\\n _ = ax.quiver(lon, lat, u850.values, v850.values, transform=proj_ccrs, regrid_shape=(38,30), scale=820, alpha=0.5)\\n\\n #--------------------------------------------------------------------------------------------------------\\n # Label highs & lows\\n #--------------------------------------------------------------------------------------------------------\\n\\n #Label highs and lows\\n add_mslp_label(ax, proj_ccrs, mslp, lat, lon)\\n\\n #========================================================================================================\\n # Step 6. Add map boundary, legend, plot title, then save image and close\\n #========================================================================================================\\n\\n #Add china province boundary\\n add_china_map_2cartopy(ax, name='province')\\n\\n #Add custom legend\\n from matplotlib.lines import Line2D\\n custom_lines = [Line2D([0], [0], color='#00A123', lw=5),\\n Line2D([0], [0], color='#0F77F7', lw=5),\\n Line2D([0], [0], color='#FFC000', lw=5),\\n Line2D([0], [0], color='k', lw=2),\\n Line2D([0], [0], color='k', lw=0.1, marker=r'$\\\\rightarrow$', ms=20),\\n Line2D([0], [0], color='r', lw=0.8),]\\n\\n ax.legend(custom_lines, ['PWAT (mm)', '200-hPa Wind (m/s)', '500-hPa Vorticity', '500-hPa Height (dam)', '850-hPa Wind (m/s)', 'MSLP (hPa)'], loc=2, prop={'size':12})\\n\\n #Format plot title\\n title = \\\"Synoptic Composite \\\\nValid: \\\" + dt.datetime.strftime(date_obj,'%Y-%m-%d %H%M UTC')\\n st = plt.suptitle(title,fontweight='bold',fontsize=16)\\n st.set_y(0.92)\\n\\n #Return figuration\\n return(fig)\",\n \"def DT(time_lvl = 0, date = 160924 ):\\n \\n #-------Customised color in RGB ------------\\n C = [[232,232,230],#grey\\n [203,203,203], #grey\\n [161,161,161], #grey\\n [130,130,130], #grey\\n [149,53,229], #lillac, 39\\t64\\t197\\t149,53,229\\n [39,64,197], #blue dark,7,67,194\\n [15,110,229], #blue\\n [80,149,240], #blue\\n [74,192,243], #blue\\n [152,219,248], #blue\\n [183,237,247], #blue\\n [251,217,198], #redish\\n [255,197,166], #redish\\n [255,172,164], #redish\\n [253,139,142], #redish\\n [253,101,105], #redish\\n [255,66,74], #redish\\n [238,13,28], #red\\n [214,78,166], #pink\\n [214,102,201], \\n [217,155,210],\\n [216,181,211]]\\n C = np.array( C )\\n C = np.divide( C, 255. ) # RGB has to be between 0 and 1 in python\\n #-----------------------------------------------------------\\n \\n fig = plt.figure()\\n \\n \\n #-----Setting our map area and projection of interest-------\\n m = Basemap( llcrnrlon = -90., llcrnrlat = 0., urcrnrlon = 50., urcrnrlat=70.,\\\\\\n resolution = 'l', area_thresh = 10000., projection = 'merc' )\\n #m = Basemap(width=11500000,height=8500000,resolution='l',projection='eqdc',\\\\\\n # lat_1=07.,lat_2=40,lat_0=44,lon_0=-30.)\\n #m = Basemap(width=190000,height=2200000,resolution='l', projection='tmerc',lon_0=-30,lat_0=44)\\n \\n map_area( m ) # ploting background\\n path = \\\"gribs/\\\"\\n file = path +\\\"DT_var.grib\\\"\\n obj = pygrib.open( file )\\n \\n #-FETCHING ALL THE VALUES----------------------------------------\\n #-----Potential temperature---------------------------------------\\n lat, lon, data = get_data( obj,'Potential temperature', 2000, date, timelevel = time_lvl )\\n contour_val = np.linspace( 264, 384, 22 ) #contours for potential tempeature\\n plot_contourf( m, lat, lon, data, C, contour_val )\\n \\n #-----Relative vorticity, diff level------------------------------\\n contour=[ 2.8E-4, 3.5E-4, 4.5E-4, 6.5E-4, 7.E-4, 7.5E-4, 8.E-4 ] #1.5E-4,2.5E-4]#\\n lat, lon, data925 = get_data( obj, 'Vorticity (relative)', 925, date, timelevel = time_lvl )\\n lat, lon, data900 = get_data( obj, 'Vorticity (relative)', 900, date, timelevel = time_lvl )\\n lat, lon, data850 = get_data( obj, 'Vorticity (relative)', 850, date, timelevel = time_lvl )\\n \\n #->--->---->--mean value over height and filtering----------------\\n data = np.sqrt( data900**2 + 2*data850**2 + data925**2 ) #Vertical \\\"average\\\", weightet values at 850hpa double.\\n footprint = np.array([[0,0,0,1,1,1,1,0,0,0], #footprint=np.ones((3,10))\\n [0,0,1,1,1,2,1,1,0,0],\\n [1,1,1,2,2,1,2,1,1,1],\\n [0,1,1,1,1,2,1,1,1,0],\\n [0,0,1,1,1,1,1,1,0,0]])\\n \\n data = ndimage.generic_filter( data, np.mean, footprint = footprint, mode='wrap' )\\n plot_contour( m, lat,lon, data,contour, clr = 'k' )\\n \\n #-----Wind barbs----------------------------------------------------\\n lat, lon, data_u = get_data( obj , 'U component of wind', 2000, date, timelevel = time_lvl )\\n lat, lon, data_v = get_data( obj , 'V component of wind', 2000, date, timelevel = time_lvl )\\n plot_wind_bar( m, lat, lon, data_u, data_v )\\n #-----------------------------------------------\\n #-----------------------------------------------\\n \\n \\n \\n #-SAVE AND CLOSE----------------------------------------------------\\n #------------------------------------------------------------------\\n obj.close()\\n if time_lvl == 0:\\n t = \\\"0000\\\"\\n elif time_lvl == 1:\\n t = \\\"1200\\\"\\n elif time_lvl == 2:\\n t = \\\"1800\\\"\\n else: \\n t = \\\"t_not_set\\\"\\n \\n fig_name = \\\"DT/DT_\\\" + str( date ) + \\\"_\\\" + str( t )+ \\\".TIFF\\\" \\n \\n ax = plt.gca( )\\n plt.rc( 'font', size = 6 )\\n fig.set_size_inches( 12.80, 7.15 )\\n \\n fig.savefig( fig_name, dpi = 600 )\\n plt.close( )\\n #plt.show()\\n #--------------------------\\n #----------------------------\",\n \"def get_ax(self, data):\\n timezone = list([x for x in data if 'UTC' in x])\\n\\n timezone_start = tuple((x/255 for x in (0, 255, 0, 100)))\\n country_start = tuple((x/255 for x in (0, 100, 0)))\\n # We ignore some countries, as they are too big and need a higher\\n # resolution for precise timezone assignment.\\n ignored_countries = ['United States', 'Australia', 'Brazil', 'Canada']\\n\\n ax = plt.axes(projection=ccrs.PlateCarree())\\n\\n # Print countries and state borders\\n ax.add_feature(cartopy.feature.LAND)\\n ax.add_feature(cartopy.feature.OCEAN)\\n ax.add_feature(cartopy.feature.COASTLINE)\\n ax.add_feature(cartopy.feature.BORDERS)\\n for state in self.states:\\n ax.add_geometries(\\n state.geometry,\\n ccrs.PlateCarree(),\\n facecolor=np.array((240, 240, 220)) / 256,\\n edgecolor='black',\\n label=state.attributes['name'],\\n )\\n\\n collected_countries = []\\n collected_timezones = []\\n collected_states = []\\n\\n timezones_to_draw = []\\n countries_to_draw = []\\n states_to_draw = []\\n for name in data:\\n # Color the timezone if we find one\\n name = map_timezone_to_utc(name)\\n if name in self.timezones_by_name:\\n timezone = self.timezones_by_name[name]\\n\\n # Prevent timezone from being applied multiple times.\\n utc_name = timezone.attributes['utc_format']\\n if utc_name not in collected_timezones:\\n collected_timezones.append(utc_name)\\n timezones_to_draw.append(timezone)\\n\\n # Check if we find a country for this timezone and draw it\\n if name in timezone_country:\\n # Check if we have a country code for this timezone\\n country_code = timezone_country[name]\\n\\n # We have no country for this code.\\n # Unfortunately the natural earth database is a little inconsistent.\\n # Try to get the full name of the country by using pycountry\\n # and resolve the country by this name.\\n if country_code not in self.countries_by_iso_a2:\\n try:\\n name = pycountries.get(alpha_2=country_code).name\\n except KeyError:\\n continue\\n\\n # We found a full name for this code.\\n # Check if we have a country for this name.\\n if name not in self.countries_by_name:\\n continue\\n\\n # We found a country for this name. Proceed\\n country = self.countries_by_name[name]\\n\\n else:\\n country = self.countries_by_iso_a2[country_code]\\n\\n # This country is too big and has many timezones it it.\\n # Try to get the state name and to color only the interesting states.\\n if country.attributes['NAME_LONG'] in ignored_countries:\\n state = map_timezone_to_state(name)\\n\\n # We couldn't find a state for this timezone\\n if state is None:\\n continue\\n\\n # We don't have this state name in our world data\\n if state not in self.states_by_name:\\n continue\\n\\n # We already have this state\\n if state in collected_states:\\n continue\\n\\n # Found a state\\n collected_states.append(state)\\n state = self.states_by_name[state]\\n states_to_draw.append(state)\\n\\n continue\\n\\n # Avoid to draw the same country multiple times\\n country_name = country.attributes['NAME_LONG']\\n if country_name in collected_countries:\\n continue\\n\\n collected_countries.append(country_name)\\n countries_to_draw.append(country)\\n\\n # Draw everything at the end.\\n # Otherwise timezones might draw over countries and fuck up the image.\\n for timezone in timezones_to_draw:\\n ax.add_geometries(\\n timezone.geometry,\\n ccrs.PlateCarree(),\\n facecolor=timezone_start,\\n label=name,\\n )\\n\\n for country in countries_to_draw:\\n ax.add_geometries(\\n country.geometry,\\n ccrs.PlateCarree(),\\n facecolor=country_start,\\n edgecolor='black',\\n label=country_name,\\n )\\n\\n for state in states_to_draw:\\n ax.add_geometries(\\n state.geometry,\\n ccrs.PlateCarree(),\\n facecolor=country_start,\\n edgecolor='black',\\n label=state.attributes['name'],\\n )\\n\\n return ax\",\n \"def generateStationPlot(dir_path, traj_list, color_scheme='light'):\\n\\n\\n # Choose the color scheme\\n cs = MapColorScheme()\\n \\n if color_scheme == 'light':\\n cs.light()\\n\\n else:\\n cs.dark()\\n\\n\\n plt.figure(figsize=(19.2, 10.8))\\n\\n # Init the map\\n m = Basemap(projection='cyl', resolution='i')\\n\\n # Draw the coast boundary and fill the oceans with the given color\\n m.drawmapboundary(fill_color=cs.map_background)\\n\\n # Fill continents, set lake color same as ocean color\\n m.fillcontinents(color=cs.continents, lake_color=cs.lakes, zorder=1)\\n\\n # Draw country borders\\n m.drawcountries(color=cs.countries)\\n m.drawstates(color=cs.states, linestyle='--')\\n\\n\\n\\n ### PLOT WORLD MAP ###\\n\\n # Group stations into countries\\n country_dict = {}\\n for traj in traj_list:\\n\\n for obs in traj.observations:\\n\\n # Extract country code\\n country_code = obs.station_id[:2]\\n\\n if country_code not in country_dict:\\n country_dict[country_code] = {}\\n \\n\\n if obs.station_id not in country_dict[country_code]:\\n country_dict[country_code][obs.station_id] = [obs.lat, obs.lon]\\n\\n\\n\\n # Plot stations in all countries\\n for country_code in country_dict:\\n\\n station_dict = country_dict[country_code]\\n\\n # Extract lat/lon\\n lat = np.degrees([station_dict[station_id][0] for station_id in station_dict])\\n lon = np.degrees([station_dict[station_id][1] for station_id in station_dict])\\n\\n # Convert lat/lon to x/y\\n x, y = m(lon, lat)\\n\\n plt.scatter(x, y, s=0.75, zorder=5, label=\\\"{:s}: {:d}\\\".format(country_code, len(lat)))\\n\\n\\n plt.legend(loc='lower left')\\n\\n plt.tight_layout()\\n\\n plt.savefig(os.path.join(dir_path, \\\"world_map.png\\\"), dpi=100)\\n\\n plt.close()\\n\\n ### ###\",\n \"def plotOceanParcelsAccumulatedResults(input_data_folder, output_folder, start_year, end_year, dt=1):\\n # Only for\\n tot_days = (end_year-start_year)*365\\n start_date = datetime.strptime(str(start_year),'%Y')\\n\\n open_files = []\\n for c_day in np.arange(0, tot_days, dt):\\n print(F\\\"------- {c_day}---------\\\")\\n # Released months\\n c_date = start_date + timedelta(days=int(c_day))\\n months = (c_date.year - start_date.year)*12 + c_date.month - start_date.month\\n\\n # Iterate over all the files that should contribute to the image\\n fig = plt.figure(figsize=(20,10))\\n ax = plt.subplot(1, 1, 1, projection=ccrs.PlateCarree())\\n for c_month in range(0, months + 1):\\n c_file_year = (start_date + relativedelta(months=int(c_month))).year\\n c_file_month = (start_date + relativedelta(months=int(c_month))).month\\n skip_days = c_day - (c_date - datetime.strptime(F\\\"{c_file_year}-{c_file_month}\\\",'%Y-%m')).days\\n\\n if len(open_files) <= c_month:\\n file_name = F\\\"TenYears_YesWinds_YesDiffusion_NoUnbeaching_{c_file_year}_{(c_file_month):02d}.nc\\\"\\n print(F\\\"Reading new file: {file_name}\\\")\\n open_files.append(Dataset(join(input_data_folder, file_name), \\\"r\\\", format=\\\"NETCDF4\\\"))\\n\\n c_time_step = c_day - skip_days\\n # lats = open_files[c_month].variables['lat'][:,c_time_step]\\n # lons = open_files[c_month].variables['lon'][:,c_time_step]\\n ax.scatter(open_files[c_month].variables['lon'][:,c_time_step], open_files[c_month].variables['lat'][:,c_time_step], color='c', s=1)\\n\\n title = F\\\"{start_date.strftime('%Y-%m-%d')} - {c_date.strftime('%Y-%m-%d')}\\\"\\n ax.coastlines()\\n ax.set_title(title, fontsize=30)\\n\\n # plt.show()\\n plt.savefig(F\\\"{output_folder}/{start_date.strftime('%Y_%m')}_{c_day:04d}.png\\\")\\n plt.close()\",\n \"def plot_mult_locations(sf, df, data, dcounts, geoid, all_geoids, l, b, w_map = 2.5, w_time = 3, h=3, \\n colors = ['orange','palevioletred','steelblue','olive'], \\n markers = ['o','^','s','P']):\\n #plot timeseries\\n ax = None\\n ax = plot_mult_timetrends(data, geoid, cols = [i for i in data.columns if (i.endswith('21day_avg') and\\n i[:12] in geoid)],\\n area = [l + w_map + 0.3,b + h/2, w_time, h/2], colors = colors,\\n markers = markers, sharex = ax, ylim_bottom = -50, ylim_top = 50,\\n xlabels=[''] * 6)\\n \\n # plot dcount timeseries\\n ax = None\\n ax = plot_mult_timetrends(dcounts, geoid, cols = [i for i in data.columns if (i.endswith('21day_avg') and\\n i[:12] in geoid)],\\n area = [l + w_map + 0.3,b,w_time,h/2], colors = colors, markers = markers, sharex = ax,\\n ylim_bottom = 0, ylim_top = 200, ylabel = 'Device count',\\n xlabels=data.index[np.arange(0,data.shape[0],28)].tolist())\\n \\n #plot map\\n plt.axes([l,b,w_map,h])\\n for i in df_edges[df_edges.ZIPR.isin(['98105','98195','98115','98102','98112'])].index:\\n shape_ex = sf_edges.shape(i)\\n x_lon = np.zeros((len(shape_ex.points),1))\\n y_lat = np.zeros((len(shape_ex.points),1))\\n for ip in range(len(shape_ex.points)):\\n x_lon[ip] = shape_ex.points[ip][0]\\n y_lat[ip] = shape_ex.points[ip][1]\\n plt.plot(x_lon,y_lat, color = 'black')\\n \\n outline_geoids(sf = sf, df = df, geoids = all_geoids, include_labels=False)\\n fill_blockgroups(sf = sf, df = df, geoids = geoid, colors=colors)\\n \\n \\n plt.xlim(-122.325,-122.25)\\n plt.ylim(47.645,47.68)\\n plt.axis('off')\",\n \"def plot_events_grid(self, scale, distrib=True, dataname='', timeres=0):\\n\\n def plot_notimeres():\\n \\\"\\\"\\\"\\n All time colapsed\\n @return:\\n \\\"\\\"\\\"\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n\\n if distrib:\\n cont = cont / np.max(cont)\\n plt.imshow(cont, interpolation='bicubic', cmap=cm.gist_yarg)\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color='#000000',\\n fill_color='#110000')\\n # mymap.addradpoint(minLat+(((scale - i)+0.5)/normLat), minLon+((j+0.5)/normLon),\\n # cont[i,j]*(circlesize/scale), \\\"#FF0000\\\")\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n plt.plot(j, scale - i, 'k.')\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color='#000000',\\n fill_color='#110000')\\n # mymap.addradpoint(minLat+(((scale - i )+0.5)/normLat),\\n # minLon+((j+0.5)/normLon), 30, \\\"#FF0000\\\")\\n\\n def plot_timeres(timeres):\\n \\\"\\\"\\\"\\n Geo points separated by the time resolution zones\\n @return:\\n \\\"\\\"\\\"\\n tint = 24 / timeres\\n step = 255 / (tint + 1)\\n\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n mxcont = np.max(cont)\\n\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i)-0.5)/normLat), minLon+((j+1.5)/normLon),\\n # cont[i,j]*(circlesize/scale), \\\"#FF0000\\\")\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color='#000000',\\n fill_color='#110000', fill_opacity=0.3)\\n # mymap.addradpoint(minLat+(((scale - i )-0.5)/normLat),\\n # minLon+((j+1.5)/normLon), 30, \\\"#FF0000\\\")\\n for t in range(tint):\\n color = '#' + (str(hex((t + 1) * step))[2:]) + (\\n str(hex((t + 1) * step))[2:]) + 'FF' # (str(hex((t+1)*step))[2:])\\n cont = np.zeros((scale, scale))\\n for i in range(self.dataset.shape[0]):\\n posy = int(((self.dataset[i][0] - minLat) * normLat))\\n posx = int(((self.dataset[i][1] - minLon) * normLon))\\n stime = time.localtime(np.int32(self.dataset[i][2]))\\n evtime = stime[3]\\n if (evtime / timeres) == t:\\n if distrib:\\n cont[scale - posy - 1, posx - 1] += 1\\n else:\\n cont[scale - posy - 1, posx - 1] = 1\\n if distrib:\\n cont = cont / mxcont\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=cont[i, j] * (circlesize / scale),\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\\n else:\\n for i in range(cont.shape[0]):\\n for j in range(cont.shape[1]):\\n if cont[i, j] > 0.01:\\n mymap.circle_marker(\\n location=[minLat + (((scale - i) - 0.5) / normLat), minLon + ((j + 1.5) / normLon)],\\n radius=30,\\n line_color=color,\\n fill_color='#110000', fill_opacity=0.2)\\n\\n print 'Generating the events plot ...'\\n circlesize = 15000\\n\\n # if timeres == 0:\\n # fig = plt.figure()\\n # ax = fig.add_subplot(111)\\n\\n minLat, maxLat, minLon, maxLon = self.city[1]\\n normLat = scale / (maxLat - minLat)\\n normLon = scale / (maxLon - minLon)\\n mymap = folium.Map(location=[(minLat + maxLat) / 2.0, (minLon + maxLon) / 2.0], zoom_start=12, width=1200,\\n height=1000)\\n\\n # mymap = pygmaps.maps((minLat+maxLat)/2,(minLon + maxLon)/2.0, 10)\\n # mymap.setgrids(minLat, maxLat, 0.01, minLon, maxLon, 0.01)\\n if timeres is None:\\n plot_notimeres()\\n else:\\n plot_timeres(timeres)\\n\\n # today = time.strftime('%Y%m%d%H%M%S', time.localtime())\\n nfile = self.application + '-' + dataname + '-Grid'\\n if self.mnhh is not None and self.mnhh is not None:\\n nfile += '-nusr' + str(self.mxhh) + '#' + str(self.mnhh)\\n if timeres is not None:\\n nfile += '-tr' + str(timeres.interval)\\n\\n nfile += '-s' + str(scale)\\n\\n # if timeres == 0:\\n # fig.savefig(homepath + 'Results/' + self.city[2] + '-' +\\n # nfile + '.pdf', orientation='landscape', format='pdf')\\n # plt.close()\\n mymap.create_map(path=homepath + 'Results/' + self.city[2] + nfile + '.html')\\n # mymap.draw(homepath + 'Results/' + self.city[2] + nfile + '.html')\",\n \"def plot(lats, lons, year):\\r\\n\\thtml_file = \\\"html_files/ufo_sightings_\\\" + str(year) + \\\".html\\\"\\r\\n\\r\\n\\tgmap = gmplot.GoogleMapPlotter(40, -100, 4)\\r\\n\\tgmap.heatmap(lats, lons)\\r\\n\\tgmap.draw(html_file)\\r\\n\\r\\n\\tget_screenshot(html_file, year)\",\n \"def main_date_plot(full_date, start_date, end_date):\\n fig, ax = plt.subplots()\\n loc = dts.MonthLocator()\\n if end_date - start_date < dt.timedelta(days=90):\\n myFmt = dts.DateFormatter('%m-%d')\\n else:\\n myFmt = dts.DateFormatter('%m')\\n \\n # check if full data is a list of lists\\n this_event = [(date, data) for date, data in full_data if\\n date >= prev_date and date <= final_date]\\n\\n date, rank = zip(*this_event)\\n\\n ax.plot(date, rank, 'k-')\\n\\n ax.set_xlabel('Month')\\n ax.set_ylabel('Rank')\\n ax.invert_yaxis()\\n ax.xaxis.set_major_formatter(myFmt)\\n ax.set_title('Rank plot for {} in {}'.format(WORD, YEAR))\\n fig.savefig('plots/{}-{}-shock-event.jpg'.format(WORD, YEAR))\\n plt.close(fig)\",\n \"def maplot_c(pdata, pdata1, title='', precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid\\n import numpy as np\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n plt.figure()\\n\\n pdata, lon1 = shiftgrid(180., pdata, lon, start=False)\\n pdata1, lon = shiftgrid(180., pdata1, lon, start=False)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n plot = m.contour(x, y, pdata, [4, 5, 6], colors='k')\\n plt.clabel(plot, inline=1, fontsize=10)\\n plot1 = m.contour(x, y, pdata1, [4, 5, 6], colors='r', linestyles='--')\\n plt.clabel(plot, inline=1, fontsize=10)\\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\\n m.drawparallels(parallels, labels=[True, True, True, True])\\n m.drawmeridians(meridians, labels=[True, True, True, True])\\n plt.title(title, y=1.08)\\n plt.show()\",\n \"def make_map(data,LatLonBox):\\n\\n proj = ccrs.LambertConformal(central_longitude=data.StationLongitude,\\n central_latitude=data.StationLatitude)\\n\\n fig = plt.figure(figsize=(17,11))\\n ax = plt.subplot(111,projection=proj)\\n \\n ax.coastlines('50m', 'black', linewidth=2, zorder=2)\\n\\n reader = shpreader.Reader('/Users/chowdahead/Documents/shapefiles/countyl010g_shp_nt00964/countyl010g.shp')\\n counties = list(reader.geometries())\\n COUNTIES = cfeature.ShapelyFeature(counties,ccrs.PlateCarree())\\n ax.add_feature(COUNTIES, facecolor='none',edgecolor='w')\\n # Grab state borders\\n state_borders = cfeature.NaturalEarthFeature(\\n category='cultural', name='admin_1_states_provinces_lines',\\n scale='50m', facecolor='none')\\n ax.add_feature(state_borders, edgecolor='w', linewidth=1, zorder=3)\\n \\n ocean = cfeature.NaturalEarthFeature('physical', 'ocean', scale='50m',\\n edgecolor='face',\\n facecolor=cfeature.COLORS['water'])\\n land = cfeature.NaturalEarthFeature('physical', 'land', scale='50m',\\n edgecolor='face',\\n facecolor=\\\"k\\\")\\n\\n ax.add_feature(ocean, zorder=-1)\\n ax.add_feature(land, zorder=-1)\\n ax.set_facecolor('black')\\n \\n ax.set_extent(LatLonBox,ccrs.PlateCarree())\\n \\n return fig,ax,proj\",\n \"def generate_geo_map(start_date, end_date):\\n start_time = dt.datetime.now()\\n\\n start_date = dt.datetime.strptime(start_date.split('T')[0], '%Y-%m-%d') # Convert strings to datetime objects\\n end_date = dt.datetime.strptime(end_date.split('T')[0], '%Y-%m-%d')\\n\\n filtered_data = filter_dataframe(df, start_date, end_date)\\n dff = filtered_data\\n\\n traces = []\\n\\n data = [ dict(\\n type = 'scattermapbox',\\n lon = dff['lat'],\\n lat = dff['lon'],\\n text = dff['timestamp'],\\n mode = 'markers',\\n marker = dict(\\n size = 8,\\n opacity = 0.8,\\n color = 'orange'\\n ))]\\n\\n # relayoutData is None by default, and {'autosize': True} without relayout action\\n # if main_graph_layout is not None and selector is not None and \\\"locked\\\" in selector:\\n # if \\\"mapbox.center\\\" in main_graph_layout.keys():\\n # lon = float(main_graph_layout[\\\"mapbox.center\\\"][\\\"lon\\\"])\\n # lat = float(main_graph_layout[\\\"mapbox.center\\\"][\\\"lat\\\"])\\n # zoom = float(main_graph_layout[\\\"mapbox.zoom\\\"])\\n # layout[\\\"mapbox\\\"][\\\"center\\\"][\\\"lon\\\"] = lon\\n # layout[\\\"mapbox\\\"][\\\"center\\\"][\\\"lat\\\"] = lat\\n # layout[\\\"mapbox\\\"][\\\"zoom\\\"] = zoom\\n\\n print('generate_geo_map:', (dt.datetime.now()-start_time).total_seconds())\\n\\n figure = dict(data=data, layout=layout)\\n return figure\",\n \"def do_month(ts, routes=\\\"m\\\"):\\n pgconn = get_dbconn(\\\"coop\\\", user=\\\"nobody\\\")\\n ccursor = pgconn.cursor(cursor_factory=psycopg2.extras.DictCursor)\\n nt = NetworkTable(\\\"IACLIMATE\\\")\\n sql = \\\"\\\"\\\"SELECT station, sum(precip) as total, max(day) as lastday\\n from alldata_ia WHERE year = %s and month = %s\\n and station != 'IA0000' and substr(station,2,1) != 'C'\\n GROUP by station\\\"\\\"\\\" % (\\n ts.year,\\n ts.month,\\n )\\n\\n lats = []\\n lons = []\\n vals = []\\n lastday = None\\n ccursor.execute(sql)\\n for row in ccursor:\\n if row[\\\"station\\\"] not in nt.sts:\\n continue\\n if lastday is None:\\n lastday = row[\\\"lastday\\\"]\\n lats.append(nt.sts[row[\\\"station\\\"]][\\\"lat\\\"])\\n lons.append(nt.sts[row[\\\"station\\\"]][\\\"lon\\\"])\\n vals.append(row[\\\"total\\\"])\\n\\n mp = MapPlot(\\n title=\\\"%s - %s\\\"\\n % (ts.strftime(\\\"%d %B %Y\\\"), lastday.strftime(\\\"%d %B %Y\\\")),\\n subtitle=\\\"%s Total Precipitation [inch]\\\" % (ts.strftime(\\\"%B %Y\\\"),),\\n )\\n mp.contourf(\\n lons, lats, vals, [0, 0.1, 0.25, 0.5, 0.75, 1, 2, 3, 4, 5, 6, 7]\\n )\\n mp.plot_values(lons, lats, vals, fmt=\\\"%.2f\\\")\\n\\n pqstr = (\\n \\\"plot %s %s summary/iemre_iowa_total_precip.png \\\"\\n \\\"%s/summary/iemre_iowa_total_precip.png png\\\"\\n ) % (routes, ts.strftime(\\\"%Y%m%d%H%M\\\"), ts.strftime(\\\"%Y/%m\\\"))\\n mp.postprocess(pqstr=pqstr)\",\n \"def pcolorDays(DIVA_results, arg):\\n \\n # use maximum or minimum value:\\n max_min = arg[0]\\n \\n # define what data should be plotted:\\n X = DIVA_results[arg[1]]\\n \\n # define rotation axis:\\n rotation_axis = arg[2]\\n \\n # assign angles and angle_locations: \\n x_angle_location = DIVA_results['angles']['x_angle_location']\\n y_angle_location = DIVA_results['angles']['y_angle_location']\\n allAngles = DIVA_results['angles']['allAngles']\\n \\n if len(arg)==0:\\n max_min = 'min'\\n else:\\n max_min = arg[0]\\n \\n axis_ind =[]\\n \\n if max_min == 'min':\\n ind=np.argmin(X,axis=0)\\n elif max_min == 'max':\\n ind=np.argmax(X,axis=0)\\n\\n\\n z_min=0\\n if rotation_axis == 'x':\\n for i in range(len(ind)):\\n axis_ind.append(x_angle_location[ind[i]])\\n z_max=max(x_angle_location)\\n elif rotation_axis == 'y':\\n for i in range(len(ind)):\\n axis_ind.append(y_angle_location[ind[i]])\\n z_max=max(y_angle_location)\\n elif rotation_axis == 'xy':\\n axis_ind = ind\\n z_max=len(allAngles[0])-1\\n else:\\n print 'axis not available'\\n dx, dy = 1, 1\\n \\n # generate 2 2d grids for the x & y bounds\\n y, x = np.mgrid[slice(0, 24 + dy, dy),\\n slice(0, 365 + dx, dx)]\\n z=[]\\n for i in range(24):\\n z.append([])\\n for j in range(365):\\n z[i].append(axis_ind[24*j + i])\\n z = np.asarray(z)\\n \\n # z_min, z_max = 0, len()\\n #print z_min, z_max\\n \\n #plt.pcolor(x, y, z, cmap='jet', vmin=z_min, vmax=z_max)\\n plt.pcolor(x, y, z, cmap='cubehelix', vmin=z_min, vmax=z_max, rasterized=True)\\n# plt.pcolor(x, y, z, cmap='PRGn', vmin=z_min, vmax=z_max)\\n #plt.pcolor(x, y, z, cmap='nipy_spectral', vmin=z_min, vmax=z_max)\\n\\n #plt.title('pcolor')\\n# plt.xlabel(\\\"Day of the Year\\\")\\n# plt.ylabel(\\\"Hour of the Day\\\")\\n # set the limits of the plot to the limits of the data\\n plt.axis([x.min(), x.max(), y.min(), y.max()])\",\n \"def plot_events(ax, MD):\\n\\n coord_vars = ['CT_at_HB', 'CT_out_HB']\\n ingestion_vars = ['F_Sets', 'at_F_Sets', 'W_Sets', 'at_W_Sets']\\n all_vars = coord_vars + ingestion_vars\\n\\n labels = ['at HB', 'out HB', 'F', 'times at F', 'W', 'times at W']\\n \\n names = ['M', 'M', 'F', 'F', 'W', 'W']\\n idx = [2, 0, 0, 1, 0, 1]\\n colors = [MD.experiment.fcolors[name][idx[c]] for c, name in enumerate(names)]\\n\\n offsets = [-3, -5, -9, -11, -14, -16]\\n height = 1.\\n \\n print \\\"plotting events..\\\"\\n\\n\\n for c, name in enumerate(all_vars):\\n\\n # load\\n if not hasattr(MD, name):\\n MD.load(name)\\n\\n events = getattr(MD, name) / 3600. - 7 \\n\\n offset = offsets[c]\\n color = colors[c]\\n label = str(events.shape[0]) + ' ' + labels[c]\\n\\n if name in ['CT_at_HB', 'CT_out_HB', 'F_Sets', 'W_Sets']:\\n label += ' events'\\n\\n if name in coord_vars:\\n \\n ax.scatter(\\n events, offset * np.ones(events.shape[0]),\\n c=color,\\n marker='|',\\n linewidths=1,\\n edgecolors=None\\n )\\n \\n\\n elif name in ingestion_vars:\\n\\n for x in events: \\n event_patch = patches.Rectangle(\\n (x[0], offset), x[1]-x[0], height, # xy lower left corner, width, height\\n linewidth=0.001,\\n fc=color, \\n ec=color\\n ) \\n ax.add_patch(event_patch) \\n\\n # event descritpion\\n ax.text(31, offset, label, color=color, \\n fontsize=7, ha='left', va='bottom'\\n )\",\n \"def calendar_plot_by_year(series_to_plot, normalize_each_year=False):\\n\\n # calculate number of years\\n start_year = series_to_plot.sort_index().index[0].year\\n end_year = series_to_plot.sort_index().index[-1].year\\n num_years = end_year - start_year + 1\\n\\n # send directly to function if we want to few heatmap across full time period\\n if not normalize_each_year:\\n calmap.calendarplot(series_to_plot, cmap='YlGn', fillcolor='grey', \\\\\\n linewidth=.05, daylabels=['M', 'T', 'W', 'T', 'F', 'S', 'S'], \\\\\\n fig_kws=dict(figsize=(12, 2*num_years)))\\n return\\n\\n # plot each year and build figure\\n fig = plt.figure(figsize=(12, 2*num_years))\\n for i, year in enumerate(range(start_year, end_year + 1), 1):\\n year_to_plot = series_to_plot[series_to_plot.index.year == year]\\n\\n # plot\\n axes = fig.add_subplot(num_years, 1, i)\\n calmap.yearplot(year_to_plot, year=year, cmap='YlGn', fillcolor='grey', linewidth=.05, \\\\\\n daylabels=['M', 'T', 'W', 'T', 'F', 'S', 'S'], ax=axes)\\n axes.set_ylabel(year)\",\n \"def visualizations():\\r\\n raise NotImplementedError\\r\\n # df = pandas.read_csv('accidents_by_hour.csv', index_col=0, header=0)\\r\\n # plt.plot(0, 0, data=df)\\r\\n # plt.show()\\r\",\n \"def plot_using_a_map(self, map, legend_name: str):\\n x_axis, y_axis = zip(*sorted(map.items()))\\n plt.plot(x_axis,\\n y_axis,\\n label=legend_name)\",\n \"def drawMap(self, M):\\n\\n for i in range(M.shape[1]):\\n self.ax.plot (M[1, i], M[2, i], 'gx')\\n\\n self.fig.canvas.draw()\",\n \"def one_period_plot():\\n file = \\\"Data/matfiles/20131221.mat\\\"\\n object = MatReader(file)\\n\\n NeA = object.NeA\\n latA = object.latA\\n times = object.secondsA\\n mlt = object.mltA\\n ind1 = 2606 #lat inds\\n ind2 = 13940 #lat inds\\n \\n ind1 = 3197 #mlat inds\\n ind2 = 14390 #mlat inds\\n \\n T = ind2 - ind1\\n ind1 += int(T/2)\\n ind2 += int(T/2)\\n\\n latA = latA[ind1:ind2]\\n NeA = NeA[ind1:ind2]\\n # NeA = object.meanie(NeA, 5)\\n times = times[ind1:ind2]\\n mlt = mlt[ind1:ind2]\\n mlt = hour_round(mlt)\\n\\n lats = np.zeros_like(latA)\\n lats[0] = latA[0]\\n for i in range(len(latA)-1):\\n dlat = latA[i+1] - latA[i]\\n if dlat < 0:\\n lats[i+1] = lats[i] - dlat\\n else:\\n lats[i+1] = lats[i] + dlat\\n\\n lats += 90\\n\\n xticks = np.array([-90, -70, -30, 30, 70, 110, 150, 210, 250, 270]) + 90\\n gridticks = np.array([-90, -70, -30, 30, 70, 77, 103, 110, 150, 210, 250, 270]) + 90\\n # plt.plot(lats, NeA, \\\".\\\", markersize = 1)\\n # plt.plot([0, 0], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([30, 30], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([60, 60], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([120, 120],[0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([150, 150], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([167, 167], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([193, 193], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([210, 210], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([240, 244], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([300, 300], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([330, 330], [0, np.max(NeA)], \\\"k\\\")\\n # plt.plot([360, 360], [0, np.max(NeA)], \\\"k\\\")\\n # plt.xticks(xticks)\\n # plt.xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n # plt.ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n # plt.title(\\\"One SWARM satellite period\\\")\\n # plt.grid(\\\"on\\\", axis = \\\"x\\\", xdata = gridticks)\\n #adding letters\\n x = (gridticks[:-1] + gridticks[1:])/2 - 3\\n y = np.zeros_like(x) - np.max(NeA)/40\\n s = [\\\"S\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"C\\\", \\\"D\\\", \\\"C\\\", \\\"B\\\", \\\"A\\\", \\\"B\\\", \\\"S\\\"]\\n # for i in range(len(x)):\\n # plt.text(x[i], y[i], s[i], fontsize = 10)\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n # plt.show()\\n\\n # plt.plot(times, latA)\\n # plt.plot(times, mlt)\\n # plt.show()\\n print(lats[0])\\n print(lats[-1])\\n \\n fig, ax = plt.subplots()\\n ax.plot(lats, NeA, \\\".\\\", markersize = 1)\\n ax.set_xticks(xticks, minor=False)\\n ax.set_xticks([167, 193], minor=True)\\n ax.xaxis.grid(True, which = \\\"major\\\")\\n ax.xaxis.grid(True, which = \\\"minor\\\")\\n for i in range(len(x)):\\n ax.text(x[i], y[i], s[i], fontsize = 10)\\n ax.set_xlabel(\\\"Geomagnetic latitude going from 0 to 360 degrees, starting and ending at south pole\\\")\\n ax.set_ylabel(\\\"Electron density [cm$^{-1}$]\\\")\\n ax.set_title(\\\"One Swarm satellite period\\\")\\n # plt.savefig(\\\"Figures/swarm_period.pdf\\\")\\n plt.show()\\n plt.plot(mlt, NeA)\\n plt.show()\\n plt.plot(mlt, lats)\\n plt.show()\",\n \"def showGlobalPlot(self,fsize=[14,14],cmap='jet',m=None,figname='fig'):\\n\\n fig=plt.figure(figsize=(14,14))\\n # read in data to use for plotted points\\n\\n A=[]\\n for key,value in self._ts_dict.iteritems():\\n A.append(np.array([i.replace(\\\"#\\\",\\\" \\\")\\n .split()[0:4] for i in value.index])\\n .astype(float))\\n\\n B=np.array(A[0]).reshape(len(A[0]),4)\\n\\n lat = (B[:,0]+B[:,1])/2\\n lon = (B[:,2]+B[:,3])/2\\n A=[]\\n for key,value in self._ts_dict.iteritems():\\n A.append(value.sum(axis=1).values)\\n\\n val = np.array(A)\\n\\n\\n # determine range to print based on min, max lat and lon of the data\\n margin = 2 # buffer to add to the range\\n lat_min = min(lat) - margin\\n lat_max = max(lat) + margin\\n lon_min = min(lon) - margin\\n lon_max = max(lon) + margin\\n\\n # create map using BASEMAP\\n if m is None:\\n m = Basemap(llcrnrlon=lon_min,\\n llcrnrlat=lat_min,\\n urcrnrlon=lon_max,\\n urcrnrlat=lat_max,\\n lat_0=(lat_max - lat_min)/2,\\n lon_0=(lon_max-lon_min)/2,\\n projection='merc',\\n resolution = 'h',\\n area_thresh=10000.,\\n )\\n m.drawcoastlines()\\n m.drawcountries()\\n m.drawstates()\\n m.drawmapboundary(fill_color='#acbcec')\\n m.fillcontinents(color = 'k',lake_color='#acbcec')\\n\\n # convert lat and lon to map projection coordinates\\n lons, lats = m(lon, lat)\\n # plot points as red dots\\n m.scatter(lons, lats,s=val+1, c=val, cmap=cmap,\\n norm=colors.LogNorm(vmin=np.min(val)+1, vmax=np.max(val)+1),\\n zorder=5)\\n\\n plt.savefig(figname+'.pdf',dpi=300,bbox_inches='tight',transparent=True)\\n\\n return m\",\n \"def _plot_map(self):\\n\\n # Plot points if they exist\\n\\n if len(self._laserX) > 0:\\n self._plot_laser()\\n\\n if len(self._goalX) > 0:\\n self._plot_goal()\\n\\n if len(self._summitX) > 0:\\n self._plot_summit()\\n\\n self._plot_objects()\\n\\n # Update Plot\\n self._fig.canvas.draw_idle()\\n\\n plt.pause(0.01)\",\n \"def plot_landings(df):\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n ax.set_position(default_timeseries_position) \\n\\n Fn = df['CatchMT'].groupby([df.Year, df.Reg, df.Sreg]).mean()\\n\\n all_data = Fn.loc[:, 'All', 'All']\\n ma_data = Fn.loc[:, '1', 'All']\\n gb_data = Fn.loc[:, '2', 'All']\\n\\n # Don't plot the first year. Also, the data is shifted by one year.\\n # For some reason, restricting the year range above results in a series\\n # that still have a multi-index. This seems like the cleanest way to do\\n # that.\\n all_data = all_data.iloc[2:]\\n ma_data = ma_data.iloc[2:]\\n gb_data = gb_data.iloc[2:]\\n all_data.index = all_data.index - 1\\n ma_data.index = ma_data.index - 1\\n gb_data.index = gb_data.index - 1\\n\\n all_data.plot(ax=ax, label='All') \\n ma_data.plot(ax=ax, label='Mid Atlantic')\\n gb_data.plot(ax=ax, label='Georges Bank')\\n\\n ax.legend(loc='best')\\n\\n content = io.BytesIO()\\n plt.savefig(content, format='png')\\n content.seek(0)\\n image_cache['landings']['landings'] = content\\n\\n plt.close()\",\n \"def plotmap(self):\\n if self.plotfigure is None: return\\n\\n self.plotfigure.clf()\\n collist = [\\\"#%.2x%.2x%.2x\\\" % (i, i, i) for i in self.currentshades]\\n cmap = colors.ListedColormap(collist)\\n if self.gs.isfixed:\\n crange = [self.minvalue] + self.currentvalues\\n elif self.gs.isperc:\\n crange = np.percentile(self.imagearray, [0.0] + self.currentpercents)\\n else:\\n crange = np.array([self.minstdd] + self.currentnsigs) * self.stdvalue + self.meanvalue\\n norm = colors.BoundaryNorm(crange, cmap.N)\\n img = plt.imshow(self.imagearray, cmap=cmap, norm=norm, origin='lower')\\n plt.colorbar(img, norm=norm, cmap=cmap, boundaries=crange, ticks=crange)\\n if self.imagetitle is not None:\\n plt.title(self.imagetitle)\",\n \"def maplot_cgt(pdata, colormax=1, mask='no', title='', precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\\n import numpy as np\\n import matplotlib as mpl\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/batch_518/atmos/item3236_monthly_mean/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n plt.figure()\\n if mask == 'yes':\\n lsm = ncread('/home/bakerh/Documents/DPhil/CPDN/\\\\\\nWeather-at-Home_ancilmaker-master/lsm_n96_add.nc', 'lsm')[0, 0, :]\\n pdata = np.ma.masked_array(pdata, mask=np.logical_not(lsm))\\n pdata, lon = shiftgrid(250., pdata, lon, start=False)\\n pdata, lon = addcyclic(pdata, lon)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=0, urcrnrlat=70,\\n llcrnrlon=-110, urcrnrlon=250, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\\n mycmap1 = plt.cm.Blues_r(np.arange(256))\\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\\n my_cmap[230:282, :] = 1\\n if precip == 'yes':\\n my_cmap = my_cmap[::-1]\\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\\\"newjet\\\", my_cmap)\\n ctrs = np.linspace(-colormax, colormax, 17)\\n plot = m.contourf(x, y, pdata, ctrs,\\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\\n extend='both')\\n plt.colorbar(plot, orientation='horizontal',\\n shrink=0.5, spacing='proportional', label='Difference (m)')\\n parallels = m.drawparallels(np.arange(-90., 91., 15.))\\n meridians = m.drawmeridians(np.arange(-180., 181., 30))\\n m.drawparallels(parallels, labels=[True, True, True, True])\\n m.drawmeridians(meridians, labels=[True, True, True, True])\\n plt.title(title, y=1.08)\\n plt.show()\",\n \"def calender(self, month, year):\\n\\n day = ['S', ' M', ' T', ' W', ' Th', 'F', ' S']\\n\\n days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\\n\\n values = 1\\n d = 1\\n\\n m = month\\n y = year\\n y0 = y - (14 - m) // 12\\n x = y0 + y0 // 4 - y0 // 100 + y0 // 400\\n m0 = m + 12 * ((14 - m) // 12) - 2\\n d0 = (d + x + 31 * m0 // 12) % 7\\n\\n if utility_obj.isleap_year(str(year)):\\n days[1] = 29\\n row = 6\\n column = 7\\n two_d_array = [[0 for j in range(column)] for i in range(row)]\\n\\n print('Your Calender is Ready\\\\n')\\n\\n for i in range(0, 6 + 1):\\n print(day[i], end=' ')\\n print()\\n for i in range(row):\\n\\n for j in range(column):\\n\\n if values <= days[m - 1]:\\n if i == 0 and j < d0:\\n two_d_array[i][j] = ' '\\n continue\\n\\n two_d_array[i][j] = values\\n values += 1\\n\\n for i in range(row):\\n\\n for j in range(column):\\n if two_d_array[i][j] != 0:\\n x = two_d_array[i][j]\\n x1 = str(x).ljust(2)\\n print(x1, end=\\\" \\\")\\n\\n print()\",\n \"def map_season(x, figsize=(8, 6), **kwargs):\\n\\n from pycmbs.mapping import map_plot\\n\\n nvals = len(x.data)\\n if nvals == 12:\\n year = True\\n elif nvals == 4:\\n year = False\\n else:\\n raise ValueError('Only data for 4-seasons or monthly data is supported!')\\n\\n #/// checks ///\\n if x.data.ndim != 3:\\n print x.data.ndim\\n raise ValueError('only 3D data supported')\\n\\n if 'vmin' not in kwargs.keys():\\n raise ValueError('vmin argument is obligatory for map_seasons()')\\n if 'vmax' not in kwargs.keys():\\n raise ValueError('vmax argument is obligatory for map_seasons()')\\n\\n if kwargs['vmin'] is None:\\n raise ValueError('vmin MUST NOT be None!')\\n if kwargs['vmax'] is None:\\n raise ValueError('vmax MUST NOT be None!')\\n\\n #/// figure and axes\\n if 'figure' in kwargs:\\n f = kwargs['figure']\\n else:\\n f = plt.figure(figsize=figsize)\\n\\n if 'title' in kwargs:\\n tit = kwargs.pop('title')\\n else:\\n tit = x.label\\n\\n if 'drawparallels' in kwargs:\\n drawparallels = kwargs.pop('drawparallels')\\n else:\\n drawparallels = False\\n\\n if 'savefile' in kwargs:\\n savefile = kwargs.pop('savefile')\\n if '.nc' in savefile:\\n savefile = savefile[:-3]\\n else:\\n savefile = None\\n\\n # plot\\n if year:\\n labels = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']\\n else:\\n labels = ['DJF', 'MAM', 'JJA', 'SON']\\n\\n # check dates\\n if year:\\n mo = 1\\n for t in x.time:\\n if x.num2date(t).month != mo:\\n print x.num2date(t), mo\\n raise ValueError('Invalid monthly sequence! Can not plot results!')\\n mo += 1\\n\\n #/// in case that an overlay is provided, this needs to be processed for each timestep individually\\n if 'overlay' in kwargs.keys():\\n overlays = kwargs.pop('overlay')\\n else:\\n overlays = None\\n\\n for i in range(nvals):\\n if year:\\n ax = f.add_subplot(4, 3, i + 1)\\n #if i % 3 == 2:\\n if i > 8:\\n show_colorbar = True\\n else:\\n show_colorbar = False\\n else:\\n ax = f.add_subplot(2, 2, i + 1)\\n if 'show_colorbar' in kwargs:\\n show_colorbar = kwargs.pop('show_colorbar')\\n else:\\n show_colorbar = True\\n\\n d = x.copy()\\n d.data = x.data[i, :, :]\\n d.label = labels[i]\\n\\n if overlays is None:\\n overlay = None\\n else:\\n overlay = overlays[i, :, :]\\n\\n if savefile is not None:\\n tmpoutname = savefile + '_' + labels[i]\\n else:\\n tmpoutname = None\\n\\n map_plot(d, ax=ax, show_colorbar=show_colorbar, overlay=overlay,\\n savefile=tmpoutname, colorbar_orientation='horizontal',\\n drawparallels=drawparallels, **kwargs)\\n del d\\n f.suptitle(tit, size=16)\\n return f\",\n \"def maplot_subs(va500, cmax=1, colormin=-999, precip='no'):\\n from mpl_toolkits.basemap import Basemap, shiftgrid, addcyclic\\n import numpy as np\\n import matplotlib as mpl\\n import matplotlib.pyplot as plt\\n from netcdfread import ncread\\n fig = plt.figure(facecolor='w', edgecolor='k', linewidth=2)\\n\\n def plotter(pdata, colormax=1, colormin=-999, title=''):\\n lon = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'longitude0')\\n lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/All-Hist/mon/tas/item3236_monthly_mean_a011_2006-01_2016-12.nc', 'latitude0')\\n #lat = ncread('/network/aopp/hera/mad/bakerh/HAPPI/HadAM3P-N96/Plus15-Future_LCO2/day/ua/item15201_daily_mean_a00b_2090-01_2100-12.nc', 'latitude1') \\n if colormin == -999:\\n colormin = -colormax\\n pdata, lon = shiftgrid(180., pdata, lon, start=False)\\n pdata, lon = addcyclic(pdata, lon)\\n meshlon, meshlat = np.meshgrid(lon, lat)\\n\\n m = Basemap(projection='cyl', llcrnrlat=-90, urcrnrlat=90,\\n llcrnrlon=-180, urcrnrlon=180, resolution='c')\\n m.drawcoastlines()\\n m.drawmapboundary()\\n x, y = m(meshlon, meshlat)\\n mycmap2 = plt.cm.YlOrRd(np.arange(256))\\n mycmap1 = plt.cm.Blues_r(np.arange(256))\\n my_cmap = np.concatenate((mycmap1, mycmap2), axis=0)\\n my_cmap[230:282, :] = 1\\n if precip == 'yes':\\n my_cmap = my_cmap[::-1]\\n newcmap = mpl.colors.LinearSegmentedColormap.from_list(\\\"newjet\\\", my_cmap)\\n ctrs = np.linspace(colormin, colormax, 17)\\n plot = m.contourf(x, y, pdata, ctrs,\\n cmap=newcmap, vmin=np.min(ctrs), vmax=np.max(ctrs),\\n extend='both')\\n\\n plt.title(title, y=1)\\n plt.show()\\n return plot\\n\\n ax1 = fig.add_subplot(3, 3, 1)\\n plotter(np.mean(va500['All-Hist'][1],axis=0)-273.15,colormax=cmax*40,title='All-Hist (multiply scale by 40)')\\n ax2 = fig.add_subplot(3, 3, 2)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='All-Hist - All-Nat')\\n ax3 = fig.add_subplot(3, 3, 3)\\n plotter(np.mean(va500['Plus15-Future'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future - All-Hist')\\n ax4 = fig.add_subplot(3, 3, 4)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['GHG-Nat'][1],axis=0),colormax=cmax,title='All-Hist - GHG-Nat')\\n ax5 = fig.add_subplot(3, 3, 5)\\n plotter(np.mean(va500['SST-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='SST-Nat - All-Nat')\\n ax6 = fig.add_subplot(3, 3, 6)\\n plotter(np.mean(va500['Plus15-Future_HCO2'][1], axis=0)-np.mean(va500['Plus15-Future_LCO2'][1],axis=0),colormax=cmax,title='Plus15-Future_HCO2 - Plus15-Future_LCO2')\\n ax7 = fig.add_subplot(3, 3, 7)\\n plotter(np.mean(va500['All-Hist'][1], axis=0)-np.mean(va500['SST-Nat'][1],axis=0),colormax=cmax,title='All-Hist - SST-Nat')\\n ax8 = fig.add_subplot(3, 3, 9)\\n plotter(np.mean(va500['Plus15-Future_LCO2'][1], axis=0)-np.mean(va500['All-Hist'][1],axis=0),colormax=cmax,title='Plus15-Future_LCO2 - All-Hist')\\n ax9 = fig.add_subplot(3, 3, 8)\\n plot = plotter(np.mean(va500['GHG-Nat'][1], axis=0)-np.mean(va500['All-Nat'][1],axis=0),colormax=cmax,title='GHG-Nat - All-Nat')\\n\\n cbar_ax = fig.add_axes([0.2, 0.1, 0.6, 0.015])\\n b = fig.colorbar(plot, cax=cbar_ax, spacing='proportional',\\n orientation='horizontal', extend='max')\\n \\n b.set_label(label='t200 difference ($^\\\\circ$C)', size=20, fontsize=20, fontname='Arial')\\n plt.subplots_adjust(hspace=0, wspace=0.05, top=.97, bottom=0.15, left=.05,\\n right=.95)\",\n \"def plotCurrentTimeAnticipatory(s, ne,nc, gs):\\n fig, ax = plt.subplots()\\n ax.set_title('time: {0}'.format(s.time))\\n for c in range(nc):\\n carTemp = s.cars.getObject(c)\\n ax.scatter(carTemp.position[0], carTemp.position[1], c='k', alpha=0.5)\\n ax.scatter([], [], c='b', marker='*', label='Opened not commited')\\n ax.scatter([], [], c='b', label='Opened commited')\\n ax.scatter([], [], c='r', label='Canceled')\\n ax.scatter([], [], c='g', label='Closed')\\n for i in range(ne):\\n eventTemp = s.events.getObject(i)\\n if eventTemp.status == Status.OPENED_COMMITED:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', alpha=0.7)\\n elif eventTemp.status == Status.OPENED_NOT_COMMITED:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='b', marker='*', alpha=0.7)\\n elif (eventTemp.status == Status.CLOSED):\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='g', alpha=0.2)\\n elif (eventTemp.status == Status.CANCELED):\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='r', alpha=0.2)\\n else:\\n ax.scatter(eventTemp.position[0], eventTemp.position[1], c='y', alpha=0.2)\\n ax.set_xlim([-1, gs + 1])\\n ax.set_ylim([-1, gs + 1])\\n ax.grid(True)\\n plt.legend()\\n # Used to return the plot as an image rray\\n fig.canvas.draw() # draw the canvas, cache the renderer\\n image = np.frombuffer(fig.canvas.tostring_rgb(), dtype='uint8')\\n image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\\n return image\",\n \"def plot_all(self, highlight_desert=False, highlight_steppe=False,\\n area=None, highlight=None):\\n if area is None:\\n area = Rectangle.entire_map(self.world)\\n for era in self.date_ranges:\\n self.plot(era, highlight_desert, highlight_steppe, area, highlight)\",\n \"def draw_map(fig, ax, coll, bgcolor=\\\"white\\\", lims=40):\\r\\n ax.set_axis_bgcolor(bgcolor)\\r\\n ax.set_aspect(\\\"equal\\\")\\r\\n ax.add_collection(coll)\\r\\n ax.minorticks_on()\\r\\n ax.set_xlim([lims, -lims])\\r\\n ax.set_ylim([-lims, lims])\\r\\n return\",\n \"def plot_map(self,map_options=None) :\\n\\n if map_options is not None :\\n self.map_options.update(map_options)\\n\\n # TODO: Add custom sizing and resolution specifications\\n fig = plt.figure(figsize=(self.map_options['img_size'][0]/2.54,\\n self.map_options['img_size'][1]/2.54))\\n\\n # TODO: Accept custom projections\\n proj = ccrs.Mercator()\\n\\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\\n ax = fig.add_subplot(1,1,1,projection = proj)\\n\\n # TODO: Increase flexibility of borders consideration\\n if self.map_options['brdr_nation'] :\\n ax.add_feature(cfeat.BORDERS)\\n\\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\\n extents=[self.lon[0],self.lon[-1],self.lat[0],self.lat[-1]]\\n ax.set_extent(extents)\\n\\n # Confusingly, this code correctly translate the lat/lon limits into the projected coordinates\\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\\n extents_proj = extents_proj[:,:2].flatten(order='F')\\n\\n # TODO: Custom colormaps, interpolation, cropping\\n im = ax.imshow(self.map,extent=extents_proj,transform=proj,origin='lower',\\n cmap=self.map_options['cmap'],interpolation='bicubic')\\n\\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\\n if self.map_options['title'] is not None :\\n ax.set_title(self.map_options['title'])\\n\\n # TODO: Add support for horizontal\\n if self.map_options['cbar'] :\\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\\n cb.ax.set_xlabel(self.units)\\n\\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\\n if self.map_options['save'] :\\n # Generate timestamp filename if relying on default\\n if self.map_options['img_filename'] == \\\"timestamp\\\" :\\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\\n\\n plt.savefig(self.map_options['img_dir']+img_filename+\\\".\\\"+self.map_options['img_filetype'],\\n bbox_inches=\\\"tight\\\",dpi=self.map_options['img_dpi'])\\n\\n plt.show()\\n\\n return self\",\n \"def draw_map(data, title, output):\\n import cartopy.crs as ccrs\\n\\n coords = get_lat_lon(data).values()\\n\\n lat = [coord[0] for coord in coords]\\n lon = [coord[1] for coord in coords]\\n\\n ax = plt.axes(projection=ccrs.PlateCarree())\\n ax.stock_img()\\n ax.coastlines()\\n ax.scatter(lon, lat, marker='o', s=50, alpha=0.8)\\n ax.set_extent([-75, -20, -35, 5], crs=ccrs.PlateCarree())\\n ax.set_title(title)\\n plt.savefig(output)\",\n \"def plotGlobal(metric):\\n #set plotting details for each metric\\n if metric == 'corr':\\n dat = starter()[0]\\n varToPlot = 'Correlation'\\n title = 'Pearson\\\\'s Correlation - 1980-2010'\\n bubbleSizeMultiplier = 200\\n elif metric == 'nse':\\n dat = starter()[2]\\n# <<<<<<< HEAD\\n# varToPlot = 'NSE(%)'\\n# title = 'NSE(%) - 1980-2010' \\n# bubbleSizeMultiplier = 3\\n# =======\\n varToPlot = 'NNSE'\\n title = 'NNSE - 1980-2010' \\n bubbleSizeMultiplier = 200\\n# >>>>>>> kiko-stuff\\n else:\\n dat = starter()[1]\\n varToPlot = 'RMSE(cm)'\\n title = 'RMSE(cm) - 1980-2010'\\n bubbleSizeMultiplier = 10\\n\\n #increase plot font size\\n sns.set_context('notebook', font_scale = 1.5)\\n \\n plt.figure(figsize=(20, 10))\\n m=Basemap(projection='cyl', lat_ts=20, llcrnrlon=-180, \\n urcrnrlon=180,llcrnrlat=-90,urcrnrlat=90, resolution='c')\\n x,y = m(dat['lon'].tolist(), dat['lat'].tolist())\\n m.drawcoastlines()\\n\\n #get degree signs \\n parallels = np.arange(-80,81,20.)\\n meridians = np.arange(-180.,180.,40.)\\n #labels = [left,right,top,bottom]\\n m.drawparallels(parallels,labels=[True,True,False,False], linewidth = 0.5)\\n m.drawmeridians(meridians,labels=[False,False,False,True], linewidth = 0.5)\\n\\n m.bluemarble(alpha = 0.8) \\n \\n #define markers -use same for all for now\\n markers = {\\\"20CR\\\": \\\"o\\\", \\\"ERA-20C\\\": \\\"o\\\", \\\"ERA-Interim\\\":'o', \\\"MERRA\\\":'o', \\\"ERA-FIVE\\\":'o'}\\n #define palette\\n color_dict = dict({'20CR':'green',\\n 'ERA-20C':'magenta',\\n 'ERA-Interim': 'black',\\n 'MERRA': 'red',\\n 'ERA-FIVE':'aqua'\\n })\\n #define bubble sizes\\n minSize = min(dat[varToPlot])*bubbleSizeMultiplier\\n if minSize < 0:\\n minSize = 0\\n maxSize = max(dat[varToPlot])*bubbleSizeMultiplier\\n \\n sns.scatterplot(x = x, y = y, markers = markers, style = 'Reanalysis',\\\\\\n size = varToPlot, sizes=(minSize, maxSize),\\\\\\n hue = 'Reanalysis', palette = color_dict, data = dat)\\n plt.legend(loc = 'lower left', ncol = 12)\\n plt.title(title)\\n os.chdir('G:\\\\\\\\data\\\\\\\\allReconstructions\\\\\\\\validation\\\\\\\\commonPeriodValidation\\\\\\\\plotFiles')\\n saveName = 'allReanalyses'+metric+'.svg'\\n plt.savefig(saveName, dpi = 400)\",\n \"def oneplot(moviedict, toplotdict, figw, figh, figdpi, fontsz, border, ylabel, ylim, time, ymin, \\n lw):\\n print(toplotdict.keys())\\n \\n fontv = mpl.font_manager.FontProperties()\\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \\n # similar (just slightly narrower).\\n fontv = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/arial.ttf')\\n fontv.set_size(fontsz)\\n \\n fonti = mpl.font_manager.FontProperties()\\n # Uncomment line below to set the font to verdana; the default matplotlib font is very \\n #similar (just slightly narrower).\\n fonti = mpl.font_manager.FontProperties(fname='/usr/share/matplotlib/mpl-data/fonts/ttf/ariali.ttf')\\n fonti.set_size(fontsz)\\n \\n fig1 = plt.figure(figsize=(figw, figh), dpi=figdpi, facecolor='w', edgecolor='k')\\n \\n #Plots data on one graph with parameters specified in the moviedict directory.\\n for k, v in moviedict.iteritems():\\n print(k)\\n cond1, offset, color, inum = v\\n xvals = toplotdict[k][0]\\n data = toplotdict[k][1] + offset\\n condition = cond1\\n \\n\\n plt.plot(xvals, data, color, linewidth=0.75, label=condition)\\n print(condition)\\n #if k == 'mov_20110113_180524':\\n #plt.text(0.5, offset+7, inum+condition, horizontalalignment='left', \\n #fontproperties=fontv)\\n #else:\\n #plt.text(0.5, offset+9, inum+condition, horizontalalignment='left', \\n #fontproperties=fontv)\\n \\n # Plots text labels\\n \\n if k == 'mov_20101130_200030':\\n plt.text(0.03, offset+6, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.11, offset+6.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n if k == 'mov_20101130_201605':\\n plt.text(0.03, offset+5, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.125, offset+5.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n if k == 'mov_20101213_193258':\\n plt.text(0.03, offset+3, inum, horizontalalignment='left', fontproperties=fontv)\\n plt.text(0.137, offset+3.5, condition, horizontalalignment='left', \\n fontproperties=fonti)\\n\\n ax = plt.gca()\\n\\n ## Plots legend.\\n #legend = plt.legend()\\n ### Manipulates order of the legend entries.\\n ##handles, labels = ax.get_legend_handles_labels()\\n ##handles2 = handles[0], handles[2], handles[1], handles[3]\\n ##labels2 = labels[0], labels[2], labels[1], labels[3]\\n ##legend = ax.legend(handles2, labels2, bbox_to_anchor=(0, 0, 1, 1), \\n ##transform=plt.gcf().transFigure)\\n ### Changes legend font to fontsz.\\n #ltext = legend.get_texts()\\n #plt.setp(ltext, fontsize=fontsz)\\n ### Removes border around the legend.\\n #legend.draw_frame(False)\\n \\n \\n #Uncomment lines below to display without top and right borders.\\n if border == 'no':\\n for loc, spine in ax.spines.iteritems():\\n if loc in ['left','bottom']:\\n pass\\n elif loc in ['right','top']:\\n spine.set_color('none') # don't draw spine\\n else:\\n raise ValueError('unknown spine location: %s'%loc)\\n \\n #Uncomment lines below to display ticks only where there are borders.\\n ax.xaxis.set_ticks_position('bottom')\\n ax.yaxis.set_ticks_position('left')\\n ## Removes tick labels and ticks from yaxis.\\n ax.axes.yaxis.set_major_locator(matplotlib.ticker.NullLocator())\\n \\n # Specifies axis labels and axis tick label sizes.\\n plt.xlabel(XLABEL, fontproperties=fontv, labelpad=4)\\n plt.ylabel(ylabel, fontproperties=fontv, labelpad=4)\\n plt.xticks(fontproperties=fontv)\\n plt.yticks(fontproperties=fontv)\\n \\n # Specifies axis limits.\\n plt.axis( [0, time, ymin, ylim])\\n \\n # Adjusts the space between the plot and the edges of the figure; (0,0) is the lower lefthand corner of the figure.\\n fig1.subplots_adjust(top=0.95)\\n fig1.subplots_adjust(left=0.15)\\n #fig1.subplots_adjust(right=0.95)\\n fig1.subplots_adjust(bottom=0.15)\",\n \"def plot_map(priors):\\n sns.set_style(\\\"white\\\")\\n\\n cmap=sns.cubehelix_palette(8, start=.5, rot=-.75,as_cmap=True)\\n hdulists=list(map(lambda prior:postmaps.make_fits_image(prior,prior.sim), priors))\\n fig = plt.figure(figsize=(10*len(priors),10))\\n figs=[]\\n for i in range(0,len(priors)):\\n figs.append(aplpy.FITSFigure(hdulists[i][1],figure=fig,subplot=(1,len(priors),i+1)))\\n\\n for i in range(0,len(priors)):\\n vmin=np.min(priors[i].sim)\\n vmax=np.max(priors[i].sim)\\n figs[i].show_colorscale(vmin=vmin,vmax=vmax,cmap=cmap)\\n figs[i].show_markers(priors[i].sra, priors[i].sdec, edgecolor='black', facecolor='black',\\n marker='o', s=20, alpha=0.5)\\n figs[i].tick_labels.set_xformat('dd.dd')\\n figs[i].tick_labels.set_yformat('dd.dd')\\n figs[i].add_colorbar()\\n figs[i].colorbar.set_location('top')\\n return figs,fig\",\n \"def draw_map(gdf_wrf_all, gdf_wrf_rw, gdf_rw):\\n fig = plt.figure(figsize=(6, 6))\\n ax = plt.axes(projection=ccrs.PlateCarree())\\n ax.coastlines(resolution='10m')\\n states_provinces = cfeature.NaturalEarthFeature(\\n category='cultural',\\n name='admin_1_states_provinces_lines',\\n scale='10m',\\n facecolor='none')\\n ax.add_feature(states_provinces, edgecolor='black')\\n ax.add_geometries(geoms=gdf_wrf_rw.geometry, crs=ccrs.Mercator.GOOGLE,\\n facecolor='#1b9e77', edgecolor='black', alpha=0.5,\\n label='Redwood range')\\n ax.add_geometries(geoms=gdf_wrf_all.geometry, crs=ccrs.Mercator.GOOGLE,\\n facecolor='white', edgecolor='black', alpha=0.3,\\n\\n label='WRF cells with redwoods')\\n ax.add_geometries(geoms=gdf_rw.geometry, crs=ccrs.Mercator.GOOGLE,\\n facecolor='#d95f02', edgecolor='black', alpha=0.5,\\n label='WRF cells with redwoods')\\n bounds = gdf_wrf.total_bounds\\n ax.set_extent(bounds[(0, 2, 1, 3), ], crs=ccrs.Mercator.GOOGLE)\\n\\n # make proxy artists for a legend\\n redwoods = mpatches.Rectangle((0, 0), 1, 1, facecolor='#d95f02')\\n wrf_cells = mpatches.Rectangle((0, 0), 1, 1, facecolor='white',\\n edgecolor='black', alpha=0.3)\\n wrf_redwoods = mpatches.Rectangle((0, 0), 1, 1, facecolor='#1b9e77',\\n edgecolor='black', alpha=0.5)\\n labels = ['Redwoods range',\\n 'WRF grid',\\n 'WRF cells with redwoods']\\n plt.legend([redwoods, wrf_cells, wrf_redwoods], labels,\\n loc='lower left', bbox_to_anchor=(0.025, -0.1), fancybox=True)\\n\\n plt.show()\",\n \"def makePlot(ra, dec, date=None, name=None, figsize=(6.,6.), dpi=80, s=50, center=None, airmass=True, moon=True, des=True):\\n #figsize=(10.5,8.5)\\n if date is None: date = ephem.now()\\n if type(date) != ephem.Date:\\n date = ephem.Date(date)\\n\\n observatory = utils.ctio()\\n observatory.date = date\\n \\n #fig, ax = plt.subplots(fig='ortho', figsize=FIGSIZE, dpi=DPI)\\n #fig = plt.figure('ortho')\\n #ax = plt.subplots(figure=fig, figsize=FIGSIZE, dpi=DPI)\\n fig = plt.figure(name, figsize=figsize, dpi=dpi)\\n\\n ra_zenith, dec_zenith = observatory.radec_of(0, '90') # RA and Dec of zenith\\n ra_zenith = np.degrees(ra_zenith)\\n dec_zenith = np.degrees(dec_zenith)\\n\\n # Zenith position\\n #lon_zen = LMC_RA; lat_zen = LMC_DEC\\n lon_zen = ra_zenith; lat_zen = dec_zenith\\n\\n # Create the basemap\\n proj_kwargs = dict(projection='ortho', celestial=True)\\n if center is None:\\n lon_0, lat_0 = -lon_zen, lat_zen # Center position\\n else:\\n lon_0, lat_0 = center[0], center[1]\\n\\n proj_kwargs.update(lon_0=lon_0, lat_0=lat_0)\\n #print proj_kwargs\\n print(proj_kwargs)\\n basemap = DECamBasemap(**proj_kwargs)\\n\\n parallels = np.arange(-90.,120.,30.)\\n basemap.drawparallels(parallels)\\n meridians = np.arange(0.,420.,60.)\\n basemap.drawmeridians(meridians)\\n\\n if des: drawDES(basemap)\\n if airmass: drawAirmassContour(basemap, observatory, 2., s=s)\\n if moon: drawMoon(basemap, date)\\n plt.title('%s UTC'%(datestring(date)))\\n \\n drawTarget(basemap, ra, dec)\\n\\n #return fig, ax, basemap\\n return fig, basemap\",\n \"def draw_weather_analysis(date_obj, data, map_region, return_dict):\\n\\n # image dictionary\\n images = collections.OrderedDict()\\n return_dict[0] = None\\n\\n # draw 2PVU surface pressure\\n image = pv.draw_pres_pv2(\\n data['pres_pv2'].values, data['pres_pv2']['lon'].values, data['pres_pv2']['lat'].values,\\n map_region=map_region, title_kwargs={'name':'CFSR', 'time': date_obj})\\n images['2PVU_Surface_Pressure'] = image\\n\\n # draw 200hPa wind field\\n image = dynamics.draw_wind_upper(\\n data['u200'].values, data['v200'].values, \\n data['u200']['lon'].values, data['u200']['lat'].values,\\n gh=data['gh200'].values, map_region=map_region, \\n title_kwargs={'name':'CFSR', 'head': \\\"200hPa Wind | GH\\\", 'time': date_obj})\\n images['200hPa_Wind'] = image\\n\\n # draw 500hPa height and temperature\\n image = dynamics.draw_height_temp(\\n data['gh500'].values, data['t500'].values, \\n data['gh500']['lon'].values, data['gh500']['lat'].values, map_region=map_region, \\n title_kwargs={'name':'CFSR', 'head': \\\"500hPa GH | T\\\", 'time': date_obj})\\n images['500hPa_Height'] = image\\n\\n # draw 500hPa vorticity\\n image = dynamics.draw_vort_high(\\n data['u500'].values, data['v500'].values, \\n data['u500']['lon'].values, data['u500']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"500hPa Wind | Vorticity | GH\\\", 'time': date_obj})\\n images['500hPa_Vorticity'] = image\\n\\n # draw 700hPa vertical velocity\\n image = dynamics.draw_vvel_high(\\n data['u700'].values, data['v700'].values, data['w700'].values, \\n data['w700']['lon'].values, data['w700']['lat'].values,\\n gh=data['gh700'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"700hPa Vertical Velocity | Wind | GH\\\", 'time': date_obj})\\n images['700hPa_Vertical_Velocity'] = image\\n\\n # draw 700hPa wind field\\n image = dynamics.draw_wind_high(\\n data['u700'].values, data['v700'].values, \\n data['u700']['lon'].values, data['u700']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"700hPa Wind | 500hPa GH\\\", 'time': date_obj})\\n images['700hPa_Wind'] = image\\n\\n # draw 700hPa temperature field\\n image = thermal.draw_temp_high(\\n data['t700'].values, data['t700']['lon'].values, data['t700']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"700hPa T | 500hPa GH\\\", 'time': date_obj})\\n images['700hPa_Temperature'] = image\\n\\n # draw 700hPa relative humidity\\n rh = calc.relative_humidity_from_specific_humidity(700 * units.hPa, data['t700'], data['q700']) * 100\\n image = moisture.draw_rh_high(\\n data['u700'].values, data['v700'].values, rh.values,\\n data['u700']['lon'].values, data['u700']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"700hPa RH | Wind | 500hPa GH\\\", 'time': date_obj})\\n images['700hPa_Relative_Humidity'] = image\\n\\n # draw 850hPa wind field\\n image = dynamics.draw_wind_high(\\n data['u850'].values, data['v850'].values, \\n data['u850']['lon'].values, data['u850']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"850hPa Wind | 500hPa GH\\\", 'time': date_obj})\\n images['850hPa_Wind'] = image\\n\\n # draw 850hPa temperature field\\n image = thermal.draw_temp_high(\\n data['t850'].values, data['t850']['lon'].values, data['t850']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"850hPa T | 500hPa GH\\\", 'time': date_obj})\\n images['850hPa_Temperature'] = image\\n\\n # draw 850hPa relative humidity\\n rh = calc.relative_humidity_from_specific_humidity(850 * units.hPa, data['t850'], data['q850']) * 100\\n image = moisture.draw_rh_high(\\n data['u850'].values, data['v850'].values, rh.values,\\n data['u850']['lon'].values, data['u850']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"850hPa RH | Wind | 500hPa GH\\\", 'time': date_obj})\\n images['850hPa_Relative_Humidity'] = image\\n\\n # draw 850hPa specific field\\n image = moisture.draw_sp_high(\\n data['u850'].values, data['v850'].values, data['q850'].values*1000.,\\n data['q850']['lon'].values, data['q850']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"850hPa SP | Wind | 500hPa GH\\\", 'time': date_obj})\\n images['850hPa_Specific_Humidity'] = image\\n\\n # draw 925hPa temperature field\\n image = thermal.draw_temp_high(\\n data['t925'].values, data['t925']['lon'].values, data['t925']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"925hPa T | 500hPa GH\\\", 'time': date_obj})\\n images['925hPa_Temperature'] = image\\n\\n # draw 925hPa wind field\\n image = dynamics.draw_wind_high(\\n data['u925'].values, data['v925'].values, \\n data['u925']['lon'].values, data['u925']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"925hPa Wind | 500hPa GH\\\", 'time': date_obj})\\n images['925hPa_Wind'] = image\\n\\n # draw 925hPa relative humidity\\n rh = calc.relative_humidity_from_specific_humidity(925 * units.hPa, data['t925'], data['q925']) * 100\\n image = moisture.draw_rh_high(\\n data['u925'].values, data['v925'].values, rh.values,\\n data['u925']['lon'].values, data['u925']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"925hPa RH | Wind | 500hPa GH\\\", 'time': date_obj})\\n images['925hPa_Relative_Humdity'] = image\\n\\n # draw 925hPa specific field\\n image = moisture.draw_sp_high(\\n data['u925'].values, data['v925'].values, data['q925'].values*1000.,\\n data['q925']['lon'].values, data['q925']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"925hPa SP | Wind | 500hPa GH\\\", 'time': date_obj})\\n images['925hPa_Specific_Humidity'] = image\\n\\n # draw precipitable water field\\n image = moisture.draw_pwat(\\n data['pwat'].values, data['pwat']['lon'].values, data['pwat']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"Precipitable Water | 500hPa GH\\\", 'time': date_obj})\\n images['Precipitable_Water'] = image\\n\\n # draw mean sea level pressure field\\n image = dynamics.draw_mslp(\\n data['mslp'].values, data['mslp']['lon'].values, data['mslp']['lat'].values,\\n gh=data['gh500'].values, map_region=map_region,\\n title_kwargs={'name':'CFSR', 'head': \\\"MSLP | 500hPa GH\\\", 'time': date_obj})\\n images['Mean_Sea_Level_Pressure'] = image\\n\\n return_dict[0] = images\",\n \"def display_calendar(daze, month, year):\\n log = daze.dateDict\\n if not year:\\n year = date.today().year # defaults to this year\\n if month:\\n first = date(year, month, 1)\\n last = max([day for day in cal.itermonthdates(year, month) if day.month == month])\\n s, ndates, firstdate, lastdate = daze.summarize(firstdate=first, lastdate=last)\\n else:\\n s, ndates, firstdate, lastdate = daze.summarize()\\n places = sorted(s, key=s.get, reverse=True)\\n colors = ['green', 'magenta', 'white', 'cyan', 'blue', 'red', 'yellow']\\n months = calendar.month_name[1:]\\n dates = [firstdate + timedelta(days=i) for i in range((lastdate - firstdate).days + 1)]\\n\\n matches = {p: c for (p, c) in zip(places, colors)}\\n\\n for (p, c) in matches.items():\\n click.secho(\\\" %s \\\" % p, bg=c, fg='black', bold=True)\\n\\n for _date in dates:\\n if _date.day == 1 or _date == firstdate:\\n click.echo('')\\n click.echo(\\\"\\\\n\\\" + months[_date.month - 1])\\n if (_date.isoweekday() != 7):\\n click.echo(\\\" \\\" * 3 * _date.isoweekday(), nl=False)\\n if _date in log:\\n p = log[_date]\\n click.secho(\\\"%s\\\" % str(_date.day).rjust(3),\\n fg='black',\\n bg=matches[p],\\n nl=(_date.isoweekday() == 6))\\n else:\\n click.secho(\\\"%s\\\" % str(_date.day).rjust(3),\\n fg='black', nl=(_date.isoweekday() == 6))\\n\\n click.echo('\\\\n\\\\n\\\\n')\",\n \"def createMap(title_in, file_in, fig_file_in, N, vmin, vmax, lon_in,\\n lat_in, sss_in, colors, label='SSS [PSS]'):\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.set_title(title_in)\\n plt.figtext(1, 0, file_in, ha='right', va='bottom', fontsize=6)\\n\\n map = Basemap(projection='moll', resolution='l', lon_0=-50, ellps='WGS84', anchor='S')\\n map.drawcoastlines(linewidth=0.01, antialiased=False)\\n map.drawmapboundary(fill_color='white', linewidth=0.01)\\n map.drawmeridians(np.arange(-180,181,60), labels=[0,0,0,0], linewidth=0.01, labelstyle=None)\\n map.drawparallels(np.arange(-90,91,30), labels=[1,0,0,0], linewidth=0.01, labelstyle=None) \\n map.fillcontinents(color='grey')\\n\\n ticks = np.linspace(vmin, vmax, N+1)\\n \\n lonout, z = map.shiftdata(lon_in, sss_in, lon_0=-50)\\n lon, lat = np.meshgrid(lonout, lat_in)\\n x, y = map(lon, lat)\\n\\n cmap = cm.get_cmap(colors, N)\\n cmap.set_bad('1.0')\\n cmap.set_under((0.0, 0.0, 0.25, 1.0))\\n cmap.set_over((0.25, 0.0, 0.0, 1.0))\\n\\n pc = map.pcolormesh(x, y, z, vmin=vmin, vmax=vmax, cmap=cmap)\\n cb = plt.colorbar(pc, shrink=0.8, orientation='horizontal', fraction=0.04, extend ='both', ticks=ticks)\\n cb.set_label(label)\\n plt.savefig(fig_file_in)\\n logging.debug(fig_file_in +' .... created!' )\\n plt.close()\\n\\n return None\",\n \"def three_moment0_maps(gal_indices,lines,**kwargs):\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n fig = plt.figure(figsize=(17,14),constrained_layout=False)\\n gs1 = fig.add_gridspec(nrows=3, ncols=3, wspace=0.05, hspace=0.02)\\n\\n if not p.R_max: p.R_max = [60.]*3\\n\\n rotate = False\\n for row_i,gal_index in enumerate(gal_indices):\\n line_i = 0\\n for quant in lines:\\n legend = True\\n label = False\\n if quant == lines[-1]: label = True\\n #if line_i == len(lines)-1: legend = True\\n ax1 = fig.add_subplot(gs1[row_i,line_i])\\n moment0_map(gal_index=gal_index,cmap=p.cmap,quant=quant,add=True,ax=ax1,R_max=p.R_max[row_i],legend=legend,label=label)\\n # Make a size indicator\\n ax1.set_xlim([-p.R_max[row_i],p.R_max[row_i]]); ax1.set_ylim([-p.R_max[row_i],p.R_max[row_i]])\\n ax1.plot([p.R_max[row_i]*(1-0.35),p.R_max[row_i]*(1-0.35)+10],[p.R_max[row_i]*(-1+0.15),p.R_max[row_i]*(-1+0.15)],lw=4,color='white')\\n ax1.text(p.R_max[row_i]*(1-0.45),p.R_max[row_i]*(-1+0.25),'10 kpc',color='white',fontsize=14)\\n # Remove axes ticks\\n ax1.tick_params(axis='x',which='both',labelbottom=False,bottom=False,top=False)\\n ax1.tick_params(axis='y',which='both',labelleft=False,bottom=False,top=False) \\n line_i += 1\\n ax1.text(p.R_max[row_i]*(-1+0.15),p.R_max[row_i]*(1-0.2),quant.replace('L_',''),color='white',fontsize=18)\\n # s = segs\\n\\n gs1.update(top=0.98,bottom=0.02,left=0.02,right=0.93)\\n #fig.text(0.97,0.5, 'log surface brightness density (Jy${\\\\cdot}$km/s / kpc$^2$)', va='center', ha='center', fontsize=22, rotation='vertical')\\n plt.tight_layout()\\n\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'pretty/'): os.mkdir(p.d_plot + 'pretty/')\\n plt.savefig('plots/pretty/moment0_maps.png',format='png',dpi=200)\",\n \"def display_map(grid):\\n fig, ax = plt.subplots(figsize=(7, 7))\\n\\n major_ticks_x = np.arange(0, LENGTH_case + 1, 5)\\n minor_ticks_x = np.arange(0, LENGTH_case + 1, 1)\\n major_ticks_y = np.arange(0, WIDTH_case + 1, 5)\\n minor_ticks_y = np.arange(0, WIDTH_case + 1, 1)\\n ax.set_xticks(major_ticks_x)\\n ax.set_xticks(minor_ticks_x, minor=True)\\n ax.set_yticks(major_ticks_y)\\n ax.set_yticks(minor_ticks_y, minor=True)\\n ax.grid(which='minor', alpha=0.2)\\n ax.grid(which='major', alpha=0.5)\\n ax.set_ylim([0, WIDTH_case])\\n ax.set_xlim([0, LENGTH_case])\\n ax.grid(True)\\n\\n # Select the colors with which to display obstacles and free cells\\n cmap = colors.ListedColormap(['white', 'red'])\\n\\n # Displaying the map\\n ax.imshow(grid, cmap=cmap)\\n plt.title(\\\"Map : free cells in white, occupied cells in red\\\");\\n\\n return fig, ax\",\n \"def _bokeh_visualization(\\n calendar: \\\"Calendar\\\",\\n n_years: int,\\n relative_dates: bool,\\n add_yticklabels: bool = True,\\n **kwargs,\\n) -> plotting.figure:\\n if add_yticklabels:\\n tooltips = [\\n (\\\"Interval\\\", \\\"@desc\\\"),\\n (\\\"Size\\\", \\\"@width_days days\\\"),\\n (\\\"Type\\\", \\\"@type\\\"),\\n ]\\n else:\\n # Do not show the actual intervals, as the calendar is not mapped.\\n tooltips = [(\\\"Size\\\", \\\"@width_days days\\\"), (\\\"Type\\\", \\\"@type\\\")]\\n\\n if \\\"width\\\" not in kwargs:\\n kwargs[\\\"width\\\"] = 500\\n if \\\"height\\\" not in kwargs:\\n kwargs[\\\"height\\\"] = 300\\n if \\\"tooltips\\\" not in kwargs:\\n kwargs[\\\"tooltips\\\"] = tooltips\\n if \\\"x_axis_type\\\" not in kwargs:\\n kwargs[\\\"x_axis_type\\\"] = \\\"linear\\\" if relative_dates else \\\"datetime\\\"\\n\\n figure = plotting.figure(\\n **kwargs,\\n )\\n\\n intervals = calendar.get_intervals()[:n_years]\\n\\n for year, year_intervals in intervals.iterrows():\\n data = generate_plot_data(\\n calendar=calendar,\\n relative_dates=relative_dates,\\n year=year,\\n year_intervals=year_intervals,\\n )\\n _generate_rectangle(figure, plotting.ColumnDataSource(data))\\n\\n figure.xaxis.axis_label = (\\n \\\"Days relative to anchor date\\\" if relative_dates else \\\"Date\\\"\\n )\\n figure.yaxis.axis_label = \\\"Anchor year\\\"\\n\\n if relative_dates:\\n figure.x_range.start = ( # type: ignore\\n np.min(data[\\\"x\\\"]) - data[\\\"width\\\"][np.argmin(data[\\\"x\\\"])] / 2 - 14\\n )\\n figure.x_range.end = ( # type: ignore\\n np.max(data[\\\"x\\\"]) + data[\\\"width\\\"][np.argmax(data[\\\"x\\\"])] / 2 + 14\\n )\\n\\n if add_yticklabels:\\n figure.yaxis.ticker = [int(x) for x in intervals.index.to_list()]\\n else:\\n figure.yaxis.ticker = []\\n\\n return figure\",\n \"def plot_current_map(inputs):\\n # plot it each epoch\\n mp = construct_map_with_sliders(inputs, extvar=extvar)\\n # to make it clearer, add the start pos\\n npa = np.concatenate([[np.concatenate(\\n [extvar[\\\"start_pos\\\"] / np.array([512, 384]), [0, 0]])], tf.stack(mp).numpy().squeeze()])\\n fig, ax = plt.subplots()\\n x, y = np.transpose(npa)[0:2]\\n #x, y = np.random.rand(2, 20)\\n line = MyLine(x, y, mfc='red', ms=12)\\n line.text.set_color('red')\\n line.text.set_fontsize(16)\\n ax.add_line(line)\\n plt.show()\",\n \"def mapa(player):\\n mapita = pd.read_csv(\\\"./data/database_shots.csv\\\")\\n mapita[\\\"coord_x\\\"] = pd.to_numeric(mapita[\\\"coord_x\\\"], downcast=\\\"float\\\")\\n mapita[\\\"coord_y\\\"] = pd.to_numeric(mapita[\\\"coord_y\\\"], downcast=\\\"float\\\")\\n mapita[\\\"coord_y\\\"] = mapita[\\\"coord_y\\\"] * (-1)\\n listita = mapita[mapita[\\\"name\\\"] == player]\\n listita_1 = pd.DataFrame(listita, columns = ['name', \\\"shot\\\", 'coord_x','coord_y'])\\n listita_1.shot = listita_1.shot.apply(lambda x: 'in' if 'in' in x else x)\\n listita_1.shot = listita_1.shot.apply(lambda x: 'in' if 'dunk' in x else x)\\n listita_1.shot = listita_1.shot.apply(lambda x: 'out' if 'out' in x else x)\\n plt.figure(figsize=(18,20))\\n pl.draw_court(outer_lines=True)\\n plt.axis('off')\\n plt.xlim(0,260)\\n plt.ylim(-283,0)\\n markers = {\\\"#local-in\\\": \\\"s\\\", \\\"#local-out\\\": \\\"x\\\"}\\n sns.scatterplot(data = listita_1, x = \\\"coord_x\\\", y = \\\"coord_y\\\", s = 300, hue = \\\"shot\\\", style = \\\"shot\\\")\\n plt.legend(loc = 4,bbox_to_anchor=(0.95,0.05), fontsize=6, title='Shots attempted',title_fontsize=8, mode = \\\"expand\\\")\\n plt.savefig(\\\"./images/map.png\\\",dpi = 600)\",\n \"def plot(self,ax=None,return_ax=False,cartopy_proj=None,prop={},map_prop={}):\\n \\n #Create instance of plot object\\n self.plot_obj = TrackPlot()\\n \\n if self.basin in ['east_pacific','west_pacific','south_pacific','australia','all']:\\n self.plot_obj.create_cartopy(proj='PlateCarree',central_longitude=180.0)\\n else:\\n self.plot_obj.create_cartopy(proj='PlateCarree',central_longitude=0.0)\\n \\n \\n #Plot storm\\n return_ax = self.plot_obj.plot_season(self,ax=ax,return_ax=return_ax,prop=prop,map_prop=map_prop)\\n \\n #Return axis\\n if ax != None or return_ax == True: return return_ax\",\n \"def VisualizeSunTrackingAngles(SunTrackingData, rotation_axis):\\n \\n dx, dy = 1, 1\\n \\n # generate 2 2d grids for the x & y bounds\\n y, x = np.mgrid[slice(0, 24 + dy, dy),\\n slice(0, 12 + dx, dx)]\\n\\n z = np.empty((24,12))*np.nan\\n \\n if rotation_axis == 'x':\\n for i in range(len(SunTrackingData['HOY'])):\\n z[SunTrackingData['HoursInMonthTracking'][i],SunTrackingData['MonthTracking'][i]-1]= SunTrackingData['Xangles'][i]\\n z_min = 0\\n z_max = 90\\n elif rotation_axis == 'y':\\n for i in range(len(SunTrackingData['HOY'])):\\n z[SunTrackingData['HoursInMonthTracking'][i],SunTrackingData['MonthTracking'][i]-1]= SunTrackingData['Yangles'][i] \\n z_min = -45\\n z_max = 45\\n else:\\n print 'axis not available'\\n \\n z_mask = np.isnan(z)\\n masked_array = np.ma.array(z, mask=z_mask)\\n cmap = plt.cm.cubehelix\\n cmap = plt.cm.RdBu\\n cmap.set_bad('grey',1.)\\n\\n \\n #plt.pcolor(x, y, z, cmap='jet', vmin=z_min, vmax=z_max)\\n plt.pcolormesh(x, y, masked_array, cmap=cmap, vmin=z_min, vmax=z_max)\\n\\n # set the limits of the plot to the limits of the data\\n plt.axis([x.min(), x.max(), 3, 22])\\n plt.colorbar()\\n plt.tick_params(axis=u'both',labelsize=14)\",\n \"def plot(self):\\n\\n self.map.plot(ax=self.ax,\\n color='white',\\n edgecolor='gray')\\n\\n plt.axis('off')\",\n \"def __init__(self, event_dict=None):\\n self.X = None\\n self.y = None\\n self.event_dict = event_dict\\n\\n defualt_events = {\\n \\\"Pride Parade\\\": [\\n \\\"6/30/2019\\\",\\n \\\"6/24/2018\\\",\\n \\\"6/25/2017\\\",\\n \\\"6/26/2016\\\",\\n \\\"6/28/2015\\\",\\n \\\"6/29/2014\\\",\\n \\\"6/30/2013\\\",\\n \\\"6/24/2012\\\",\\n \\\"6/26/2011\\\",\\n \\\"6/27/2010\\\",\\n ],\\n \\\"Seafair\\\": [\\n \\\"8/2/2019\\\",\\n \\\"8/3/2019\\\",\\n \\\"8/4/2019\\\",\\n \\\"8/3/2018\\\",\\n \\\"8/4/2018\\\",\\n \\\"8/5/2018\\\",\\n \\\"8/4/2017\\\",\\n \\\"8/5/2017\\\",\\n \\\"8/6/2017\\\",\\n \\\"8/5/2016\\\",\\n \\\"8/6/2016\\\",\\n \\\"8/7/2016\\\",\\n \\\"7/31/2015\\\",\\n \\\"8/1/2015\\\",\\n \\\"8/2/2015\\\",\\n \\\"8/1/2014\\\",\\n \\\"8/2/2014\\\",\\n \\\"8/3/2014\\\",\\n \\\"8/2/2013\\\",\\n \\\"8/3/2013\\\",\\n \\\"8/4/2013\\\",\\n \\\"8/3/2012\\\",\\n \\\"8/4/2012\\\",\\n \\\"8/5/2012\\\",\\n \\\"8/5/2011\\\",\\n \\\"8/6/2011\\\",\\n \\\"8/7/2011\\\",\\n \\\"8/6/2010\\\",\\n \\\"8/7/2010\\\",\\n \\\"8/8/2010\\\",\\n ],\\n \\\"Soltice Parade\\\": [\\n \\\"6/30/2019\\\",\\n \\\"6/16/2018\\\",\\n \\\"6/17/2017\\\",\\n \\\"6/18/2016\\\",\\n \\\"6/20/2015\\\",\\n \\\"6/21/2014\\\",\\n \\\"6/22/2013\\\",\\n \\\"6/16/2012\\\",\\n \\\"6/18/2011\\\",\\n \\\"6/19/2010\\\",\\n ],\\n \\\"Womens March\\\": [\\\"1/19/2019\\\", \\\"1/20/2018\\\", \\\"1/21/2017\\\"],\\n }\\n\\n if self.event_dict == None:\\n self.event_dict = defualt_events\",\n \"def plot_2018_board():\\n top_left_corner_border = plt.Polygon([[0,823], [91,823], [0,747]], fill='k', edgecolor='k')\\n bottom_left_corner_border = plt.Polygon([[0,0], [0,76], [91,0]], fill='k', edgecolor='k')\\n plt.gca().add_line(top_left_corner_border)\\n plt.gca().add_line(bottom_left_corner_border)\\n\\n # Auto Line\\n auto_line = plt.Line2D((305, 305), (0, 823), lw=2.5)\\n plt.gca().add_line(auto_line)\\n\\n # Exchange Zone\\n exchange_zone = plt.Rectangle((0, 442), 91, 122, fc='r')\\n plt.gca().add_patch(exchange_zone)\\n\\n # Power Cube Zone\\n power_cube_zone = plt.Rectangle((249, 354), 107, 114, fc='r')\\n plt.gca().add_patch(power_cube_zone)\\n\\n # Switch Zone\\n switch_zone = plt.Rectangle((356, 216), 142, 390, fc='grey')\\n plt.gca().add_patch(switch_zone)\\n\\n # Power Cubes next to Switch Zone\\n for i in range(0,6,1):\\n cube = plt.Rectangle((498, 216+i*(33+38.4)), 33, 33, fc='yellow')\\n plt.gca().add_patch(cube)\\n\\n # Null territory\\n null_territory_top = plt.Polygon([[731.5, 581], [731.5, 823], [823, 823], [823, 581]], fill=None, edgecolor='k')\\n null_territory_bottom = plt.Polygon([[731.5, 0], [731.5, 242], [823, 242], [823, 0]], fill=None, edgecolor='k')\\n plt.gca().add_line(null_territory_top)\\n plt.gca().add_line(null_territory_bottom)\\n\\n # Scale\\n scale = plt.Rectangle((653.5, 242), 823-653.5, 581-242, fc='black')\\n plt.gca().add_patch(scale)\",\n \"def __plot( dict1, title):\\n plt.title(title)\\n plt.xlabel(\\\"Run Time (microsecondsS)\\\")\\n plt.ylabel(\\\"Number of Items Retreived\\\")\\n plt.ylim(0, max(dict1.values()))\\n plt.xlim(min(dict1.keys()), max(dict1.keys()) )\\n x1, y1 = zip(*dict1.items())\\n\\n plt.scatter(x1, y1)\\n plt.show()\",\n \"def visualize_days():\\n\\n # grab our parsed data that we parsed earlier\\n data_file = parse(MY_FILE, \\\",\\\")\\n\\n counter = Counter(item['DayOfWeek'] for item in data_file)\\n\\n data_list = [\\n counter['Monday'],\\n counter['Tuesday'],\\n counter['Wednesday'],\\n counter['Thursday'],\\n counter['Friday'],\\n counter['Saturday'],\\n counter['Sunday']\\n ]\\n\\n day_tuple = tuple(['Mon','Tues','Wed','Thurs','Fri','Sat','Sun'])\\n\\n plt.plot(data_list)\\n\\n # num of ticks needed for our x-axis & assign labels\\n plt.xticks(range(len(day_tuple)),day_tuple)\\n \\n plt.savefig(\\\"Days.png\\\")\\n plt.clf()\",\n \"def plot(self, view='section', **kwargs):\\n if view=='section':\\n ax = self.data.plot('d','z',**kwargs)\\n elif view=='map':\\n ax = self.location.plot('x','y',**kwargs)\\n else:\\n logger.warning('{0} is not a valid view option'.format(view))\\n ax=None\\n return ax\",\n \"def generate_line_plot():\\n df = pd.read_csv(\\\"/Users/maxwell/Documents/workspace/CoronaScan/results.csv\\\",\\n names=[i for i in subreddits])\\n\\n dates = df.loc['2020-04-28']\",\n \"def plot_heatmap(self, blur=False, area=None, highlight=None):\\n if area is None:\\n area = Rectangle.entire_map(self.world)\\n xmin, xmax, ymin, ymax = area.bounds()\\n\\n for era in self.date_ranges:\\n fig, ax, colour_map = _init_world_plot()\\n\\n plot_data = self.data[era][xmin:xmax, ymin:ymax]\\n\\n if blur:\\n plot_data = ndimage.gaussian_filter(plot_data, sigma=blur)\\n # Normalise\\n vmax = np.max(plot_data)\\n plot_data = plot_data/vmax\\n\\n # Create rgb data\\n plot_data = colour_map(plot_data)\\n plot_data = _colour_special_tiles(plot_data, self.world, area=area)\\n if highlight:\\n plot_data = _highlight(plot_data, area, highlight)\\n\\n im = ax.imshow(np.rot90(plot_data), cmap=colour_map, vmax=vmax,\\n vmin=0)\\n fig.colorbar(im)\\n fig.savefig('{}_{}.pdf'.format(self._prefix, era))\",\n \"def plot_all_dates_by_ar(ipcc_counts_dates, meta, cmap):\\r\\n ipcc_counts_dates = rp_da.scale_counts(ipcc_counts_dates.copy())\\r\\n # prep for plotting\\r\\n counts_meta = rp_da.merge_counts_meta(ipcc_counts_dates, meta)\\r\\n dates = list({str(year):0 for year in range(2000,2105,10)}.keys())\\r\\n # Plot the seperate temps\\r\\n means = counts_meta.groupby(\\\"AR\\\").mean().iloc[:,3:]\\r\\n ax = means.plot(kind=\\\"bar\\\", stacked=True, cmap=cmap) \\r\\n handles, labels = ax.get_legend_handles_labels()\\r\\n ax.legend(handles[::-1], labels[::-1],loc='upper right', bbox_to_anchor=(1.12, 0.962),labelspacing=1.4, frameon=False)\\r\\n # Make pretty\\r\\n ax.set_ylabel(\\\"% Mentions\\\")\\r\\n plot_nicer(ax)\\r\\n fig = plt.gcf()\\r\\n fig.set_size_inches(8,8)\\r\\n fig.tight_layout()\\r\\n plt.savefig(\\\"Figures\\\"+ os.sep + \\\"Supplementary\\\" + os.sep + \\\"AR_all_dates_grouped.png\\\", dpi=200)\\r\\n plt.close()\",\n \"def plot_days_at_sea(days_at_sea_series):\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n\\n ax.set_position(default_timeseries_position) \\n\\n days_at_sea_series.plot(ax=ax)\\n ax.set_ylabel('Days at Sea')\\n\\n content = io.BytesIO()\\n plt.savefig(content, format='png')\\n content.seek(0)\\n image_cache['days_at_sea']['days_at_sea'] = content\\n\\n plt.close()\",\n \"def plot_map(fig=None,\\n coast='110m',\\n figsize=(10, 10),\\n bounds=None,\\n cp=None,\\n grid_linewidth=1,\\n **kwargs,\\n ):\\n crs = ccrs.PlateCarree()\\n #\\n if fig is None:\\n fig = plt.figure(figsize=figsize)\\n else:\\n fig.clf()\\n\\n if bounds is None:\\n if cp is not None:\\n bounds = cp.bounds\\n else:\\n bounds = _bounds_default\\n\\n ax = fig.add_subplot(111, projection=crs)\\n ax.set_extent(bounds, crs=crs)\\n gl = ax.gridlines(crs=crs,\\n draw_labels=True,\\n linewidth=grid_linewidth,\\n color='k',\\n alpha=0.5, linestyle='--',\\n )\\n gl.xlabels_top = False\\n #\\n if coast in ['10m', '50m', '110m']:\\n ax.coastlines(resolution=coast, color='k')\\n elif coast in ['auto', 'coarse', 'low', 'intermediate', 'high', 'full']:\\n shpfile = shapereader.gshhs('h')\\n shp = shapereader.Reader(shpfile)\\n ax.add_geometries(\\n shp.geometries(), crs, edgecolor='black', facecolor='none')\\n elif coast=='med':\\n # conda install -c conda-forge gdal\\n # ogr2ogr -f \\\"ESRI Shapefile\\\" med_coast.shp /Users/aponte/.local/share/cartopy/shapefiles/gshhs/h/GSHHS_h_L1.shp -clipsrc 5 42. 7 44.\\n shp = shapereader.Reader(os.getenv('HOME')+'/data/OSM/med/med_coast.shp')\\n for record, geometry in zip(shp.records(), shp.geometries()):\\n ax.add_geometries([geometry], crs, facecolor='None', edgecolor='black')\\n elif coast=='med_high':\\n # conda install -c conda-forge gdal\\n # ogr2ogr -f \\\"ESRI Shapefile\\\" med_high_coast.shp ../coastlines/lines.shp -clipsrc 6 7 42.5 43.5\\n shp = shapereader.Reader(os.getenv('HOME')+'/data/OSM/med/med_high_coast.shp')\\n for record, geometry in zip(shp.records(), shp.geometries()):\\n ax.add_geometries([geometry], crs, facecolor='None', edgecolor='black')\\n\\n return [fig, ax, crs]\",\n \"def basic_map(proj):\\n fig = plt.figure(figsize=(15, 10))\\n add_metpy_logo(fig, 0, 80, size='large')\\n view = fig.add_axes([0, 0, 1, 1], projection=proj)\\n view.set_extent([-120, -70, 20, 50])\\n view.add_feature(cfeature.STATES.with_scale('50m'))\\n view.add_feature(cfeature.OCEAN)\\n view.add_feature(cfeature.COASTLINE)\\n view.add_feature(cfeature.BORDERS, linestyle=':')\\n return fig, view\",\n \"def station_map(data, station_counter):\\n r = 6373.0\\n\\n phi = np.cos(55.943894)\\n\\n stations = list(set(data['start_station_name'].tolist() + data['end_station_name'].tolist()))\\n dict = {name: () for name in stations}\\n for index, row in data.iterrows():\\n dict[row['start_station_name']] = (row['start_station_latitude'], row['start_station_longitude'])\\n dict[row['end_station_name']] = (row['end_station_latitude'], row['end_station_longitude'])\\n # number of stations\\n n = len(dict.keys())\\n\\n # Convert to XY coordinates\\n dict_xy = {ids: (station_counter[ids], (r * dict[ids][1] * phi, r * dict[ids][0])) for ids in dict.keys()}\\n\\n journeys, loc = zip(*list(dict_xy.values()))\\n x, y = zip(*list(loc))\\n journeys = [i for i in journeys]\\n\\n fig, ax = plt.subplots(figsize=(13, 8))\\n plt.scatter(x, y, s=journeys)\\n\\n for ii in dict_xy.keys():\\n ax.annotate(ii, dict_xy[ii][1], dict_xy[ii][1])\\n\\n plt.show()\",\n \"def plot_vals(df, colors, events):\\n #to do: take df.Datum.loc[0] und df.Datum.loc[-1], datetime.strftime() back to str, set as start&end\\n fig, ax = plt.subplots(figsize=(16,5))\\n ax.axis([0, 1440, 0, 5])\\n start, end = ax.get_xlim()\\n formatter = FuncFormatter(my_ticks)\\n plt.xticks(rotation=70)\\n ax.xaxis.set_major_locator(ticker.MultipleLocator(60.00))\\n ax.xaxis.set_major_formatter(formatter)\\n plt.yticks((1,2,3,4), events)\\n ax.set_title(\\\"Jakobs Tag\\\") # to do: add dates (siehe oben)\\n for ind, ev in enumerate(events):\\n (xs,ys,dotsizes) = create_scatter_vals(df, ev, (ind+1))\\n plt.scatter(xs, ys, s=dotsizes, marker=\\\"o\\\", alpha=0.5, color=colors[ind])\\n plt.savefig(\\\"test1.pdf\\\")\\n return fig,ax\",\n \"def filter_plot(mode, country, continent, start_date, end_date, options):\\n # Default is World mode\\n chart_data = world_daywise_df\\n map_data = countries_daywise_df\\n print(country, continent)\\n if mode == SelectionMode.Continents.value:\\n #Continents mode\\n if not isinstance(continent, list):\\n continent = [continent]\\n\\n chart_data = continents_daywise_df[continents_daywise_df['WHO Region'].isin(continent)]\\n map_data = map_data[map_data['WHO Region'].isin(continent)]\\n elif mode == SelectionMode.Countries.value:\\n # Countries mode\\n if not isinstance(country, list):\\n country = [country]\\n\\n chart_data = countries_daywise_df[countries_daywise_df['Country/Region'].isin(country)]\\n map_data = chart_data\\n\\n chart_data = chart_data.query('Date >= @start_date & Date <= @end_date')\\n map_data = map_data.query('Date >= @start_date & Date <= @end_date')\\n\\n # fix error when groupby geometry or put it in the aggregate column\\n temp = map_data.drop(['geometry', 'country_code', 'Date'], axis=1).groupby(['Country/Region']).agg(metrics).reset_index()\\n map_data = join_country_code_data(temp, country_code_data)\\n\\n if is_perCapita(options):\\n for metric in ['Confirmed', 'Deaths', 'Recovered']:\\n chart_data[metric + '_per_capita'] = chart_data[metric] / chart_data['Population']\\n map_data[metric + '_per_capita'] = map_data[metric] / map_data['Population']\\n \\n if is_perCapita(options):\\n return plot(chart_data, 'Confirmed_per_capita', 'Confirmed Cases Per Capita'), \\\\\\n plot(chart_data, 'Deaths_per_capita', 'Confirmed Deaths Per Capita'), \\\\\\n plot(chart_data, 'Recovered_per_capita', 'Confirmed Recoveries Per Capita'), \\\\\\n generate_map(map_data)\\n\\n return plot(chart_data, 'Confirmed', 'Confirmed Cases'), \\\\\\n plot(chart_data, 'Deaths', 'Confirmed Deaths'), \\\\\\n plot(chart_data, 'Recovered', 'Confirmed Recoveries'), \\\\\\n generate_map(map_data)\",\n \"def visualizemap(dna, map_view=\\\"linear\\\", feature_list=None, start=0, end=None,label_location=None, display_label=2, display_title=True, display_axis=True, fontsize=None, fontsize_nucl=None, \\n tick_interval=\\\"auto\\\", labelcolor=\\\"k\\\", title=None, width_scale=\\\"auto\\\", height_scale=1.0, linebreak=None, seq=False, rcseq=False, diamater_scale=1.0, fig= None):\\n\\n if fontsize is None and map_view == \\\"linear\\\":\\n fontsize = 12\\n elif fontsize is None and map_view == \\\"circular\\\":\\n fontsize = 10\\n else:\\n pass \\n\\n if title is None or title == \\\"\\\":\\n display_titlee = False\\n\\n #if map_view == \\\"circular\\\":\\n #feature_list.sort(key=lambda x:len(dna.printsequence(x.start, x.end)))\\n \\n standard_scale = 4000\\n if map_view == \\\"circular\\\":\\n figo, ax1, ax2= vc.visualize(dna, format=0, feature_list=feature_list, bottom=400 * diamater_scale, label_visible=display_label, fontsize=fontsize, \\n title_visible=display_title, axis_visible=display_axis, tick_space=tick_interval, labelcolor=labelcolor, \\n titlename=title, fig=fig)\\n try:\\n import patchworklib \\n _patchworklib = True\\n except:\\n _patchworklib = False\\n \\n if _patchworklib == True:\\n ax1 = patchworklib.cBrick(ax=ax1)\\n ax2 = patchworklib.Brick(ax=ax2)\\n if fig == patchworklib.Brick._figure or fig is None:\\n return patchworklib.Bricks({ax1.get_label():ax1, ax2.get_label():ax2}) \\n else:\\n return figo\\n else:\\n return figo\\n else:\\n if feature_list is None:\\n feature_list = dna.dnafeatures\\n figo, ax = vl.visualize(dna, start=start, end=end, feature_list=feature_list, wrap_width=linebreak, annotation_loc=label_location, unvisible_types=[\\\"source\\\"], \\n visible_types=[], enlarge_w=width_scale, enlarge_h=height_scale, fontsize=fontsize, fontsize_nucl=fontsize_nucl, with_seq=seq, with_seqr=rcseq, nucl_char=None, nucl_color_dict=None, \\n label_visible=display_label, scale=\\\"fix\\\", title_visible=display_title, axis_visible=display_axis, tick_space=tick_interval, \\n labelcolor=labelcolor, titlename=title, fig=fig)\\n try:\\n import patchworklib \\n _patchworklib = True\\n except:\\n _patchworklib = False\\n \\n if _patchworklib == True:\\n if fig == patchworklib.Brick._figure or fig is None:\\n return ax\\n else:\\n return figo \\n else:\\n return figo\",\n \"def make_map(\\n shape_df,\\n df,\\n dates,\\n adm_key,\\n cols,\\n output_dir,\\n title_prefix=None,\\n log_scale=True,\\n colormap=\\\"Reds\\\",\\n outline_df=None,\\n):\\n # Maps are joined one level down from the map-level\\n # National maps color by state, state maps color by county\\n join_key = \\\"adm2\\\" if adm_key == \\\"adm1\\\" else \\\"adm1\\\"\\n\\n # For colorbar scaling\\n data_ranges = []\\n\\n # If log, use a different colormap and scale columns\\n if log_scale:\\n # formatter = LogFormatter(10, labelOnlyBase=False)\\n\\n # Log scale columns and save\\n for col in cols:\\n\\n col_name = \\\"log_\\\" + col\\n df = pd.concat([df, np.log10(1.0 + df[col]).rename(col_name)], axis=1)\\n\\n # Save min and max\\n data_ranges.append([df[col_name].min(), df[col_name].max()])\\n\\n else:\\n # formatter = ScalarFormatter()\\n\\n for col in cols:\\n data_ranges.append([df[col].min(), df[col].max()])\\n\\n # Index by date\\n df[\\\"date\\\"] = pd.to_datetime(df[\\\"date\\\"])\\n df = df.set_index([\\\"date\\\", join_key])\\n\\n # Make maps for each requested data\\n for date in dates:\\n\\n # Get data for this date and merge with shape data\\n date_df = shape_df.merge(df.xs(date, level=0), on=join_key)\\n\\n for i, column in enumerate(cols):\\n\\n # Create title\\n map_title = readable_col_names[column] + \\\" \\\" + str(date.date())\\n\\n if title_prefix is not None:\\n map_title = title_prefix + \\\" \\\" + map_title\\n val_range = data_ranges[i]\\n\\n # Determine column to plot\\n if log_scale:\\n column = \\\"log_\\\" + column\\n\\n # date_df = date_df.to_crs(epsg=2163)\\n\\n # Plot\\n ax = date_df.plot(\\n column=column,\\n cmap=colormap,\\n vmin=val_range[0],\\n vmax=val_range[1],\\n legend=True,\\n legend_kwds={\\n \\\"orientation\\\": \\\"horizontal\\\",\\n \\\"shrink\\\": 0.8,\\n \\\"aspect\\\": 50,\\n \\\"label\\\": \\\"Log10-scaled (10 ^ x)\\\",\\n },\\n edgecolor=\\\"black\\\",\\n linewidth=0.1,\\n figsize=(16, 9),\\n )\\n\\n if outline_df is not None:\\n outline_df.boundary.plot(ax=ax, edgecolor=\\\"black\\\", linewidth=0.5)\\n\\n plt.title(map_title)\\n plt.tight_layout()\\n plt.axis(\\\"off\\\")\\n axes = plt.gca()\\n axes.set_aspect(\\\"equal\\\")\\n\\n # Create filename\\n filename = os.path.join(output_dir, adm_key + \\\"_\\\" + map_title.replace(\\\" \\\", \\\"\\\") + \\\".png\\\")\\n\\n # print(filename)\\n # plt.show()\\n df.xs(date, level=0).to_csv(os.path.join(output_dir, adm_key + \\\"_\\\" + map_title.replace(\\\" \\\", \\\"\\\") + \\\".csv\\\"))\\n plt.savefig(filename)\\n plt.close()\",\n \"def pcolorMonths(monthlyData, arg):\\n # use maximum or minimum value:\\n max_min = arg[0]\\n \\n # define what data should be plotted:\\n X = monthlyData[arg[1]]\\n \\n # define rotation axis:\\n rotation_axis = arg[2]\\n \\n # define mask:\\n if arg[3]=='DIVA':\\n sunMask = monthlyData['DIVAmask']\\n elif arg[3]=='LB':\\n sunMask = monthlyData['LBmask']\\n else:\\n raise ValueError('mask does not exist')\\n \\n # assign angles and angle_locations: \\n x_angle_location = monthlyData['angles']['x_angle_location']\\n y_angle_location = monthlyData['angles']['y_angle_location']\\n allAngles = monthlyData['angles']['allAngles']\\n \\n # find index of max/min from data according to the given option:\\n if max_min == 'min':\\n ind=np.argmin(X,axis=0)\\n elif max_min == 'max':\\n ind=np.argmax(X,axis=0)\\n else:\\n print \\\"somehow max min is not working\\\"\\n\\n # define axis index list: \\n axis_ind =[]\\n \\n # assign indices according to option:\\n z_min=0\\n if rotation_axis == 'x':\\n for i in range(len(ind)):\\n axis_ind.append(x_angle_location[ind[i]])\\n z_max=max(x_angle_location)\\n elif rotation_axis == 'y':\\n for i in range(len(ind)):\\n axis_ind.append(y_angle_location[ind[i]])\\n z_max=max(y_angle_location)\\n elif rotation_axis == 'xy':\\n axis_ind = ind\\n z_max=len(allAngles[0])-1\\n else:\\n print 'axis not available'\\n dx, dy = 1, 1\\n \\n # generate 2 2d grids for the x & y bounds:\\n y, x = np.mgrid[slice(0, 24 + dy, dy),\\n slice(0, 12 + dx, dx)]\\n \\n # create array with data that will be plotted:\\n z=[]\\n for i in range(24):\\n z.append([])\\n for j in range(12):\\n z[i].append(axis_ind[24*j + i])\\n z = np.asarray(z)\\n \\n # create masked array from sunMask:\\n masked_array = np.ma.array(z, mask=sunMask)\\n \\n # define colormap:\\n# cmap = plt.cm.cubehelix\\n #cmap = plt.cm.PRGn\\n# cmap = plt.cm.RdBu$\\n cmap = plt.cm.CMRmap\\n cmap = plt.cm.gnuplot\\n cmap = plt.cm.afmhot\\n \\n # define what happens to bad data (i.e. data outside the mask):\\n cmap.set_bad('grey',1.)\\n \\n # create the carpet plot:\\n plt.pcolormesh(x, y, masked_array, cmap=cmap, vmin=z_min, vmax=z_max, rasterized=True)\\n\\n # set the limits of the plot to the limits of the data\\n plt.axis([x.min(), x.max(), 3, 22])\\n plt.tick_params(axis=u'both',labelsize=14)\",\n \"def map_plot(self, iter_no):\\n \\n m = self._m\\n n = self._n\\n plt.figure()\\n label=np.zeros(m*n)\\n self._trained = True\\n mapped = self.map_vects(datanorm)\\n mapped=tuple(map(tuple, mapped))\\n c=Counter(mapped)\\n \\n c= sorted(c.items(), key=itemgetter(1))\\n a=[m*n]\\n for i in range(0,len(c)):\\n x=(((c[i])[0])[0])\\n y=(((c[i])[0])[1])\\n z=((c[i])[1])\\n plt.plot(x, y, 'ro', markersize= z/(2*m*n)) \\n plt.savefig('exoplanet{}.png'.format(iter_no))\\n p=plt.imread('exoplanet{}.png'.format(iter_no))\\n imgs.append(p)\\n plt.show()\\n plt.close()\\n print(c)\\n self._trained = False\",\n \"def bokeh_visualization(\\n calendar,\\n n_years: int,\\n relative_dates: bool,\\n add_yticklabels: bool = True,\\n **kwargs,\\n) -> None:\\n bokeh_fig = _bokeh_visualization(\\n calendar, n_years, relative_dates, add_yticklabels, **kwargs\\n )\\n if \\\"pytest\\\" in sys.modules: # Do not open browser if we are testing.\\n plotting.save(bokeh_fig)\\n else:\\n plotting.show(bokeh_fig)\",\n \"def raster(self, event_times_list, color='k'):\\n ax = plt.gca()\\n for ith, trial in enumerate(event_times_list):\\n plt.vlines(trial, ith + .5, ith + 1.5, color=color)\\n plt.ylim(.5, len(event_times_list) + .5)\\n return ax\",\n \"def plot_maps(self, astrometry, gs=None, plotmaps=['broad', 'core', 'wing'], savefig=False):\\n\\n extent = np.array([-astrometry.par.ncrop / 2, astrometry.par.ncrop / 2,\\n -astrometry.par.ncrop / 2, astrometry.par.ncrop / 2]\\n )\\n\\n # extent *= astrometry.par.sampling * 1e3 # implement cellsize in cube!\\n\\n if gs == None:\\n fig = plt.figure(figsize=(9, 2 + 1.5 * len(astrometry.fluxmap.__dict__)), dpi=150)\\n gs = gridspec.GridSpec(3, len(plotmaps) + 1, wspace=.07, hspace=.06)\\n\\n # Top row: flux maps\\n cmap = mpl.cm.get_cmap('gist_earth_r')\\n for idx, component in enumerate(plotmaps):\\n fluxmap = astrometry.basis.components[component].fluxmap\\n ax = plt.subplot(gs[0, idx])\\n im = ax.imshow(fluxmap / np.nanmax(fluxmap), origin='lower', cmap=cmap, # extent=extent,\\n norm=LogNorm(vmin=2e-2, vmax=1))\\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\\n\\n # annotations\\n ax.annotate(component, xy=(0.9, 0.85), fontsize=14, ha='right', xycoords='axes fraction')\\n ax.annotate('(' + chr(0 * len(plotmaps) + idx + 97) + ')',\\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\\n if idx == 0: ax.annotate(r'Data', xy=(0.9, .7), fontsize=14, ha='right', xycoords='axes fraction')\\n\\n # axes labels and ticks\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n ax.tick_params(axis='both', labelbottom=False)\\n if idx == 0:\\n ax.set_ylabel(r'$\\\\Delta \\\\, \\\\delta \\\\,[{\\\\rm px}]$')\\n else:\\n ax.tick_params(axis='both', labelleft=False)\\n\\n # colorbar\\n if idx == len(plotmaps) - 1:\\n ax = plt.subplot(gs[0, idx + 1])\\n cbarlabel = r'$ \\\\Sigma$'\\n colorbar(ax, im, label=cbarlabel)\\n\\n # Row 2: Model light distribution\\n for idx, component in enumerate(plotmaps):\\n fluxmap = astrometry.basis.components[component].fluxmap\\n ax = plt.subplot(gs[1, idx])\\n im = ax.imshow(fluxmap / np.nanmax(fluxmap), origin='lower', cmap=cmap, # extent=extent\\n norm=LogNorm(vmin=2e-2, vmax=1))\\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\\n\\n # annotations\\n if idx == 0: ax.annotate('Model', ha='right', xy=(0.9, 0.85), fontsize=14, xycoords='axes fraction')\\n ax.annotate('(' + chr(1 * len(plotmaps) + idx + 97) + ')',\\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\\n\\n # centroid location\\n # add the location of the component, which is measured in coordinates of the minicube pixels\\n\\n ax.scatter(astrometry.basis.components['broad'].centroid[0], # + extent[0],\\n astrometry.basis.components['broad'].centroid[1], # + extent[2],\\n marker='x', c='firebrick', s=40, label='AGN')\\n if idx > 0:\\n ax.scatter(astrometry.basis.components[component].centroid[0], # + extent[0],\\n astrometry.basis.components[component].centroid[1], # + extent[2],\\n marker='x', c='gold', s=40, label='centroid')\\n\\n # add legend\\n if idx == len(plotmaps) - 1:\\n legend = ax.legend(fontsize=8, bbox_to_anchor=(0.98, 0.98), loc='upper right', framealpha=.5)\\n # legend.get_frame()._alpha(.4)\\n\\n # axes labels and ticks\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n ax.tick_params(axis='both', labelbottom=False)\\n if idx == 0:\\n ax.set_ylabel(r'$\\\\Delta \\\\, \\\\delta \\\\,[{\\\\rm px}]$')\\n else:\\n ax.tick_params(axis='both', labelleft=False)\\n\\n # colorbar\\n if idx == len(plotmaps) - 1:\\n ax = plt.subplot(gs[1, idx + 1])\\n cbarlabel = r'$ \\\\Sigma$'\\n colorbar(ax, im, label=cbarlabel)\\n\\n # Row 3: Residual maps\\n cmap = mpl.cm.get_cmap('seismic')\\n for idx, component in enumerate(plotmaps):\\n\\n # combine systematic error from PSF with statistical error from data cube noise\\n # compute systematic error from the normalized map, scaled to the component flux map\\n residuals = astrometry.basis.components[component].fluxmap - astrometry.basis.components[component].fluxmodel\\n error = np.sqrt(astrometry.basis.components[component].errmap**2 +\\n (astrometry.sysmap * astrometry.basis.components[component].fluxmap)**2\\n )\\n\\n ax = plt.subplot(gs[2, idx])\\n im = ax.imshow(residuals/error, origin='lower', cmap=cmap, vmin=-1, vmax=1) # , extent=extent)\\n scalebar(ax, astrometry, c='k', loc=(.5, .22), distance=50)\\n\\n # annotations\\n if idx == 0: ax.annotate('Residual', ha='right', xy=(0.9, 0.85), fontsize=14, xycoords='axes fraction')\\n ax.annotate('(' + chr(2 * len(plotmaps) + idx + 97) + ')',\\n ha='left', xy=(0.1, 0.85), fontsize=14, xycoords='axes fraction')\\n\\n # labels and ticks\\n ax.xaxis.set_minor_locator(AutoMinorLocator())\\n ax.yaxis.set_minor_locator(AutoMinorLocator())\\n ax.set_xlabel(r'$\\\\Delta \\\\, \\\\alpha \\\\,[{\\\\rm px}]$')\\n if idx == 0:\\n ax.set_ylabel(r'$\\\\Delta \\\\, \\\\delta \\\\,[{\\\\rm px}]$')\\n else:\\n ax.tick_params(axis='both', labelleft=False)\\n\\n # colorbar\\n if idx == len(plotmaps) - 1:\\n ax = plt.subplot(gs[2, idx + 1])\\n cbarlabel = 'residual/error'\\n colorbar(ax, im, label=cbarlabel)\\n\\n # *** interactive plot ***\\n self.boxes = np.full([astrometry.par.ncrop, astrometry.par.ncrop], mpl.lines.Line2D)\\n for i in range(astrometry.par.ncrop):\\n for j in range(astrometry.par.ncrop):\\n # plot all boxes\\n xbox = np.array([i, i, i + 1, i + 1, i]) - .5\\n ybox = np.array([j, j + 1, j + 1, j, j]) - .5\\n self.boxes[i, j] = self.fig.axes[3].plot(xbox, ybox, color='r', linewidth=2)[0]\\n self.boxes[i, j].set_visible(False)\\n\\n if savefig:\\n plt.savefig(astrometry.par.output_dir + '/' + astrometry.par.obj +\\n '.spectroastrometry_maps.png', bbox_inches='tight')\",\n \"def plot_typical_day(bdf):\\n\\n bdf[\\\"time\\\"] = bdf.index.time\\n bdf[\\\"weekday\\\"] = bdf.index.weekday < 5\\n week_profile = bdf[bdf.weekday].pivot_table(\\n index=\\\"time\\\", values=\\\"load\\\", aggfunc=[\\\"mean\\\", \\\"max\\\", \\\"min\\\"]\\n )\\n week_profile.columns = [\\\"week_mean\\\", \\\"week_max\\\", \\\"week_min\\\"]\\n weekend_profile = bdf[~bdf.weekday].pivot_table(\\n index=\\\"time\\\", values=\\\"load\\\", aggfunc=[\\\"mean\\\", \\\"max\\\", \\\"min\\\"]\\n )\\n weekend_profile.columns = [\\\"weekend_mean\\\", \\\"weekend_max\\\", \\\"weekend_min\\\"]\\n profile = week_profile.merge(weekend_profile, left_index=True, right_index=True)\\n fig = profile.iplot(\\n asFigure=True,\\n layout=dict(\\n title=\\\"Typisch week/weekend profiel\\\",\\n xaxis=dict(title=\\\"Tijd vd dag [-]\\\"),\\n yaxis=dict(title=\\\"Belasting [MW]\\\"),\\n ),\\n )\\n\\n # Update traces based on name\\n for trace in fig.data:\\n if \\\"week\\\" in trace[\\\"name\\\"]:\\n trace.update(line=dict(color=\\\"blue\\\"))\\n if \\\"weekend\\\" in trace[\\\"name\\\"]:\\n trace.update(line=dict(color=\\\"green\\\"))\\n if \\\"min\\\" in trace[\\\"name\\\"] or \\\"max\\\" in trace[\\\"name\\\"]:\\n trace.update(line=dict(dash=\\\"dot\\\"))\\n\\n return fig\",\n \"def plot(self):\\n fig, ax = plt.subplots()\\n ticklabels = [item.strftime('%b %d') for item in self.series.index]\\n ax.xaxis.set_major_formatter(ticker.FixedFormatter(ticklabels))\\n\\n plt.ylabel('#Cases')\\n i = 0\\n for y in self.countries:\\n plt.plot(ticklabels, self.series[y], GRAPH_FORMATS[i], label=y)\\n i += 1\\n ax.set_xticklabels(ticklabels, rotation='vertical', fontsize=10)\\n plt.legend()\\n plt.grid()\\n if self.log:\\n plt.yscale(\\\"log\\\")\\n plt.show()\",\n \"def worldplot(data):\\n \\n plt.rcParams['font.size'] = 18\\n world_df= geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'));\\n\\n world_df = world_df[world_df[\\\"iso_a3\\\"].isin(data[\\\"recipient_iso3\\\"])];\\n\\n #world_2df.[\\\"OFa_all_con\\\"] = np.nan;\\n #world_2df.sort_values(by=\\\"iso_a3\\\").head()\\n for i in world_df.index:\\n for j in data.index:\\n if world_df.loc[i,\\\"iso_a3\\\"] == data.loc[j,\\\"recipient_iso3\\\"]:\\n world_df.loc[i,\\\"OFa_all_con\\\"] = data.loc[j, \\\"OFa_all_con\\\"];\\n\\n\\n fig, ax = plt.subplots(1,1, figsize=(22,14))\\n ax.axis('off')\\n fig.suptitle('Chinese Development Finance', fontsize=25)\\n \\n world_df.plot(column='OFa_all_con', ax = ax, legend=True, legend_kwds={\\\"label\\\":\\\"\\\\n Chinese Development Finance in $10 bln.\\\",\\n \\\"orientation\\\": \\\"horizontal\\\"}, \\n missing_kwds={\\\"color\\\": \\\"lightgrey\\\",\\n \\\"edgecolor\\\": \\\"red\\\",\\n \\\"hatch\\\": \\\"///\\\",\\n \\\"label\\\": \\\"Missing values\\\"});\",\n \"def map_plot(iso3_codes, countries_organisations_amount,countries_list):\\n d = {'ISO-3': iso3_codes, 'spending': countries_organisations_amount, 'countries': countries_list}\\n df = pd.DataFrame(data=d)\\n fig = px.choropleth(df,\\n locations='ISO-3',\\n color=\\\"spending\\\",\\n scope=\\\"world\\\",\\n labels={'spending': 'Amount of organisations'},\\n height=500,\\n hover_name=df['countries'],\\n hover_data=['spending'],\\n custom_data=['spending','countries']\\n )\\n\\n fig.update_layout(\\n title_text='Number of organisations lobbying in the EU',\\n geo=dict(\\n showframe=False,\\n showcoastlines=False,\\n projection_type='equirectangular'))\\n fig.update_traces(hovertemplate=\\\"<b> %{customdata[1]} </b> : Number of organisations: %{customdata[0]}\\\")\\n return fig\",\n \"def worldplot_2(data, cc, pc):\\n # define the columns of input\\n # cc = data.columns[checkcol]\\n #pc = data.columns[plotcol]\\n \\n plt.rcParams['font.size'] = 18\\n # generate standart geopandas dataframe\\n world_df = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'));\\n #check indicies of the input dataframe and modify standart geopandas df\\n world_df = world_df[world_df[\\\"iso_a3\\\"].isin(data[cc])];\\n\\n #world_2df.[\\\"OFa_all_con\\\"] = np.nan;\\n #world_2df.sort_values(by=\\\"iso_a3\\\").head()\\n for i in world_df.index:\\n for j in data.index:\\n if world_df.loc[i,\\\"iso_a3\\\"] == data.loc[j, cc]:\\n try:\\n world_df.loc[i,pc] = data.loc[j, pc];\\n except: \\n print(\\\"\\\\nError! Invalid Input. Example for input: OFa_all_con\\\")\\n return\\n \\n\\n fig, ax = plt.subplots(1,1, figsize=(22,12))\\n ax.axis('off')\\n \\n \\n if pc == \\\"OFa_all_con\\\":\\n fig.suptitle('Chinese Development Finance (financial amount)', fontsize=25)\\n world_df.plot(column=pc, ax = ax, legend=True, cmap='jet', legend_kwds={\\\"label\\\":\\\"\\\\n Chinese Development Finance in $10 bln (2000-2014)\\\",\\n \\\"orientation\\\": \\\"horizontal\\\"}, \\n missing_kwds={\\\"color\\\": \\\"lightgrey\\\",\\n \\\"edgecolor\\\": \\\"red\\\",\\n \\\"hatch\\\": \\\"///\\\",\\n \\\"label\\\": \\\"Missing values\\\"});\\n else:\\n fig.suptitle('Chinese Development Finance (probability)', fontsize=25)\\n world_df.plot(column=pc, ax = ax, legend=True, cmap='jet', legend_kwds={\\\"label\\\":\\\"\\\\n Probability of receiving Chinese Development Finance (2000-2014)\\\",###ADDDDJUST!!!!!\\n \\\"orientation\\\": \\\"horizontal\\\"}, \\n missing_kwds={\\\"color\\\": \\\"lightgrey\\\",\\n \\\"edgecolor\\\": \\\"red\\\",\\n \\\"hatch\\\": \\\"///\\\",\\n \\\"label\\\": \\\"Missing values\\\"});\",\n \"def plot_pc(*args, x='date', y='pc_new_positives', days=0):\\r\\n # unpack args (stored in tuple) to list form\\r\\n a = []\\r\\n a.append(x)\\r\\n a.append(y)\\r\\n for arg in args:\\r\\n a.append(arg)\\r\\n # format dates\\r\\n if (days > 0) & (days < 32):\\r\\n locator = mdates.DayLocator()\\r\\n formatter = mdates.DateFormatter('%d')\\r\\n else:\\r\\n locator = mdates.MonthLocator()\\r\\n formatter = mdates.DateFormatter('%m-%d')\\r\\n # set up axes for subplots\\r\\n fig, ax = plt.subplots(figsize=(8, 8))\\r\\n # format dates on x-axis\\r\\n ax.xaxis.set_major_locator(locator)\\r\\n ax.xaxis.set_major_formatter(formatter)\\r\\n for state in args:\\r\\n # subset df for our plots. dropna() ensures same date range for all plots\\r\\n plot_data = df[df['State'] == state]\\r\\n # subset for number of days\\r\\n if days > 0:\\r\\n plot_data = plot_data[:days+1]\\r\\n # make plot\\r\\n ax.plot(plot_data[x], plot_data[y][plot_data['State'] == state], linestyle='-', label=state)\\r\\n # set titles\\r\\n ax.set_title(\\\"{} per 100,000 people\\\".format(y))\\r\\n #show legend\\r\\n ax.legend()\",\n \"def __init__(self, gdf_map):\\n\\n self.fig = plt.figure(figsize=(13,13))\\n self.ax = self.fig.add_subplot(1,1,1)\\n self.fontsize = 18\\n\\n self.city_markersize = 6\\n self.city_marker = 'o'\\n self.city_markercolor = 'k'\\n self.cmap = 'Reds'\\n\\n self.map = gdf_map\",\n \"def heatmap_drawer(fname, month_or_year, waste_or_encamp):\\r\\n assert isinstance(fname, str)\\r\\n assert isinstance(month_or_year, str)\\r\\n assert isinstance(waste_or_encamp, str)\\r\\n assert fname[-4:] == '.csv'\\r\\n assert month_or_year == 'M' or month_or_year == 'Y'\\r\\n assert waste_or_encamp == 'W' or waste_or_encamp == 'E'\\r\\n \\r\\n data = pd.read_csv(fname)\\r\\n \\r\\n if month_or_year == 'Y':\\r\\n if waste_or_encamp == 'E':\\r\\n for i in range(2008, 2020):\\r\\n draw_map_y(data, i, 'Encampment Reports')\\r\\n elif waste_or_encamp == 'W':\\r\\n for i in range(2008, 2020):\\r\\n draw_map_y(data, i, 'Human or Animal Waste')\\r\\n elif month_or_year == 'M':\\r\\n if waste_or_encamp == 'E':\\r\\n for i in range(1, 10):\\r\\n draw_map_m(data, i, 'Encampment Reports')\\r\\n for i in range(10, 13):\\r\\n draw_map_m_2(data, i, 'Encampment Reports')\\r\\n elif waste_or_encamp == 'W':\\r\\n for i in range(1, 10):\\r\\n draw_map_m(data, i, 'Human or Animal Waste')\\r\\n for i in range(10, 13):\\r\\n draw_map_m_2(data, i, 'Human or Animal Waste')\",\n \"def display_calendar_redo(daze, year, month):\\n log = daze.dateDict\\n\\n # Set first and last dates\\n if year is None:\\n year = date.today().year\\n if month is None:\\n first = date(year, 1, 1)\\n if year == date.today().year:\\n last = date.today()\\n else:\\n last = date(year, 12, 31)\\n else:\\n first = date(year, month, 1)\\n last = date(2016, month, calendar.monthrange(2016, month)[1])\\n\\n # Get summarized data\\n s, ndates, firstdate, lastdate = daze.summarize()\\n places = sorted(s, key=s.get, reverse=True)\\n colors = ['green', 'magenta', 'white', 'cyan', 'blue', 'red', 'yellow']\",\n \"def show_MAP_frequencies(self, figure_name):\\n if not self.get('MAP_done'): return\\n\\n modes = self.get('modes') \\n obs_freq = np.array([mode.freq for mode in modes]) # unit: per day\\n d_freq = obs_freq[1:] - obs_freq[:-1]\\n\\n # MAP_names = self.get('feature_names')\\n # MAP_features = self.get('MAP_feature')\\n MAP_freq = self.get('MAP_frequencies')\\n\\n fig, ax = plt.subplots(1, figsize=(4,3), tight_layout=True)\\n\\n for k, freq in enumerate(obs_freq):\\n ax.axvline(x=freq, ymin=0, ymax=1, linestyle='solid', color='r', lw=2)\\n ax.axvline(x=MAP_freq[k], ymin=0, ymax=0.8, linestyle='dashed', color='k', lw=1)\\n\\n # Axis cosmetics\\n ax.set_ylim(0, 1.2)\\n ax.set_yticklabels(())\\n ax.set_xlabel(r'Frequency (per day)')\\n # Legend\\n ax.plot([], [], linestyle='solid', lw=4, color='r', label='Observed')\\n ax.plot([], [], linestyle='dashed', lw=2, color='k', label='Model')\\n leg = ax.legend(loc=1)\\n\\n plt.savefig(figure_name)\\n logger.info('show_MAP_frequencies: saved {0}'.format(figure_name))\\n plt.close()\",\n \"def visualize_days():\\n\\t\\n\\t#grab our parsed data that we parsed earlier\\n\\tdata_file = parse(MY_FILE, \\\",\\\")\\n\\t\\n\\t#make a new variable, counter, from iterating through each line of\\n\\t#data in the parsed data, and count how many incidents happen on each\\n\\t#day of the week\\n\\tcounter = Counter(item[\\\"DayOfWeek\\\"] for item in data_file)\\n\\t\\n\\t#separate the x-axis data (days of the week) from the counter variable\\n\\t#from the y-axis (number of incidents each day)\\n\\tdata_list = [\\n\\t\\t\\t\\tcounter[\\\"Monday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Tuesday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Wednesday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Thursday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Friday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Saturday\\\"],\\n\\t\\t\\t\\tcounter[\\\"Sunday\\\"]\\n\\t\\t\\t\\t]\\n\\tday_tuple = tuple([\\\"Mon\\\", \\\"Tues\\\", \\\"Wed\\\", \\\"Thurs\\\", \\\"Fri\\\", \\\"Sat\\\", \\\"Sun\\\"])\\n\\t\\n\\t#with y-axis data, assign it to a matplotlib plot instance\\n\\tplt.plot(data_list)\\n\\t\\n\\t#create amount of ticks need for x and y axes and assign labels\\n\\tplt.xticks(range(len(day_tuple)), day_tuple)\\n\\t\\n\\t#save the plot\\n\\tplt.savefig(\\\"Days.png\\\")\\n\\t\\n\\t#close plot file\\n\\tplt.clf()\",\n \"def plot_map(data, pixlist, nside, runconf, title, unit):\\n hpmap = np.repeat(np.nan, hp.pixelfunc.nside2npix(nside))\\n hpmap[pixlist] = data\\n plot_lon_cen, plot_lat_cen = runconf['ra'], runconf['dec']\\n if plot_lon_cen > 180:\\n plot_lon_cen -= 360\\n plot_bounds = (1.0 + 1.1 * runconf['radius']) * np.array([-1.0, 1.0])\\n \\n hp.cartview(hpmap, rot=(plot_lon_cen, plot_lat_cen, 0), \\n lonra=plot_bounds, latra=plot_bounds,\\n notext=True, unit=unit, title=title, \\n min=min(data), max=max(data), coord='C', flip='astro')\\n\\n dec0 = np.round(runconf['dec'])\\n dec_spacing = runconf['radius']/2.0\\n decs = dec0 + np.arange(-2*runconf['radius'], 2.1*runconf['radius'], dec_spacing)\\n decs_min, decs_max = min(decs), max(decs)\\n\\n ra0 = np.round(runconf['ra'])\\n cosdelt =np.cos(np.deg2rad(dec0)) \\n ra_spacing = runconf['radius']/cosdelt / 2.0\\n ras = ra0 + np.arange(-2.0*runconf['radius']/cosdelt, 2.1*runconf['radius']/cosdelt, ra_spacing)\\n ras_min, ras_max = min(ras), max(ras)\\n #num_ras = np.ceil(1.0 * runconf['radius'] / grid_spacing / np.cos(np.deg2rad(min(decs))) )\\n\\n line_dec = np.linspace(decs_min, decs_max, 100)\\n line_ra = np.linspace(ras_min, ras_max, 100)\\n for ra in ras:\\n hp.projplot(np.repeat(ra, 100), line_dec, lonlat=True, ls='dashed', color='black')\\n hp.projtext(ra, dec0, r\\\"{ra:0.1f}$^\\\\circ$\\\".format(ra=ra), lonlat=True, clip_on=True)\\n for dec in decs:\\n hp.projplot(line_ra, np.repeat(dec, 100), lonlat=True, ls='dashed', color='black')\\n hp.projtext(ra0, dec, r\\\"{dec:0.1f}$^\\\\circ$\\\".format(dec=dec), lonlat=True, clip_on=True, rotation=90)\\n return\",\n \"def draw_galaxies(fig, ax):\\r\\n table = os.path.join(tables_dir, \\\"misgeld_et_al_2008.tsv\\\")\\r\\n ra, dec, diam = np.loadtxt(table, usecols=(0, 1, 15), delimiter=\\\"|\\\").T\\r\\n ################################################\\r\\n # Center is set in NGC 3311 according to catalog\\r\\n x = canvas.arcsec2kpc(3600. * (ra - canvas.ra0))\\r\\n y = canvas.arcsec2kpc(3600. * (dec - canvas.dec0))\\r\\n #################################################\\r\\n ax.plot(x, y, \\\"og\\\", ms=16, markerfacecolor='none', mec=\\\"y\\\")\\r\\n return\",\n \"def plot_dep(self,period=6.,projection='lambert',geopolygons=None, showfig=True, vmin=None, vmax=None, hillshade=False):\\n\\t\\tif hillshade:\\n\\t\\t\\talpha = 0.5\\n\\t\\telse:\\n\\t\\t\\talpha =1.\\n\\t\\tm = self._get_basemap(projection=projection, geopolygons=geopolygons,hillshade=hillshade)\\n\\t\\tgroup = self['%g_sec'%( period )]\\n\\t\\tx, y = m(group['lonArr'].value, group['latArr'].value)\\n\\t\\tmy_cmap = pycpt.load.gmtColormap('/work3/wang/code_bkup/ToolKit/Models/ETOPO1/ETOPO1.cpt')\\n\\t\\tdep_Arr = group['dep_Arr'].value\\n\\t\\tif vmin == None:\\n\\t\\t\\tvmin = np.nanmin(dep_Arr)\\n\\t\\t\\tvmin = np.floor(vmin/100.)*100.\\n\\t\\tif vmax == None:\\n\\t\\t\\tvmax = np.nanmax(dep_Arr)\\n\\t\\t\\tvmax = np.ceil(vmax/100.)*100.\\n\\t\\tim = m.pcolormesh(x, y, dep_Arr, cmap=my_cmap, shading='gouraud', vmin=vmin, vmax=vmax, alpha=alpha)\\n\\t\\tcb = m.colorbar(im, \\\"bottom\\\", size=\\\"3%\\\", pad='2%', format='%d')\\n\\t\\tcb.set_label('Topography (m)', fontsize=12, rotation=0)\\n\\t\\tcb.set_alpha(1)\\n\\t\\tcb.draw_all()\\n\\t\\tax = plt.gca() # only plot the oceanic part for JdF\\n\\t\\t# ax.set_xlim(right=x_max)\\n\\t\\tif showfig:\\n\\t\\t\\tplt.show()\\n\\t\\treturn\",\n \"def plot_timeline_overview(logs):\\n\\tfig, ax = plt.subplots(figsize=(11,6))\\n\\tfig.autofmt_xdate()\\n\\tc = 0\\n\\tline2D_array = []\\n\\tplot_data_dict = {}\\n\\tfor l in logs:\\n\\t\\tplot_data, _, dates, _ = l.give_plot_data()\\n\\t\\ttmp, = ax.plot(dates, [c]*len(dates), label=l.name, picker=10, marker='.', linestyle='-', linewidth=0.05, ms=5)\\n\\t\\tplot_data_dict[tmp.get_c()] = plot_data\\n\\t\\tline2D_array.append(tmp)\\n\\t\\tc += 1\\n\\tmyFmt = DateFormatter(\\\"%Y %d.%b %H:%M\\\")\\n\\tax.xaxis.set_major_formatter(myFmt)\\n\\tax.set_yticks(range(0,len(logs)))\\n\\tax.set_yticklabels([x.name for x in logs])\\n\\tnames = ' and '.join([x.name for x in logs])\\n\\tplt.title('Analysis of the files ' + names)\\n\\tt = 0.15+(0.1)*len(logs)\\n\\tplt.subplots_adjust(left=0.23, bottom=0.2, right=0.9, top=t)\\n\\n\\tannot = ax.annotate(\\\"\\\", xy=(0,0), xytext=(0.01,0.01) ,textcoords='figure fraction', bbox=dict(boxstyle=\\\"round\\\", fc=\\\"cyan\\\"), arrowprops=dict(arrowstyle=\\\"->\\\"))\\n\\tannot.set_visible(False)\\n\\tax.set_xlabel('timestamps in UTC')\\n\\tax.set_ylabel('log files')\\n\\n\\tdef update_annot(l,ind):\\n\\t\\tplot_data = plot_data_dict[l.get_c()]\\n\\t\\tx,y = l.get_data()\\n\\t\\tannot.xy = (x[ind[\\\"ind\\\"][0]], y[ind[\\\"ind\\\"][0]])\\n\\t\\ttext = plot_data[ind[\\\"ind\\\"][0]]\\n\\t\\tannot.set_text(text)\\n\\t\\tannot.get_bbox_patch().set_alpha(0.4)\\n\\n\\tdef hover(event):\\n\\t\\tvis = annot.get_visible()\\n\\t\\tif event.inaxes == ax:\\n\\t\\t\\tfor l in line2D_array:\\n\\t\\t\\t\\tcont, ind = l.contains(event)\\n\\t\\t\\t\\tif cont:\\n\\t\\t\\t\\t\\tupdate_annot(l,ind)\\n\\t\\t\\t\\t\\tannot.set_visible(True)\\n\\t\\t\\t\\t\\tfig.canvas.draw_idle()\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif vis:\\n\\t\\t\\t\\t\\t\\tannot.set_visible(False)\\n\\t\\t\\t\\t\\t\\tfig.canvas.draw_idle()\\n\\n\\tfig.canvas.mpl_connect(\\\"motion_notify_event\\\", hover)\\n\\tfig.canvas.mpl_connect('key_press_event', _quit_figure)\",\n \"def test_render_world_map():\\n gdpinfo = {\\n \\\"gdpfile\\\": \\\"isp_gdp.csv\\\",\\n \\\"separator\\\": \\\",\\\",\\n \\\"quote\\\": '\\\"',\\n \\\"min_year\\\": 1960,\\n \\\"max_year\\\": 2015,\\n \\\"country_name\\\": \\\"Country Name\\\",\\n \\\"country_code\\\": \\\"Country Code\\\"\\n }\\n\\n # Get pygal country code map\\n pygal_countries = pygal.maps.world.COUNTRIES\\n #pygal_countries = {'KEN':'Kenya', 'IDN':'Indonesia', 'IND':'India', \\\\\\n #'USA':'United States of America'}\\n\\n # 1960\\n #render_world_map(gdpinfo, pygal_countries, \\\"1960\\\", \\\"isp_gdp_world_name_1960.svg\\\")\\n\\n # 1980\\n #render_world_map(gdpinfo, pygal_countries, \\\"1980\\\", \\\"isp_gdp_world_name_1980.svg\\\")\\n\\n # 2000\\n #render_world_map(gdpinfo, pygal_countries, \\\"2000\\\", \\\"isp_gdp_world_name_2000.svg\\\")\\n\\n # 2010\\n render_world_map(gdpinfo, pygal_countries, \\\"2010\\\", \\\"isp_gdp_world_name_2010.svg\\\")\",\n \"def world_map_template():\\n fig, ax = plt.subplots(figsize=(20, 10))\\n ax.plot(\\n laea_x(np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(-np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(-np.pi, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(-np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(-np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(-2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(-2 * np.pi / 3, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(0, np.linspace(-np.pi / 2, np.pi / 2)),\\n laea_y(0, np.linspace(-np.pi / 2, np.pi / 2)),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.linspace(-np.pi, np.pi), 0),\\n laea_y(np.linspace(-np.pi, np.pi), 0),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.linspace(-np.pi, np.pi), np.pi / 6),\\n laea_y(np.linspace(-np.pi, np.pi), np.pi / 6),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.linspace(-np.pi, np.pi), -np.pi / 6),\\n laea_y(np.linspace(-np.pi, np.pi), -np.pi / 6),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.linspace(-np.pi, np.pi), np.pi / 3),\\n laea_y(np.linspace(-np.pi, np.pi), np.pi / 3),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.plot(\\n laea_x(np.linspace(-np.pi, np.pi), -np.pi / 3),\\n laea_y(np.linspace(-np.pi, np.pi), -np.pi / 3),\\n color=\\\"k\\\",\\n zorder=10,\\n )\\n ax.text(0, 1.47, r\\\"$|0\\\\rangle$\\\", fontsize=20)\\n ax.text(0, -1.53, r\\\"$|1\\\\rangle$\\\", fontsize=20)\\n ax.text(0.05, 0.05, r\\\"$|+\\\\rangle$\\\", fontsize=20)\\n ax.text(2.9, 0, r\\\"$|-\\\\rangle$\\\", fontsize=20)\\n ax.text(-3.2, 0, r\\\"$|-\\\\rangle$\\\", fontsize=20)\\n\\n return fig, ax\",\n \"def map_area( m ):\\n \\n \\n m.drawcoastlines( linewidth = 1.5, linestyle = 'solid', color = [ 75./255., 75/255., 75/255. ] )\\t\\n # ------draw parallels----------------\\n circles = np.arange( -90., 90. + 30, 30. ) #delat = 30.\\n m.drawparallels( circles, labels = [ 1, 0, 0, 0 ] )\\n \\n # -------draw meridians---------------\\n meridians = np.arange( 0., 360, 60. ) #delon = 60.\\n m.drawmeridians( meridians, labels = [ 0, 0, 0, 1 ] )\",\n \"def experimental_report(environment, species, time_series,path=None,events=None):\\n\\n\\n M = len(environment)+1\\n L = int(np.ceil(1 + len(time_series)/2))\\n fig = plt.figure(figsize=(5*M,5*L))\\n \\n colormaps = [\\\"Greens\\\",\\\"bwr\\\",\\\"Blues\\\",\\\"Oranges\\\",\\\"RdPu\\\",\\\"Reds\\\"]\\n for i,(k,v) in enumerate(environment):\\n plt.subplot(L,M,i+1)\\n plt.imshow(v,\\n interpolation='None',\\n cmap=colormaps[i%len(colormaps)],\\n vmin=0,vmax=1,\\n aspect=\\\"equal\\\")\\n plt.xticks([])\\n plt.yticks([])\\n plt.title(k)\\n plt.colorbar(orientation=\\\"horizontal\\\", fraction=0.045)\\n plt.subplot(L,M,M)\\n niches(species,path=path)\\n\\n colors = [\\\"blue\\\",\\\"green\\\",\\\"brown\\\",\\\"purple\\\",\\\"red\\\"]\\n host = [host_subplot(L*100+10+2+j, axes_class=AA.Axes) for j in range(L-1)]\\n\\n\\n for i,(k,v) in enumerate(time_series):\\n #if False and i%2 != 0:\\n # ax = host[int(i/2)].twinx()\\n #else:\\n ax = host[int(i/2)]\\n ax.set_ylabel(k)\\n if len(v) == 2:\\n T = len(v[0])\\n ax.plot(v[0],\\n label=k,\\n color=colors[i%len(colors)],\\n linewidth=2)\\n ax.fill_between(range(len(v[0])),\\n v[0]-v[1], v[0]+v[1],\\n alpha=0.3,\\n color=colors[i%len(colors)])\\n else:\\n T = len(v)\\n ax.plot(range(len(v)),v, color=colors[i%len(colors)], label=k)\\n \\n \\n for h in host:\\n h.set_xlim((0,T-1))\\n h.legend()\\n h.set_xlabel(\\\"Time\\\")\\n \\n h.set_ymargin(0.05)\\n h.autoscale(enable=True, axis=u'both', tight=False)\\n\\n if events is not None:\\n h.vlines(events,*h.get_ylim(),alpha=0.1)\",\n \"def drawHeatMap(xdat, name=None, colors=pylab.cm.Reds, dendro=False, protColors=None, cIndex=None, km=None, \\r\\n nameDict={}, scale=None, saveName=None, colorBar=False, figSize=(6,6), topDendro=False, fig=None, axData=None):\\r\\n\\r\\n data = xdat['data']\\r\\n if nameDict is None:\\r\\n nameList = [i for i in xdat['fractions']]\\r\\n else:\\r\\n nameList = [nameDict[i] for i in xdat['fractions']]\\r\\n\\r\\n proteins = [i for i in xdat['proteins']]\\r\\n if fig is None:\\r\\n fig = pylab.figure(figsize=figSize)\\r\\n if not (name is None):\\r\\n fig.suptitle(name)\\r\\n ##Draw heatmap\\r\\n xOffset = 0.05\\r\\n if colorBar:\\r\\n xLess = 0.10\\r\\n else:\\r\\n xLess = 0.00\\r\\n if dendro:\\r\\n xStart = 0.375\\r\\n xLength = 0.55-xLess\\r\\n else:\\r\\n xStart = 0.125\\r\\n xLength = 0.85-xLess\\r\\n if (km is None) and (topDendro is False):\\r\\n yStart = 0.05\\r\\n yLength = 0.9\\r\\n else:\\r\\n yStart = 0.05\\r\\n yLength = 0.8\\r\\n figAxes = heatMapAxes(data, dims = [xStart, yStart, xLength, yLength], columns=nameList, rows=proteins, protColors=protColors, cIndex=cIndex, fig=fig, colors=colors, axData=axData)\\r\\n ##Draw colorbar\\r\\n if colorBar:\\r\\n fig.colorbar(figAxes)\\r\\n\\r\\n if dendro:\\r\\n ax2Data = fig.add_axes([xOffset, yStart, xLength-0.3, yLength])\\r\\n sch.dendrogram(xdat['rightDendro'], orientation='right', color_threshold=0.0)\\r\\n ax2Data.set_xticks([])\\r\\n ax2Data.set_yticks([])\\r\\n \\r\\n if topDendro:\\r\\n ax4Data = fig.add_axes([xStart, yStart+yLength, xLength, 0.1])\\r\\n sch.dendrogram(xdat['topDendro'], orientation='down', color_threshold=0.0)\\r\\n ax4Data.set_xticks([])\\r\\n ax4Data.set_yticks([])\\r\\n \\r\\n if not km is None:\\r\\n small = data.min()\\r\\n big = data.max()\\r\\n if math.fabs(small) > math.fabs(big):\\r\\n big = 0-small\\r\\n else:\\r\\n small = 0-big\\r\\n offset=0.0\\r\\n ax3Data = fig.add_axes([xStart, yLength+offset, xLength-0.1, 0.1])\\r\\n ax3Data.matshow(km, aspect='auto', origin='lower', cmap=colors, vmin=small, vmax=big)\\r\\n for i in range(len(km)):\\r\\n ax3Data.text(-0.75, i, 'clus'+str(i), verticalalignment=\\\"center\\\", horizontalalignment=\\\"right\\\", fontsize=10, color=cIndex(float(i)/(protColors.max()+1)))\\r\\n ax3Data.set_xticks([])\\r\\n ax3Data.set_yticks([])\\r\\n #fig.tight_layout()\\r\\n if not (saveName is None):\\r\\n pylab.savefig(saveName)\\r\\n \\r\\n return fig\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69210756","0.6444934","0.6395161","0.6322168","0.6316235","0.6248","0.62450975","0.62378526","0.62311244","0.62179315","0.6160899","0.6084357","0.60731095","0.60508186","0.60447294","0.6003607","0.5985491","0.5948202","0.593896","0.59218866","0.5912166","0.5911991","0.5896895","0.58811337","0.5868478","0.5853717","0.58506924","0.5833216","0.5829562","0.58042055","0.5796632","0.5793956","0.5786859","0.5753024","0.5750055","0.57495123","0.57399845","0.57302755","0.5729665","0.5712559","0.57100147","0.56888825","0.56858957","0.5681565","0.5679576","0.5675159","0.5675155","0.5674074","0.5664828","0.5664053","0.5662951","0.56558883","0.5648441","0.56321007","0.5624304","0.56123036","0.5605652","0.559905","0.55963886","0.5594","0.5593571","0.5587986","0.5583623","0.55821365","0.55785036","0.5567213","0.5566568","0.5527703","0.5524539","0.55137444","0.55102223","0.5505112","0.5502621","0.55005646","0.54973334","0.54969394","0.54888207","0.54804623","0.5476629","0.5472135","0.54696995","0.546258","0.54599285","0.54597044","0.5458997","0.54566205","0.5454489","0.5448086","0.54451066","0.54422385","0.5440551","0.5433148","0.5428035","0.5419516","0.5419373","0.5418789","0.54183185","0.54181117","0.5412298","0.54092634"],"string":"[\n \"0.69210756\",\n \"0.6444934\",\n \"0.6395161\",\n \"0.6322168\",\n \"0.6316235\",\n \"0.6248\",\n \"0.62450975\",\n \"0.62378526\",\n \"0.62311244\",\n \"0.62179315\",\n \"0.6160899\",\n \"0.6084357\",\n \"0.60731095\",\n \"0.60508186\",\n \"0.60447294\",\n \"0.6003607\",\n \"0.5985491\",\n \"0.5948202\",\n \"0.593896\",\n \"0.59218866\",\n \"0.5912166\",\n \"0.5911991\",\n \"0.5896895\",\n \"0.58811337\",\n \"0.5868478\",\n \"0.5853717\",\n \"0.58506924\",\n \"0.5833216\",\n \"0.5829562\",\n \"0.58042055\",\n \"0.5796632\",\n \"0.5793956\",\n \"0.5786859\",\n \"0.5753024\",\n \"0.5750055\",\n \"0.57495123\",\n \"0.57399845\",\n \"0.57302755\",\n \"0.5729665\",\n \"0.5712559\",\n \"0.57100147\",\n \"0.56888825\",\n \"0.56858957\",\n \"0.5681565\",\n \"0.5679576\",\n \"0.5675159\",\n \"0.5675155\",\n \"0.5674074\",\n \"0.5664828\",\n \"0.5664053\",\n \"0.5662951\",\n \"0.56558883\",\n \"0.5648441\",\n \"0.56321007\",\n \"0.5624304\",\n \"0.56123036\",\n \"0.5605652\",\n \"0.559905\",\n \"0.55963886\",\n \"0.5594\",\n \"0.5593571\",\n \"0.5587986\",\n \"0.5583623\",\n \"0.55821365\",\n \"0.55785036\",\n \"0.5567213\",\n \"0.5566568\",\n \"0.5527703\",\n \"0.5524539\",\n \"0.55137444\",\n \"0.55102223\",\n \"0.5505112\",\n \"0.5502621\",\n \"0.55005646\",\n \"0.54973334\",\n \"0.54969394\",\n \"0.54888207\",\n \"0.54804623\",\n \"0.5476629\",\n \"0.5472135\",\n \"0.54696995\",\n \"0.546258\",\n \"0.54599285\",\n \"0.54597044\",\n \"0.5458997\",\n \"0.54566205\",\n \"0.5454489\",\n \"0.5448086\",\n \"0.54451066\",\n \"0.54422385\",\n \"0.5440551\",\n \"0.5433148\",\n \"0.5428035\",\n \"0.5419516\",\n \"0.5419373\",\n \"0.5418789\",\n \"0.54183185\",\n \"0.54181117\",\n \"0.5412298\",\n \"0.54092634\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7201914"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85195,"cells":{"query":{"kind":"string","value":"counts reviewer comments, checks for protm tag, counts rxns"},"document":{"kind":"string","value":"def calc_comments(self):\n for comment in self.pull_request.get_comments():\n self._users.add(comment.user.login)\n lowercase_body = comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_comments += 1\n if comment.body is not None:\n self.len_comments += len(comment.body)\n for reaction in comment.get_reactions():\n self._users.add(reaction.user.login)\n self.comment_reactions += 1"},"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 calc_conv_comments(self):\n for conv_comment in self.pull_request.get_issue_comments():\n self._users.add(conv_comment.user.login)\n lowercase_body = conv_comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_conv_comments += 1\n for reaction in conv_comment.get_reactions():\n self._users.add(reaction.user.login)\n self.conv_comment_reactions += 1\n if conv_comment.body is not None:\n self.len_issue_comments += len(conv_comment.body)","def count_comments(self):\n return self.run_query(f\"count({self.r}/comment)\")","def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\n if project_name == PROJECT_ALL:\n # comments in changes across all projects after from_datetime\n comments = reviewer.comments.filter(\n timestamp__gte=from_datetime).distinct()\n else:\n # comments in changes in given project after from_datetime\n comments = reviewer.comments.filter(\n change__project_name=project_name,\n timestamp__gte=from_datetime).distinct()\n\n return comments.count()","def getReviewNumbers(singleStoryFooter):\n\twords = singleStoryFooter.get_text()\n\treview = re.compile(r\"Reviews: \\d+\").search(words)\n\tif review:\n\t\treviewNum = review.group()[9:]\n\t\treturn int(reviewNum)\n\telse: return 0","def parseCommentsTotalCount(data):\n p = re.compile(r\"\\d+ Reviews\")\n\n for line in data:\n line = line.replace(\",\", \"\")\n match = re.search(p, line)\n if match != None:\n getNmbr = match.group().split(\" \")\n return int(getNmbr[0])\n return -1","def getCommentCount(self, source):\n commentStart = source.find('item?id=')\n commentCountStart = source.find('>', commentStart) + 1\n commentEnd = source.find('</a>', commentStart)\n commentCountString = source[commentCountStart:commentEnd]\n if commentCountString == \"discuss\":\n return 0\n elif commentCountString == \"\":\n return 0\n else:\n commentCountString = commentCountString.split(' ')[0]\n return int(commentCountString)","def count_reddit_comments_ngram_strs(year, month, n):\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\n return Counter(itertools.chain.from_iterable(ngram_strs))","def number_of_subscribers(subreddit):\n h = {'user-agent': 'GEEK1050'}\n link = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n req = requests.get(link, headers=h)\n\n req_data = req.json().get(\"data\").get(\"subscribers\")\n for element in req_data['children']:\n print(element['children']['title'])","def getNumberOfReviews(self):\n try:\n count = 0\n with open(self.metadata_path, \"r\", newline='') as metadata:\n mdata = csv.reader(metadata, delimiter=' ', quotechar='|')\n for review_data in mdata:\n count += 1\n return count\n except Exception:\n print(\"Cant load metadata file\")\n traceback.print_exc()","def github_num_reactions(comment_object: Dict[str, Any]) -> int:\n return comment_object.get('reactions', {}).get('total_count', 0)","def get_comments_count(self, thread_uid: str) -> int:\n pass","def count_regexp():\r\n # Here's an example regular expression that roughly matches a valid email address.\r\n # The ones you write below should be shorter than this\r\n email = re.compile(\"[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+\\.[a-zA-Z]{2,5}\")\r\n\r\n ###### Write below #########\r\n subheading = re.compile(\"\\=\\=+.*\\=\\=+\")\r\n link_to_subheading = re.compile(\"\\[\\[[\\w\\'*\\-*\\:*\\(*\\)*\\_*\\s*]+[#][\\s*\\w\\\\'*\\-*\\:*\\(*\\)*\\_*s*]+\\|*\")\r\n doi_citation = re.compile(\"\\{\\{[c][ite](?!{{).*[dD][oO][iI]\\s*[:|,=\\/]*\\s*[0-9]+\\.[0-9]+.*\\}\\}\")\r\n ###### End of your work #########\r\n\r\n patterns = {\r\n \"emails\": email,\r\n \"subheadings\": subheading,\r\n \"links to subheadings\": link_to_subheading,\r\n \"citations with DOI numbers\": doi_citation,\r\n }\r\n\r\n with open(RAW_DUMP_XML, encoding=\"utf-8\") as f:\r\n dump_text = f.read()\r\n for name, pattern in patterns.items():\r\n if pattern is None:\r\n continue\r\n matches = pattern.findall(dump_text)\r\n count = len(matches)\r\n\r\n example_matches = [matches[i * (count // 5)] for i in range(5)]\r\n\r\n print(\"Found {} occurences of {}\".format(count, name))\r\n print(\"Here are examples:\")\r\n print(\"\\n\".join(example_matches))\r\n print(\"\\n\")","def number_of_subscribers(subreddit):\n header = {\"User-agent\": \"darth\"}\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n response = (requests.get(url, headers=header))\n if response.status_code != 200:\n return 0\n return response.json().get('data').get('subscribers')","def number_of_subscribers(subreddit):\n link = 'http://www.reddit.com/r/{}/about.json'.format(subreddit)\n red = requests.get(link, headers={'User-Agent': 'tope628'}).json()\n try:\n subs = red.get('data').get('subscribers')\n except:\n return 0\n if red is None:\n return 0\n return subs","def _get_token_cnts(self, doc, doc_type):\n tokenized_doc = self.nlp(doc)\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\n doc_len = len([t for t in tokenized_doc])\n self.stat_dict[doc_type][1].append(doc_len)\n if doc_len < 50 and doc_type == \"answer\":\n print(\"Document less than 50 tokens:\", url)","def count_other_citations(pmid,linkname):\n link = f\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\"\n sleep(0.3)\n page = requests.get(link).text\n soup = BeautifulSoup(page, 'html.parser') \n count = int(soup.find_all(attrs={\"name\": \"ncbi_resultcount\"})[0][\"content\"])\n return(count)","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}/about.json\"\n headers = {\n 'User-Agent': 'My User Agent 1.0',\n 'From': 'youremail@domain.com'\n }\n r_subs = requests.get(url.format(subreddit), headers=headers)\n if r_subs.status_code == 200:\n data = r_subs.json()['data']\n subscribers = data.get('subscribers')\n if subscribers is not None:\n return subscribers\n return 0","def count():","def sent_count(comment):\n return comment.__len__()","async def scrape_comments(self):\n\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\n\n comment_count = 0\n async for comment in subreddit_origin.comments(limit=self.limit):\n if self.memory.contains(comment.id):\n continue\n\n self.memory.add(comment.id)\n\n # Parse Comment\n comment = self.parse_comment(comment)\n\n # Save in Pub/Sub\n if self.enable_publish:\n self.publish(comment)\n\n comment_count += 1\n\n return comment_count","def stat_reviews(self, year):\n stats = dict()\n reviews = list(self.get_reviews(year))\n stats['reviews'] = len(reviews)\n stats['open'] = len(\n [review['issue'] for review in reviews if not review['closed']]\n )\n (messages, comments, patchsets) = (dict(), dict(), dict())\n for review in reviews:\n id = review['issue']\n messages[id] = len(review['messages'])\n patchsets[id] = len(review['patchsets'])\n comments[id] = 0\n for patchset in review['patchsets'].values():\n comments[id] += patchset['num_comments']\n stats['messages'] = helpers.sort(messages, desc=True)\n stats['comments'] = helpers.sort(comments, desc=True)\n stats['patchsets'] = helpers.sort(patchsets, desc=True)\n return stats","def number_of_subscribers(subreddit):\n response = requests.get('https://www.reddit.com/r/{}/about.json'\n .format(subreddit),\n headers={'User-Agent': 'Camilo@holberton'},\n allow_redirects=False)\n if response.status_code == 200:\n response = response.json()\n data = response.get('data')\n subs_count = data.get('subscribers')\n if data and subs_count:\n return subs_count\n return 0","def get_count(username):\n return get_contributor(username)[\"count\"]","def number_of_subscribers(subreddit):\n import requests\n headers = {'User-Agent': 'Godfather'}\n about = requests.get(\n 'https://www.reddit.com/r/{}/about.json'.format(\n subreddit), headers=headers).json()\n try:\n subscribers = about.get('data').get('subscribers')\n if subscribers is None:\n raise TypeError\n return subscribers\n except:\n return 0","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}.json\".format(subreddit)\n r = requests.get(url, headers={'User-agent': 'shoji'},\n allow_redirects=False)\n data = r.json()\n if not r.status_code == 200:\n return 0\n try:\n sub = data.get(\"data\")\n children = sub.get(\"children\")\n subreddit = children[0].get(\"data\")\n subscriber_count = subreddit.get(\"subreddit_subscribers\")\n except Exception as e:\n print(\"Something went wrong\\n {}\".format(e))\n return 0\n\n return subscriber_count","def number_of_subscribers(subreddit):\n url = requests.get(\"https://www.reddit.com/r/{}/about.json\"\n .format(subreddit), headers={\"User-Agent\": \"kalkidan\"})\n if url.status_code == 200:\n return url.json().get(\"data\").get(\"subscribers\")\n else:\n return 0","def get_comment_count(self, postid=0, blogid=1):\n \n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)","def findNoteCounts(self, authenticationToken, filter, withTrash):\r\n pass","def wcount(lines, topn=10):\n my_socket = urllib.request.urlopen(lines)\n dta = my_socket.read().decode()\n my_socket.close()\n #get the text from url\n \n s=dta.replace(',',' ')\n b=s.replace('.',' ')\n c=b.replace('?',' ')\n d=c.replace('_',' ')\n e=d.replace(']',' ')\n f=e.replace('[',' ')\n g=f.replace('*',' ')\n h=g.replace('%',' ')\n i=h.replace('!',' ')\n j=i.replace('\"',' ')\n k=j.replace(':',' ')\n l=k.replace(';',' ')\n m=l.replace('(',' ')\n n=m.replace(')',' ')\n o=n.replace('-',' ')\n p=o.replace('_',' ')\n q=p.replace('/','')\n q=q.lower()\n x=q.split()\n y=set(x)\n #Processed documents are converted into ordered strings\n \n lst={}\n for i in y:\n num=x.count(i)\n lst[i]=num\n \n r=list(lst.values())\n r.sort(reverse=True)\n for i in r[:topn]:\n print(list(lst.keys())[list(lst.values()).index(i)].ljust(15)+\" \"+str(i))\n \n pass","def cmd_account_comment_count(client, args):\n account_comment_count = client.get_account_comment_count(args.username)\n generate_output({'account_comment_count': account_comment_count})","def number_of_subscribers(subreddit):\n url = \"https://api.reddit.com/r/{}/about\".format(subreddit)\n header = {'User-Agent': 'CustomClient/1.0'}\n request = requests.get(url, headers=header, allow_redirects=False)\n\n if request.status_code != 200:\n return 0\n jreq = request.json()\n\n if 'data' in jreq:\n return jreq.get(\"data\").get(\"subscribers\")\n else:\n return 0","def number_of_subscribers(subreddit):\n if subreddit is None or type(subreddit) is not str:\n return 0\n BASE_URL = 'http://www.reddit.com/r/{}/about.json'\n head = {'User-Agent': 'Mozilla/5.0'}\n r = requests.get(BASE_URL.format(subreddit), headers=head)\n return r.json().get('data', {}).get('subscribers', 0)","def number_of_subscribers(subreddit):\n header = {'User-Agent': 'Chrome/90.0.4430.212 Safari/537.36'}\n req = requests.get('https://www.reddit.com/r/{}/about.json'\n .format(subreddit), allow_redirects=False,\n headers=header)\n if req.status_code == 200:\n subscribers = req.json().get('data').get('subscribers')\n return subscribers\n else:\n return 0","def sorter(r):\n\n ans = len(r.description)\n if additional:\n for rr in r.monkey_additional:\n ans += len(rr)\n return ans","def count_comment_karma(user):\r\n\r\n karma = 0\r\n comments = Comment.objects.filter(name=user).all()\r\n for comment in comments:\r\n karma += comment.likes.count()\r\n\r\n return karma","def get_product_total_reviews(self, driver):\n try:\n frame = driver.find_element_by_id(\"BVRRRatingSummaryLinkReadID\")\n total_reviews = frame.find_element_by_class_name(\"BVRRNumber\").text\n return total_reviews\n except NoSuchElementException:\n return 0","def analyze_reviews(reviews):\n\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\n\n print 'len(good_reviews)=%s' % len(good_reviews)\n print 'len(bad_reviews)=%s' % len(bad_reviews)\n\n m = re.compile('\\d')\n\n english_stop_words=stopwords.words('english')\n\n\n def tokenize(text):\n tokens=nltk.word_tokenize(text)\n # strip out trailing puncutation\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\n\n # lower case\n tokens = [token.lower() for token in tokens]\n\n # Take only relativly long characters\n tokens = [token for token in tokens if len(token)>=3]\n\n # remove words with numbers/digits\n tokens = [token for token in tokens if m.search(token) is None]\n\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\n tokens = [token for token in tokens if token not in english_stop_words]\n return tokens\n\n good_tokens_list = []\n for i,review in good_reviews.iterrows():\n text=review['rs_review_text']\n good_tokens_list.append(tokenize(text))\n\n bad_tokens_list = []\n for i,review in bad_reviews.iterrows():\n text=review['rs_review_text']\n bad_tokens_list.append(tokenize(text))\n\n all_words=Counter()\n for tokens in good_tokens_list + bad_tokens_list:\n for token in tokens:\n all_words[token]+=1\n\n most_common=all_words.most_common(2000)\n most_common=zip(*most_common)[0]\n\n print 'most_common_words = ',most_common[-20:]\n\n def document_features(tokens):\n return {word:word in tokens for word in most_common}\n\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\n\n train_set = good_set + bad_set\n random.shuffle(train_set) # dunno if this is necessary\n\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\n\n classifier.show_most_informative_features(300)\n\n return classifier","def cmd_gallery_comment_count(client, args):\n gallery_comment_count = client.gallery_comment_count(args.item_id)\n generate_output({'gallery_comment_count': gallery_comment_count})","def number_of_subscribers(subreddit):\n URL = 'https://api.reddit.com/r/{}/about'.format(subreddit)\n header = {'User-Agent': 'Custom-User'}\n\n resp = requests.get(URL, headers=header).json()\n try:\n return resp['data']['subscribers']\n except Exception:\n return 0","def count_revisions_by_user(self):\n return self.run_query(f\"count({self.r}/contributor[id = 5558])\")","def number_of_subscribers(subreddit):\n\n import requests\n\n resInf = requests.get(\"https://www.reddit.com/r/{}/about.json\"\n .format(subreddit),\n headers={\"User-Agent\": \"My-User-Agent\"},\n allow_redirects=False)\n if resInf.status_code >= 300:\n return 0\n\n return resInf.json().get(\"data\").get(\"subscribers\")","def do_get_user_comment_count(parser, token):\r\n error_message = \"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\" % (token.contents.split()[0], token.contents.split()[0])\r\n try:\r\n split = token.split_contents()\r\n except ValueError:\r\n raise template.TemplateSyntaxError, error_message\r\n if len(split) != 5:\r\n raise template.TemplateSyntaxError, error_message\r\n return UserCommentCountNode(split[2], split[4])","def get_matches_count():\n\n return ''\n \"\"\"\n TODO: count matches\n dtr5app_flag.sender\n dtr5app_flag.receiver\n dtr5app_flag.flag\n \"\"\"","def getCounter(self):\n word_count, noun_word_count = Counter(), Counter()\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\n docs = self.nlp.pipe(\n self.docs, n_process=1, disable=self.disablelayers)\n \n\n for index, doc in enumerate(docs):\n for token in doc:\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\n if token.pos_ == 'PROPN':\n word_count[token.lemma_] += 1\n word_rating[token.lemma_].append(self.ratings[index])\n else:\n noun_word_count[token.lemma_] += 1\n noun_word_rating[token.lemma_].append(self.ratings[index])\n\n # if 0<=proper nouns<=5 found, add regular nouns\n if not word_count or len(word_count) <= 5:\n word_count += noun_word_count\n word_rating = {**word_rating, **noun_word_rating}\n \n word_color = {word: self.getColor(\n ratings)[1] for word, ratings in word_rating.items()}\n word_sentiment = {word: self.getColor(\n ratings)[0] for word, ratings in word_rating.items()}\n\n return word_count, word_color, word_sentiment","def number_of_subscribers(subreddit):\n\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\n\n headers = {'User-Agent': 'My User Agent 1.0'}\n\n request = requests.get(url, headers=headers)\n req = request.json()\n\n if request.status_code == 404:\n return 0\n\n subs = req.get('data').get('subscribers')\n return subs","def number_of_subscribers(subreddit):\n url = 'https://www.reddit.com/r/{}/about.json'\n headers = {'user-agent': 'X-Modhash'}\n url_format = requests.get(url.format(subreddit), headers=headers).json()\n try:\n name = url_format['data']['subscribers']\n return name\n except:\n return 0","def counts(self, regex = \"\\w+\"): \n tokenizer = RegexpTokenizer(r'{}'.format(regex))\n count = []\n for i in tqdm(self.text):\n count.append(len(tokenizer.tokenize(i)))\n return count","def comments_count(self) -> int:\n return pulumi.get(self, \"comments_count\")","def number_of_subscribers(subreddit):\n\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n headers = {\"User-Agent\": \"my-integration/1.2.3\"}\n\n response = get(url=url, headers=headers)\n\n if response.status_code == 200:\n # print(response.json())\n\n response_json = response.json()\n data = response_json.get('data')\n subscribers = data.get(\"subscribers\")\n\n return subscribers\n\n return 0","def number_of_subscribers(subreddit):\n r = requests.get('https://api.reddit.com/r/{}/about.json'\n .format(subreddit),\n headers={'user-agent': 'ianscustomthing'},\n allow_redirects=False)\n rj = r.json()\n if rj.get('message') == 'Not Found':\n return 0\n s = rj.get('data').get('subscribers')\n return s","def count_ngrams(self, corpus):\n \n self.unigramcounts = {} # might want to use defaultdict or Counter instead\n self.bigramcounts = {} \n self.trigramcounts = {} \n\n self.total = 2\n ##Your code here\n\n for sentence in corpus:\n temp_1 = get_ngrams(sentence,1)\n temp_2 = get_ngrams(sentence,2)\n temp_3 = get_ngrams(sentence,3)\n for i in range(len(temp_1)):\n if temp_1[i] in self.unigramcounts:\n self.unigramcounts[temp_1[i]] += 1\n else:\n self.unigramcounts[temp_1[i]] = 1\n self.total += 1\n\n for i in range(len(temp_2)):\n if temp_2[i] in self.bigramcounts:\n self.bigramcounts[temp_2[i]] += 1\n else:\n self.bigramcounts[temp_2[i]] = 1\n\n for i in range(len(temp_3)):\n if temp_3[i] in self.trigramcounts:\n self.trigramcounts[temp_3[i]] += 1\n else:\n self.trigramcounts[temp_3[i]] = 1\n return","def getTokenSizeOfReviews(self):\n res = 0\n with open(self.word_to_docs_path, 'rb') as bin:\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n res += frequency\n # skip documents:\n int.from_bytes(bin.read(4 * frequency), 'big')\n return res","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def review_count(self):\n\t\tcount = self.reviews.aggregate(\n\t\t\tcount=models.Count('rating'))['count']\n\t\tif count is None:\n\t\t\tcount = 0\n\t\treturn count","def number_of_subscribers(subreddit):\n url_rsubs = \"https://api.reddit.com/r/{}/about\".format(subreddit)\n headers = {'User-Agent': 'Python3'}\n response = requests.get(url_rsubs, headers=headers,\n allow_redirects=False)\n if str(response) != \"<Response [200]>\":\n return 0\n r_json = response.json()\n subs_count = r_json.get('data').get('subscribers')\n return subs_count","def get_about_count_results(soup):\n title = soup.find('div', {'id': 'gs_ab_md'})\n if title:\n title = title.find('div', {'class': 'gs_ab_mdw'})\n if title:\n count_papers = title.text\n if count_papers:\n count_papers = count_papers.split(' ')[1].replace(',', '')\n else:\n count_papers = len(soup.find_all('h3', class_=\"gs_rt\"))\n try:\n int(count_papers)\n except:\n count_papers = title.text.split(' ')[0].replace(',', '')\n else:\n count_papers = len(soup.find_all('h3', class_=\"gs_rt\"))\n return int(count_papers)","def number_of_subscribers(subreddit):\n\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n headers = {'user-agent': 'request'}\n response = requests.get(url, headers=headers, allow_redirects=False)\n if str(response) != '<Response [200]>':\n return 0\n response_json = response.json()\n subs = response_json.get('data').get('subscribers')\n return subs","def get_indicators_and_clean_comments(df):\n # Count number of \\n\n df[\"ant_slash_n\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\n\", x))\n # Get length in words and characters\n df[\"raw_word_len\"] = df[\"comment_text\"].apply(lambda x: len(x.split()))\n df[\"raw_char_len\"] = df[\"comment_text\"].apply(lambda x: len(x))\n # Check number of upper case, if you're angry you may write in upper case\n df[\"nb_upper\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[A-Z]\", x))\n # Number of F words - f..k contains folk, fork,\n df[\"nb_fk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[Ff]\\S{2}[Kk]\", x))\n # Number of S word\n df[\"nb_sk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[Ss]\\S{2}[Kk]\", x))\n # Number of D words\n df[\"nb_dk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[dD]ick\", x))\n # Number of occurence of You, insulting someone usually needs someone called : you\n df[\"nb_you\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\W[Yy]ou\\W\", x))\n # Just to check you really refered to my mother ;-)\n df[\"nb_mother\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\Wmother\\W\", x))\n # Just checking for toxic 19th century vocabulary\n df[\"nb_ng\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\Wnigger\\W\", x))\n # Some Sentences start with a <:> so it may help\n df[\"start_with_columns\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"^\\:+\", x))\n # Check for time stamp\n df[\"has_timestamp\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\d{2}|:\\d{2}\", x))\n # Check for dates 18:44, 8 December 2010\n df[\"has_date_long\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\D\\d{2}:\\d{2}, \\d{1,2} \\w+ \\d{4}\", x))\n # Check for date short 8 December 2010\n df[\"has_date_short\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\D\\d{1,2} \\w+ \\d{4}\", x))\n # Check for http links\n df[\"has_http\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"http[s]{0,1}://\\S+\", x))\n # check for mail\n df[\"has_mail\"] = df[\"comment_text\"].apply(\n lambda x: count_regexp_occ(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+', x)\n )\n # Looking for words surrounded by == word == or \"\"\"\" word \"\"\"\"\n df[\"has_emphasize_equal\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\={2}.+\\={2}\", x))\n df[\"has_emphasize_quotes\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\\"{4}\\S+\\\"{4}\", x))\n\n # Now clean comments\n df[\"clean_comment\"] = df[\"comment_text\"].apply(lambda x: prepare_for_char_n_gram(x))\n\n # Get the new length in words and characters\n df[\"clean_word_len\"] = df[\"clean_comment\"].apply(lambda x: len(x.split()))\n df[\"clean_char_len\"] = df[\"clean_comment\"].apply(lambda x: len(x))\n # Number of different characters used in a comment\n # Using the f word only will reduce the number of letters required in the comment\n df[\"clean_chars\"] = df[\"clean_comment\"].apply(lambda x: len(set(x)))\n df[\"clean_chars_ratio\"] = df[\"clean_comment\"].apply(lambda x: len(set(x))) / df[\"clean_comment\"].apply(\n lambda x: 1 + min(99, len(x)))","def number_of_subscribers(subreddit):\n url = \"https://www.reddit.com/r/{}/about.json\".format(subreddit)\n header = {\"Content-Type\": \"application/json\",\n \"User-Agent\": \"Mozilla/5.0\"}\n request = requests.get(\n url,\n headers=header,\n allow_redirects=False)\n if request.status_code >= 300:\n return 0\n return json.loads(request.content.decode(\"utf-8\"))[\"data\"][\"subscribers\"]","def review_counts(stat_info_dict):\n review_counts = {}\n for release, stat_dict in stat_info_dict.items():\n review_counts_per_release = {}\n for key, stat in stat_dict.items():\n # review count\n review_counts_per_release[key] = stat['metric']\n review_counts[release] = review_counts_per_release\n return review_counts","def number_of_reviews(user: User, only_today: bool) -> int:\n since = arrow.utcnow() if only_today else arrow.get(0)\n since_timestamp = since.format('YYYY-MM-DD')\n\n num_edits = DBDiscussionSession.query(ReviewEdit).filter(\n ReviewEdit.detector_uid == user.uid,\n ReviewEdit.timestamp >= since_timestamp).count()\n num_deletes = DBDiscussionSession.query(ReviewDelete).filter(\n ReviewDelete.detector_uid == user.uid,\n ReviewDelete.timestamp >= since_timestamp).count()\n num_optimizations = DBDiscussionSession.query(ReviewOptimization).filter(\n ReviewOptimization.detector_uid == user.uid,\n ReviewOptimization.timestamp >= since_timestamp).count()\n num_duplicates = DBDiscussionSession.query(ReviewDuplicate).filter(\n ReviewDuplicate.detector_uid == user.uid,\n ReviewOptimization.timestamp >= since_timestamp).count()\n\n return num_edits + num_deletes + num_optimizations + num_duplicates","def number_of_subscribers(subreddit):\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\n response = requests.get(url,\n allow_redirects=False,\n headers={'User-Agent': 'MyChromeBook'})\n if response:\n suscribers_number = response.json().get('data').get('subscribers')\n return suscribers_number\n else:\n return 0","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def correct_counts():\n articles = mongo.db[app.config['ARTICLES_COLLECTION']]\n monitors = mongo.db[app.config['MONITORS_COLLECTION']]\n unique = articles.distinct('feed_source', dict())\n for link in unique:\n count = articles.count({'feed_source': link})\n monitors.update({'metadata.rss_link': link}, {'$set': {'hits': count}})","def comment_count(self):\n return self.comments.filter_by(state=0).count()","def generate_reddit_comments_ngram_counts(\n year, month, n, root=paths.DEFAULT_REDDIT_NGRAMS_DATA):\n ngram_path = paths.get_reddit_ngrams_local(year, month, n, root=root)\n if os.path.isfile(ngram_path):\n logging.warning(\"Cache exists for all requested n-grams.\"\n \"Skipping %04d-%02d\\n\" % (year, month))\n return False\n\n counts = count_reddit_comments_ngram_strs(year, month, n)\n with gzip.GzipFile(ngram_path, 'wb') as fh:\n for k, v in counts.items():\n fh.write(\"{}\\t{}\\n\".format(k, v).encode())\n return True","def fetch_counts(datestruct):\n response = call_responder('elasticsearch', 'query/daily_proofreader_hits')\n for rec in response['result']['hits']['hits']:\n data = rec['_source']\n if data['user'] not in datestruct:\n datestruct[data['user']] = {\"cleave\": 0, \"merge\": 0,\n \"split-supervoxel\": 0}\n if '/cleave/' in data['uri']:\n datestruct[data['user']]['cleave'] += 1\n elif '/merge' in data['uri']:\n datestruct[data['user']]['merge'] += 1\n elif '/split-supervoxel' in data['uri']:\n datestruct[data['user']]['split-supervoxel'] += 1","def num_reviews(self):\n return self.review_set.count()","def run_compute_reread_counts(self):\n questions = []\n contexts = []\n student_data = self.responses[:]\n for response in student_data:\n if response.question.text not in questions:\n questions.append(response.question.text)\n if response.context.text not in contexts:\n contexts.append(response.context.text)\n\n compute_reread_counts_data = []\n\n for question in questions:\n for context in contexts:\n compute_reread_counts_data.append(self.compute_reread_counts(\n question, context))\n\n return compute_reread_counts_data","def count_comments(self):\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\n count = comments.count()\n return count","def count_relation_doc(document):\n count = {}\n for line in document[1:]:\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\n for relation in relation_types:\n if relation in count:\n count[relation] += 1\n else:\n count[relation] = 1\n return count","def core(self):\n \n \n comments = self.bot.subreddit(\n \"all\").stream.comments(\n skip_existing = True)\n \n \n for comment in comments:\n \n text = comment.body.lower().replace(\".\", \"\")\n \n for card in self.catalog:\n \n if (\n card[1].lower() in text\n and card[0].lower() in text\n and not comment.submission.id in self.responded\n and not comment.subreddit.user_is_banned):\n\n self.get_info(card)\n\n if not self.details:\n \n break\n\n audio = [\n \"audiobook\", \n \"audio book\"]\n \n author_format = [\n name.lower() for name in card[1].split(\" \") \n if len(name) >= 3]\n\n if (\n self.details[\"duration\"] > 10800\n and card[0].lower() in self.details[\n \"title\"].lower()\n and any(\n item in self.details[\n \"title\"].lower() for item in audio)\n and all(\n item in self.details[\n \"title\"].lower() for item in author_format)):\n \n \n saw_the_sign = (\n \"\"\"[^(Source Code)](https://capybasilisk.com/posts/\"\"\"\n \"\"\"2020/04/speculative-fiction-bot/) \"\"\"\n \"\"\"^| [^(Feedback)](https://www.reddit.com/message/\"\"\"\n \"\"\"compose?to=Capybasilisk&subject=Robot) \"\"\"\n \"\"\"^| [^(Programmer)](https://www.reddit.com/u/\"\"\"\n \"\"\"capybasilisk) \"\"\"\n \"\"\"^| ^(Downvote To Remove) \"\"\" \n \"\"\"^| ^(Version 1.4.0) \"\"\"\n \"\"\"^| ^(Support Robot Rights!)\"\"\")\n \n\n comment.reply(\n f\"\"\"Hi. You just mentioned *{card[0]}* by \"\"\" \n f\"\"\"{card[1]}.\\n\\nI've found an audiobook of \"\"\" \n \"\"\"that novel on YouTube. You can listen to it here\"\"\"\n f\"\"\":\\n\\n[YouTube | {self.details['title']}]\"\"\"\n f\"\"\"({self.details['webpage_url']})\\n\\n*I\\'m a bot that \"\"\" \n \"\"\"searches YouTube for science fiction and fantasy\"\"\" \n f\"\"\" audiobooks.*\\n***\\n{saw_the_sign}\"\"\")\n\n \n self.responded.append(\n comment.submission.id)\n \n with open(\n \"activity.csv\", \n \"a\", \n encoding = \"UTF-8\") as actlog:\n\n activity = clevercsv.writer(\n actlog)\n\n if actlog.tell() == 0:\n\n activity.writerow(\n [\"Book\",\n \"Comment\", \n \"Author\", \n \"Thread\", \n \"Subreddit\", \n \"Time\"])\n\n activity.writerow(\n [f\"{card[0]} by {card[1]}\",\n f\"{comment.body}\",\n f\"{comment.author}\",\n f\"{comment.submission.title}\",\n f\"{comment.subreddit}\",\n f\"{pendulum.now().to_datetime_string()}\"])\n \n self.details = None\n \n break\n \n break \n \n if pendulum.now().to_time_string().endswith(\n \"0:00\"):\n \n self.tidy()","def visualize_raw_dat_rating_cnt(self, dat):\n print('Number of Reviews')\n\n plt.hist(dat['User Rating Count'].dropna())\n plt.show()\n\n print('There is a long-tail to the data, so a subset will be shown as well')\n print('~80% of the data is pictured below')\n plt.hist(dat[dat['User Rating Count'] < 500].dropna(subset = ['User Rating Count'])['User Rating Count'])\n plt.show()","def task2(self, doc) -> dict:\n country_count = {}\n match_records = []\n for entry in self.records:\n if (entry['event_type'] =='read'):\n if entry['subject_doc_id'] == doc:\n match_records.append(entry)\n for rec in match_records:\n if (rec['visitor_country'] in country_count):\n country_count[rec['visitor_country']] += 1\n else:\n country_count[rec['visitor_country']] = 1\n print(country_count)\n return country_count","def get_replies_count(khoros_object, user_settings=None, user_id=None, login=None, email=None):\n user_settings = _process_settings_and_user_id(khoros_object, user_settings, user_id, login, email)\n select_fields = ('messages.count(*)', 'topics.count(*)')\n api_response = query_users_table_by_id(khoros_object, select_fields, user_settings['id'])\n items_list = api.get_items_list(api_response)\n return int(items_list['messages']['count']) - int(items_list['topics']['count'])","def count_pubmed_pubmed_citations(pmid):\n link = f\"https://www.ncbi.nlm.nih.gov/pubmed?linkname=pubmed_pubmed_citedin&from_uid={pmid}\"\n sleep(0.3)\n page = requests.get(link).text\n soup = BeautifulSoup(page, 'html.parser') \n count = int(soup.find_all(attrs={\"name\": \"ncbi_resultcount\"})[0][\"content\"])\n return(count)","def count(self, ngram, options):\n return len(self.find_docs(ngram, options))","def count_reads(titer):\n c = Counter()\n for template in titer:\n for mate in template:\n for cat in (mate['cat_list'] or ['nocat']):\n c[cat] += 1\n return c","def test_count_publications(self):\n pass","def test_status_reply_count(self):\n with self.app.app_context():\n u = user(save=True)\n s = status(user=u, project=None, save=True)\n for i in range(5):\n status(user=u, project=None, reply_to=s, save=True)\n\n eq_(s.reply_count, 5)","def do_get_comment_count(parser, token):\r\n error_message = \"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\" % (token.contents.split()[0], token.contents.split()[0])\r\n try:\r\n split = token.split_contents()\r\n except ValueError:\r\n raise template.TemplateSyntaxError, error_message\r\n if split[1] != 'for' or split[3] != 'as':\r\n raise template.TemplateSyntaxError, error_message\r\n return ThreadedCommentCountNode(split[2], split[4])","def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\n reviewers_mapping = {}\n\n # Reviewers are supposed to be those mentions who have given thumbs up.\n for comment in issue_comments:\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\n reviewers_mapping[comment.user.login] = dict(\n tagged_at=None,\n responded_at=None,\n gave_thumbs_up_at=comment.created_at\n )\n\n # We have reviewers, now, look for the time for their first response in issue comments.\n for comment in issue_comments:\n if comment.user.login in reviewers_mapping.keys() \\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n # TODO: Scrap the time when the PR's body was updated.\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\n # for the reviewers that are in PR's body.\n\n # Look for time when each of reviewer was tagged, this should be\n # searched in pull request body and issue comments.\n for login in reviewers_mapping.keys():\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\n if reviewers_mapping[login]['responded_at'] is None \\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\n reviewers_mapping[login]['tagged_at'] = comment.created_at\n\n # Check for reviewers' first response in review comments too, and\n # update the reviewers_mapping if necessary.\n for comment in review_comments:\n if comment.user.login in reviewers_mapping.keys():\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n return reviewers_mapping","def addCommentCount(self,count):\n self.commentCount += count\n return None","def document_count(self):\n raise NotImplementedError","def get_num_topics(soup):\n try:\n #num = int(re.search(\"Suche ergab (\\\\d+)\", str(soup)).group(1)) \n num = int(re.search(\"(\\\\d+) Treffer\", str(soup)).group(1)) \n except: \n num = 0\n print(traceback.format_exc()) \n\n return num","def basic_statistics_of_email(data):\n word_counts = []\n character_count = 0\n\n for ind, row in data.iterrows():\n tokenizer = RegexpTokenizer(r'\\w+')\n real_words = tokenizer.tokenize(row[\"RawText\"].lower())\n\n character_count += sum(map(len, real_words))\n word_counts.append(len(real_words))\n\n return character_count, pd.Series(word_counts)","def analyze_comments():\n\n scores = {} # {docket_id: [comment1_score, comment2_score, ...]}\n positive_counts = {} # {docket_id: num_positive_comments}\n neutral_counts = {} # {docket_id: num_neutral_comments}\n negative_counts = {} # {docket_id: num_negative_comments}\n\n comment_sentiments = {} # {comment_id: sentiment} to write to database\n comment_complexity = {} # {comment_id: complexity} to write to database\n\n for comment in lib.mongo.retrieve_comments(1000):\n docket_id = comment['docketId']\n comment_id = comment['documentId']\n text = comment.get('commentText', '').strip()\n\n # Fill in the 'sentiment' field of this comment.\n if 'sentiment' in comment:\n score = comment['sentiment']\n else:\n score = lib.analyze_text.getSentiment(text)\n comment_sentiments[comment_id] = score\n\n logging.info('docket %s, comment %s: sentiment %s (%r)' %\n (docket_id, comment_id, score, text[:20]))\n\n # Fill in the 'complexity' field of this comment.\n if 'complexity' not in comment:\n comment_complexity[comment_id] = lib.analyze_text.get_complexity(text)\n\n # Aggregate the sentiment scores for each docket.\n scores.setdefault(docket_id, []).append(score)\n counts = positive_counts if score > 0 else (\n negative_counts if score < 0 else neutral_counts)\n counts[docket_id] = counts.get(docket_id, 0) + 1\n\n if len(comment_sentiments) >= 10:\n logging.info('updating %d comments sentiment...' % len(comment_sentiments))\n lib.mongo.update_comments('sentiment', comment_sentiments)\n comment_sentiments = {}\n\n if len(comment_complexity) >= 10:\n logging.info('updating %d comments complexity...' % len(comment_complexity))\n lib.mongo.update_comments('complexity', comment_complexity)\n comment_complexity = {}\n\n logging.info('updating %d comments...' % len(comment_sentiments))\n lib.mongo.update_comments('sentiment', comment_sentiments)\n lib.mongo.update_comments('complexity', comment_complexity)\n logging.info('done!')\n\n docket_sentiments = {} # {docket_id: sentiment} to write to database\n\n for docket in lib.mongo.dockets.find():\n docket_id = docket.get('docketId', '')\n positive_count = positive_counts.get(docket_id, 0)\n neutral_count = neutral_counts.get(docket_id, 0)\n negative_count = negative_counts.get(docket_id, 0)\n rating = compute_rating(positive_count, neutral_count, negative_count)\n logging.info('docket %s: %d positive, %d neutral, %d negative - %s' %\n (docket_id, positive_count, neutral_count, negative_count,\n rating))\n\n docket_sentiments[docket_id] = {\n 'positive': positive_count,\n 'neutral': neutral_count,\n 'negative': negative_count,\n 'rating': rating\n }\n\n logging.info('updating %d dockets...' % len(docket_sentiments))\n lib.mongo.update_dockets('sentiment', docket_sentiments)\n logging.info('done!')","def dcount(ev):\n profData = getProfilingData(ev)\n if profData is not None:\n a = profData.Descendants().AsArray()\n if len(a) > 0:\n return profData.DescendantCount(a[0])\n return \"\"","def reply_count(self, url, mode=5, after=0):\n\n sql = \"\"\"\n SELECT\n c.parent, count(*)\n FROM comments AS c\n INNER JOIN threads AS t\n ON t.uri=%s AND c.tid = t.id AND\n (%s | c.mode = %s) AND\n c.created > %s\n GROUP BY c.parent\n \"\"\"\n\n return dict(self.db.fetchall(sql, [url, mode, mode, after]))","def countFullBrowser(self, data, docID):\n for entry in data.genData():\n if 'visitor_useragent' in entry and 'event_type' in entry:\n if entry['event_type'] == 'read':\n if str(entry['subject_doc_id']) == docID:\n if entry['visitor_useragent'] in self.browserCounts:\n self.browserCounts[entry['visitor_useragent']] += 1\n else:\n self.browserCounts[entry['visitor_useragent']] = 1","def get_subscriber_count(self, response):\n return response.css('.yt-subscriber-count')\\\n .extract_first(default='')","def utr5_motif_counts(self, pattern):\n return len(re.findall(pattern.upper(), self.five_prime_utr_sequence.upper()))","def test_issue_get_comment_reactions(self):\n pass","def github_num_positive_reactions(comment_object: Dict[str, Any]) -> int:\n num_positive_reactions = 0\n positive_emojis = {'+1', 'laugh', 'hooray', 'heart', 'rocket', 'eyes'}\n reactions = comment_object.get('reactions', {})\n for emoji in positive_emojis:\n num_positive_reactions += reactions.get(emoji, 0)\n return num_positive_reactions","def get_author_and_comment_count_per_sub(config: Config, sanitized_authors: dict):\n\n start = time.time()\n raw_result = get_raw_author_and_comment_count_per_sub(config, sanitized_authors)\n end = time.time()\n print(f\"get_raw_author_and_comment_count_per_sub took {end - start} seconds\")\n\n start = time.time()\n sanitized_result = sanitize_author_and_comment_count_per_sub(raw_result)\n end = time.time()\n print(f\"sanitize_author_and_comment_count_per_sub took {end - start} seconds\")\n\n return sanitized_result","def get_comments_num(self): \n num=len(self.comments_set.all())\n return num","def count_tags():\r\n trans = transaction.begin()\r\n StatBookmarkMgr.count_total_tags()\r\n trans.commit()","def totaled_tbr_no_lgtm(cc, sql_time_specification):\n cc.execute(\"\"\"SELECT git_commit.review_url, git_commit.timestamp,\n git_commit.subject, git_commit.hash\n FROM review\n INNER JOIN git_commit\n ON review.review_url = git_commit.review_url\n INNER JOIN commit_people\n ON commit_people.git_commit_hash = git_commit.hash\n LEFT JOIN (\n SELECT review_url, COUNT(*) AS c\n FROM review_people\n WHERE type = 'lgtm'\n GROUP BY review_url) lgtm_count\n ON review.review_url = lgtm_count.review_url\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\n AND commit_people.type = 'author' AND %s\"\"\" % sql_time_specification)\n result = cc.fetchall()\n count = len(result)\n formatted_data = []\n for data in result:\n subject = data[2]\n formatted_data.append([data[0], data[1].strftime(\"%Y-%m-%d %H:%M:%S\"),\n subject.replace('-', ' '), data[3]])\n results = sorted(formatted_data, key=lambda x: x[1], reverse=True)\n return count, results","def compute_reread_counts(self, question, context):\n\n # Checks that the question and context are not blank\n if question == '' or context == '':\n return {}\n\n # Collects the reread count for every student id of the provided context and question\n raw_reread_counts = []\n for row in self.responses:\n table_context = row.context.text\n table_question = row.question.text\n view_count = len(row.get_parsed_views())\n if context in table_context:\n if question in table_question:\n raw_reread_counts.append(view_count)\n\n # Tallies the raw reread counts into the dictionary to be returned\n organized_data = {}\n mean_reread_count = 0\n sum_of_views = 0\n student_count = 0\n final_student_count = 0\n\n for entry in raw_reread_counts:\n if entry in organized_data.keys():\n organized_data[entry] += 1\n elif len(raw_reread_counts) != 0:\n organized_data.update({entry: 1})\n keys_of_dictionary = organized_data.keys()\n for entry in keys_of_dictionary:\n sum_of_views += entry * organized_data[entry]\n student_count += organized_data[entry]\n\n if student_count == 0:\n return 0\n else:\n mean_reread_count = round((sum_of_views / student_count), 2)\n sum_of_views = 0\n final_student_count = student_count\n student_count = 0\n\n print(organized_data)\n return [question, context, mean_reread_count, final_student_count]"],"string":"[\n \"def calc_conv_comments(self):\\n for conv_comment in self.pull_request.get_issue_comments():\\n self._users.add(conv_comment.user.login)\\n lowercase_body = conv_comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_conv_comments += 1\\n for reaction in conv_comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.conv_comment_reactions += 1\\n if conv_comment.body is not None:\\n self.len_issue_comments += len(conv_comment.body)\",\n \"def count_comments(self):\\n return self.run_query(f\\\"count({self.r}/comment)\\\")\",\n \"def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\\n if project_name == PROJECT_ALL:\\n # comments in changes across all projects after from_datetime\\n comments = reviewer.comments.filter(\\n timestamp__gte=from_datetime).distinct()\\n else:\\n # comments in changes in given project after from_datetime\\n comments = reviewer.comments.filter(\\n change__project_name=project_name,\\n timestamp__gte=from_datetime).distinct()\\n\\n return comments.count()\",\n \"def getReviewNumbers(singleStoryFooter):\\n\\twords = singleStoryFooter.get_text()\\n\\treview = re.compile(r\\\"Reviews: \\\\d+\\\").search(words)\\n\\tif review:\\n\\t\\treviewNum = review.group()[9:]\\n\\t\\treturn int(reviewNum)\\n\\telse: return 0\",\n \"def parseCommentsTotalCount(data):\\n p = re.compile(r\\\"\\\\d+ Reviews\\\")\\n\\n for line in data:\\n line = line.replace(\\\",\\\", \\\"\\\")\\n match = re.search(p, line)\\n if match != None:\\n getNmbr = match.group().split(\\\" \\\")\\n return int(getNmbr[0])\\n return -1\",\n \"def getCommentCount(self, source):\\n commentStart = source.find('item?id=')\\n commentCountStart = source.find('>', commentStart) + 1\\n commentEnd = source.find('</a>', commentStart)\\n commentCountString = source[commentCountStart:commentEnd]\\n if commentCountString == \\\"discuss\\\":\\n return 0\\n elif commentCountString == \\\"\\\":\\n return 0\\n else:\\n commentCountString = commentCountString.split(' ')[0]\\n return int(commentCountString)\",\n \"def count_reddit_comments_ngram_strs(year, month, n):\\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\\n return Counter(itertools.chain.from_iterable(ngram_strs))\",\n \"def number_of_subscribers(subreddit):\\n h = {'user-agent': 'GEEK1050'}\\n link = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n req = requests.get(link, headers=h)\\n\\n req_data = req.json().get(\\\"data\\\").get(\\\"subscribers\\\")\\n for element in req_data['children']:\\n print(element['children']['title'])\",\n \"def getNumberOfReviews(self):\\n try:\\n count = 0\\n with open(self.metadata_path, \\\"r\\\", newline='') as metadata:\\n mdata = csv.reader(metadata, delimiter=' ', quotechar='|')\\n for review_data in mdata:\\n count += 1\\n return count\\n except Exception:\\n print(\\\"Cant load metadata file\\\")\\n traceback.print_exc()\",\n \"def github_num_reactions(comment_object: Dict[str, Any]) -> int:\\n return comment_object.get('reactions', {}).get('total_count', 0)\",\n \"def get_comments_count(self, thread_uid: str) -> int:\\n pass\",\n \"def count_regexp():\\r\\n # Here's an example regular expression that roughly matches a valid email address.\\r\\n # The ones you write below should be shorter than this\\r\\n email = re.compile(\\\"[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+\\\\.[a-zA-Z]{2,5}\\\")\\r\\n\\r\\n ###### Write below #########\\r\\n subheading = re.compile(\\\"\\\\=\\\\=+.*\\\\=\\\\=+\\\")\\r\\n link_to_subheading = re.compile(\\\"\\\\[\\\\[[\\\\w\\\\'*\\\\-*\\\\:*\\\\(*\\\\)*\\\\_*\\\\s*]+[#][\\\\s*\\\\w\\\\\\\\'*\\\\-*\\\\:*\\\\(*\\\\)*\\\\_*s*]+\\\\|*\\\")\\r\\n doi_citation = re.compile(\\\"\\\\{\\\\{[c][ite](?!{{).*[dD][oO][iI]\\\\s*[:|,=\\\\/]*\\\\s*[0-9]+\\\\.[0-9]+.*\\\\}\\\\}\\\")\\r\\n ###### End of your work #########\\r\\n\\r\\n patterns = {\\r\\n \\\"emails\\\": email,\\r\\n \\\"subheadings\\\": subheading,\\r\\n \\\"links to subheadings\\\": link_to_subheading,\\r\\n \\\"citations with DOI numbers\\\": doi_citation,\\r\\n }\\r\\n\\r\\n with open(RAW_DUMP_XML, encoding=\\\"utf-8\\\") as f:\\r\\n dump_text = f.read()\\r\\n for name, pattern in patterns.items():\\r\\n if pattern is None:\\r\\n continue\\r\\n matches = pattern.findall(dump_text)\\r\\n count = len(matches)\\r\\n\\r\\n example_matches = [matches[i * (count // 5)] for i in range(5)]\\r\\n\\r\\n print(\\\"Found {} occurences of {}\\\".format(count, name))\\r\\n print(\\\"Here are examples:\\\")\\r\\n print(\\\"\\\\n\\\".join(example_matches))\\r\\n print(\\\"\\\\n\\\")\",\n \"def number_of_subscribers(subreddit):\\n header = {\\\"User-agent\\\": \\\"darth\\\"}\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n response = (requests.get(url, headers=header))\\n if response.status_code != 200:\\n return 0\\n return response.json().get('data').get('subscribers')\",\n \"def number_of_subscribers(subreddit):\\n link = 'http://www.reddit.com/r/{}/about.json'.format(subreddit)\\n red = requests.get(link, headers={'User-Agent': 'tope628'}).json()\\n try:\\n subs = red.get('data').get('subscribers')\\n except:\\n return 0\\n if red is None:\\n return 0\\n return subs\",\n \"def _get_token_cnts(self, doc, doc_type):\\n tokenized_doc = self.nlp(doc)\\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\\n doc_len = len([t for t in tokenized_doc])\\n self.stat_dict[doc_type][1].append(doc_len)\\n if doc_len < 50 and doc_type == \\\"answer\\\":\\n print(\\\"Document less than 50 tokens:\\\", url)\",\n \"def count_other_citations(pmid,linkname):\\n link = f\\\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\\\"\\n sleep(0.3)\\n page = requests.get(link).text\\n soup = BeautifulSoup(page, 'html.parser') \\n count = int(soup.find_all(attrs={\\\"name\\\": \\\"ncbi_resultcount\\\"})[0][\\\"content\\\"])\\n return(count)\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\"\\n headers = {\\n 'User-Agent': 'My User Agent 1.0',\\n 'From': 'youremail@domain.com'\\n }\\n r_subs = requests.get(url.format(subreddit), headers=headers)\\n if r_subs.status_code == 200:\\n data = r_subs.json()['data']\\n subscribers = data.get('subscribers')\\n if subscribers is not None:\\n return subscribers\\n return 0\",\n \"def count():\",\n \"def sent_count(comment):\\n return comment.__len__()\",\n \"async def scrape_comments(self):\\n\\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\\n\\n comment_count = 0\\n async for comment in subreddit_origin.comments(limit=self.limit):\\n if self.memory.contains(comment.id):\\n continue\\n\\n self.memory.add(comment.id)\\n\\n # Parse Comment\\n comment = self.parse_comment(comment)\\n\\n # Save in Pub/Sub\\n if self.enable_publish:\\n self.publish(comment)\\n\\n comment_count += 1\\n\\n return comment_count\",\n \"def stat_reviews(self, year):\\n stats = dict()\\n reviews = list(self.get_reviews(year))\\n stats['reviews'] = len(reviews)\\n stats['open'] = len(\\n [review['issue'] for review in reviews if not review['closed']]\\n )\\n (messages, comments, patchsets) = (dict(), dict(), dict())\\n for review in reviews:\\n id = review['issue']\\n messages[id] = len(review['messages'])\\n patchsets[id] = len(review['patchsets'])\\n comments[id] = 0\\n for patchset in review['patchsets'].values():\\n comments[id] += patchset['num_comments']\\n stats['messages'] = helpers.sort(messages, desc=True)\\n stats['comments'] = helpers.sort(comments, desc=True)\\n stats['patchsets'] = helpers.sort(patchsets, desc=True)\\n return stats\",\n \"def number_of_subscribers(subreddit):\\n response = requests.get('https://www.reddit.com/r/{}/about.json'\\n .format(subreddit),\\n headers={'User-Agent': 'Camilo@holberton'},\\n allow_redirects=False)\\n if response.status_code == 200:\\n response = response.json()\\n data = response.get('data')\\n subs_count = data.get('subscribers')\\n if data and subs_count:\\n return subs_count\\n return 0\",\n \"def get_count(username):\\n return get_contributor(username)[\\\"count\\\"]\",\n \"def number_of_subscribers(subreddit):\\n import requests\\n headers = {'User-Agent': 'Godfather'}\\n about = requests.get(\\n 'https://www.reddit.com/r/{}/about.json'.format(\\n subreddit), headers=headers).json()\\n try:\\n subscribers = about.get('data').get('subscribers')\\n if subscribers is None:\\n raise TypeError\\n return subscribers\\n except:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}.json\\\".format(subreddit)\\n r = requests.get(url, headers={'User-agent': 'shoji'},\\n allow_redirects=False)\\n data = r.json()\\n if not r.status_code == 200:\\n return 0\\n try:\\n sub = data.get(\\\"data\\\")\\n children = sub.get(\\\"children\\\")\\n subreddit = children[0].get(\\\"data\\\")\\n subscriber_count = subreddit.get(\\\"subreddit_subscribers\\\")\\n except Exception as e:\\n print(\\\"Something went wrong\\\\n {}\\\".format(e))\\n return 0\\n\\n return subscriber_count\",\n \"def number_of_subscribers(subreddit):\\n url = requests.get(\\\"https://www.reddit.com/r/{}/about.json\\\"\\n .format(subreddit), headers={\\\"User-Agent\\\": \\\"kalkidan\\\"})\\n if url.status_code == 200:\\n return url.json().get(\\\"data\\\").get(\\\"subscribers\\\")\\n else:\\n return 0\",\n \"def get_comment_count(self, postid=0, blogid=1):\\n \\n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)\",\n \"def findNoteCounts(self, authenticationToken, filter, withTrash):\\r\\n pass\",\n \"def wcount(lines, topn=10):\\n my_socket = urllib.request.urlopen(lines)\\n dta = my_socket.read().decode()\\n my_socket.close()\\n #get the text from url\\n \\n s=dta.replace(',',' ')\\n b=s.replace('.',' ')\\n c=b.replace('?',' ')\\n d=c.replace('_',' ')\\n e=d.replace(']',' ')\\n f=e.replace('[',' ')\\n g=f.replace('*',' ')\\n h=g.replace('%',' ')\\n i=h.replace('!',' ')\\n j=i.replace('\\\"',' ')\\n k=j.replace(':',' ')\\n l=k.replace(';',' ')\\n m=l.replace('(',' ')\\n n=m.replace(')',' ')\\n o=n.replace('-',' ')\\n p=o.replace('_',' ')\\n q=p.replace('/','')\\n q=q.lower()\\n x=q.split()\\n y=set(x)\\n #Processed documents are converted into ordered strings\\n \\n lst={}\\n for i in y:\\n num=x.count(i)\\n lst[i]=num\\n \\n r=list(lst.values())\\n r.sort(reverse=True)\\n for i in r[:topn]:\\n print(list(lst.keys())[list(lst.values()).index(i)].ljust(15)+\\\" \\\"+str(i))\\n \\n pass\",\n \"def cmd_account_comment_count(client, args):\\n account_comment_count = client.get_account_comment_count(args.username)\\n generate_output({'account_comment_count': account_comment_count})\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://api.reddit.com/r/{}/about\\\".format(subreddit)\\n header = {'User-Agent': 'CustomClient/1.0'}\\n request = requests.get(url, headers=header, allow_redirects=False)\\n\\n if request.status_code != 200:\\n return 0\\n jreq = request.json()\\n\\n if 'data' in jreq:\\n return jreq.get(\\\"data\\\").get(\\\"subscribers\\\")\\n else:\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n if subreddit is None or type(subreddit) is not str:\\n return 0\\n BASE_URL = 'http://www.reddit.com/r/{}/about.json'\\n head = {'User-Agent': 'Mozilla/5.0'}\\n r = requests.get(BASE_URL.format(subreddit), headers=head)\\n return r.json().get('data', {}).get('subscribers', 0)\",\n \"def number_of_subscribers(subreddit):\\n header = {'User-Agent': 'Chrome/90.0.4430.212 Safari/537.36'}\\n req = requests.get('https://www.reddit.com/r/{}/about.json'\\n .format(subreddit), allow_redirects=False,\\n headers=header)\\n if req.status_code == 200:\\n subscribers = req.json().get('data').get('subscribers')\\n return subscribers\\n else:\\n return 0\",\n \"def sorter(r):\\n\\n ans = len(r.description)\\n if additional:\\n for rr in r.monkey_additional:\\n ans += len(rr)\\n return ans\",\n \"def count_comment_karma(user):\\r\\n\\r\\n karma = 0\\r\\n comments = Comment.objects.filter(name=user).all()\\r\\n for comment in comments:\\r\\n karma += comment.likes.count()\\r\\n\\r\\n return karma\",\n \"def get_product_total_reviews(self, driver):\\n try:\\n frame = driver.find_element_by_id(\\\"BVRRRatingSummaryLinkReadID\\\")\\n total_reviews = frame.find_element_by_class_name(\\\"BVRRNumber\\\").text\\n return total_reviews\\n except NoSuchElementException:\\n return 0\",\n \"def analyze_reviews(reviews):\\n\\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\\n\\n print 'len(good_reviews)=%s' % len(good_reviews)\\n print 'len(bad_reviews)=%s' % len(bad_reviews)\\n\\n m = re.compile('\\\\d')\\n\\n english_stop_words=stopwords.words('english')\\n\\n\\n def tokenize(text):\\n tokens=nltk.word_tokenize(text)\\n # strip out trailing puncutation\\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\\n\\n # lower case\\n tokens = [token.lower() for token in tokens]\\n\\n # Take only relativly long characters\\n tokens = [token for token in tokens if len(token)>=3]\\n\\n # remove words with numbers/digits\\n tokens = [token for token in tokens if m.search(token) is None]\\n\\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\\n tokens = [token for token in tokens if token not in english_stop_words]\\n return tokens\\n\\n good_tokens_list = []\\n for i,review in good_reviews.iterrows():\\n text=review['rs_review_text']\\n good_tokens_list.append(tokenize(text))\\n\\n bad_tokens_list = []\\n for i,review in bad_reviews.iterrows():\\n text=review['rs_review_text']\\n bad_tokens_list.append(tokenize(text))\\n\\n all_words=Counter()\\n for tokens in good_tokens_list + bad_tokens_list:\\n for token in tokens:\\n all_words[token]+=1\\n\\n most_common=all_words.most_common(2000)\\n most_common=zip(*most_common)[0]\\n\\n print 'most_common_words = ',most_common[-20:]\\n\\n def document_features(tokens):\\n return {word:word in tokens for word in most_common}\\n\\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\\n\\n train_set = good_set + bad_set\\n random.shuffle(train_set) # dunno if this is necessary\\n\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n\\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\\n\\n classifier.show_most_informative_features(300)\\n\\n return classifier\",\n \"def cmd_gallery_comment_count(client, args):\\n gallery_comment_count = client.gallery_comment_count(args.item_id)\\n generate_output({'gallery_comment_count': gallery_comment_count})\",\n \"def number_of_subscribers(subreddit):\\n URL = 'https://api.reddit.com/r/{}/about'.format(subreddit)\\n header = {'User-Agent': 'Custom-User'}\\n\\n resp = requests.get(URL, headers=header).json()\\n try:\\n return resp['data']['subscribers']\\n except Exception:\\n return 0\",\n \"def count_revisions_by_user(self):\\n return self.run_query(f\\\"count({self.r}/contributor[id = 5558])\\\")\",\n \"def number_of_subscribers(subreddit):\\n\\n import requests\\n\\n resInf = requests.get(\\\"https://www.reddit.com/r/{}/about.json\\\"\\n .format(subreddit),\\n headers={\\\"User-Agent\\\": \\\"My-User-Agent\\\"},\\n allow_redirects=False)\\n if resInf.status_code >= 300:\\n return 0\\n\\n return resInf.json().get(\\\"data\\\").get(\\\"subscribers\\\")\",\n \"def do_get_user_comment_count(parser, token):\\r\\n error_message = \\\"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\\\" % (token.contents.split()[0], token.contents.split()[0])\\r\\n try:\\r\\n split = token.split_contents()\\r\\n except ValueError:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n if len(split) != 5:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n return UserCommentCountNode(split[2], split[4])\",\n \"def get_matches_count():\\n\\n return ''\\n \\\"\\\"\\\"\\n TODO: count matches\\n dtr5app_flag.sender\\n dtr5app_flag.receiver\\n dtr5app_flag.flag\\n \\\"\\\"\\\"\",\n \"def getCounter(self):\\n word_count, noun_word_count = Counter(), Counter()\\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\\n docs = self.nlp.pipe(\\n self.docs, n_process=1, disable=self.disablelayers)\\n \\n\\n for index, doc in enumerate(docs):\\n for token in doc:\\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\\n if token.pos_ == 'PROPN':\\n word_count[token.lemma_] += 1\\n word_rating[token.lemma_].append(self.ratings[index])\\n else:\\n noun_word_count[token.lemma_] += 1\\n noun_word_rating[token.lemma_].append(self.ratings[index])\\n\\n # if 0<=proper nouns<=5 found, add regular nouns\\n if not word_count or len(word_count) <= 5:\\n word_count += noun_word_count\\n word_rating = {**word_rating, **noun_word_rating}\\n \\n word_color = {word: self.getColor(\\n ratings)[1] for word, ratings in word_rating.items()}\\n word_sentiment = {word: self.getColor(\\n ratings)[0] for word, ratings in word_rating.items()}\\n\\n return word_count, word_color, word_sentiment\",\n \"def number_of_subscribers(subreddit):\\n\\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\\n\\n headers = {'User-Agent': 'My User Agent 1.0'}\\n\\n request = requests.get(url, headers=headers)\\n req = request.json()\\n\\n if request.status_code == 404:\\n return 0\\n\\n subs = req.get('data').get('subscribers')\\n return subs\",\n \"def number_of_subscribers(subreddit):\\n url = 'https://www.reddit.com/r/{}/about.json'\\n headers = {'user-agent': 'X-Modhash'}\\n url_format = requests.get(url.format(subreddit), headers=headers).json()\\n try:\\n name = url_format['data']['subscribers']\\n return name\\n except:\\n return 0\",\n \"def counts(self, regex = \\\"\\\\w+\\\"): \\n tokenizer = RegexpTokenizer(r'{}'.format(regex))\\n count = []\\n for i in tqdm(self.text):\\n count.append(len(tokenizer.tokenize(i)))\\n return count\",\n \"def comments_count(self) -> int:\\n return pulumi.get(self, \\\"comments_count\\\")\",\n \"def number_of_subscribers(subreddit):\\n\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n headers = {\\\"User-Agent\\\": \\\"my-integration/1.2.3\\\"}\\n\\n response = get(url=url, headers=headers)\\n\\n if response.status_code == 200:\\n # print(response.json())\\n\\n response_json = response.json()\\n data = response_json.get('data')\\n subscribers = data.get(\\\"subscribers\\\")\\n\\n return subscribers\\n\\n return 0\",\n \"def number_of_subscribers(subreddit):\\n r = requests.get('https://api.reddit.com/r/{}/about.json'\\n .format(subreddit),\\n headers={'user-agent': 'ianscustomthing'},\\n allow_redirects=False)\\n rj = r.json()\\n if rj.get('message') == 'Not Found':\\n return 0\\n s = rj.get('data').get('subscribers')\\n return s\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = {} # might want to use defaultdict or Counter instead\\n self.bigramcounts = {} \\n self.trigramcounts = {} \\n\\n self.total = 2\\n ##Your code here\\n\\n for sentence in corpus:\\n temp_1 = get_ngrams(sentence,1)\\n temp_2 = get_ngrams(sentence,2)\\n temp_3 = get_ngrams(sentence,3)\\n for i in range(len(temp_1)):\\n if temp_1[i] in self.unigramcounts:\\n self.unigramcounts[temp_1[i]] += 1\\n else:\\n self.unigramcounts[temp_1[i]] = 1\\n self.total += 1\\n\\n for i in range(len(temp_2)):\\n if temp_2[i] in self.bigramcounts:\\n self.bigramcounts[temp_2[i]] += 1\\n else:\\n self.bigramcounts[temp_2[i]] = 1\\n\\n for i in range(len(temp_3)):\\n if temp_3[i] in self.trigramcounts:\\n self.trigramcounts[temp_3[i]] += 1\\n else:\\n self.trigramcounts[temp_3[i]] = 1\\n return\",\n \"def getTokenSizeOfReviews(self):\\n res = 0\\n with open(self.word_to_docs_path, 'rb') as bin:\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n res += frequency\\n # skip documents:\\n int.from_bytes(bin.read(4 * frequency), 'big')\\n return res\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def review_count(self):\\n\\t\\tcount = self.reviews.aggregate(\\n\\t\\t\\tcount=models.Count('rating'))['count']\\n\\t\\tif count is None:\\n\\t\\t\\tcount = 0\\n\\t\\treturn count\",\n \"def number_of_subscribers(subreddit):\\n url_rsubs = \\\"https://api.reddit.com/r/{}/about\\\".format(subreddit)\\n headers = {'User-Agent': 'Python3'}\\n response = requests.get(url_rsubs, headers=headers,\\n allow_redirects=False)\\n if str(response) != \\\"<Response [200]>\\\":\\n return 0\\n r_json = response.json()\\n subs_count = r_json.get('data').get('subscribers')\\n return subs_count\",\n \"def get_about_count_results(soup):\\n title = soup.find('div', {'id': 'gs_ab_md'})\\n if title:\\n title = title.find('div', {'class': 'gs_ab_mdw'})\\n if title:\\n count_papers = title.text\\n if count_papers:\\n count_papers = count_papers.split(' ')[1].replace(',', '')\\n else:\\n count_papers = len(soup.find_all('h3', class_=\\\"gs_rt\\\"))\\n try:\\n int(count_papers)\\n except:\\n count_papers = title.text.split(' ')[0].replace(',', '')\\n else:\\n count_papers = len(soup.find_all('h3', class_=\\\"gs_rt\\\"))\\n return int(count_papers)\",\n \"def number_of_subscribers(subreddit):\\n\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n headers = {'user-agent': 'request'}\\n response = requests.get(url, headers=headers, allow_redirects=False)\\n if str(response) != '<Response [200]>':\\n return 0\\n response_json = response.json()\\n subs = response_json.get('data').get('subscribers')\\n return subs\",\n \"def get_indicators_and_clean_comments(df):\\n # Count number of \\\\n\\n df[\\\"ant_slash_n\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\n\\\", x))\\n # Get length in words and characters\\n df[\\\"raw_word_len\\\"] = df[\\\"comment_text\\\"].apply(lambda x: len(x.split()))\\n df[\\\"raw_char_len\\\"] = df[\\\"comment_text\\\"].apply(lambda x: len(x))\\n # Check number of upper case, if you're angry you may write in upper case\\n df[\\\"nb_upper\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[A-Z]\\\", x))\\n # Number of F words - f..k contains folk, fork,\\n df[\\\"nb_fk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[Ff]\\\\S{2}[Kk]\\\", x))\\n # Number of S word\\n df[\\\"nb_sk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[Ss]\\\\S{2}[Kk]\\\", x))\\n # Number of D words\\n df[\\\"nb_dk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[dD]ick\\\", x))\\n # Number of occurence of You, insulting someone usually needs someone called : you\\n df[\\\"nb_you\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\W[Yy]ou\\\\W\\\", x))\\n # Just to check you really refered to my mother ;-)\\n df[\\\"nb_mother\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\Wmother\\\\W\\\", x))\\n # Just checking for toxic 19th century vocabulary\\n df[\\\"nb_ng\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\Wnigger\\\\W\\\", x))\\n # Some Sentences start with a <:> so it may help\\n df[\\\"start_with_columns\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"^\\\\:+\\\", x))\\n # Check for time stamp\\n df[\\\"has_timestamp\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\d{2}|:\\\\d{2}\\\", x))\\n # Check for dates 18:44, 8 December 2010\\n df[\\\"has_date_long\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\D\\\\d{2}:\\\\d{2}, \\\\d{1,2} \\\\w+ \\\\d{4}\\\", x))\\n # Check for date short 8 December 2010\\n df[\\\"has_date_short\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\D\\\\d{1,2} \\\\w+ \\\\d{4}\\\", x))\\n # Check for http links\\n df[\\\"has_http\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"http[s]{0,1}://\\\\S+\\\", x))\\n # check for mail\\n df[\\\"has_mail\\\"] = df[\\\"comment_text\\\"].apply(\\n lambda x: count_regexp_occ(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\\\.[a-zA-Z0-9-.]+', x)\\n )\\n # Looking for words surrounded by == word == or \\\"\\\"\\\"\\\" word \\\"\\\"\\\"\\\"\\n df[\\\"has_emphasize_equal\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\={2}.+\\\\={2}\\\", x))\\n df[\\\"has_emphasize_quotes\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\\\\"{4}\\\\S+\\\\\\\"{4}\\\", x))\\n\\n # Now clean comments\\n df[\\\"clean_comment\\\"] = df[\\\"comment_text\\\"].apply(lambda x: prepare_for_char_n_gram(x))\\n\\n # Get the new length in words and characters\\n df[\\\"clean_word_len\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(x.split()))\\n df[\\\"clean_char_len\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(x))\\n # Number of different characters used in a comment\\n # Using the f word only will reduce the number of letters required in the comment\\n df[\\\"clean_chars\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(set(x)))\\n df[\\\"clean_chars_ratio\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(set(x))) / df[\\\"clean_comment\\\"].apply(\\n lambda x: 1 + min(99, len(x)))\",\n \"def number_of_subscribers(subreddit):\\n url = \\\"https://www.reddit.com/r/{}/about.json\\\".format(subreddit)\\n header = {\\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"User-Agent\\\": \\\"Mozilla/5.0\\\"}\\n request = requests.get(\\n url,\\n headers=header,\\n allow_redirects=False)\\n if request.status_code >= 300:\\n return 0\\n return json.loads(request.content.decode(\\\"utf-8\\\"))[\\\"data\\\"][\\\"subscribers\\\"]\",\n \"def review_counts(stat_info_dict):\\n review_counts = {}\\n for release, stat_dict in stat_info_dict.items():\\n review_counts_per_release = {}\\n for key, stat in stat_dict.items():\\n # review count\\n review_counts_per_release[key] = stat['metric']\\n review_counts[release] = review_counts_per_release\\n return review_counts\",\n \"def number_of_reviews(user: User, only_today: bool) -> int:\\n since = arrow.utcnow() if only_today else arrow.get(0)\\n since_timestamp = since.format('YYYY-MM-DD')\\n\\n num_edits = DBDiscussionSession.query(ReviewEdit).filter(\\n ReviewEdit.detector_uid == user.uid,\\n ReviewEdit.timestamp >= since_timestamp).count()\\n num_deletes = DBDiscussionSession.query(ReviewDelete).filter(\\n ReviewDelete.detector_uid == user.uid,\\n ReviewDelete.timestamp >= since_timestamp).count()\\n num_optimizations = DBDiscussionSession.query(ReviewOptimization).filter(\\n ReviewOptimization.detector_uid == user.uid,\\n ReviewOptimization.timestamp >= since_timestamp).count()\\n num_duplicates = DBDiscussionSession.query(ReviewDuplicate).filter(\\n ReviewDuplicate.detector_uid == user.uid,\\n ReviewOptimization.timestamp >= since_timestamp).count()\\n\\n return num_edits + num_deletes + num_optimizations + num_duplicates\",\n \"def number_of_subscribers(subreddit):\\n url = 'https://www.reddit.com/r/{}/about.json'.format(subreddit)\\n response = requests.get(url,\\n allow_redirects=False,\\n headers={'User-Agent': 'MyChromeBook'})\\n if response:\\n suscribers_number = response.json().get('data').get('subscribers')\\n return suscribers_number\\n else:\\n return 0\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def correct_counts():\\n articles = mongo.db[app.config['ARTICLES_COLLECTION']]\\n monitors = mongo.db[app.config['MONITORS_COLLECTION']]\\n unique = articles.distinct('feed_source', dict())\\n for link in unique:\\n count = articles.count({'feed_source': link})\\n monitors.update({'metadata.rss_link': link}, {'$set': {'hits': count}})\",\n \"def comment_count(self):\\n return self.comments.filter_by(state=0).count()\",\n \"def generate_reddit_comments_ngram_counts(\\n year, month, n, root=paths.DEFAULT_REDDIT_NGRAMS_DATA):\\n ngram_path = paths.get_reddit_ngrams_local(year, month, n, root=root)\\n if os.path.isfile(ngram_path):\\n logging.warning(\\\"Cache exists for all requested n-grams.\\\"\\n \\\"Skipping %04d-%02d\\\\n\\\" % (year, month))\\n return False\\n\\n counts = count_reddit_comments_ngram_strs(year, month, n)\\n with gzip.GzipFile(ngram_path, 'wb') as fh:\\n for k, v in counts.items():\\n fh.write(\\\"{}\\\\t{}\\\\n\\\".format(k, v).encode())\\n return True\",\n \"def fetch_counts(datestruct):\\n response = call_responder('elasticsearch', 'query/daily_proofreader_hits')\\n for rec in response['result']['hits']['hits']:\\n data = rec['_source']\\n if data['user'] not in datestruct:\\n datestruct[data['user']] = {\\\"cleave\\\": 0, \\\"merge\\\": 0,\\n \\\"split-supervoxel\\\": 0}\\n if '/cleave/' in data['uri']:\\n datestruct[data['user']]['cleave'] += 1\\n elif '/merge' in data['uri']:\\n datestruct[data['user']]['merge'] += 1\\n elif '/split-supervoxel' in data['uri']:\\n datestruct[data['user']]['split-supervoxel'] += 1\",\n \"def num_reviews(self):\\n return self.review_set.count()\",\n \"def run_compute_reread_counts(self):\\n questions = []\\n contexts = []\\n student_data = self.responses[:]\\n for response in student_data:\\n if response.question.text not in questions:\\n questions.append(response.question.text)\\n if response.context.text not in contexts:\\n contexts.append(response.context.text)\\n\\n compute_reread_counts_data = []\\n\\n for question in questions:\\n for context in contexts:\\n compute_reread_counts_data.append(self.compute_reread_counts(\\n question, context))\\n\\n return compute_reread_counts_data\",\n \"def count_comments(self):\\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\\n count = comments.count()\\n return count\",\n \"def count_relation_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\\n for relation in relation_types:\\n if relation in count:\\n count[relation] += 1\\n else:\\n count[relation] = 1\\n return count\",\n \"def core(self):\\n \\n \\n comments = self.bot.subreddit(\\n \\\"all\\\").stream.comments(\\n skip_existing = True)\\n \\n \\n for comment in comments:\\n \\n text = comment.body.lower().replace(\\\".\\\", \\\"\\\")\\n \\n for card in self.catalog:\\n \\n if (\\n card[1].lower() in text\\n and card[0].lower() in text\\n and not comment.submission.id in self.responded\\n and not comment.subreddit.user_is_banned):\\n\\n self.get_info(card)\\n\\n if not self.details:\\n \\n break\\n\\n audio = [\\n \\\"audiobook\\\", \\n \\\"audio book\\\"]\\n \\n author_format = [\\n name.lower() for name in card[1].split(\\\" \\\") \\n if len(name) >= 3]\\n\\n if (\\n self.details[\\\"duration\\\"] > 10800\\n and card[0].lower() in self.details[\\n \\\"title\\\"].lower()\\n and any(\\n item in self.details[\\n \\\"title\\\"].lower() for item in audio)\\n and all(\\n item in self.details[\\n \\\"title\\\"].lower() for item in author_format)):\\n \\n \\n saw_the_sign = (\\n \\\"\\\"\\\"[^(Source Code)](https://capybasilisk.com/posts/\\\"\\\"\\\"\\n \\\"\\\"\\\"2020/04/speculative-fiction-bot/) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| [^(Feedback)](https://www.reddit.com/message/\\\"\\\"\\\"\\n \\\"\\\"\\\"compose?to=Capybasilisk&subject=Robot) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| [^(Programmer)](https://www.reddit.com/u/\\\"\\\"\\\"\\n \\\"\\\"\\\"capybasilisk) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| ^(Downvote To Remove) \\\"\\\"\\\" \\n \\\"\\\"\\\"^| ^(Version 1.4.0) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| ^(Support Robot Rights!)\\\"\\\"\\\")\\n \\n\\n comment.reply(\\n f\\\"\\\"\\\"Hi. You just mentioned *{card[0]}* by \\\"\\\"\\\" \\n f\\\"\\\"\\\"{card[1]}.\\\\n\\\\nI've found an audiobook of \\\"\\\"\\\" \\n \\\"\\\"\\\"that novel on YouTube. You can listen to it here\\\"\\\"\\\"\\n f\\\"\\\"\\\":\\\\n\\\\n[YouTube | {self.details['title']}]\\\"\\\"\\\"\\n f\\\"\\\"\\\"({self.details['webpage_url']})\\\\n\\\\n*I\\\\'m a bot that \\\"\\\"\\\" \\n \\\"\\\"\\\"searches YouTube for science fiction and fantasy\\\"\\\"\\\" \\n f\\\"\\\"\\\" audiobooks.*\\\\n***\\\\n{saw_the_sign}\\\"\\\"\\\")\\n\\n \\n self.responded.append(\\n comment.submission.id)\\n \\n with open(\\n \\\"activity.csv\\\", \\n \\\"a\\\", \\n encoding = \\\"UTF-8\\\") as actlog:\\n\\n activity = clevercsv.writer(\\n actlog)\\n\\n if actlog.tell() == 0:\\n\\n activity.writerow(\\n [\\\"Book\\\",\\n \\\"Comment\\\", \\n \\\"Author\\\", \\n \\\"Thread\\\", \\n \\\"Subreddit\\\", \\n \\\"Time\\\"])\\n\\n activity.writerow(\\n [f\\\"{card[0]} by {card[1]}\\\",\\n f\\\"{comment.body}\\\",\\n f\\\"{comment.author}\\\",\\n f\\\"{comment.submission.title}\\\",\\n f\\\"{comment.subreddit}\\\",\\n f\\\"{pendulum.now().to_datetime_string()}\\\"])\\n \\n self.details = None\\n \\n break\\n \\n break \\n \\n if pendulum.now().to_time_string().endswith(\\n \\\"0:00\\\"):\\n \\n self.tidy()\",\n \"def visualize_raw_dat_rating_cnt(self, dat):\\n print('Number of Reviews')\\n\\n plt.hist(dat['User Rating Count'].dropna())\\n plt.show()\\n\\n print('There is a long-tail to the data, so a subset will be shown as well')\\n print('~80% of the data is pictured below')\\n plt.hist(dat[dat['User Rating Count'] < 500].dropna(subset = ['User Rating Count'])['User Rating Count'])\\n plt.show()\",\n \"def task2(self, doc) -> dict:\\n country_count = {}\\n match_records = []\\n for entry in self.records:\\n if (entry['event_type'] =='read'):\\n if entry['subject_doc_id'] == doc:\\n match_records.append(entry)\\n for rec in match_records:\\n if (rec['visitor_country'] in country_count):\\n country_count[rec['visitor_country']] += 1\\n else:\\n country_count[rec['visitor_country']] = 1\\n print(country_count)\\n return country_count\",\n \"def get_replies_count(khoros_object, user_settings=None, user_id=None, login=None, email=None):\\n user_settings = _process_settings_and_user_id(khoros_object, user_settings, user_id, login, email)\\n select_fields = ('messages.count(*)', 'topics.count(*)')\\n api_response = query_users_table_by_id(khoros_object, select_fields, user_settings['id'])\\n items_list = api.get_items_list(api_response)\\n return int(items_list['messages']['count']) - int(items_list['topics']['count'])\",\n \"def count_pubmed_pubmed_citations(pmid):\\n link = f\\\"https://www.ncbi.nlm.nih.gov/pubmed?linkname=pubmed_pubmed_citedin&from_uid={pmid}\\\"\\n sleep(0.3)\\n page = requests.get(link).text\\n soup = BeautifulSoup(page, 'html.parser') \\n count = int(soup.find_all(attrs={\\\"name\\\": \\\"ncbi_resultcount\\\"})[0][\\\"content\\\"])\\n return(count)\",\n \"def count(self, ngram, options):\\n return len(self.find_docs(ngram, options))\",\n \"def count_reads(titer):\\n c = Counter()\\n for template in titer:\\n for mate in template:\\n for cat in (mate['cat_list'] or ['nocat']):\\n c[cat] += 1\\n return c\",\n \"def test_count_publications(self):\\n pass\",\n \"def test_status_reply_count(self):\\n with self.app.app_context():\\n u = user(save=True)\\n s = status(user=u, project=None, save=True)\\n for i in range(5):\\n status(user=u, project=None, reply_to=s, save=True)\\n\\n eq_(s.reply_count, 5)\",\n \"def do_get_comment_count(parser, token):\\r\\n error_message = \\\"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\\\" % (token.contents.split()[0], token.contents.split()[0])\\r\\n try:\\r\\n split = token.split_contents()\\r\\n except ValueError:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n if split[1] != 'for' or split[3] != 'as':\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n return ThreadedCommentCountNode(split[2], split[4])\",\n \"def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\\n reviewers_mapping = {}\\n\\n # Reviewers are supposed to be those mentions who have given thumbs up.\\n for comment in issue_comments:\\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\\n reviewers_mapping[comment.user.login] = dict(\\n tagged_at=None,\\n responded_at=None,\\n gave_thumbs_up_at=comment.created_at\\n )\\n\\n # We have reviewers, now, look for the time for their first response in issue comments.\\n for comment in issue_comments:\\n if comment.user.login in reviewers_mapping.keys() \\\\\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n # TODO: Scrap the time when the PR's body was updated.\\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\\n # for the reviewers that are in PR's body.\\n\\n # Look for time when each of reviewer was tagged, this should be\\n # searched in pull request body and issue comments.\\n for login in reviewers_mapping.keys():\\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\\n if reviewers_mapping[login]['responded_at'] is None \\\\\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\\n reviewers_mapping[login]['tagged_at'] = comment.created_at\\n\\n # Check for reviewers' first response in review comments too, and\\n # update the reviewers_mapping if necessary.\\n for comment in review_comments:\\n if comment.user.login in reviewers_mapping.keys():\\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n return reviewers_mapping\",\n \"def addCommentCount(self,count):\\n self.commentCount += count\\n return None\",\n \"def document_count(self):\\n raise NotImplementedError\",\n \"def get_num_topics(soup):\\n try:\\n #num = int(re.search(\\\"Suche ergab (\\\\\\\\d+)\\\", str(soup)).group(1)) \\n num = int(re.search(\\\"(\\\\\\\\d+) Treffer\\\", str(soup)).group(1)) \\n except: \\n num = 0\\n print(traceback.format_exc()) \\n\\n return num\",\n \"def basic_statistics_of_email(data):\\n word_counts = []\\n character_count = 0\\n\\n for ind, row in data.iterrows():\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\n real_words = tokenizer.tokenize(row[\\\"RawText\\\"].lower())\\n\\n character_count += sum(map(len, real_words))\\n word_counts.append(len(real_words))\\n\\n return character_count, pd.Series(word_counts)\",\n \"def analyze_comments():\\n\\n scores = {} # {docket_id: [comment1_score, comment2_score, ...]}\\n positive_counts = {} # {docket_id: num_positive_comments}\\n neutral_counts = {} # {docket_id: num_neutral_comments}\\n negative_counts = {} # {docket_id: num_negative_comments}\\n\\n comment_sentiments = {} # {comment_id: sentiment} to write to database\\n comment_complexity = {} # {comment_id: complexity} to write to database\\n\\n for comment in lib.mongo.retrieve_comments(1000):\\n docket_id = comment['docketId']\\n comment_id = comment['documentId']\\n text = comment.get('commentText', '').strip()\\n\\n # Fill in the 'sentiment' field of this comment.\\n if 'sentiment' in comment:\\n score = comment['sentiment']\\n else:\\n score = lib.analyze_text.getSentiment(text)\\n comment_sentiments[comment_id] = score\\n\\n logging.info('docket %s, comment %s: sentiment %s (%r)' %\\n (docket_id, comment_id, score, text[:20]))\\n\\n # Fill in the 'complexity' field of this comment.\\n if 'complexity' not in comment:\\n comment_complexity[comment_id] = lib.analyze_text.get_complexity(text)\\n\\n # Aggregate the sentiment scores for each docket.\\n scores.setdefault(docket_id, []).append(score)\\n counts = positive_counts if score > 0 else (\\n negative_counts if score < 0 else neutral_counts)\\n counts[docket_id] = counts.get(docket_id, 0) + 1\\n\\n if len(comment_sentiments) >= 10:\\n logging.info('updating %d comments sentiment...' % len(comment_sentiments))\\n lib.mongo.update_comments('sentiment', comment_sentiments)\\n comment_sentiments = {}\\n\\n if len(comment_complexity) >= 10:\\n logging.info('updating %d comments complexity...' % len(comment_complexity))\\n lib.mongo.update_comments('complexity', comment_complexity)\\n comment_complexity = {}\\n\\n logging.info('updating %d comments...' % len(comment_sentiments))\\n lib.mongo.update_comments('sentiment', comment_sentiments)\\n lib.mongo.update_comments('complexity', comment_complexity)\\n logging.info('done!')\\n\\n docket_sentiments = {} # {docket_id: sentiment} to write to database\\n\\n for docket in lib.mongo.dockets.find():\\n docket_id = docket.get('docketId', '')\\n positive_count = positive_counts.get(docket_id, 0)\\n neutral_count = neutral_counts.get(docket_id, 0)\\n negative_count = negative_counts.get(docket_id, 0)\\n rating = compute_rating(positive_count, neutral_count, negative_count)\\n logging.info('docket %s: %d positive, %d neutral, %d negative - %s' %\\n (docket_id, positive_count, neutral_count, negative_count,\\n rating))\\n\\n docket_sentiments[docket_id] = {\\n 'positive': positive_count,\\n 'neutral': neutral_count,\\n 'negative': negative_count,\\n 'rating': rating\\n }\\n\\n logging.info('updating %d dockets...' % len(docket_sentiments))\\n lib.mongo.update_dockets('sentiment', docket_sentiments)\\n logging.info('done!')\",\n \"def dcount(ev):\\n profData = getProfilingData(ev)\\n if profData is not None:\\n a = profData.Descendants().AsArray()\\n if len(a) > 0:\\n return profData.DescendantCount(a[0])\\n return \\\"\\\"\",\n \"def reply_count(self, url, mode=5, after=0):\\n\\n sql = \\\"\\\"\\\"\\n SELECT\\n c.parent, count(*)\\n FROM comments AS c\\n INNER JOIN threads AS t\\n ON t.uri=%s AND c.tid = t.id AND\\n (%s | c.mode = %s) AND\\n c.created > %s\\n GROUP BY c.parent\\n \\\"\\\"\\\"\\n\\n return dict(self.db.fetchall(sql, [url, mode, mode, after]))\",\n \"def countFullBrowser(self, data, docID):\\n for entry in data.genData():\\n if 'visitor_useragent' in entry and 'event_type' in entry:\\n if entry['event_type'] == 'read':\\n if str(entry['subject_doc_id']) == docID:\\n if entry['visitor_useragent'] in self.browserCounts:\\n self.browserCounts[entry['visitor_useragent']] += 1\\n else:\\n self.browserCounts[entry['visitor_useragent']] = 1\",\n \"def get_subscriber_count(self, response):\\n return response.css('.yt-subscriber-count')\\\\\\n .extract_first(default='')\",\n \"def utr5_motif_counts(self, pattern):\\n return len(re.findall(pattern.upper(), self.five_prime_utr_sequence.upper()))\",\n \"def test_issue_get_comment_reactions(self):\\n pass\",\n \"def github_num_positive_reactions(comment_object: Dict[str, Any]) -> int:\\n num_positive_reactions = 0\\n positive_emojis = {'+1', 'laugh', 'hooray', 'heart', 'rocket', 'eyes'}\\n reactions = comment_object.get('reactions', {})\\n for emoji in positive_emojis:\\n num_positive_reactions += reactions.get(emoji, 0)\\n return num_positive_reactions\",\n \"def get_author_and_comment_count_per_sub(config: Config, sanitized_authors: dict):\\n\\n start = time.time()\\n raw_result = get_raw_author_and_comment_count_per_sub(config, sanitized_authors)\\n end = time.time()\\n print(f\\\"get_raw_author_and_comment_count_per_sub took {end - start} seconds\\\")\\n\\n start = time.time()\\n sanitized_result = sanitize_author_and_comment_count_per_sub(raw_result)\\n end = time.time()\\n print(f\\\"sanitize_author_and_comment_count_per_sub took {end - start} seconds\\\")\\n\\n return sanitized_result\",\n \"def get_comments_num(self): \\n num=len(self.comments_set.all())\\n return num\",\n \"def count_tags():\\r\\n trans = transaction.begin()\\r\\n StatBookmarkMgr.count_total_tags()\\r\\n trans.commit()\",\n \"def totaled_tbr_no_lgtm(cc, sql_time_specification):\\n cc.execute(\\\"\\\"\\\"SELECT git_commit.review_url, git_commit.timestamp,\\n git_commit.subject, git_commit.hash\\n FROM review\\n INNER JOIN git_commit\\n ON review.review_url = git_commit.review_url\\n INNER JOIN commit_people\\n ON commit_people.git_commit_hash = git_commit.hash\\n LEFT JOIN (\\n SELECT review_url, COUNT(*) AS c\\n FROM review_people\\n WHERE type = 'lgtm'\\n GROUP BY review_url) lgtm_count\\n ON review.review_url = lgtm_count.review_url\\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\\n AND commit_people.type = 'author' AND %s\\\"\\\"\\\" % sql_time_specification)\\n result = cc.fetchall()\\n count = len(result)\\n formatted_data = []\\n for data in result:\\n subject = data[2]\\n formatted_data.append([data[0], data[1].strftime(\\\"%Y-%m-%d %H:%M:%S\\\"),\\n subject.replace('-', ' '), data[3]])\\n results = sorted(formatted_data, key=lambda x: x[1], reverse=True)\\n return count, results\",\n \"def compute_reread_counts(self, question, context):\\n\\n # Checks that the question and context are not blank\\n if question == '' or context == '':\\n return {}\\n\\n # Collects the reread count for every student id of the provided context and question\\n raw_reread_counts = []\\n for row in self.responses:\\n table_context = row.context.text\\n table_question = row.question.text\\n view_count = len(row.get_parsed_views())\\n if context in table_context:\\n if question in table_question:\\n raw_reread_counts.append(view_count)\\n\\n # Tallies the raw reread counts into the dictionary to be returned\\n organized_data = {}\\n mean_reread_count = 0\\n sum_of_views = 0\\n student_count = 0\\n final_student_count = 0\\n\\n for entry in raw_reread_counts:\\n if entry in organized_data.keys():\\n organized_data[entry] += 1\\n elif len(raw_reread_counts) != 0:\\n organized_data.update({entry: 1})\\n keys_of_dictionary = organized_data.keys()\\n for entry in keys_of_dictionary:\\n sum_of_views += entry * organized_data[entry]\\n student_count += organized_data[entry]\\n\\n if student_count == 0:\\n return 0\\n else:\\n mean_reread_count = round((sum_of_views / student_count), 2)\\n sum_of_views = 0\\n final_student_count = student_count\\n student_count = 0\\n\\n print(organized_data)\\n return [question, context, mean_reread_count, final_student_count]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6474507","0.6455249","0.6259978","0.62172806","0.61330706","0.60819334","0.6049567","0.6044032","0.5932042","0.59275013","0.5864903","0.5854539","0.5774755","0.57618237","0.57519615","0.5748041","0.5737438","0.57298326","0.5722486","0.57208025","0.5704539","0.5679689","0.56764793","0.5675034","0.5652255","0.5650857","0.56417763","0.56316864","0.56072104","0.5606781","0.55977505","0.55949366","0.559021","0.5586891","0.5570351","0.55694914","0.5569242","0.55631053","0.55476075","0.5546867","0.55424106","0.5540871","0.55377704","0.5509792","0.5503108","0.550028","0.5490699","0.54856193","0.54723847","0.5465742","0.5461022","0.5457444","0.54570115","0.54570115","0.5445716","0.5440436","0.54333943","0.54312855","0.5406683","0.54018515","0.5392259","0.5389509","0.53842753","0.5375159","0.53714174","0.53606665","0.5357214","0.53512037","0.53466415","0.534456","0.5343988","0.53420764","0.53297836","0.53259","0.53178096","0.5303388","0.5295092","0.5290609","0.5288685","0.5281199","0.5272644","0.52572984","0.52506024","0.5246792","0.5240268","0.52388537","0.5222954","0.52190167","0.5202774","0.5190109","0.5185142","0.51747674","0.5169925","0.5164904","0.5155318","0.51533866","0.51511955","0.5147983","0.5146361","0.5134819"],"string":"[\n \"0.6474507\",\n \"0.6455249\",\n \"0.6259978\",\n \"0.62172806\",\n \"0.61330706\",\n \"0.60819334\",\n \"0.6049567\",\n \"0.6044032\",\n \"0.5932042\",\n \"0.59275013\",\n \"0.5864903\",\n \"0.5854539\",\n \"0.5774755\",\n \"0.57618237\",\n \"0.57519615\",\n \"0.5748041\",\n \"0.5737438\",\n \"0.57298326\",\n \"0.5722486\",\n \"0.57208025\",\n \"0.5704539\",\n \"0.5679689\",\n \"0.56764793\",\n \"0.5675034\",\n \"0.5652255\",\n \"0.5650857\",\n \"0.56417763\",\n \"0.56316864\",\n \"0.56072104\",\n \"0.5606781\",\n \"0.55977505\",\n \"0.55949366\",\n \"0.559021\",\n \"0.5586891\",\n \"0.5570351\",\n \"0.55694914\",\n \"0.5569242\",\n \"0.55631053\",\n \"0.55476075\",\n \"0.5546867\",\n \"0.55424106\",\n \"0.5540871\",\n \"0.55377704\",\n \"0.5509792\",\n \"0.5503108\",\n \"0.550028\",\n \"0.5490699\",\n \"0.54856193\",\n \"0.54723847\",\n \"0.5465742\",\n \"0.5461022\",\n \"0.5457444\",\n \"0.54570115\",\n \"0.54570115\",\n \"0.5445716\",\n \"0.5440436\",\n \"0.54333943\",\n \"0.54312855\",\n \"0.5406683\",\n \"0.54018515\",\n \"0.5392259\",\n \"0.5389509\",\n \"0.53842753\",\n \"0.5375159\",\n \"0.53714174\",\n \"0.53606665\",\n \"0.5357214\",\n \"0.53512037\",\n \"0.53466415\",\n \"0.534456\",\n \"0.5343988\",\n \"0.53420764\",\n \"0.53297836\",\n \"0.53259\",\n \"0.53178096\",\n \"0.5303388\",\n \"0.5295092\",\n \"0.5290609\",\n \"0.5288685\",\n \"0.5281199\",\n \"0.5272644\",\n \"0.52572984\",\n \"0.52506024\",\n \"0.5246792\",\n \"0.5240268\",\n \"0.52388537\",\n \"0.5222954\",\n \"0.52190167\",\n \"0.5202774\",\n \"0.5190109\",\n \"0.5185142\",\n \"0.51747674\",\n \"0.5169925\",\n \"0.5164904\",\n \"0.5155318\",\n \"0.51533866\",\n \"0.51511955\",\n \"0.5147983\",\n \"0.5146361\",\n \"0.5134819\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.668312"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85196,"cells":{"query":{"kind":"string","value":"counts conversational comments, checks for protm tag, counts rxns"},"document":{"kind":"string","value":"def calc_conv_comments(self):\n for conv_comment in self.pull_request.get_issue_comments():\n self._users.add(conv_comment.user.login)\n lowercase_body = conv_comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_conv_comments += 1\n for reaction in conv_comment.get_reactions():\n self._users.add(reaction.user.login)\n self.conv_comment_reactions += 1\n if conv_comment.body is not None:\n self.len_issue_comments += len(conv_comment.body)"},"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 count_comments(self):\n return self.run_query(f\"count({self.r}/comment)\")","def calc_comments(self):\n for comment in self.pull_request.get_comments():\n self._users.add(comment.user.login)\n lowercase_body = comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_comments += 1\n if comment.body is not None:\n self.len_comments += len(comment.body)\n for reaction in comment.get_reactions():\n self._users.add(reaction.user.login)\n self.comment_reactions += 1","def get_indicators_and_clean_comments(df):\n # Count number of \\n\n df[\"ant_slash_n\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\n\", x))\n # Get length in words and characters\n df[\"raw_word_len\"] = df[\"comment_text\"].apply(lambda x: len(x.split()))\n df[\"raw_char_len\"] = df[\"comment_text\"].apply(lambda x: len(x))\n # Check number of upper case, if you're angry you may write in upper case\n df[\"nb_upper\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[A-Z]\", x))\n # Number of F words - f..k contains folk, fork,\n df[\"nb_fk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[Ff]\\S{2}[Kk]\", x))\n # Number of S word\n df[\"nb_sk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[Ss]\\S{2}[Kk]\", x))\n # Number of D words\n df[\"nb_dk\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"[dD]ick\", x))\n # Number of occurence of You, insulting someone usually needs someone called : you\n df[\"nb_you\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\W[Yy]ou\\W\", x))\n # Just to check you really refered to my mother ;-)\n df[\"nb_mother\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\Wmother\\W\", x))\n # Just checking for toxic 19th century vocabulary\n df[\"nb_ng\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\Wnigger\\W\", x))\n # Some Sentences start with a <:> so it may help\n df[\"start_with_columns\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"^\\:+\", x))\n # Check for time stamp\n df[\"has_timestamp\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\d{2}|:\\d{2}\", x))\n # Check for dates 18:44, 8 December 2010\n df[\"has_date_long\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\D\\d{2}:\\d{2}, \\d{1,2} \\w+ \\d{4}\", x))\n # Check for date short 8 December 2010\n df[\"has_date_short\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\D\\d{1,2} \\w+ \\d{4}\", x))\n # Check for http links\n df[\"has_http\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"http[s]{0,1}://\\S+\", x))\n # check for mail\n df[\"has_mail\"] = df[\"comment_text\"].apply(\n lambda x: count_regexp_occ(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\.[a-zA-Z0-9-.]+', x)\n )\n # Looking for words surrounded by == word == or \"\"\"\" word \"\"\"\"\n df[\"has_emphasize_equal\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\={2}.+\\={2}\", x))\n df[\"has_emphasize_quotes\"] = df[\"comment_text\"].apply(lambda x: count_regexp_occ(r\"\\\"{4}\\S+\\\"{4}\", x))\n\n # Now clean comments\n df[\"clean_comment\"] = df[\"comment_text\"].apply(lambda x: prepare_for_char_n_gram(x))\n\n # Get the new length in words and characters\n df[\"clean_word_len\"] = df[\"clean_comment\"].apply(lambda x: len(x.split()))\n df[\"clean_char_len\"] = df[\"clean_comment\"].apply(lambda x: len(x))\n # Number of different characters used in a comment\n # Using the f word only will reduce the number of letters required in the comment\n df[\"clean_chars\"] = df[\"clean_comment\"].apply(lambda x: len(set(x)))\n df[\"clean_chars_ratio\"] = df[\"clean_comment\"].apply(lambda x: len(set(x))) / df[\"clean_comment\"].apply(\n lambda x: 1 + min(99, len(x)))","def count_reddit_comments_ngram_strs(year, month, n):\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\n return Counter(itertools.chain.from_iterable(ngram_strs))","def sent_count(comment):\n return comment.__len__()","def getCommentCount(self, source):\n commentStart = source.find('item?id=')\n commentCountStart = source.find('>', commentStart) + 1\n commentEnd = source.find('</a>', commentStart)\n commentCountString = source[commentCountStart:commentEnd]\n if commentCountString == \"discuss\":\n return 0\n elif commentCountString == \"\":\n return 0\n else:\n commentCountString = commentCountString.split(' ')[0]\n return int(commentCountString)","def do_get_comment_count(parser, token):\r\n error_message = \"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\" % (token.contents.split()[0], token.contents.split()[0])\r\n try:\r\n split = token.split_contents()\r\n except ValueError:\r\n raise template.TemplateSyntaxError, error_message\r\n if split[1] != 'for' or split[3] != 'as':\r\n raise template.TemplateSyntaxError, error_message\r\n return ThreadedCommentCountNode(split[2], split[4])","def count_regexp():\r\n # Here's an example regular expression that roughly matches a valid email address.\r\n # The ones you write below should be shorter than this\r\n email = re.compile(\"[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+\\.[a-zA-Z]{2,5}\")\r\n\r\n ###### Write below #########\r\n subheading = re.compile(\"\\=\\=+.*\\=\\=+\")\r\n link_to_subheading = re.compile(\"\\[\\[[\\w\\'*\\-*\\:*\\(*\\)*\\_*\\s*]+[#][\\s*\\w\\\\'*\\-*\\:*\\(*\\)*\\_*s*]+\\|*\")\r\n doi_citation = re.compile(\"\\{\\{[c][ite](?!{{).*[dD][oO][iI]\\s*[:|,=\\/]*\\s*[0-9]+\\.[0-9]+.*\\}\\}\")\r\n ###### End of your work #########\r\n\r\n patterns = {\r\n \"emails\": email,\r\n \"subheadings\": subheading,\r\n \"links to subheadings\": link_to_subheading,\r\n \"citations with DOI numbers\": doi_citation,\r\n }\r\n\r\n with open(RAW_DUMP_XML, encoding=\"utf-8\") as f:\r\n dump_text = f.read()\r\n for name, pattern in patterns.items():\r\n if pattern is None:\r\n continue\r\n matches = pattern.findall(dump_text)\r\n count = len(matches)\r\n\r\n example_matches = [matches[i * (count // 5)] for i in range(5)]\r\n\r\n print(\"Found {} occurences of {}\".format(count, name))\r\n print(\"Here are examples:\")\r\n print(\"\\n\".join(example_matches))\r\n print(\"\\n\")","def parseCommentsTotalCount(data):\n p = re.compile(r\"\\d+ Reviews\")\n\n for line in data:\n line = line.replace(\",\", \"\")\n match = re.search(p, line)\n if match != None:\n getNmbr = match.group().split(\" \")\n return int(getNmbr[0])\n return -1","def analyze_comments():\n\n scores = {} # {docket_id: [comment1_score, comment2_score, ...]}\n positive_counts = {} # {docket_id: num_positive_comments}\n neutral_counts = {} # {docket_id: num_neutral_comments}\n negative_counts = {} # {docket_id: num_negative_comments}\n\n comment_sentiments = {} # {comment_id: sentiment} to write to database\n comment_complexity = {} # {comment_id: complexity} to write to database\n\n for comment in lib.mongo.retrieve_comments(1000):\n docket_id = comment['docketId']\n comment_id = comment['documentId']\n text = comment.get('commentText', '').strip()\n\n # Fill in the 'sentiment' field of this comment.\n if 'sentiment' in comment:\n score = comment['sentiment']\n else:\n score = lib.analyze_text.getSentiment(text)\n comment_sentiments[comment_id] = score\n\n logging.info('docket %s, comment %s: sentiment %s (%r)' %\n (docket_id, comment_id, score, text[:20]))\n\n # Fill in the 'complexity' field of this comment.\n if 'complexity' not in comment:\n comment_complexity[comment_id] = lib.analyze_text.get_complexity(text)\n\n # Aggregate the sentiment scores for each docket.\n scores.setdefault(docket_id, []).append(score)\n counts = positive_counts if score > 0 else (\n negative_counts if score < 0 else neutral_counts)\n counts[docket_id] = counts.get(docket_id, 0) + 1\n\n if len(comment_sentiments) >= 10:\n logging.info('updating %d comments sentiment...' % len(comment_sentiments))\n lib.mongo.update_comments('sentiment', comment_sentiments)\n comment_sentiments = {}\n\n if len(comment_complexity) >= 10:\n logging.info('updating %d comments complexity...' % len(comment_complexity))\n lib.mongo.update_comments('complexity', comment_complexity)\n comment_complexity = {}\n\n logging.info('updating %d comments...' % len(comment_sentiments))\n lib.mongo.update_comments('sentiment', comment_sentiments)\n lib.mongo.update_comments('complexity', comment_complexity)\n logging.info('done!')\n\n docket_sentiments = {} # {docket_id: sentiment} to write to database\n\n for docket in lib.mongo.dockets.find():\n docket_id = docket.get('docketId', '')\n positive_count = positive_counts.get(docket_id, 0)\n neutral_count = neutral_counts.get(docket_id, 0)\n negative_count = negative_counts.get(docket_id, 0)\n rating = compute_rating(positive_count, neutral_count, negative_count)\n logging.info('docket %s: %d positive, %d neutral, %d negative - %s' %\n (docket_id, positive_count, neutral_count, negative_count,\n rating))\n\n docket_sentiments[docket_id] = {\n 'positive': positive_count,\n 'neutral': neutral_count,\n 'negative': negative_count,\n 'rating': rating\n }\n\n logging.info('updating %d dockets...' % len(docket_sentiments))\n lib.mongo.update_dockets('sentiment', docket_sentiments)\n logging.info('done!')","def count():","def _get_token_cnts(self, doc, doc_type):\n tokenized_doc = self.nlp(doc)\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\n doc_len = len([t for t in tokenized_doc])\n self.stat_dict[doc_type][1].append(doc_len)\n if doc_len < 50 and doc_type == \"answer\":\n print(\"Document less than 50 tokens:\", url)","def generate_reddit_comments_ngram_counts(\n year, month, n, root=paths.DEFAULT_REDDIT_NGRAMS_DATA):\n ngram_path = paths.get_reddit_ngrams_local(year, month, n, root=root)\n if os.path.isfile(ngram_path):\n logging.warning(\"Cache exists for all requested n-grams.\"\n \"Skipping %04d-%02d\\n\" % (year, month))\n return False\n\n counts = count_reddit_comments_ngram_strs(year, month, n)\n with gzip.GzipFile(ngram_path, 'wb') as fh:\n for k, v in counts.items():\n fh.write(\"{}\\t{}\\n\".format(k, v).encode())\n return True","def get_comment_count(self, postid=0, blogid=1):\n \n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)","def get_comments_count(self, thread_uid: str) -> int:\n pass","def wcount(lines, topn=10):\n my_socket = urllib.request.urlopen(lines)\n dta = my_socket.read().decode()\n my_socket.close()\n #get the text from url\n \n s=dta.replace(',',' ')\n b=s.replace('.',' ')\n c=b.replace('?',' ')\n d=c.replace('_',' ')\n e=d.replace(']',' ')\n f=e.replace('[',' ')\n g=f.replace('*',' ')\n h=g.replace('%',' ')\n i=h.replace('!',' ')\n j=i.replace('\"',' ')\n k=j.replace(':',' ')\n l=k.replace(';',' ')\n m=l.replace('(',' ')\n n=m.replace(')',' ')\n o=n.replace('-',' ')\n p=o.replace('_',' ')\n q=p.replace('/','')\n q=q.lower()\n x=q.split()\n y=set(x)\n #Processed documents are converted into ordered strings\n \n lst={}\n for i in y:\n num=x.count(i)\n lst[i]=num\n \n r=list(lst.values())\n r.sort(reverse=True)\n for i in r[:topn]:\n print(list(lst.keys())[list(lst.values()).index(i)].ljust(15)+\" \"+str(i))\n \n pass","def getCounter(self):\n word_count, noun_word_count = Counter(), Counter()\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\n docs = self.nlp.pipe(\n self.docs, n_process=1, disable=self.disablelayers)\n \n\n for index, doc in enumerate(docs):\n for token in doc:\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\n if token.pos_ == 'PROPN':\n word_count[token.lemma_] += 1\n word_rating[token.lemma_].append(self.ratings[index])\n else:\n noun_word_count[token.lemma_] += 1\n noun_word_rating[token.lemma_].append(self.ratings[index])\n\n # if 0<=proper nouns<=5 found, add regular nouns\n if not word_count or len(word_count) <= 5:\n word_count += noun_word_count\n word_rating = {**word_rating, **noun_word_rating}\n \n word_color = {word: self.getColor(\n ratings)[1] for word, ratings in word_rating.items()}\n word_sentiment = {word: self.getColor(\n ratings)[0] for word, ratings in word_rating.items()}\n\n return word_count, word_color, word_sentiment","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def comment_count(self):\n return self.comments.filter_by(state=0).count()","def count_ngrams(self, corpus):\n \n self.unigramcounts = {} # might want to use defaultdict or Counter instead\n self.bigramcounts = {} \n self.trigramcounts = {} \n\n self.total = 2\n ##Your code here\n\n for sentence in corpus:\n temp_1 = get_ngrams(sentence,1)\n temp_2 = get_ngrams(sentence,2)\n temp_3 = get_ngrams(sentence,3)\n for i in range(len(temp_1)):\n if temp_1[i] in self.unigramcounts:\n self.unigramcounts[temp_1[i]] += 1\n else:\n self.unigramcounts[temp_1[i]] = 1\n self.total += 1\n\n for i in range(len(temp_2)):\n if temp_2[i] in self.bigramcounts:\n self.bigramcounts[temp_2[i]] += 1\n else:\n self.bigramcounts[temp_2[i]] = 1\n\n for i in range(len(temp_3)):\n if temp_3[i] in self.trigramcounts:\n self.trigramcounts[temp_3[i]] += 1\n else:\n self.trigramcounts[temp_3[i]] = 1\n return","def commentaires(file_name_c):\n com = subprocess.run([\"grep\", \"eleves_bis/\" + file_name_c, \"-e\", '/\\*'], stdout=subprocess.PIPE)\n return com.stdout.decode().count(\"\\n\")","def get_matches_count():\n\n return ''\n \"\"\"\n TODO: count matches\n dtr5app_flag.sender\n dtr5app_flag.receiver\n dtr5app_flag.flag\n \"\"\"","def count_ngrams(self, corpus):\n \n self.unigramcounts = defaultdict(int)\n self.bigramcounts = defaultdict(int)\n self.trigramcounts = defaultdict(int)\n\n self.sentence_counts = 0\n self.word_count = 0\n\n for line in corpus:\n sequence = line\n self.sentence_counts +=1\n\n unigrams = get_ngrams(sequence, n=1)\n for gram in unigrams:\n self.word_count += 1\n self.unigramcounts[gram] +=1\n\n bigrams = get_ngrams(sequence, n=2)\n for gram in bigrams:\n self.bigramcounts[gram] +=1\n\n trigrams = get_ngrams(sequence, n=3)\n for gram in trigrams:\n self.trigramcounts[gram] +=1\n\n #self.unigramcounts[('START')] = self.sentence_counts *2\n self.bigramcounts[('START', 'START')] = self.sentence_counts\n\n #return self","def Counting(seq):\n\n #Scan the sequence, looking for motifs\n\n counting = {k: 0 for k in MOT} # Initialize the counting dictionary.\n # Scan all the motifs and find them in the sequence\n for motif in MOT:\n if len(seq) > len(motif): # Check if the sequence is longer than the motif itself.\n for i in range(len(seq)-len(motif)+1):\n if i == 0: # In case the motif is in the beginning of the sequence\n # print(\"start: \" + seq[i:i+len(motif)] + \" next nuc: \" + seq[i+len(motif)])\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0]: # Check if the next nucleotide is in not part of the motif.\n counting[motif] += 1\n elif i == len(seq)-len(motif): # In case the motif is in the end of the sequence\n \n if seq[i:i+len(motif)] == motif and seq[i-1] != motif[0]: # Check if the previuos nucleotide is in not part of the motif.\n counting[motif] += 1\n elif len(seq) > len(motif)+1: # In case the motif is in the middle of the sequence.\n # Check if the motif is not part of another motif (e.g. TT is in TTT).\n\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0] and seq[i-1] != motif[0]:\n counting[motif] += 1\n for nuc_nr in NUC_NR:\n counting[nuc_nr+\"_NR\"] = seq.count(nuc_nr)\n\n return counting","async def scrape_comments(self):\n\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\n\n comment_count = 0\n async for comment in subreddit_origin.comments(limit=self.limit):\n if self.memory.contains(comment.id):\n continue\n\n self.memory.add(comment.id)\n\n # Parse Comment\n comment = self.parse_comment(comment)\n\n # Save in Pub/Sub\n if self.enable_publish:\n self.publish(comment)\n\n comment_count += 1\n\n return comment_count","def count_other_citations(pmid,linkname):\n link = f\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\"\n sleep(0.3)\n page = requests.get(link).text\n soup = BeautifulSoup(page, 'html.parser') \n count = int(soup.find_all(attrs={\"name\": \"ncbi_resultcount\"})[0][\"content\"])\n return(count)","def count_comments(self):\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\n count = comments.count()\n return count","def main ():\n fio = FileIo(\"../input2.txt\")\n text = fio.getInput()\n p = re.compile(r'#?\\d[\\s\\.]?[\\s]?')\n out = filter(None, p.split(text))\n #print out[2]\n #print len(out)\n wc = 0\n\n for s in out:\n text = nltk.word_tokenize(s)\n wc += wordCount( text )\n print wc","def do_get_free_comment_count(parser, token):\r\n error_message = \"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\" % (token.contents.split()[0], token.contents.split()[0])\r\n try:\r\n split = token.split_contents()\r\n except ValueError:\r\n raise template.TemplateSyntaxError, error_message\r\n if split[1] != 'for' or split[3] != 'as':\r\n raise template.TemplateSyntaxError, error_message\r\n return FreeThreadedCommentCountNode(split[2], split[4])","def text_cond_count(self, condition):\n res = 0\n for intv in self:\n if condition(intv._text):\n res += 1\n return res","def do_get_user_comment_count(parser, token):\r\n error_message = \"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\" % (token.contents.split()[0], token.contents.split()[0])\r\n try:\r\n split = token.split_contents()\r\n except ValueError:\r\n raise template.TemplateSyntaxError, error_message\r\n if len(split) != 5:\r\n raise template.TemplateSyntaxError, error_message\r\n return UserCommentCountNode(split[2], split[4])","def comments_count(self) -> int:\n return pulumi.get(self, \"comments_count\")","def getNumberOfComments(node, catalog=None):\n if catalog is None:\n catalog = getToolByName(node, 'portal_catalog')\n return len(catalog(\n object_provides=IComment.__identifier__,\n path='/'.join(node.getPhysicalPath())))","def count_relation_doc(document):\n count = {}\n for line in document[1:]:\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\n for relation in relation_types:\n if relation in count:\n count[relation] += 1\n else:\n count[relation] = 1\n return count","def count_reads(titer):\n c = Counter()\n for template in titer:\n for mate in template:\n for cat in (mate['cat_list'] or ['nocat']):\n c[cat] += 1\n return c","def counts(self, regex = \"\\w+\"): \n tokenizer = RegexpTokenizer(r'{}'.format(regex))\n count = []\n for i in tqdm(self.text):\n count.append(len(tokenizer.tokenize(i)))\n return count","def findNoteCounts(self, authenticationToken, filter, withTrash):\r\n pass","def count_verbs(text):\n\n\t# ... in the parse trees\n\tpt_VB_ = len(re_pt_VB_.findall(text))\t# VB* all forms\n\tpt_VBb = len(re_pt_VBb.findall(text))\t# VB base form\n\tpt_VBD = len(re_pt_VBD.findall(text))\t# VBD past tense\n\tpt_VBG = len(re_pt_VBG.findall(text))\t# VBG gerund or past participle\n\tpt_VBN = len(re_pt_VBN.findall(text))\t# VBN past participle\n\tpt_VBP = len(re_pt_VBP.findall(text))\t# VBP present tense, except 3rd Per Sing\n\tpt_VBZ = len(re_pt_VBZ.findall(text))\t# VBZ present tense, 3rd Person Singular\n\n\t# ... in the tagged sentences\n\tts_VB_ = len(re_ts_VB_.findall(text))\t# VB* all forms\n\tts_VBb = len(re_ts_VBb.findall(text))\t# VB base form\n\tts_VBD = len(re_ts_VBD.findall(text))\t# VBD past tense\n\tts_VBG = len(re_ts_VBG.findall(text))\t# VBG gerund or past participle\n\tts_VBN = len(re_ts_VBN.findall(text))\t# VBN past participle\n\tts_VBP = len(re_ts_VBP.findall(text))\t# VBP present tense, except 3rd Per Sing\n\tts_VBZ = len(re_ts_VBZ.findall(text))\t# VBZ present tense, 3rd Person Singular\n\n\t# ... collect all counts\n\tpt_verb_counts = ( pt_VBb, pt_VBD, pt_VBG, pt_VBN, pt_VBP, pt_VBZ, pt_VB_, )\n\tts_verb_counts = ( ts_VBb, ts_VBD, ts_VBG, ts_VBN, ts_VBP, ts_VBZ, ts_VB_, )\n\n\t# check agreement\n\tif (pt_verb_counts != ts_verb_counts):\n\t\tprint(\"ERROR: counts from parse tree do not agree with counts from tagged sentences.\")\n\n\t# return all counts\n\treturn ( pt_verb_counts, ts_verb_counts, )","def cmd_account_comment_count(client, args):\n account_comment_count = client.get_account_comment_count(args.username)\n generate_output({'account_comment_count': account_comment_count})","def count_exclamations(txt):\n count = 0\n for c in txt:\n if c == '!':\n count += 1\n return count","def pos_tag_counts(doc):\n tags = []\n for token in doc:\n tags.append(token.pos_)\n frequency = dict(Counter(tags).most_common()) \n return frequency","def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\n if project_name == PROJECT_ALL:\n # comments in changes across all projects after from_datetime\n comments = reviewer.comments.filter(\n timestamp__gte=from_datetime).distinct()\n else:\n # comments in changes in given project after from_datetime\n comments = reviewer.comments.filter(\n change__project_name=project_name,\n timestamp__gte=from_datetime).distinct()\n\n return comments.count()","def count_tags(tag_events):\n tagged_lines = []\n for tag_event in tag_events:\n for tag in tag_event[1][\"tag\"][\"labels\"]:\n tagged_lines.append(tag)\n tag_counts = Counter(tagged_lines)\n return tag_counts","def countsubcatchments(inputfilename=FileSettings.settingsdict['inputfilename']):\r\n global count\r\n with open(inputfilename, 'r') as swmmput:\r\n contents = swmmput.readlines()\r\n count = len(contents)\r\n return(count)","def dcount(ev):\n profData = getProfilingData(ev)\n if profData is not None:\n a = profData.Descendants().AsArray()\n if len(a) > 0:\n return profData.DescendantCount(a[0])\n return \"\"","def commentinator(coms, ctype, btag, tag):\n # Construct the message\n tag = btag + tag\n \n if ctype.lower() == 'notes':\n coms.notes.append(tag)\n elif ctype.lower() == 'warning':\n coms.warnings.append(tag)\n elif ctype.lower() == 'error':\n coms.errors.append(tag)\n elif ctype.lower() == 'tip':\n coms.tips.append(tag)\n \n return coms","def _count_comment_rows(vcf_path):\n vcf_lines_generator = lines_from_vcf(vcf_path)\n\n comment_lines_count = 0\n for line in vcf_lines_generator:\n if line.startswith('#'):\n comment_lines_count += 1\n else:\n vcf_lines_generator.close() # Don't leave the file handle opened\n # Don't continue reading the VCF once the comments section ended\n break\n\n return comment_lines_count","def basic_statistics_of_email(data):\n word_counts = []\n character_count = 0\n\n for ind, row in data.iterrows():\n tokenizer = RegexpTokenizer(r'\\w+')\n real_words = tokenizer.tokenize(row[\"RawText\"].lower())\n\n character_count += sum(map(len, real_words))\n word_counts.append(len(real_words))\n\n return character_count, pd.Series(word_counts)","def core(self):\n \n \n comments = self.bot.subreddit(\n \"all\").stream.comments(\n skip_existing = True)\n \n \n for comment in comments:\n \n text = comment.body.lower().replace(\".\", \"\")\n \n for card in self.catalog:\n \n if (\n card[1].lower() in text\n and card[0].lower() in text\n and not comment.submission.id in self.responded\n and not comment.subreddit.user_is_banned):\n\n self.get_info(card)\n\n if not self.details:\n \n break\n\n audio = [\n \"audiobook\", \n \"audio book\"]\n \n author_format = [\n name.lower() for name in card[1].split(\" \") \n if len(name) >= 3]\n\n if (\n self.details[\"duration\"] > 10800\n and card[0].lower() in self.details[\n \"title\"].lower()\n and any(\n item in self.details[\n \"title\"].lower() for item in audio)\n and all(\n item in self.details[\n \"title\"].lower() for item in author_format)):\n \n \n saw_the_sign = (\n \"\"\"[^(Source Code)](https://capybasilisk.com/posts/\"\"\"\n \"\"\"2020/04/speculative-fiction-bot/) \"\"\"\n \"\"\"^| [^(Feedback)](https://www.reddit.com/message/\"\"\"\n \"\"\"compose?to=Capybasilisk&subject=Robot) \"\"\"\n \"\"\"^| [^(Programmer)](https://www.reddit.com/u/\"\"\"\n \"\"\"capybasilisk) \"\"\"\n \"\"\"^| ^(Downvote To Remove) \"\"\" \n \"\"\"^| ^(Version 1.4.0) \"\"\"\n \"\"\"^| ^(Support Robot Rights!)\"\"\")\n \n\n comment.reply(\n f\"\"\"Hi. You just mentioned *{card[0]}* by \"\"\" \n f\"\"\"{card[1]}.\\n\\nI've found an audiobook of \"\"\" \n \"\"\"that novel on YouTube. You can listen to it here\"\"\"\n f\"\"\":\\n\\n[YouTube | {self.details['title']}]\"\"\"\n f\"\"\"({self.details['webpage_url']})\\n\\n*I\\'m a bot that \"\"\" \n \"\"\"searches YouTube for science fiction and fantasy\"\"\" \n f\"\"\" audiobooks.*\\n***\\n{saw_the_sign}\"\"\")\n\n \n self.responded.append(\n comment.submission.id)\n \n with open(\n \"activity.csv\", \n \"a\", \n encoding = \"UTF-8\") as actlog:\n\n activity = clevercsv.writer(\n actlog)\n\n if actlog.tell() == 0:\n\n activity.writerow(\n [\"Book\",\n \"Comment\", \n \"Author\", \n \"Thread\", \n \"Subreddit\", \n \"Time\"])\n\n activity.writerow(\n [f\"{card[0]} by {card[1]}\",\n f\"{comment.body}\",\n f\"{comment.author}\",\n f\"{comment.submission.title}\",\n f\"{comment.subreddit}\",\n f\"{pendulum.now().to_datetime_string()}\"])\n \n self.details = None\n \n break\n \n break \n \n if pendulum.now().to_time_string().endswith(\n \"0:00\"):\n \n self.tidy()","def sendUpStatCountTagCounts(node, tag):\n def pushUp(node):\n t = 0\n ta = 0\n for child in node.children:\n tc, tac = pushUp(child)\n ta += tac\n t += tc\n node.tagTranscriptAnnotations += ta\n node.tagTranscripts += t\n return node.tagTranscripts, node.tagTranscriptAnnotations\n if ':' in tag:\n tag = tag.split(':')[-1]\n pushUp(node)","def test_counts(self):\n lines, words, chars = analyze_text(self.filename)\n self.assertEqual(lines, 4)\n self.assertEqual(words, 8)\n self.assertEqual(chars, 36)","def cmd_gallery_comment_count(client, args):\n gallery_comment_count = client.gallery_comment_count(args.item_id)\n generate_output({'gallery_comment_count': gallery_comment_count})","def addCommentCount(self,count):\n self.commentCount += count\n return None","def __call__(self, example):\n para_counter = data.count_tokens(example['context_tokens'] if not self._iterate_over_example\n else [c for tkn in example['context_tokens'] for c in tkn])\n ques_counter = data.count_tokens(example['ques_tokens'] if not self._iterate_over_example\n else [c for tkn in example['ques_tokens'] for c in tkn])\n counter = para_counter + ques_counter\n return list(counter.items())","def count_tags():\r\n trans = transaction.begin()\r\n StatBookmarkMgr.count_total_tags()\r\n trans.commit()","def getTokenSizeOfReviews(self):\n res = 0\n with open(self.word_to_docs_path, 'rb') as bin:\n while bin.tell() != os.fstat(bin.fileno()).st_size:\n # get wordid:\n int.from_bytes(bin.read(4), 'big')\n # get frequency:\n frequency = int.from_bytes(bin.read(4), 'big')\n res += frequency\n # skip documents:\n int.from_bytes(bin.read(4 * frequency), 'big')\n return res","def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def get_stats(sents):\n import os\n import re \n # first, put the relevant trees into temp file\n if 'outname' in kwargs.keys():\n to_open = 'tmp-%s.txt' % kwargs['outname']\n else:\n to_open = 'tmp.txt'\n with open(to_open, \"w\") as fo:\n for sent in sents:\n statsmode_results['Sentences'] += 1\n fo.write(sent.parse_string.rstrip().encode('utf-8', errors = 'ignore') + '\\n')\n deps = get_deps(sent, dep_type)\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\n statsmode_results['Passives'] += numpass\n statsmode_results['Tokens'] += len(sent.tokens)\n statsmode_results['Words'] += len([w for w in sent.tokens if w.word.isalnum()])\n #statsmode_results['Unique words'] += len(set([w.word.lower() for w in sent.tokens if w.word.isalnum()]))\n #statsmode_results['Unique lemmata'] += len(set([w.lemma.lower() for w in sent.tokens if w.word.isalnum()]))\n\n # count moods via trees (/\\?/ !< __)\n from dictionaries.process_types import processes\n from corpkit.other import as_regex\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\n #'Open interrogative': r'ROOT < SBARQ <<- (/\\?/ !< __)', \n #'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\?/ !< __))',\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\n 'Open class words': r'/^(NN|JJ|VB|RB)/ < __',\n 'Closed class words': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\n 'Clauses': r'/^S/ < __',\n 'Interrogative': r'ROOT << (/\\?/ !< __)',\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.mental, boundaries = 'w'),\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.verbal, boundaries = 'w'),\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.relational, boundaries = 'w')}\n\n for name, q in sorted(tregex_qs.items()):\n res = tregex_engine(query = q, \n options = ['-o', '-C'], \n corpus = to_open, \n root = root)\n statsmode_results[name] += int(res)\n global numdone\n numdone += 1\n if root:\n root.update()\n if not root:\n tot_string = str(numdone + 1) + '/' + str(total_files * len(tregex_qs.keys()))\n if 'outname' in kwargs.keys():\n tot_string = '%s: %s' % (kwargs['outname'], tot_string)\n animator(p, numdone, tot_string, **par_args)\n if 'note' in kwargs.keys() and kwargs['note'] is not False:\n kwargs['note'].progvar.set((numdone * 100.0 / (total_files * len(tregex_qs.keys())) / denom) + startnum)\n os.remove(to_open)","def set_n_comments_observed_task2(posts):\n for p in posts:\n p['n_comments_observed'] = get_hostile_indices(p)[0] + 1","def message_count(self):\n pass","def contig_count(contig):\n return sum([1 for line in open(contig, 'rU').readlines() if line.startswith('>')])","def derive_terms_and_comments(infile: str = None, outfile: str = None) -> None:\n\n id_ctr = 0\n comment_ctr = 0\n missing_id_ctr = 0\n missing_comment_ctr = 0\n null_comment_ctr = 0\n terms_and_comments_list = []\n\n logging.info(\"Abou to parse '{}'\".format(infile))\n\n with open(infile) as file:\n\n documents = yaml.full_load(file)\n\n for item, doc in documents.items():\n if item == '@graph':\n logging.info(\"Found '@graph' section\")\n\n graph_list = doc\n\n for graph_dict in graph_list:\n term_name = None\n comment = None\n if '@id' in graph_dict:\n term_name = graph_dict['@id']\n id_ctr += 1\n if 'rdfs:comment' in graph_dict:\n comment = graph_dict['rdfs:comment']\n if comment is None or comment == '':\n comment = 'N/A'\n logging.info(\"Found term '{}' with null comment so assigned '{}'\".format(term_name, comment))\n null_comment_ctr += 1\n else:\n logging.info(\"Found term '{}' with comment '{}'\".format(term_name, comment))\n comment_ctr += 1\n else:\n logging.info(\"Did not find comment for term '{}'\".format(term_name))\n missing_comment_ctr += 1\n else:\n logging.error(\"Did not find id!\")\n missing_id_ctr += 1\n\n terms_and_comments_list.append([term_name, comment])\n\n logging.info(\"Found '{}' ids\".format(id_ctr))\n logging.info(\"Found '{}' comments\".format(comment_ctr))\n\n if missing_id_ctr > 0:\n print(\"Encountered '{}' missing ids\".format(missing_id_ctr))\n\n if missing_comment_ctr > 0:\n print(\"Encountered '{}' missing comments\".format(missing_comment_ctr))\n\n if null_comment_ctr > 0:\n print(\"Encountered '{}' comments with null values\".format(null_comment_ctr))\n\n with open(outfile, 'w') as fh:\n for term_and_comment in terms_and_comments_list:\n fh.write(term_and_comment[0] + \"\\t\" + term_and_comment[1] + \"\\n\")\n\n logging.info(\"Wrote '{}'\".format(outfile))\n print(\"Wrote '{}'\".format(outfile))","def keyword_count(searches, doc):\n for search in searches:\n print \"\\\"{0}\\\": {1}\".format(search, len(re.findall(searches[search], doc)))","def count(text):\n return len(text)","def test_get_comments_len(self):\n comments = self.story.get_comments()\n soup = utils.get_item_soup(7324236)\n for anchor in soup.find_all('a'):\n if 'More' in anchor.text:\n more_button_present = True\n\n # Note: Hacker News is not consistent about the number of comments per\n # page. On multiple comment page stories, the number of comments on a\n # page is never less than 90. On single comment page stories, the\n # number of comments on the sole page is always less than 110.\n if more_button_present:\n self.assertTrue(len(comments) > 90)\n else:\n self.assertTrue(len(comments) < 110)","def get_comments(qint,conn):\n\n comms = ('SELECT DISTINCT ip.value '\n 'FROM interaction i, interactionprop ip, cvterm cvt '\n 'WHERE i.interaction_id = ip.interaction_id AND ip.type_id = cvt.cvterm_id '\n 'AND cvt.is_obsolete=0 AND cvt.name != \\'comments on source\\' '\n 'AND cvt.name != \\'internalnotes\\' AND i.uniquename = %s')\n comnts = connect(comms, qint, conn)\n return(comnts)","def github_num_reactions(comment_object: Dict[str, Any]) -> int:\n return comment_object.get('reactions', {}).get('total_count', 0)","def paragraph_count(self, doc):\n\n paragraphs = doc.split(\"\\n\\n\")\n # remove the empty string\n return len([paragraph for paragraph in paragraphs if paragraph])","def utr5_motif_counts(self, pattern):\n return len(re.findall(pattern.upper(), self.five_prime_utr_sequence.upper()))","def count_prepositions(text):\n\t# parse tree, tag 'IN'\n\tpt_IN = re_pt_IN.findall(text)\n\tpt_IN_lc = [ s.lower() for s in pt_IN ]\n\t\n\t# parse tree, tag 'TO'\n\tpt_TO = re_pt_TO.findall(text)\n\tpt_TO_lc = [ s.lower() for s in pt_TO ]\n\t\n\t# compile counts and most frequent prepositions\n\tcount_total = len(pt_IN_lc) + len(pt_TO_lc)\n\tfd_TO_IN = FreqDist(pt_TO_lc + pt_IN_lc)\n\tcount_unique = len(fd_TO_IN)\n\tmost_common_3 = fd_TO_IN.most_common(3)\n\t\n\t# return results and frequency distribution\n\treturn count_total, count_unique, most_common_3, fd_TO_IN","def test_comments(self):\n\n comment_str = \"# This is a comment\\n# This is another comment\"\n doc = parser.parse(comment_str)\n\n self.assertEqual(len(doc.children()), 2)","def count_entity_doc(document):\n count = {}\n for line in document[1:]:\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\n if entity_type in count:\n count[entity_type] += 1\n else:\n count[entity_type] = 1\n return count","def wcount(lines,topn=10):\n doc = urlopen(lines)\n docstr = doc.read()\n doc.close()\n txt = docstr.decode() #获得文档，命名为txt\n \n turn1=txt.maketrans('~`!@#$%^&*)(}{][:;\"?/\\|<>,.=+_\"',' ') #将特殊符号替换为空格\n txt=txt.translate(turn1)\n turn2=txt.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz') #将大写转化为小写\n txt=txt.translate(turn2)\n txt=txt.split()\n \n ans={} #建立一个列表，储存得到的数据\n for i in txt:\n ans[i] = ans.get(i, 0)+1 #对单词进行数数\n ans_list=sorted(ans.items(),key=lambda x:x[1],reverse=True) #对得到的数据根据出现次数大小降序排列,用list便于操作。\n ans_dict=dict(ans_list)\n \n if topn <= len(ans): #如果topn小于字典长度，输出topn个值，否则输出全部\n for (i,v) in ans_list[:topn]:\n print(i,' ',v)\n else:\n for (i,v) in ans_dict.items():\n print(i,' ',v)","def getNumberTerms(content): \n return Counter(getTerms(content))","def test_task_count_tags(self):\r\n tasks.count_tags()\r\n\r\n stat = StatBookmark.query.first()\r\n self.assertEqual(stat.attrib, stats.TAG_CT)\r\n self.assertEqual(stat.data, 4)","def codon_counts(self):\n # Removing 5' UTR and 3' UTR sequences\n sequence = self.sequence.replace(self.five_prime_utr_sequence, \"\").replace(self.three_prime_utr_sequence, \"\")\n return len(sequence) / 3","def analyzeCppCode(self, sourceFile):\n numLines = 0 # Number of lines of code\n numComments = 0 # Number of comments in the code\n\n f=self.openFile(sourceFile)\n for line in f:\n numLines += 1;\n loc = 0\n while (loc != -1): #count the # of times the '/*' characters appears\n loc = line.find(\"#\", loc)\n if (loc != -1):\n loc += 1\n numComments += 1\n \n loc = 0\n loc = line.find('//', loc) #count the # of times the '//' characters appears\n if (loc != -1):\n loc += 1\n numComments += 1\n \n f.close()\n return numLines, numComments","def wcount(lines, topn):\n l = re.split('[.,:-^(){}?\"\\n\\r!;\\' /&#*@_]',lines)#将lines里的单词分隔，放入列表l\n statistics = {}\n for i in l:\n if i not in statistics:\n statistics[i] = 1\n else:\n statistics[i] = statistics[i] + 1 #用字典统计单词出现的次数\n lis = sorted(statistics.items(),key = lambda x:x[1],reverse = True) #将单词出现的次数由大到小排序\n if topn > len(lis):#超出单词种类数，输出全部结果\n dic = dict(lis[1:]) \n else: #否则输出想要的个数\n dic = dict(lis[1:topn+1])\n for k in dic:\n print(str(k) + \" \" + str(dic[k])) #将字典以一列key，一列对应的value的形式输出\n pass","def get_number_of_comments(self):\n return self._performed_actions[WRITE_COMMENT]","def _readComments(self): \n self.NSCOML = nappy.utils.text_parser.readItemFromLine(self.file.readline(), int)\n self._readSpecialComments()\n self.NNCOML = nappy.utils.text_parser.readItemFromLine(self.file.readline(), int)\n self._readNormalComments()","def wcount(lines, topn=10):\n '''a=[]\n for line in lines:\n word = line.strip()\n a.append(word)\n def histogram(s):\n d = dict()\n for i in s:\n if i in d:\n d[i]+=1\n else:\n d[i]=1\n return d'''\n def process_line(lines,diction):\n lines = lines.replace('-',' ')\n for word in lines.split():\n word=word.strip(string.punctuation+string.whitespace)\n word.lower()\n diction[word]=diction.get(word,0)+1\n\n def process_file(lines):\n diction = {}\n process_line(lines,diction)\n return diction\n diction=process_file(lines)\n x=list(diction.values())\n x.sort()\n x.reverse()\n count = 0\n for i in range(topn):\n for key in list(diction.keys()):\n if diction[key]==x[i] and count<topn:\n print(\"%s %d\"%(key,diction[key]))\n count +=1\n del diction[key]\n pass","def totaled_tbr_no_lgtm(cc, sql_time_specification):\n cc.execute(\"\"\"SELECT git_commit.review_url, git_commit.timestamp,\n git_commit.subject, git_commit.hash\n FROM review\n INNER JOIN git_commit\n ON review.review_url = git_commit.review_url\n INNER JOIN commit_people\n ON commit_people.git_commit_hash = git_commit.hash\n LEFT JOIN (\n SELECT review_url, COUNT(*) AS c\n FROM review_people\n WHERE type = 'lgtm'\n GROUP BY review_url) lgtm_count\n ON review.review_url = lgtm_count.review_url\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\n AND commit_people.type = 'author' AND %s\"\"\" % sql_time_specification)\n result = cc.fetchall()\n count = len(result)\n formatted_data = []\n for data in result:\n subject = data[2]\n formatted_data.append([data[0], data[1].strftime(\"%Y-%m-%d %H:%M:%S\"),\n subject.replace('-', ' '), data[3]])\n results = sorted(formatted_data, key=lambda x: x[1], reverse=True)\n return count, results","def count(self, sub) -> int:\n pass","def resultCounter(detections):\n counter = 0\n for attribute, value in classIterator(detections):\n if 'crease' in attribute:\n counter += len(value)\n return counter","def _readNormalComments(self):\n self.NCOM = self._readLines(self.NNCOML)\n return self.NCOM","def analyze_reviews(reviews):\n\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\n\n print 'len(good_reviews)=%s' % len(good_reviews)\n print 'len(bad_reviews)=%s' % len(bad_reviews)\n\n m = re.compile('\\d')\n\n english_stop_words=stopwords.words('english')\n\n\n def tokenize(text):\n tokens=nltk.word_tokenize(text)\n # strip out trailing puncutation\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\n\n # lower case\n tokens = [token.lower() for token in tokens]\n\n # Take only relativly long characters\n tokens = [token for token in tokens if len(token)>=3]\n\n # remove words with numbers/digits\n tokens = [token for token in tokens if m.search(token) is None]\n\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\n tokens = [token for token in tokens if token not in english_stop_words]\n return tokens\n\n good_tokens_list = []\n for i,review in good_reviews.iterrows():\n text=review['rs_review_text']\n good_tokens_list.append(tokenize(text))\n\n bad_tokens_list = []\n for i,review in bad_reviews.iterrows():\n text=review['rs_review_text']\n bad_tokens_list.append(tokenize(text))\n\n all_words=Counter()\n for tokens in good_tokens_list + bad_tokens_list:\n for token in tokens:\n all_words[token]+=1\n\n most_common=all_words.most_common(2000)\n most_common=zip(*most_common)[0]\n\n print 'most_common_words = ',most_common[-20:]\n\n def document_features(tokens):\n return {word:word in tokens for word in most_common}\n\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\n\n train_set = good_set + bad_set\n random.shuffle(train_set) # dunno if this is necessary\n\n classifier = nltk.NaiveBayesClassifier.train(train_set)\n\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\n\n classifier.show_most_informative_features(300)\n\n return classifier","def ngram_detection(self, min_topic_count=5, min_text_id_count=4):\n\n for text_id, text in self.texts.items():\n # single-word topics act a bit different (no zips or comprehensions)\n # store data in self.topics, not zip_grams\n for word in text['doc']:\n word_lemma = word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_\n\n if {word.text}.intersection(self.punct) or {word.lemma_}.intersection(self.stop_words):\n continue\n\n if not (word.pos in self.nouns or word.ent_type in self.entities):\n continue\n\n if word_lemma in self.topics:\n self.topics[word_lemma][\"count\"] += 1\n self.topics[word_lemma][\"textIDs\"] |= {text_id}\n self.topics[word_lemma][\"verbatims\"] |= {word.text.lower()}\n else:\n self.topics[word_lemma] = {\"name\": word_lemma,\n \"count\": 1,\n \"textIDs\": {text_id},\n \"verbatims\": {word.text.lower()},\n \"subtopics\": {}}\n\n # Populate self.ngrams and self.topics\n for text_id, text in self.texts.items():\n doc = text['doc']\n\n # Find pentagrams - ngrams with 5 words\n for ngram in zip(doc, doc[1:], doc[2:], doc[3:], doc[4:]):\n self._ngram_counter(ngram, 5, text_id, doc)\n\n # Find pentagrams - ngrams with 4 words\n for ngram in zip(doc, doc[1:], doc[2:], doc[3:]):\n self._ngram_counter(ngram, 4, text_id, doc)\n\n for ngram in zip(doc, doc[1:], doc[2:]):\n self._ngram_counter(ngram, 3, text_id, doc)\n\n for ngram in zip(doc, doc[1:]):\n self._ngram_counter(ngram, 2, text_id, doc)\n\n\n # Add text_id_count (the number of texts that the topic occurs in; so a topic might occur 50 times,\n # but it's only mentioned in 3 different texts, we'd show 3.\n for _, topic in self.topics.items():\n topic['textIDCount'] = len(topic['textIDs'])\n for _, ngram in self.ngrams.items():\n ngram['textIDCount'] = len(ngram['textIDs'])\n\n # Eliminate rarely occurring topics and ngrams.\n self.topics = {k: v for k, v in self.topics.items() if\n v['textIDCount'] >= min_text_id_count and v['count'] >= min_topic_count}\n self.ngrams = {k: v for k, v in self.ngrams.items() if\n v['textIDCount'] >= min_text_id_count}\n\n # Loop through each ngram pair: outer loop is all ngrams, inner loop is all ngrams\n for ngram_lemma, ngram in self.ngrams.items():\n for ngram_plus_lemma, ngram_plus in self.ngrams.items():\n # only stay in this loop if the inner ngram is one word longer than the outer loop and if the\n # inner loop lemma contains the outer group lemma (avoid partial word matches like man in woman)\n # r'\\b' + ngram_lemma + r'\\b' --> does the ngram lemma fit in ngram_plus lemma (\\b is word boundary)\n if ngram['n'] + 1 != ngram_plus['n']:\n continue\n\n if not re.search(r'\\b' + ngram_lemma + r'\\b', ngram_plus_lemma):\n continue\n\n # Is the absolute count of occurrences and the count of text_id occurrences both big enough to use it\n # instead of the other loop?\n if ngram_plus['count'] + 3 >= ngram['count'] and ngram_plus['textIDCount'] + 3 >= ngram['textIDCount']:\n # TODO: Is this the right action (deleting shorter, but not much more explanatory) phrase?\n # TODO: Is this enough? Or will I end up double explaining things sometimes?\n ngram['count'] = -1\n\n # Eliminate newly demoted items\n self.ngrams = {ngram_lemma: ngram for ngram_lemma, ngram in self.ngrams.items() if ngram['count'] > 0}","def count_tokens(txt_to_tokenise_and_count):\n\n txt_tokens = nltk.word_tokenize(txt_to_tokenise_and_count) \n counts = Counter(txt_tokens)\n\n print (counts.most_common(10))\n return counts","def counts(page):\n # Read the page into the string s\n s = page.read()\n # Count different brackets\n print(f\"( count = {s.count('(')}\")\n print(f\") count = {s.count(')')}\")\n print(f\"[ count = {s.count('[')}\")\n print(f\"] count = {s.count(']')}\")\n print(\"{\", f\"count = {s.count('{')}\")\n print(\"}\", f\"count = {s.count('}')}\")\n print(f\"< count = {s.count('<')}\")\n print(f\"> count = {s.count('>')}\")\n # Print if brackets are balanced or not.\n if s.count('(') == s.count(')'):\n print(\"( and ) are balanced.\")\n else:\n print(\"( and ) are not balanced.\")\n if s.count('[') == s.count(']'):\n print(\"[ and ] are balanced.\")\n else:\n print(\"[ and ] are not balanced.\")\n if s.count('{') == s.count('}'):\n print(\"{ and } are balanced.\")\n else:\n print(\"{ and } are not balanced.\")\n if s.count('<') == s.count('>'):\n print(\"< and > are balanced.\")\n else:\n print(\"< and > are not balanced.\")","def count_questions(txt):\n count = 0\n for c in txt:\n if c == '?':\n count += 1\n return count","def count_cop(self, infile):\n n_cop = 0\n dgs_in = self._file_handler.file_to_dg_list(infile)\n for dg in dgs_in:\n if dg.has_cop_deprel():\n n_cop += 1\n return n_cop, len(dgs_in)","def word_count(self, document):\n start_time = time.time()\n dictionary = dict()\n counter = defaultdict(int)\n for line in document.splitlines():\n for word in line.split():\n if word not in PUNCTUATION_MARK:\n counter[word] += 1\n for word, cnt in sorted(counter.items(), key=lambda x: (-x[1], x[0])):\n dictionary[word] = cnt\n self.log.info(\"Duration count dictionary: {duration}\".format(duration=float(time.time() - start_time)))\n return dictionary","def count(self, ngram, options):\n return len(self.find_docs(ngram, options))","def sentence_count(self):\n count = 0\n for line in self.lines:\n if '.' in line:\n count += 1\n if count == 0:\n count = 1\n return count\n #return line.count('.')\n #else:\n #return 1","def _ngram_counter(self, ngram, ngram_length, text_id, doc):\n\n # Only process this ngram is it's punctuation-free (punct --> token.dep == ss.punct) and the 1st / last\n # words are not stopwords (line mechanics: make a set, look for an intersection with another set)\n if ([word for word in ngram if word.dep == ss.punct] or\n {ngram[0].lemma_, ngram[ngram_length - 1].lemma_}.intersection(self.stop_words)):\n return\n\n # Only keep this ngram is it has 1+ nouns in it\n if len([word for word in ngram if word.pos in self.nouns or word.ent_type in self.entities]) == 0:\n return\n\n ngram_lemma = ' '.join([word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_ for word in ngram])\n verbatim = ' '.join([word.text.lower() for word in ngram])\n\n # add the ngram_lemma to each proximal topic\n window_start = 0 if ngram[0].i < 7 else ngram[0].i - 7\n window_end = len(doc) if ngram[0].i + 7 + ngram_length > len(doc) else ngram[0].i + 7 + ngram_length\n for word in doc[window_start:window_end]:\n if word.lemma_ in self.topics: # is this a topic we're tracking?\n # Yes. So let's add it to the subtopic dictionary (with an occurrence count)\n if ngram_lemma in self.topics[word.lemma_]['subtopics']:\n self.topics[word.lemma_]['subtopics'][ngram_lemma].add(text_id)\n else:\n self.topics[word.lemma_]['subtopics'][ngram_lemma] = {text_id}\n\n # TODO: Do I even need self.ngrams anymore? Maybe track everything in the subtopics area?\n # Keep it! And it's not the first time we've found it.\n if ngram_lemma in self.ngrams:\n self.ngrams[ngram_lemma][\"count\"] += 1\n self.ngrams[ngram_lemma][\"textIDs\"] |= {text_id}\n self.ngrams[ngram_lemma][\"verbatims\"] |= {verbatim}\n # Keep it! This is the 1st instance.\n else:\n self.ngrams[ngram_lemma] = {\"name\": ngram_lemma,\n \"count\": 1,\n \"textIDs\": {text_id},\n \"n\": ngram_length,\n \"verbatims\": {verbatim},\n \"topic_lemmas\": []}","def utr3_motif_counts(self, pattern):\n return len(re.findall(pattern.upper(), self.three_prime_utr_sequence.upper()))","def sorter(r):\n\n ans = len(r.description)\n if additional:\n for rr in r.monkey_additional:\n ans += len(rr)\n return ans","def get_most_extreme_comments():\n pass","def count_posTags(self):\n pos_list = ['NUM', 'AUX', 'ADV', 'DET', 'NOUN', 'ADP', 'ADJ', 'NOUN', 'VERB', 'NOUN', 'PUNCT', 'PUNCT']\n result = count_posTags(pos_list)\n self.assertEqual(result, (3, 1, 1, 1, 2))"],"string":"[\n \"def count_comments(self):\\n return self.run_query(f\\\"count({self.r}/comment)\\\")\",\n \"def calc_comments(self):\\n for comment in self.pull_request.get_comments():\\n self._users.add(comment.user.login)\\n lowercase_body = comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_comments += 1\\n if comment.body is not None:\\n self.len_comments += len(comment.body)\\n for reaction in comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.comment_reactions += 1\",\n \"def get_indicators_and_clean_comments(df):\\n # Count number of \\\\n\\n df[\\\"ant_slash_n\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\n\\\", x))\\n # Get length in words and characters\\n df[\\\"raw_word_len\\\"] = df[\\\"comment_text\\\"].apply(lambda x: len(x.split()))\\n df[\\\"raw_char_len\\\"] = df[\\\"comment_text\\\"].apply(lambda x: len(x))\\n # Check number of upper case, if you're angry you may write in upper case\\n df[\\\"nb_upper\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[A-Z]\\\", x))\\n # Number of F words - f..k contains folk, fork,\\n df[\\\"nb_fk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[Ff]\\\\S{2}[Kk]\\\", x))\\n # Number of S word\\n df[\\\"nb_sk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[Ss]\\\\S{2}[Kk]\\\", x))\\n # Number of D words\\n df[\\\"nb_dk\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"[dD]ick\\\", x))\\n # Number of occurence of You, insulting someone usually needs someone called : you\\n df[\\\"nb_you\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\W[Yy]ou\\\\W\\\", x))\\n # Just to check you really refered to my mother ;-)\\n df[\\\"nb_mother\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\Wmother\\\\W\\\", x))\\n # Just checking for toxic 19th century vocabulary\\n df[\\\"nb_ng\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\Wnigger\\\\W\\\", x))\\n # Some Sentences start with a <:> so it may help\\n df[\\\"start_with_columns\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"^\\\\:+\\\", x))\\n # Check for time stamp\\n df[\\\"has_timestamp\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\d{2}|:\\\\d{2}\\\", x))\\n # Check for dates 18:44, 8 December 2010\\n df[\\\"has_date_long\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\D\\\\d{2}:\\\\d{2}, \\\\d{1,2} \\\\w+ \\\\d{4}\\\", x))\\n # Check for date short 8 December 2010\\n df[\\\"has_date_short\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\D\\\\d{1,2} \\\\w+ \\\\d{4}\\\", x))\\n # Check for http links\\n df[\\\"has_http\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"http[s]{0,1}://\\\\S+\\\", x))\\n # check for mail\\n df[\\\"has_mail\\\"] = df[\\\"comment_text\\\"].apply(\\n lambda x: count_regexp_occ(r'[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\\\\.[a-zA-Z0-9-.]+', x)\\n )\\n # Looking for words surrounded by == word == or \\\"\\\"\\\"\\\" word \\\"\\\"\\\"\\\"\\n df[\\\"has_emphasize_equal\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\={2}.+\\\\={2}\\\", x))\\n df[\\\"has_emphasize_quotes\\\"] = df[\\\"comment_text\\\"].apply(lambda x: count_regexp_occ(r\\\"\\\\\\\"{4}\\\\S+\\\\\\\"{4}\\\", x))\\n\\n # Now clean comments\\n df[\\\"clean_comment\\\"] = df[\\\"comment_text\\\"].apply(lambda x: prepare_for_char_n_gram(x))\\n\\n # Get the new length in words and characters\\n df[\\\"clean_word_len\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(x.split()))\\n df[\\\"clean_char_len\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(x))\\n # Number of different characters used in a comment\\n # Using the f word only will reduce the number of letters required in the comment\\n df[\\\"clean_chars\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(set(x)))\\n df[\\\"clean_chars_ratio\\\"] = df[\\\"clean_comment\\\"].apply(lambda x: len(set(x))) / df[\\\"clean_comment\\\"].apply(\\n lambda x: 1 + min(99, len(x)))\",\n \"def count_reddit_comments_ngram_strs(year, month, n):\\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\\n return Counter(itertools.chain.from_iterable(ngram_strs))\",\n \"def sent_count(comment):\\n return comment.__len__()\",\n \"def getCommentCount(self, source):\\n commentStart = source.find('item?id=')\\n commentCountStart = source.find('>', commentStart) + 1\\n commentEnd = source.find('</a>', commentStart)\\n commentCountString = source[commentCountStart:commentEnd]\\n if commentCountString == \\\"discuss\\\":\\n return 0\\n elif commentCountString == \\\"\\\":\\n return 0\\n else:\\n commentCountString = commentCountString.split(' ')[0]\\n return int(commentCountString)\",\n \"def do_get_comment_count(parser, token):\\r\\n error_message = \\\"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\\\" % (token.contents.split()[0], token.contents.split()[0])\\r\\n try:\\r\\n split = token.split_contents()\\r\\n except ValueError:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n if split[1] != 'for' or split[3] != 'as':\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n return ThreadedCommentCountNode(split[2], split[4])\",\n \"def count_regexp():\\r\\n # Here's an example regular expression that roughly matches a valid email address.\\r\\n # The ones you write below should be shorter than this\\r\\n email = re.compile(\\\"[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+\\\\.[a-zA-Z]{2,5}\\\")\\r\\n\\r\\n ###### Write below #########\\r\\n subheading = re.compile(\\\"\\\\=\\\\=+.*\\\\=\\\\=+\\\")\\r\\n link_to_subheading = re.compile(\\\"\\\\[\\\\[[\\\\w\\\\'*\\\\-*\\\\:*\\\\(*\\\\)*\\\\_*\\\\s*]+[#][\\\\s*\\\\w\\\\\\\\'*\\\\-*\\\\:*\\\\(*\\\\)*\\\\_*s*]+\\\\|*\\\")\\r\\n doi_citation = re.compile(\\\"\\\\{\\\\{[c][ite](?!{{).*[dD][oO][iI]\\\\s*[:|,=\\\\/]*\\\\s*[0-9]+\\\\.[0-9]+.*\\\\}\\\\}\\\")\\r\\n ###### End of your work #########\\r\\n\\r\\n patterns = {\\r\\n \\\"emails\\\": email,\\r\\n \\\"subheadings\\\": subheading,\\r\\n \\\"links to subheadings\\\": link_to_subheading,\\r\\n \\\"citations with DOI numbers\\\": doi_citation,\\r\\n }\\r\\n\\r\\n with open(RAW_DUMP_XML, encoding=\\\"utf-8\\\") as f:\\r\\n dump_text = f.read()\\r\\n for name, pattern in patterns.items():\\r\\n if pattern is None:\\r\\n continue\\r\\n matches = pattern.findall(dump_text)\\r\\n count = len(matches)\\r\\n\\r\\n example_matches = [matches[i * (count // 5)] for i in range(5)]\\r\\n\\r\\n print(\\\"Found {} occurences of {}\\\".format(count, name))\\r\\n print(\\\"Here are examples:\\\")\\r\\n print(\\\"\\\\n\\\".join(example_matches))\\r\\n print(\\\"\\\\n\\\")\",\n \"def parseCommentsTotalCount(data):\\n p = re.compile(r\\\"\\\\d+ Reviews\\\")\\n\\n for line in data:\\n line = line.replace(\\\",\\\", \\\"\\\")\\n match = re.search(p, line)\\n if match != None:\\n getNmbr = match.group().split(\\\" \\\")\\n return int(getNmbr[0])\\n return -1\",\n \"def analyze_comments():\\n\\n scores = {} # {docket_id: [comment1_score, comment2_score, ...]}\\n positive_counts = {} # {docket_id: num_positive_comments}\\n neutral_counts = {} # {docket_id: num_neutral_comments}\\n negative_counts = {} # {docket_id: num_negative_comments}\\n\\n comment_sentiments = {} # {comment_id: sentiment} to write to database\\n comment_complexity = {} # {comment_id: complexity} to write to database\\n\\n for comment in lib.mongo.retrieve_comments(1000):\\n docket_id = comment['docketId']\\n comment_id = comment['documentId']\\n text = comment.get('commentText', '').strip()\\n\\n # Fill in the 'sentiment' field of this comment.\\n if 'sentiment' in comment:\\n score = comment['sentiment']\\n else:\\n score = lib.analyze_text.getSentiment(text)\\n comment_sentiments[comment_id] = score\\n\\n logging.info('docket %s, comment %s: sentiment %s (%r)' %\\n (docket_id, comment_id, score, text[:20]))\\n\\n # Fill in the 'complexity' field of this comment.\\n if 'complexity' not in comment:\\n comment_complexity[comment_id] = lib.analyze_text.get_complexity(text)\\n\\n # Aggregate the sentiment scores for each docket.\\n scores.setdefault(docket_id, []).append(score)\\n counts = positive_counts if score > 0 else (\\n negative_counts if score < 0 else neutral_counts)\\n counts[docket_id] = counts.get(docket_id, 0) + 1\\n\\n if len(comment_sentiments) >= 10:\\n logging.info('updating %d comments sentiment...' % len(comment_sentiments))\\n lib.mongo.update_comments('sentiment', comment_sentiments)\\n comment_sentiments = {}\\n\\n if len(comment_complexity) >= 10:\\n logging.info('updating %d comments complexity...' % len(comment_complexity))\\n lib.mongo.update_comments('complexity', comment_complexity)\\n comment_complexity = {}\\n\\n logging.info('updating %d comments...' % len(comment_sentiments))\\n lib.mongo.update_comments('sentiment', comment_sentiments)\\n lib.mongo.update_comments('complexity', comment_complexity)\\n logging.info('done!')\\n\\n docket_sentiments = {} # {docket_id: sentiment} to write to database\\n\\n for docket in lib.mongo.dockets.find():\\n docket_id = docket.get('docketId', '')\\n positive_count = positive_counts.get(docket_id, 0)\\n neutral_count = neutral_counts.get(docket_id, 0)\\n negative_count = negative_counts.get(docket_id, 0)\\n rating = compute_rating(positive_count, neutral_count, negative_count)\\n logging.info('docket %s: %d positive, %d neutral, %d negative - %s' %\\n (docket_id, positive_count, neutral_count, negative_count,\\n rating))\\n\\n docket_sentiments[docket_id] = {\\n 'positive': positive_count,\\n 'neutral': neutral_count,\\n 'negative': negative_count,\\n 'rating': rating\\n }\\n\\n logging.info('updating %d dockets...' % len(docket_sentiments))\\n lib.mongo.update_dockets('sentiment', docket_sentiments)\\n logging.info('done!')\",\n \"def count():\",\n \"def _get_token_cnts(self, doc, doc_type):\\n tokenized_doc = self.nlp(doc)\\n self.stat_dict[doc_type][0].append(len([s for s in tokenized_doc.sents]))\\n doc_len = len([t for t in tokenized_doc])\\n self.stat_dict[doc_type][1].append(doc_len)\\n if doc_len < 50 and doc_type == \\\"answer\\\":\\n print(\\\"Document less than 50 tokens:\\\", url)\",\n \"def generate_reddit_comments_ngram_counts(\\n year, month, n, root=paths.DEFAULT_REDDIT_NGRAMS_DATA):\\n ngram_path = paths.get_reddit_ngrams_local(year, month, n, root=root)\\n if os.path.isfile(ngram_path):\\n logging.warning(\\\"Cache exists for all requested n-grams.\\\"\\n \\\"Skipping %04d-%02d\\\\n\\\" % (year, month))\\n return False\\n\\n counts = count_reddit_comments_ngram_strs(year, month, n)\\n with gzip.GzipFile(ngram_path, 'wb') as fh:\\n for k, v in counts.items():\\n fh.write(\\\"{}\\\\t{}\\\\n\\\".format(k, v).encode())\\n return True\",\n \"def get_comment_count(self, postid=0, blogid=1):\\n \\n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)\",\n \"def get_comments_count(self, thread_uid: str) -> int:\\n pass\",\n \"def wcount(lines, topn=10):\\n my_socket = urllib.request.urlopen(lines)\\n dta = my_socket.read().decode()\\n my_socket.close()\\n #get the text from url\\n \\n s=dta.replace(',',' ')\\n b=s.replace('.',' ')\\n c=b.replace('?',' ')\\n d=c.replace('_',' ')\\n e=d.replace(']',' ')\\n f=e.replace('[',' ')\\n g=f.replace('*',' ')\\n h=g.replace('%',' ')\\n i=h.replace('!',' ')\\n j=i.replace('\\\"',' ')\\n k=j.replace(':',' ')\\n l=k.replace(';',' ')\\n m=l.replace('(',' ')\\n n=m.replace(')',' ')\\n o=n.replace('-',' ')\\n p=o.replace('_',' ')\\n q=p.replace('/','')\\n q=q.lower()\\n x=q.split()\\n y=set(x)\\n #Processed documents are converted into ordered strings\\n \\n lst={}\\n for i in y:\\n num=x.count(i)\\n lst[i]=num\\n \\n r=list(lst.values())\\n r.sort(reverse=True)\\n for i in r[:topn]:\\n print(list(lst.keys())[list(lst.values()).index(i)].ljust(15)+\\\" \\\"+str(i))\\n \\n pass\",\n \"def getCounter(self):\\n word_count, noun_word_count = Counter(), Counter()\\n word_rating, noun_word_rating = defaultdict(list), defaultdict(list)\\n docs = self.nlp.pipe(\\n self.docs, n_process=1, disable=self.disablelayers)\\n \\n\\n for index, doc in enumerate(docs):\\n for token in doc:\\n if not token.is_stop and not token.is_punct and token.pos_ in self.pos:\\n if token.pos_ == 'PROPN':\\n word_count[token.lemma_] += 1\\n word_rating[token.lemma_].append(self.ratings[index])\\n else:\\n noun_word_count[token.lemma_] += 1\\n noun_word_rating[token.lemma_].append(self.ratings[index])\\n\\n # if 0<=proper nouns<=5 found, add regular nouns\\n if not word_count or len(word_count) <= 5:\\n word_count += noun_word_count\\n word_rating = {**word_rating, **noun_word_rating}\\n \\n word_color = {word: self.getColor(\\n ratings)[1] for word, ratings in word_rating.items()}\\n word_sentiment = {word: self.getColor(\\n ratings)[0] for word, ratings in word_rating.items()}\\n\\n return word_count, word_color, word_sentiment\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def comment_count(self):\\n return self.comments.filter_by(state=0).count()\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = {} # might want to use defaultdict or Counter instead\\n self.bigramcounts = {} \\n self.trigramcounts = {} \\n\\n self.total = 2\\n ##Your code here\\n\\n for sentence in corpus:\\n temp_1 = get_ngrams(sentence,1)\\n temp_2 = get_ngrams(sentence,2)\\n temp_3 = get_ngrams(sentence,3)\\n for i in range(len(temp_1)):\\n if temp_1[i] in self.unigramcounts:\\n self.unigramcounts[temp_1[i]] += 1\\n else:\\n self.unigramcounts[temp_1[i]] = 1\\n self.total += 1\\n\\n for i in range(len(temp_2)):\\n if temp_2[i] in self.bigramcounts:\\n self.bigramcounts[temp_2[i]] += 1\\n else:\\n self.bigramcounts[temp_2[i]] = 1\\n\\n for i in range(len(temp_3)):\\n if temp_3[i] in self.trigramcounts:\\n self.trigramcounts[temp_3[i]] += 1\\n else:\\n self.trigramcounts[temp_3[i]] = 1\\n return\",\n \"def commentaires(file_name_c):\\n com = subprocess.run([\\\"grep\\\", \\\"eleves_bis/\\\" + file_name_c, \\\"-e\\\", '/\\\\*'], stdout=subprocess.PIPE)\\n return com.stdout.decode().count(\\\"\\\\n\\\")\",\n \"def get_matches_count():\\n\\n return ''\\n \\\"\\\"\\\"\\n TODO: count matches\\n dtr5app_flag.sender\\n dtr5app_flag.receiver\\n dtr5app_flag.flag\\n \\\"\\\"\\\"\",\n \"def count_ngrams(self, corpus):\\n \\n self.unigramcounts = defaultdict(int)\\n self.bigramcounts = defaultdict(int)\\n self.trigramcounts = defaultdict(int)\\n\\n self.sentence_counts = 0\\n self.word_count = 0\\n\\n for line in corpus:\\n sequence = line\\n self.sentence_counts +=1\\n\\n unigrams = get_ngrams(sequence, n=1)\\n for gram in unigrams:\\n self.word_count += 1\\n self.unigramcounts[gram] +=1\\n\\n bigrams = get_ngrams(sequence, n=2)\\n for gram in bigrams:\\n self.bigramcounts[gram] +=1\\n\\n trigrams = get_ngrams(sequence, n=3)\\n for gram in trigrams:\\n self.trigramcounts[gram] +=1\\n\\n #self.unigramcounts[('START')] = self.sentence_counts *2\\n self.bigramcounts[('START', 'START')] = self.sentence_counts\\n\\n #return self\",\n \"def Counting(seq):\\n\\n #Scan the sequence, looking for motifs\\n\\n counting = {k: 0 for k in MOT} # Initialize the counting dictionary.\\n # Scan all the motifs and find them in the sequence\\n for motif in MOT:\\n if len(seq) > len(motif): # Check if the sequence is longer than the motif itself.\\n for i in range(len(seq)-len(motif)+1):\\n if i == 0: # In case the motif is in the beginning of the sequence\\n # print(\\\"start: \\\" + seq[i:i+len(motif)] + \\\" next nuc: \\\" + seq[i+len(motif)])\\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0]: # Check if the next nucleotide is in not part of the motif.\\n counting[motif] += 1\\n elif i == len(seq)-len(motif): # In case the motif is in the end of the sequence\\n \\n if seq[i:i+len(motif)] == motif and seq[i-1] != motif[0]: # Check if the previuos nucleotide is in not part of the motif.\\n counting[motif] += 1\\n elif len(seq) > len(motif)+1: # In case the motif is in the middle of the sequence.\\n # Check if the motif is not part of another motif (e.g. TT is in TTT).\\n\\n if seq[i:i+len(motif)] == motif and seq[i+len(motif)] != motif[0] and seq[i-1] != motif[0]:\\n counting[motif] += 1\\n for nuc_nr in NUC_NR:\\n counting[nuc_nr+\\\"_NR\\\"] = seq.count(nuc_nr)\\n\\n return counting\",\n \"async def scrape_comments(self):\\n\\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\\n\\n comment_count = 0\\n async for comment in subreddit_origin.comments(limit=self.limit):\\n if self.memory.contains(comment.id):\\n continue\\n\\n self.memory.add(comment.id)\\n\\n # Parse Comment\\n comment = self.parse_comment(comment)\\n\\n # Save in Pub/Sub\\n if self.enable_publish:\\n self.publish(comment)\\n\\n comment_count += 1\\n\\n return comment_count\",\n \"def count_other_citations(pmid,linkname):\\n link = f\\\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\\\"\\n sleep(0.3)\\n page = requests.get(link).text\\n soup = BeautifulSoup(page, 'html.parser') \\n count = int(soup.find_all(attrs={\\\"name\\\": \\\"ncbi_resultcount\\\"})[0][\\\"content\\\"])\\n return(count)\",\n \"def count_comments(self):\\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\\n count = comments.count()\\n return count\",\n \"def main ():\\n fio = FileIo(\\\"../input2.txt\\\")\\n text = fio.getInput()\\n p = re.compile(r'#?\\\\d[\\\\s\\\\.]?[\\\\s]?')\\n out = filter(None, p.split(text))\\n #print out[2]\\n #print len(out)\\n wc = 0\\n\\n for s in out:\\n text = nltk.word_tokenize(s)\\n wc += wordCount( text )\\n print wc\",\n \"def do_get_free_comment_count(parser, token):\\r\\n error_message = \\\"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\\\" % (token.contents.split()[0], token.contents.split()[0])\\r\\n try:\\r\\n split = token.split_contents()\\r\\n except ValueError:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n if split[1] != 'for' or split[3] != 'as':\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n return FreeThreadedCommentCountNode(split[2], split[4])\",\n \"def text_cond_count(self, condition):\\n res = 0\\n for intv in self:\\n if condition(intv._text):\\n res += 1\\n return res\",\n \"def do_get_user_comment_count(parser, token):\\r\\n error_message = \\\"%r tag must be of format {%% %r for OBJECT as CONTEXT_VARIABLE %%}\\\" % (token.contents.split()[0], token.contents.split()[0])\\r\\n try:\\r\\n split = token.split_contents()\\r\\n except ValueError:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n if len(split) != 5:\\r\\n raise template.TemplateSyntaxError, error_message\\r\\n return UserCommentCountNode(split[2], split[4])\",\n \"def comments_count(self) -> int:\\n return pulumi.get(self, \\\"comments_count\\\")\",\n \"def getNumberOfComments(node, catalog=None):\\n if catalog is None:\\n catalog = getToolByName(node, 'portal_catalog')\\n return len(catalog(\\n object_provides=IComment.__identifier__,\\n path='/'.join(node.getPhysicalPath())))\",\n \"def count_relation_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\\n for relation in relation_types:\\n if relation in count:\\n count[relation] += 1\\n else:\\n count[relation] = 1\\n return count\",\n \"def count_reads(titer):\\n c = Counter()\\n for template in titer:\\n for mate in template:\\n for cat in (mate['cat_list'] or ['nocat']):\\n c[cat] += 1\\n return c\",\n \"def counts(self, regex = \\\"\\\\w+\\\"): \\n tokenizer = RegexpTokenizer(r'{}'.format(regex))\\n count = []\\n for i in tqdm(self.text):\\n count.append(len(tokenizer.tokenize(i)))\\n return count\",\n \"def findNoteCounts(self, authenticationToken, filter, withTrash):\\r\\n pass\",\n \"def count_verbs(text):\\n\\n\\t# ... in the parse trees\\n\\tpt_VB_ = len(re_pt_VB_.findall(text))\\t# VB* all forms\\n\\tpt_VBb = len(re_pt_VBb.findall(text))\\t# VB base form\\n\\tpt_VBD = len(re_pt_VBD.findall(text))\\t# VBD past tense\\n\\tpt_VBG = len(re_pt_VBG.findall(text))\\t# VBG gerund or past participle\\n\\tpt_VBN = len(re_pt_VBN.findall(text))\\t# VBN past participle\\n\\tpt_VBP = len(re_pt_VBP.findall(text))\\t# VBP present tense, except 3rd Per Sing\\n\\tpt_VBZ = len(re_pt_VBZ.findall(text))\\t# VBZ present tense, 3rd Person Singular\\n\\n\\t# ... in the tagged sentences\\n\\tts_VB_ = len(re_ts_VB_.findall(text))\\t# VB* all forms\\n\\tts_VBb = len(re_ts_VBb.findall(text))\\t# VB base form\\n\\tts_VBD = len(re_ts_VBD.findall(text))\\t# VBD past tense\\n\\tts_VBG = len(re_ts_VBG.findall(text))\\t# VBG gerund or past participle\\n\\tts_VBN = len(re_ts_VBN.findall(text))\\t# VBN past participle\\n\\tts_VBP = len(re_ts_VBP.findall(text))\\t# VBP present tense, except 3rd Per Sing\\n\\tts_VBZ = len(re_ts_VBZ.findall(text))\\t# VBZ present tense, 3rd Person Singular\\n\\n\\t# ... collect all counts\\n\\tpt_verb_counts = ( pt_VBb, pt_VBD, pt_VBG, pt_VBN, pt_VBP, pt_VBZ, pt_VB_, )\\n\\tts_verb_counts = ( ts_VBb, ts_VBD, ts_VBG, ts_VBN, ts_VBP, ts_VBZ, ts_VB_, )\\n\\n\\t# check agreement\\n\\tif (pt_verb_counts != ts_verb_counts):\\n\\t\\tprint(\\\"ERROR: counts from parse tree do not agree with counts from tagged sentences.\\\")\\n\\n\\t# return all counts\\n\\treturn ( pt_verb_counts, ts_verb_counts, )\",\n \"def cmd_account_comment_count(client, args):\\n account_comment_count = client.get_account_comment_count(args.username)\\n generate_output({'account_comment_count': account_comment_count})\",\n \"def count_exclamations(txt):\\n count = 0\\n for c in txt:\\n if c == '!':\\n count += 1\\n return count\",\n \"def pos_tag_counts(doc):\\n tags = []\\n for token in doc:\\n tags.append(token.pos_)\\n frequency = dict(Counter(tags).most_common()) \\n return frequency\",\n \"def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\\n if project_name == PROJECT_ALL:\\n # comments in changes across all projects after from_datetime\\n comments = reviewer.comments.filter(\\n timestamp__gte=from_datetime).distinct()\\n else:\\n # comments in changes in given project after from_datetime\\n comments = reviewer.comments.filter(\\n change__project_name=project_name,\\n timestamp__gte=from_datetime).distinct()\\n\\n return comments.count()\",\n \"def count_tags(tag_events):\\n tagged_lines = []\\n for tag_event in tag_events:\\n for tag in tag_event[1][\\\"tag\\\"][\\\"labels\\\"]:\\n tagged_lines.append(tag)\\n tag_counts = Counter(tagged_lines)\\n return tag_counts\",\n \"def countsubcatchments(inputfilename=FileSettings.settingsdict['inputfilename']):\\r\\n global count\\r\\n with open(inputfilename, 'r') as swmmput:\\r\\n contents = swmmput.readlines()\\r\\n count = len(contents)\\r\\n return(count)\",\n \"def dcount(ev):\\n profData = getProfilingData(ev)\\n if profData is not None:\\n a = profData.Descendants().AsArray()\\n if len(a) > 0:\\n return profData.DescendantCount(a[0])\\n return \\\"\\\"\",\n \"def commentinator(coms, ctype, btag, tag):\\n # Construct the message\\n tag = btag + tag\\n \\n if ctype.lower() == 'notes':\\n coms.notes.append(tag)\\n elif ctype.lower() == 'warning':\\n coms.warnings.append(tag)\\n elif ctype.lower() == 'error':\\n coms.errors.append(tag)\\n elif ctype.lower() == 'tip':\\n coms.tips.append(tag)\\n \\n return coms\",\n \"def _count_comment_rows(vcf_path):\\n vcf_lines_generator = lines_from_vcf(vcf_path)\\n\\n comment_lines_count = 0\\n for line in vcf_lines_generator:\\n if line.startswith('#'):\\n comment_lines_count += 1\\n else:\\n vcf_lines_generator.close() # Don't leave the file handle opened\\n # Don't continue reading the VCF once the comments section ended\\n break\\n\\n return comment_lines_count\",\n \"def basic_statistics_of_email(data):\\n word_counts = []\\n character_count = 0\\n\\n for ind, row in data.iterrows():\\n tokenizer = RegexpTokenizer(r'\\\\w+')\\n real_words = tokenizer.tokenize(row[\\\"RawText\\\"].lower())\\n\\n character_count += sum(map(len, real_words))\\n word_counts.append(len(real_words))\\n\\n return character_count, pd.Series(word_counts)\",\n \"def core(self):\\n \\n \\n comments = self.bot.subreddit(\\n \\\"all\\\").stream.comments(\\n skip_existing = True)\\n \\n \\n for comment in comments:\\n \\n text = comment.body.lower().replace(\\\".\\\", \\\"\\\")\\n \\n for card in self.catalog:\\n \\n if (\\n card[1].lower() in text\\n and card[0].lower() in text\\n and not comment.submission.id in self.responded\\n and not comment.subreddit.user_is_banned):\\n\\n self.get_info(card)\\n\\n if not self.details:\\n \\n break\\n\\n audio = [\\n \\\"audiobook\\\", \\n \\\"audio book\\\"]\\n \\n author_format = [\\n name.lower() for name in card[1].split(\\\" \\\") \\n if len(name) >= 3]\\n\\n if (\\n self.details[\\\"duration\\\"] > 10800\\n and card[0].lower() in self.details[\\n \\\"title\\\"].lower()\\n and any(\\n item in self.details[\\n \\\"title\\\"].lower() for item in audio)\\n and all(\\n item in self.details[\\n \\\"title\\\"].lower() for item in author_format)):\\n \\n \\n saw_the_sign = (\\n \\\"\\\"\\\"[^(Source Code)](https://capybasilisk.com/posts/\\\"\\\"\\\"\\n \\\"\\\"\\\"2020/04/speculative-fiction-bot/) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| [^(Feedback)](https://www.reddit.com/message/\\\"\\\"\\\"\\n \\\"\\\"\\\"compose?to=Capybasilisk&subject=Robot) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| [^(Programmer)](https://www.reddit.com/u/\\\"\\\"\\\"\\n \\\"\\\"\\\"capybasilisk) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| ^(Downvote To Remove) \\\"\\\"\\\" \\n \\\"\\\"\\\"^| ^(Version 1.4.0) \\\"\\\"\\\"\\n \\\"\\\"\\\"^| ^(Support Robot Rights!)\\\"\\\"\\\")\\n \\n\\n comment.reply(\\n f\\\"\\\"\\\"Hi. You just mentioned *{card[0]}* by \\\"\\\"\\\" \\n f\\\"\\\"\\\"{card[1]}.\\\\n\\\\nI've found an audiobook of \\\"\\\"\\\" \\n \\\"\\\"\\\"that novel on YouTube. You can listen to it here\\\"\\\"\\\"\\n f\\\"\\\"\\\":\\\\n\\\\n[YouTube | {self.details['title']}]\\\"\\\"\\\"\\n f\\\"\\\"\\\"({self.details['webpage_url']})\\\\n\\\\n*I\\\\'m a bot that \\\"\\\"\\\" \\n \\\"\\\"\\\"searches YouTube for science fiction and fantasy\\\"\\\"\\\" \\n f\\\"\\\"\\\" audiobooks.*\\\\n***\\\\n{saw_the_sign}\\\"\\\"\\\")\\n\\n \\n self.responded.append(\\n comment.submission.id)\\n \\n with open(\\n \\\"activity.csv\\\", \\n \\\"a\\\", \\n encoding = \\\"UTF-8\\\") as actlog:\\n\\n activity = clevercsv.writer(\\n actlog)\\n\\n if actlog.tell() == 0:\\n\\n activity.writerow(\\n [\\\"Book\\\",\\n \\\"Comment\\\", \\n \\\"Author\\\", \\n \\\"Thread\\\", \\n \\\"Subreddit\\\", \\n \\\"Time\\\"])\\n\\n activity.writerow(\\n [f\\\"{card[0]} by {card[1]}\\\",\\n f\\\"{comment.body}\\\",\\n f\\\"{comment.author}\\\",\\n f\\\"{comment.submission.title}\\\",\\n f\\\"{comment.subreddit}\\\",\\n f\\\"{pendulum.now().to_datetime_string()}\\\"])\\n \\n self.details = None\\n \\n break\\n \\n break \\n \\n if pendulum.now().to_time_string().endswith(\\n \\\"0:00\\\"):\\n \\n self.tidy()\",\n \"def sendUpStatCountTagCounts(node, tag):\\n def pushUp(node):\\n t = 0\\n ta = 0\\n for child in node.children:\\n tc, tac = pushUp(child)\\n ta += tac\\n t += tc\\n node.tagTranscriptAnnotations += ta\\n node.tagTranscripts += t\\n return node.tagTranscripts, node.tagTranscriptAnnotations\\n if ':' in tag:\\n tag = tag.split(':')[-1]\\n pushUp(node)\",\n \"def test_counts(self):\\n lines, words, chars = analyze_text(self.filename)\\n self.assertEqual(lines, 4)\\n self.assertEqual(words, 8)\\n self.assertEqual(chars, 36)\",\n \"def cmd_gallery_comment_count(client, args):\\n gallery_comment_count = client.gallery_comment_count(args.item_id)\\n generate_output({'gallery_comment_count': gallery_comment_count})\",\n \"def addCommentCount(self,count):\\n self.commentCount += count\\n return None\",\n \"def __call__(self, example):\\n para_counter = data.count_tokens(example['context_tokens'] if not self._iterate_over_example\\n else [c for tkn in example['context_tokens'] for c in tkn])\\n ques_counter = data.count_tokens(example['ques_tokens'] if not self._iterate_over_example\\n else [c for tkn in example['ques_tokens'] for c in tkn])\\n counter = para_counter + ques_counter\\n return list(counter.items())\",\n \"def count_tags():\\r\\n trans = transaction.begin()\\r\\n StatBookmarkMgr.count_total_tags()\\r\\n trans.commit()\",\n \"def getTokenSizeOfReviews(self):\\n res = 0\\n with open(self.word_to_docs_path, 'rb') as bin:\\n while bin.tell() != os.fstat(bin.fileno()).st_size:\\n # get wordid:\\n int.from_bytes(bin.read(4), 'big')\\n # get frequency:\\n frequency = int.from_bytes(bin.read(4), 'big')\\n res += frequency\\n # skip documents:\\n int.from_bytes(bin.read(4 * frequency), 'big')\\n return res\",\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def get_stats(sents):\\n import os\\n import re \\n # first, put the relevant trees into temp file\\n if 'outname' in kwargs.keys():\\n to_open = 'tmp-%s.txt' % kwargs['outname']\\n else:\\n to_open = 'tmp.txt'\\n with open(to_open, \\\"w\\\") as fo:\\n for sent in sents:\\n statsmode_results['Sentences'] += 1\\n fo.write(sent.parse_string.rstrip().encode('utf-8', errors = 'ignore') + '\\\\n')\\n deps = get_deps(sent, dep_type)\\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\\n statsmode_results['Passives'] += numpass\\n statsmode_results['Tokens'] += len(sent.tokens)\\n statsmode_results['Words'] += len([w for w in sent.tokens if w.word.isalnum()])\\n #statsmode_results['Unique words'] += len(set([w.word.lower() for w in sent.tokens if w.word.isalnum()]))\\n #statsmode_results['Unique lemmata'] += len(set([w.lemma.lower() for w in sent.tokens if w.word.isalnum()]))\\n\\n # count moods via trees (/\\\\?/ !< __)\\n from dictionaries.process_types import processes\\n from corpkit.other import as_regex\\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\\n #'Open interrogative': r'ROOT < SBARQ <<- (/\\\\?/ !< __)', \\n #'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\\\?/ !< __))',\\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\\n 'Open class words': r'/^(NN|JJ|VB|RB)/ < __',\\n 'Closed class words': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\\n 'Clauses': r'/^S/ < __',\\n 'Interrogative': r'ROOT << (/\\\\?/ !< __)',\\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.mental, boundaries = 'w'),\\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.verbal, boundaries = 'w'),\\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.relational, boundaries = 'w')}\\n\\n for name, q in sorted(tregex_qs.items()):\\n res = tregex_engine(query = q, \\n options = ['-o', '-C'], \\n corpus = to_open, \\n root = root)\\n statsmode_results[name] += int(res)\\n global numdone\\n numdone += 1\\n if root:\\n root.update()\\n if not root:\\n tot_string = str(numdone + 1) + '/' + str(total_files * len(tregex_qs.keys()))\\n if 'outname' in kwargs.keys():\\n tot_string = '%s: %s' % (kwargs['outname'], tot_string)\\n animator(p, numdone, tot_string, **par_args)\\n if 'note' in kwargs.keys() and kwargs['note'] is not False:\\n kwargs['note'].progvar.set((numdone * 100.0 / (total_files * len(tregex_qs.keys())) / denom) + startnum)\\n os.remove(to_open)\",\n \"def set_n_comments_observed_task2(posts):\\n for p in posts:\\n p['n_comments_observed'] = get_hostile_indices(p)[0] + 1\",\n \"def message_count(self):\\n pass\",\n \"def contig_count(contig):\\n return sum([1 for line in open(contig, 'rU').readlines() if line.startswith('>')])\",\n \"def derive_terms_and_comments(infile: str = None, outfile: str = None) -> None:\\n\\n id_ctr = 0\\n comment_ctr = 0\\n missing_id_ctr = 0\\n missing_comment_ctr = 0\\n null_comment_ctr = 0\\n terms_and_comments_list = []\\n\\n logging.info(\\\"Abou to parse '{}'\\\".format(infile))\\n\\n with open(infile) as file:\\n\\n documents = yaml.full_load(file)\\n\\n for item, doc in documents.items():\\n if item == '@graph':\\n logging.info(\\\"Found '@graph' section\\\")\\n\\n graph_list = doc\\n\\n for graph_dict in graph_list:\\n term_name = None\\n comment = None\\n if '@id' in graph_dict:\\n term_name = graph_dict['@id']\\n id_ctr += 1\\n if 'rdfs:comment' in graph_dict:\\n comment = graph_dict['rdfs:comment']\\n if comment is None or comment == '':\\n comment = 'N/A'\\n logging.info(\\\"Found term '{}' with null comment so assigned '{}'\\\".format(term_name, comment))\\n null_comment_ctr += 1\\n else:\\n logging.info(\\\"Found term '{}' with comment '{}'\\\".format(term_name, comment))\\n comment_ctr += 1\\n else:\\n logging.info(\\\"Did not find comment for term '{}'\\\".format(term_name))\\n missing_comment_ctr += 1\\n else:\\n logging.error(\\\"Did not find id!\\\")\\n missing_id_ctr += 1\\n\\n terms_and_comments_list.append([term_name, comment])\\n\\n logging.info(\\\"Found '{}' ids\\\".format(id_ctr))\\n logging.info(\\\"Found '{}' comments\\\".format(comment_ctr))\\n\\n if missing_id_ctr > 0:\\n print(\\\"Encountered '{}' missing ids\\\".format(missing_id_ctr))\\n\\n if missing_comment_ctr > 0:\\n print(\\\"Encountered '{}' missing comments\\\".format(missing_comment_ctr))\\n\\n if null_comment_ctr > 0:\\n print(\\\"Encountered '{}' comments with null values\\\".format(null_comment_ctr))\\n\\n with open(outfile, 'w') as fh:\\n for term_and_comment in terms_and_comments_list:\\n fh.write(term_and_comment[0] + \\\"\\\\t\\\" + term_and_comment[1] + \\\"\\\\n\\\")\\n\\n logging.info(\\\"Wrote '{}'\\\".format(outfile))\\n print(\\\"Wrote '{}'\\\".format(outfile))\",\n \"def keyword_count(searches, doc):\\n for search in searches:\\n print \\\"\\\\\\\"{0}\\\\\\\": {1}\\\".format(search, len(re.findall(searches[search], doc)))\",\n \"def count(text):\\n return len(text)\",\n \"def test_get_comments_len(self):\\n comments = self.story.get_comments()\\n soup = utils.get_item_soup(7324236)\\n for anchor in soup.find_all('a'):\\n if 'More' in anchor.text:\\n more_button_present = True\\n\\n # Note: Hacker News is not consistent about the number of comments per\\n # page. On multiple comment page stories, the number of comments on a\\n # page is never less than 90. On single comment page stories, the\\n # number of comments on the sole page is always less than 110.\\n if more_button_present:\\n self.assertTrue(len(comments) > 90)\\n else:\\n self.assertTrue(len(comments) < 110)\",\n \"def get_comments(qint,conn):\\n\\n comms = ('SELECT DISTINCT ip.value '\\n 'FROM interaction i, interactionprop ip, cvterm cvt '\\n 'WHERE i.interaction_id = ip.interaction_id AND ip.type_id = cvt.cvterm_id '\\n 'AND cvt.is_obsolete=0 AND cvt.name != \\\\'comments on source\\\\' '\\n 'AND cvt.name != \\\\'internalnotes\\\\' AND i.uniquename = %s')\\n comnts = connect(comms, qint, conn)\\n return(comnts)\",\n \"def github_num_reactions(comment_object: Dict[str, Any]) -> int:\\n return comment_object.get('reactions', {}).get('total_count', 0)\",\n \"def paragraph_count(self, doc):\\n\\n paragraphs = doc.split(\\\"\\\\n\\\\n\\\")\\n # remove the empty string\\n return len([paragraph for paragraph in paragraphs if paragraph])\",\n \"def utr5_motif_counts(self, pattern):\\n return len(re.findall(pattern.upper(), self.five_prime_utr_sequence.upper()))\",\n \"def count_prepositions(text):\\n\\t# parse tree, tag 'IN'\\n\\tpt_IN = re_pt_IN.findall(text)\\n\\tpt_IN_lc = [ s.lower() for s in pt_IN ]\\n\\t\\n\\t# parse tree, tag 'TO'\\n\\tpt_TO = re_pt_TO.findall(text)\\n\\tpt_TO_lc = [ s.lower() for s in pt_TO ]\\n\\t\\n\\t# compile counts and most frequent prepositions\\n\\tcount_total = len(pt_IN_lc) + len(pt_TO_lc)\\n\\tfd_TO_IN = FreqDist(pt_TO_lc + pt_IN_lc)\\n\\tcount_unique = len(fd_TO_IN)\\n\\tmost_common_3 = fd_TO_IN.most_common(3)\\n\\t\\n\\t# return results and frequency distribution\\n\\treturn count_total, count_unique, most_common_3, fd_TO_IN\",\n \"def test_comments(self):\\n\\n comment_str = \\\"# This is a comment\\\\n# This is another comment\\\"\\n doc = parser.parse(comment_str)\\n\\n self.assertEqual(len(doc.children()), 2)\",\n \"def count_entity_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, entity_type, _, _ = conll04_parser.split_line(line)\\n if entity_type in count:\\n count[entity_type] += 1\\n else:\\n count[entity_type] = 1\\n return count\",\n \"def wcount(lines,topn=10):\\n doc = urlopen(lines)\\n docstr = doc.read()\\n doc.close()\\n txt = docstr.decode() #获得文档，命名为txt\\n \\n turn1=txt.maketrans('~`!@#$%^&*)(}{][:;\\\"?/\\\\|<>,.=+_\\\"',' ') #将特殊符号替换为空格\\n txt=txt.translate(turn1)\\n turn2=txt.maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz') #将大写转化为小写\\n txt=txt.translate(turn2)\\n txt=txt.split()\\n \\n ans={} #建立一个列表，储存得到的数据\\n for i in txt:\\n ans[i] = ans.get(i, 0)+1 #对单词进行数数\\n ans_list=sorted(ans.items(),key=lambda x:x[1],reverse=True) #对得到的数据根据出现次数大小降序排列,用list便于操作。\\n ans_dict=dict(ans_list)\\n \\n if topn <= len(ans): #如果topn小于字典长度，输出topn个值，否则输出全部\\n for (i,v) in ans_list[:topn]:\\n print(i,' ',v)\\n else:\\n for (i,v) in ans_dict.items():\\n print(i,' ',v)\",\n \"def getNumberTerms(content): \\n return Counter(getTerms(content))\",\n \"def test_task_count_tags(self):\\r\\n tasks.count_tags()\\r\\n\\r\\n stat = StatBookmark.query.first()\\r\\n self.assertEqual(stat.attrib, stats.TAG_CT)\\r\\n self.assertEqual(stat.data, 4)\",\n \"def codon_counts(self):\\n # Removing 5' UTR and 3' UTR sequences\\n sequence = self.sequence.replace(self.five_prime_utr_sequence, \\\"\\\").replace(self.three_prime_utr_sequence, \\\"\\\")\\n return len(sequence) / 3\",\n \"def analyzeCppCode(self, sourceFile):\\n numLines = 0 # Number of lines of code\\n numComments = 0 # Number of comments in the code\\n\\n f=self.openFile(sourceFile)\\n for line in f:\\n numLines += 1;\\n loc = 0\\n while (loc != -1): #count the # of times the '/*' characters appears\\n loc = line.find(\\\"#\\\", loc)\\n if (loc != -1):\\n loc += 1\\n numComments += 1\\n \\n loc = 0\\n loc = line.find('//', loc) #count the # of times the '//' characters appears\\n if (loc != -1):\\n loc += 1\\n numComments += 1\\n \\n f.close()\\n return numLines, numComments\",\n \"def wcount(lines, topn):\\n l = re.split('[.,:-^(){}?\\\"\\\\n\\\\r!;\\\\' /&#*@_]',lines)#将lines里的单词分隔，放入列表l\\n statistics = {}\\n for i in l:\\n if i not in statistics:\\n statistics[i] = 1\\n else:\\n statistics[i] = statistics[i] + 1 #用字典统计单词出现的次数\\n lis = sorted(statistics.items(),key = lambda x:x[1],reverse = True) #将单词出现的次数由大到小排序\\n if topn > len(lis):#超出单词种类数，输出全部结果\\n dic = dict(lis[1:]) \\n else: #否则输出想要的个数\\n dic = dict(lis[1:topn+1])\\n for k in dic:\\n print(str(k) + \\\" \\\" + str(dic[k])) #将字典以一列key，一列对应的value的形式输出\\n pass\",\n \"def get_number_of_comments(self):\\n return self._performed_actions[WRITE_COMMENT]\",\n \"def _readComments(self): \\n self.NSCOML = nappy.utils.text_parser.readItemFromLine(self.file.readline(), int)\\n self._readSpecialComments()\\n self.NNCOML = nappy.utils.text_parser.readItemFromLine(self.file.readline(), int)\\n self._readNormalComments()\",\n \"def wcount(lines, topn=10):\\n '''a=[]\\n for line in lines:\\n word = line.strip()\\n a.append(word)\\n def histogram(s):\\n d = dict()\\n for i in s:\\n if i in d:\\n d[i]+=1\\n else:\\n d[i]=1\\n return d'''\\n def process_line(lines,diction):\\n lines = lines.replace('-',' ')\\n for word in lines.split():\\n word=word.strip(string.punctuation+string.whitespace)\\n word.lower()\\n diction[word]=diction.get(word,0)+1\\n\\n def process_file(lines):\\n diction = {}\\n process_line(lines,diction)\\n return diction\\n diction=process_file(lines)\\n x=list(diction.values())\\n x.sort()\\n x.reverse()\\n count = 0\\n for i in range(topn):\\n for key in list(diction.keys()):\\n if diction[key]==x[i] and count<topn:\\n print(\\\"%s %d\\\"%(key,diction[key]))\\n count +=1\\n del diction[key]\\n pass\",\n \"def totaled_tbr_no_lgtm(cc, sql_time_specification):\\n cc.execute(\\\"\\\"\\\"SELECT git_commit.review_url, git_commit.timestamp,\\n git_commit.subject, git_commit.hash\\n FROM review\\n INNER JOIN git_commit\\n ON review.review_url = git_commit.review_url\\n INNER JOIN commit_people\\n ON commit_people.git_commit_hash = git_commit.hash\\n LEFT JOIN (\\n SELECT review_url, COUNT(*) AS c\\n FROM review_people\\n WHERE type = 'lgtm'\\n GROUP BY review_url) lgtm_count\\n ON review.review_url = lgtm_count.review_url\\n WHERE lgtm_count.c = 0 OR lgtm_count.c IS NULL\\n AND commit_people.type = 'author' AND %s\\\"\\\"\\\" % sql_time_specification)\\n result = cc.fetchall()\\n count = len(result)\\n formatted_data = []\\n for data in result:\\n subject = data[2]\\n formatted_data.append([data[0], data[1].strftime(\\\"%Y-%m-%d %H:%M:%S\\\"),\\n subject.replace('-', ' '), data[3]])\\n results = sorted(formatted_data, key=lambda x: x[1], reverse=True)\\n return count, results\",\n \"def count(self, sub) -> int:\\n pass\",\n \"def resultCounter(detections):\\n counter = 0\\n for attribute, value in classIterator(detections):\\n if 'crease' in attribute:\\n counter += len(value)\\n return counter\",\n \"def _readNormalComments(self):\\n self.NCOM = self._readLines(self.NNCOML)\\n return self.NCOM\",\n \"def analyze_reviews(reviews):\\n\\n good_reviews=reviews[reviews['rs_review_movie_score']>=9]\\n bad_reviews=reviews[reviews['rs_review_movie_score']<=2]\\n\\n print 'len(good_reviews)=%s' % len(good_reviews)\\n print 'len(bad_reviews)=%s' % len(bad_reviews)\\n\\n m = re.compile('\\\\d')\\n\\n english_stop_words=stopwords.words('english')\\n\\n\\n def tokenize(text):\\n tokens=nltk.word_tokenize(text)\\n # strip out trailing puncutation\\n tokens = [ token[:-1] if token[-1] in ['.',',','!','?'] else token for token in tokens]\\n\\n # lower case\\n tokens = [token.lower() for token in tokens]\\n\\n # Take only relativly long characters\\n tokens = [token for token in tokens if len(token)>=3]\\n\\n # remove words with numbers/digits\\n tokens = [token for token in tokens if m.search(token) is None]\\n\\n # Remove stop words: http://nltk.googlecode.com/svn/trunk/doc/book/ch02.html\\n tokens = [token for token in tokens if token not in english_stop_words]\\n return tokens\\n\\n good_tokens_list = []\\n for i,review in good_reviews.iterrows():\\n text=review['rs_review_text']\\n good_tokens_list.append(tokenize(text))\\n\\n bad_tokens_list = []\\n for i,review in bad_reviews.iterrows():\\n text=review['rs_review_text']\\n bad_tokens_list.append(tokenize(text))\\n\\n all_words=Counter()\\n for tokens in good_tokens_list + bad_tokens_list:\\n for token in tokens:\\n all_words[token]+=1\\n\\n most_common=all_words.most_common(2000)\\n most_common=zip(*most_common)[0]\\n\\n print 'most_common_words = ',most_common[-20:]\\n\\n def document_features(tokens):\\n return {word:word in tokens for word in most_common}\\n\\n good_set=[(document_features(tokens), 'pos') for tokens in good_tokens_list]\\n bad_set=[(document_features(tokens), 'neg') for tokens in bad_tokens_list]\\n\\n train_set = good_set + bad_set\\n random.shuffle(train_set) # dunno if this is necessary\\n\\n classifier = nltk.NaiveBayesClassifier.train(train_set)\\n\\n print 'accuracy',nltk.classify.accuracy(classifier, train_set)\\n\\n classifier.show_most_informative_features(300)\\n\\n return classifier\",\n \"def ngram_detection(self, min_topic_count=5, min_text_id_count=4):\\n\\n for text_id, text in self.texts.items():\\n # single-word topics act a bit different (no zips or comprehensions)\\n # store data in self.topics, not zip_grams\\n for word in text['doc']:\\n word_lemma = word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_\\n\\n if {word.text}.intersection(self.punct) or {word.lemma_}.intersection(self.stop_words):\\n continue\\n\\n if not (word.pos in self.nouns or word.ent_type in self.entities):\\n continue\\n\\n if word_lemma in self.topics:\\n self.topics[word_lemma][\\\"count\\\"] += 1\\n self.topics[word_lemma][\\\"textIDs\\\"] |= {text_id}\\n self.topics[word_lemma][\\\"verbatims\\\"] |= {word.text.lower()}\\n else:\\n self.topics[word_lemma] = {\\\"name\\\": word_lemma,\\n \\\"count\\\": 1,\\n \\\"textIDs\\\": {text_id},\\n \\\"verbatims\\\": {word.text.lower()},\\n \\\"subtopics\\\": {}}\\n\\n # Populate self.ngrams and self.topics\\n for text_id, text in self.texts.items():\\n doc = text['doc']\\n\\n # Find pentagrams - ngrams with 5 words\\n for ngram in zip(doc, doc[1:], doc[2:], doc[3:], doc[4:]):\\n self._ngram_counter(ngram, 5, text_id, doc)\\n\\n # Find pentagrams - ngrams with 4 words\\n for ngram in zip(doc, doc[1:], doc[2:], doc[3:]):\\n self._ngram_counter(ngram, 4, text_id, doc)\\n\\n for ngram in zip(doc, doc[1:], doc[2:]):\\n self._ngram_counter(ngram, 3, text_id, doc)\\n\\n for ngram in zip(doc, doc[1:]):\\n self._ngram_counter(ngram, 2, text_id, doc)\\n\\n\\n # Add text_id_count (the number of texts that the topic occurs in; so a topic might occur 50 times,\\n # but it's only mentioned in 3 different texts, we'd show 3.\\n for _, topic in self.topics.items():\\n topic['textIDCount'] = len(topic['textIDs'])\\n for _, ngram in self.ngrams.items():\\n ngram['textIDCount'] = len(ngram['textIDs'])\\n\\n # Eliminate rarely occurring topics and ngrams.\\n self.topics = {k: v for k, v in self.topics.items() if\\n v['textIDCount'] >= min_text_id_count and v['count'] >= min_topic_count}\\n self.ngrams = {k: v for k, v in self.ngrams.items() if\\n v['textIDCount'] >= min_text_id_count}\\n\\n # Loop through each ngram pair: outer loop is all ngrams, inner loop is all ngrams\\n for ngram_lemma, ngram in self.ngrams.items():\\n for ngram_plus_lemma, ngram_plus in self.ngrams.items():\\n # only stay in this loop if the inner ngram is one word longer than the outer loop and if the\\n # inner loop lemma contains the outer group lemma (avoid partial word matches like man in woman)\\n # r'\\\\b' + ngram_lemma + r'\\\\b' --> does the ngram lemma fit in ngram_plus lemma (\\\\b is word boundary)\\n if ngram['n'] + 1 != ngram_plus['n']:\\n continue\\n\\n if not re.search(r'\\\\b' + ngram_lemma + r'\\\\b', ngram_plus_lemma):\\n continue\\n\\n # Is the absolute count of occurrences and the count of text_id occurrences both big enough to use it\\n # instead of the other loop?\\n if ngram_plus['count'] + 3 >= ngram['count'] and ngram_plus['textIDCount'] + 3 >= ngram['textIDCount']:\\n # TODO: Is this the right action (deleting shorter, but not much more explanatory) phrase?\\n # TODO: Is this enough? Or will I end up double explaining things sometimes?\\n ngram['count'] = -1\\n\\n # Eliminate newly demoted items\\n self.ngrams = {ngram_lemma: ngram for ngram_lemma, ngram in self.ngrams.items() if ngram['count'] > 0}\",\n \"def count_tokens(txt_to_tokenise_and_count):\\n\\n txt_tokens = nltk.word_tokenize(txt_to_tokenise_and_count) \\n counts = Counter(txt_tokens)\\n\\n print (counts.most_common(10))\\n return counts\",\n \"def counts(page):\\n # Read the page into the string s\\n s = page.read()\\n # Count different brackets\\n print(f\\\"( count = {s.count('(')}\\\")\\n print(f\\\") count = {s.count(')')}\\\")\\n print(f\\\"[ count = {s.count('[')}\\\")\\n print(f\\\"] count = {s.count(']')}\\\")\\n print(\\\"{\\\", f\\\"count = {s.count('{')}\\\")\\n print(\\\"}\\\", f\\\"count = {s.count('}')}\\\")\\n print(f\\\"< count = {s.count('<')}\\\")\\n print(f\\\"> count = {s.count('>')}\\\")\\n # Print if brackets are balanced or not.\\n if s.count('(') == s.count(')'):\\n print(\\\"( and ) are balanced.\\\")\\n else:\\n print(\\\"( and ) are not balanced.\\\")\\n if s.count('[') == s.count(']'):\\n print(\\\"[ and ] are balanced.\\\")\\n else:\\n print(\\\"[ and ] are not balanced.\\\")\\n if s.count('{') == s.count('}'):\\n print(\\\"{ and } are balanced.\\\")\\n else:\\n print(\\\"{ and } are not balanced.\\\")\\n if s.count('<') == s.count('>'):\\n print(\\\"< and > are balanced.\\\")\\n else:\\n print(\\\"< and > are not balanced.\\\")\",\n \"def count_questions(txt):\\n count = 0\\n for c in txt:\\n if c == '?':\\n count += 1\\n return count\",\n \"def count_cop(self, infile):\\n n_cop = 0\\n dgs_in = self._file_handler.file_to_dg_list(infile)\\n for dg in dgs_in:\\n if dg.has_cop_deprel():\\n n_cop += 1\\n return n_cop, len(dgs_in)\",\n \"def word_count(self, document):\\n start_time = time.time()\\n dictionary = dict()\\n counter = defaultdict(int)\\n for line in document.splitlines():\\n for word in line.split():\\n if word not in PUNCTUATION_MARK:\\n counter[word] += 1\\n for word, cnt in sorted(counter.items(), key=lambda x: (-x[1], x[0])):\\n dictionary[word] = cnt\\n self.log.info(\\\"Duration count dictionary: {duration}\\\".format(duration=float(time.time() - start_time)))\\n return dictionary\",\n \"def count(self, ngram, options):\\n return len(self.find_docs(ngram, options))\",\n \"def sentence_count(self):\\n count = 0\\n for line in self.lines:\\n if '.' in line:\\n count += 1\\n if count == 0:\\n count = 1\\n return count\\n #return line.count('.')\\n #else:\\n #return 1\",\n \"def _ngram_counter(self, ngram, ngram_length, text_id, doc):\\n\\n # Only process this ngram is it's punctuation-free (punct --> token.dep == ss.punct) and the 1st / last\\n # words are not stopwords (line mechanics: make a set, look for an intersection with another set)\\n if ([word for word in ngram if word.dep == ss.punct] or\\n {ngram[0].lemma_, ngram[ngram_length - 1].lemma_}.intersection(self.stop_words)):\\n return\\n\\n # Only keep this ngram is it has 1+ nouns in it\\n if len([word for word in ngram if word.pos in self.nouns or word.ent_type in self.entities]) == 0:\\n return\\n\\n ngram_lemma = ' '.join([word.text.lower() if word.lemma_ == '-PRON-' else word.lemma_ for word in ngram])\\n verbatim = ' '.join([word.text.lower() for word in ngram])\\n\\n # add the ngram_lemma to each proximal topic\\n window_start = 0 if ngram[0].i < 7 else ngram[0].i - 7\\n window_end = len(doc) if ngram[0].i + 7 + ngram_length > len(doc) else ngram[0].i + 7 + ngram_length\\n for word in doc[window_start:window_end]:\\n if word.lemma_ in self.topics: # is this a topic we're tracking?\\n # Yes. So let's add it to the subtopic dictionary (with an occurrence count)\\n if ngram_lemma in self.topics[word.lemma_]['subtopics']:\\n self.topics[word.lemma_]['subtopics'][ngram_lemma].add(text_id)\\n else:\\n self.topics[word.lemma_]['subtopics'][ngram_lemma] = {text_id}\\n\\n # TODO: Do I even need self.ngrams anymore? Maybe track everything in the subtopics area?\\n # Keep it! And it's not the first time we've found it.\\n if ngram_lemma in self.ngrams:\\n self.ngrams[ngram_lemma][\\\"count\\\"] += 1\\n self.ngrams[ngram_lemma][\\\"textIDs\\\"] |= {text_id}\\n self.ngrams[ngram_lemma][\\\"verbatims\\\"] |= {verbatim}\\n # Keep it! This is the 1st instance.\\n else:\\n self.ngrams[ngram_lemma] = {\\\"name\\\": ngram_lemma,\\n \\\"count\\\": 1,\\n \\\"textIDs\\\": {text_id},\\n \\\"n\\\": ngram_length,\\n \\\"verbatims\\\": {verbatim},\\n \\\"topic_lemmas\\\": []}\",\n \"def utr3_motif_counts(self, pattern):\\n return len(re.findall(pattern.upper(), self.three_prime_utr_sequence.upper()))\",\n \"def sorter(r):\\n\\n ans = len(r.description)\\n if additional:\\n for rr in r.monkey_additional:\\n ans += len(rr)\\n return ans\",\n \"def get_most_extreme_comments():\\n pass\",\n \"def count_posTags(self):\\n pos_list = ['NUM', 'AUX', 'ADV', 'DET', 'NOUN', 'ADP', 'ADJ', 'NOUN', 'VERB', 'NOUN', 'PUNCT', 'PUNCT']\\n result = count_posTags(pos_list)\\n self.assertEqual(result, (3, 1, 1, 1, 2))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66587913","0.6579101","0.6395755","0.6311714","0.6095312","0.6047312","0.5910355","0.5901797","0.5876962","0.5855314","0.58521634","0.5803708","0.57817703","0.5762721","0.57504636","0.5726828","0.5711957","0.57052165","0.57052165","0.57011557","0.5694786","0.56886756","0.5666868","0.56655145","0.5633301","0.5584729","0.55492187","0.55381215","0.55092305","0.5498859","0.54881054","0.546753","0.5462499","0.54563516","0.54456","0.5437851","0.54374415","0.5423933","0.54235005","0.5400078","0.53956395","0.5392149","0.5363392","0.534801","0.5336853","0.5314466","0.5296825","0.5295489","0.5293375","0.5291815","0.5291057","0.5276459","0.5266279","0.5264782","0.52542937","0.52485675","0.5247571","0.5247398","0.5241733","0.5240229","0.52383584","0.52257305","0.5223653","0.52145296","0.5207886","0.5199968","0.51959366","0.51925033","0.51900566","0.5184527","0.51839453","0.51773316","0.51750654","0.51642627","0.51636904","0.51542044","0.5153176","0.51422447","0.513478","0.5126592","0.51156396","0.5110781","0.51072687","0.5102475","0.50957286","0.5090372","0.5085209","0.5070199","0.50630826","0.50616616","0.5060532","0.50589573","0.50589067","0.5055461","0.5050872","0.5050286","0.5048215","0.5042039","0.50413346","0.5039407"],"string":"[\n \"0.66587913\",\n \"0.6579101\",\n \"0.6395755\",\n \"0.6311714\",\n \"0.6095312\",\n \"0.6047312\",\n \"0.5910355\",\n \"0.5901797\",\n \"0.5876962\",\n \"0.5855314\",\n \"0.58521634\",\n \"0.5803708\",\n \"0.57817703\",\n \"0.5762721\",\n \"0.57504636\",\n \"0.5726828\",\n \"0.5711957\",\n \"0.57052165\",\n \"0.57052165\",\n \"0.57011557\",\n \"0.5694786\",\n \"0.56886756\",\n \"0.5666868\",\n \"0.56655145\",\n \"0.5633301\",\n \"0.5584729\",\n \"0.55492187\",\n \"0.55381215\",\n \"0.55092305\",\n \"0.5498859\",\n \"0.54881054\",\n \"0.546753\",\n \"0.5462499\",\n \"0.54563516\",\n \"0.54456\",\n \"0.5437851\",\n \"0.54374415\",\n \"0.5423933\",\n \"0.54235005\",\n \"0.5400078\",\n \"0.53956395\",\n \"0.5392149\",\n \"0.5363392\",\n \"0.534801\",\n \"0.5336853\",\n \"0.5314466\",\n \"0.5296825\",\n \"0.5295489\",\n \"0.5293375\",\n \"0.5291815\",\n \"0.5291057\",\n \"0.5276459\",\n \"0.5266279\",\n \"0.5264782\",\n \"0.52542937\",\n \"0.52485675\",\n \"0.5247571\",\n \"0.5247398\",\n \"0.5241733\",\n \"0.5240229\",\n \"0.52383584\",\n \"0.52257305\",\n \"0.5223653\",\n \"0.52145296\",\n \"0.5207886\",\n \"0.5199968\",\n \"0.51959366\",\n \"0.51925033\",\n \"0.51900566\",\n \"0.5184527\",\n \"0.51839453\",\n \"0.51773316\",\n \"0.51750654\",\n \"0.51642627\",\n \"0.51636904\",\n \"0.51542044\",\n \"0.5153176\",\n \"0.51422447\",\n \"0.513478\",\n \"0.5126592\",\n \"0.51156396\",\n \"0.5110781\",\n \"0.51072687\",\n \"0.5102475\",\n \"0.50957286\",\n \"0.5090372\",\n \"0.5085209\",\n \"0.5070199\",\n \"0.50630826\",\n \"0.50616616\",\n \"0.5060532\",\n \"0.50589573\",\n \"0.50589067\",\n \"0.5055461\",\n \"0.5050872\",\n \"0.5050286\",\n \"0.5048215\",\n \"0.5042039\",\n \"0.50413346\",\n \"0.5039407\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68003654"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85197,"cells":{"query":{"kind":"string","value":"finds issues in PR"},"document":{"kind":"string","value":"def issues(self):\n if self.pull_request.body is not None:\n regex = r\"(?<=closes: #|elated: #)\\d{5}\"\n issue_strs = re.findall(regex, self.pull_request.body)\n self.issue_nums = [eval(s) for s in issue_strs]"},"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 test_issue_list_issues(self):\n pass","def get_issues(): # pragma: no cover\n global issue_data\n team = {\n 'stevex196x': 0,\n 'TheSchaft': 0,\n 'melxtru': 0,\n 'aylish19': 0,\n 'connormlewis': 0,\n 'tsukkisuki': 0\n }\n all_issues = 0\n while all_issues == 0:\n url = ('https://api.github.com/repos/connormlewis/idb/'\n 'issues?state=all&filter=all&per_page=100')\n data = requests.get(\n url, headers={'Authorization': 'token ' + os.environ['API_TOKEN']})\n link = data.headers.get('Link', None)\n for i in range(1, int(find_last_page(link)) + 1):\n url = (\n 'https://api.github.com/repos/connormlewis/idb/'\n 'issues?state=all&filter=all&per_page=100' + '&page=' + str(i))\n data = requests.get(\n url,\n headers={'Authorization': 'token ' + os.environ['API_TOKEN']})\n json_list = data.json()\n for entry in json_list:\n if 'pull_request' not in entry:\n all_issues += 1\n if entry['user']['login'] in team:\n team[entry['user']['login']] += 1\n return team, all_issues","def test_issue_get_repo_comments(self):\n pass","def test_issue_search_issues(self):\n pass","def test_issue_get_issue(self):\n pass","async def _get_pull_requests_for_issue(self, session: ClientSession, issue: dict, data: dict) -> dict:\n url = self._build_url('dev-status/1.0/issue/detail')\n async with session.get(url, params=data) as resp:\n response = await resp.json()\n response['detail'][0].update(issue)\n return response","def test_issue_get_comments(self):\n pass","def main():\n verbose = False\n online = True\n\n if online:\n TOKEN = \"\"\n g = Github(base_url=\"https://github.ibm.com/api/v3\", login_or_token=TOKEN)\n repo = g.get_repo(\"Raphael-Lambert/test_note\")\n\n path = \"C:/Users/RaphaelLambert/Documents/git_issues\"\n onlyfiles = [f for f in listdir(path) if isfile(join(path, f))]\n if verbose:\n print(onlyfiles)\n treated = []\n issues = []\n\n with open(join(path, 'log.txt'), 'r') as doc:\n for line in doc:\n treated.append(line.rstrip('\\n'))\n\n with open(join(path, 'issues.txt'), 'r') as doc:\n for line in doc:\n issues.append(int(line.rstrip('\\n')))\n\n for title in onlyfiles:\n if title != 'log.txt' and title != 'issues.txt' and title not in treated:\n with open(join(path, title), 'rb') as fhdl:\n raw_email = fhdl.read()\n\n parsed_eml = eml_parser.eml_parser.decode_email_b(raw_email, include_raw_body=True)\n if verbose:\n print('-----------------')\n print(title)\n print('-----------------')\n print(parsed_eml)\n print('-----------------')\n body = parsed_eml['body']\n if len(body) > 0:\n raw_text = body[0]['content']\n else:\n raw_text = \"unable to retrieve the message\"\n raw_text = link_breaker(raw_text)\n num_get = 0\n if online and title[:4] == 'Re ' and title[4:] in treated:\n cont_issue = repo.get_issue(issues[treated.index(title[4:])])\n num_get = cont_issue.number\n cont_issue.create_comment(body=raw_text)\n elif online:\n new_issue = repo.create_issue(title=\"Conversation number {}: {}\".format(len(treated), title[:10]+\"...\"),\n body=raw_text)\n if verbose:\n print(new_issue)\n num_get = new_issue.number\n treated.append(title)\n issues.append(num_get)\n\n if verbose:\n print(treated)\n\n with open(join(path, 'log.txt'), 'w') as doc:\n for title in treated:\n doc.write(title+'\\n')\n with open(join(path, 'issues.txt'), 'w') as doc:\n for title in issues:\n doc.write(str(title)+'\\n')","def get_open_issues_and_prs(repo):\n open_issues = []\n open_pull_requests = []\n params = {\"state\": \"open\"}\n result = github.get(\"/repos/adafruit/\" + repo[\"name\"] + \"/issues\", params=params)\n if not result.ok:\n return [], []\n\n issues = result.json()\n for issue in issues:\n created = datetime.datetime.strptime(issue[\"created_at\"], \"%Y-%m-%dT%H:%M:%SZ\")\n days_open = datetime.datetime.today() - created\n if days_open.days < 0: # opened earlier today\n days_open += datetime.timedelta(days=(days_open.days * -1))\n\n issue_title = \"{0} (Open {1} days)\".format(issue[\"title\"], days_open.days)\n if \"pull_request\" not in issue: # ignore pull requests\n issue_labels = [\"None\"]\n if len(issue[\"labels\"]) != 0:\n issue_labels = [label[\"name\"] for label in issue[\"labels\"]]\n\n issue_dict = {\n \"title\": issue_title,\n \"url\": issue[\"html_url\"],\n \"labels\": issue_labels,\n }\n\n open_issues.append(issue_dict)\n else:\n open_pull_requests.append({issue[\"html_url\"]: issue_title})\n\n return open_issues, open_pull_requests","def find_issue_id(self):","def _search_issues(self, summary):\n try:\n issues = self.jira.get_issues_by_summary(summary)\n except Exception as e:\n logging.error(\"Failed searching issues: \"+ str(e))\n return []\n return issues","def test_api_can_request_issues(self):\n payload = request_github_issues('razat249', 'github-view')\n self.assertEqual(payload['error'], False)\n self.assertLess(payload['status_code'], 400)","def getRelevantPRData():\n prInfoFromAPI = getPRsFromAPI()\n diffHeader = headers.copy()\n diffHeader['Accept'] = \"application/vnd.github.v3.diff\"\n textForReviewPRs = []\n\n for PR in prInfoFromAPI:\n labels = [label[\"name\"] for label in PR['labels']]\n if \"Text for Review\" in labels:\n diffResponse = requests.get(PR[\"url\"], headers=diffHeader)\n diff = diffResponse.text\n # Add the info the list\n textForReviewPRs.append({\n \"pull_request_link\": PR[\"html_url\"],\n \"diff\": diff\n })\n if int(diffResponse.headers[\"X-RateLimit-Remaining\"]) <= 2:\n print('GitHub api rate limit will be exceeded; the GITHUB_TOKEN env variable needs to be set.')\n break\n return textForReviewPRs","def matching_pull_requests(age):\n today = datetime.utcnow().date()\n created = today - relativedelta(years=age)\n response = requests.get(GITHUB + '/search/issues?q=type:pr created:{:%Y-%m-%d} is:open'.format(created))\n return response.json()","def detect_issues(ctx, sha, message):\n\n if sha and message:\n raise click.UsageError('Use either --sha or --message, not both.')\n\n if not sha and not message:\n raise click.UsageError('Must specify either --sha or --message.')\n\n try:\n log.echo('Detecting issue...', break_line=False)\n issues = ctx.obj.github.detect_issues(sha=sha, message=message)\n log.checkmark()\n for issue in issues:\n log.echo('Issue detected: {}'.format(issue.url))\n except BaseException as _:\n log.xmark()\n raise","def getIssuesFromAPI():\n issues = []\n pageNumber = 1\n numberOfIssuesReturned = 1\n while numberOfIssuesReturned != 0:\n issuesResponse = requests.get(\n \"https://api.github.com/repos/greenelab/covid19-review/issues?state=all&per_page=50&page=\" +\n str(pageNumber), headers=headers)\n issues_page = json.loads(issuesResponse.text)\n issues = issues + issues_page\n numberOfIssuesReturned = len(issues_page)\n pageNumber += 1\n return issues","def find_lint_bot_comments(repo, token, pr_number):\n # repo is in the form of \"org/repo\"\n # API doc: https://docs.github.com/en/rest/issues/comments?apiVersion=2022-11-28#list-issue-comments # noqa\n response = requests.get(\n f\"https://api.github.com/repos/{repo}/issues/{pr_number}/comments\",\n headers=get_headers(token),\n )\n response.raise_for_status()\n all_comments = response.json()\n\n failed_comment = \"❌ Linting issues\"\n success_comment = \"✔️ Linting Passed\"\n\n # Find all comments that match the linting bot, and return the first one.\n # There should always be only one such comment, or none, if the PR is\n # just created.\n comments = [\n comment\n for comment in all_comments\n if comment[\"user\"][\"login\"] == \"github-actions[bot]\"\n and (failed_comment in comment[\"body\"] or success_comment in comment[\"body\"])\n ]\n\n if len(all_comments) > 25 and not comments:\n # By default the API returns the first 30 comments. If we can't find the\n # comment created by the bot in those, then we raise and we skip creating\n # a comment in the first place.\n raise RuntimeError(\"Comment not found in the first 30 comments.\")\n\n return comments[0] if comments else None","def test_issue_get_comment(self):\n pass","def markdown_report(issues, commits):\n print()\n print('Handled issues:')\n print()\n\n for issue in issues:\n markdown_item(\n '#{0} {1}'.format(\n issue.number,\n issue.title,\n ),\n issue.html_url,\n )\n\n print()\n print('Commits:')\n print()\n\n for commit in commits:\n markdown_item(\n '{0} - {1}'.format(\n commit.sha[:7],\n commit.commit.message.split('\\n')[0]\n ),\n commit.html_url,\n )","def search_pulls(self, query=None, sort=None, order=None):\n base_q = \"type:pr\"\n\n if query is None:\n query = base_q\n else:\n query = \"{} {}\".format(query, base_q)\n\n return self.search_issues(query, sort, order)","def get_issues(project=\"nipy/nitime\", state=\"closed\", pulls=False):\r\n which = 'pulls' if pulls else 'issues'\r\n url = \"https://api.github.com/repos/%s/%s?state=%s&per_page=%i\" % (project, which, state, PER_PAGE)\r\n return get_paged_request(url)","def report(issues, show_urls=False):\r\n # titles may have unicode in them, so we must encode everything below\r\n if show_urls:\r\n for i in issues:\r\n role = 'ghpull' if 'merged' in i else 'ghissue'\r\n print('* :%s:`%d`: %s' % (role, i['number'],\r\n i['title'].encode('utf-8')))\r\n else:\r\n for i in issues:\r\n print('* %d: %s' % (i['number'], i['title'].encode('utf-8')))","def test_findBugfixes(self):\n bugfixes = self.builder._findChanges(\n self.project, self.builder._BUGFIX)\n self.assertEquals(\n bugfixes,\n [(23, 'Broken stuff was fixed.')])","def visit_all_issues_in_list(self, issues):\n for issue in issues:\n self.driver.implicitly_wait(3)\n self.driver.get(issue)\n config_type_text = self.driver.find_element_by_xpath(\"/html/body/b-service-bootstrap/\"\\\n \"app-root/div[7]/div/div/edit-issue-page/b-resolving-issue-references/div[2]/div[1]/\"\\\n \"div[3]/div/div/div[2]/div[2]/div[3]/div/div[1]/div/span/span[6]/span/span/a\").text\n\n source_html = self.driver.page_source\n soup = BeautifulSoup(source_html, \"html.parser\")\n\n advanced_fields = {}\n advanced_fields[\"Issue Id\"] = issue.replace(\"https://b.corp.google.com/issues/\", \"\")\n reporter_tag = soup.find(\"div\", \"bv2-issue-metadata-field-inner \"\\\n \"bv2-issue-metadata-field-reporter\")\n reporter = reporter_tag[\"aria-label\"].replace(\n \" value is \", \"\\n\").split(\"\\n\")\n advanced_fields[reporter[0]] = reporter[1]\n assignee_tag = soup.find(\"div\", \"bv2-issue-metadata-field-inner bv2-issue-metadata-\"\\\n \"field-assignee\")\n assignee = assignee_tag[\"aria-label\"].replace(\n \" value is \", \"\\n\").split(\"\\n\")\n if assignee[1] != \"empty\":\n advanced_fields[assignee[0]] = assignee[1]\n\n if \"EnqueueRule\" in config_type_text:\n config_type = \"EnqueueRules\"\n elif \"RoutingTargets\" in config_type_text:\n config_type = \"RoutingTargets\"\n elif \"QueueInfo\" in config_type_text:\n config_type = \"QueueInfo\"\n\n advanced_fields[\"Config Type\"] = config_type\n\n if config_type == \"QueueInfo\":\n if assignee[1] != constants.AUTOMATION_USER:\n continue\n\n self.scrape_queue_info(advanced_fields)\n elif config_type == \"RoutingTargets\":\n if assignee[1] != constants.AUTOMATION_USER:\n continue\n self.scrape_routing_targets(advanced_fields)\n elif config_type == \"EnqueueRules\":\n self._message_parsing_util.parse_page(soup, reporter[1], issue)","def getIssues(url):\n r = requests.get(url)\n if r.status_code != 200:\n raise \"There call to the GitHub issues API failed\"\n return r.json()","def _return_specific_comment_prs(all_prs, filters):\n if _validate_list_of_dict(all_prs):\n pr_issue = []\n for pull_request in all_prs:\n issue = pull_request['issue']\n comments = issue.get_comments()\n logger.debug(\"COMMENTS: %s\", [comment.body for comment in comments])\n matched_comments = [comment.body for comment in comments if re.search(filters['comment'], comment.body)]\n if matched_comments:\n pr_issue.append({'pr':pull_request['pr'], 'issue':pull_request['issue']})\n logger.debug(\"MATCHED COMMENTS: %s\", matched_comments)\n return pr_issue\n else:\n return []","def get_issue(self, context):","def get_jira_defects(project):\n return get_jira_issues('project = \"{}\" AND filter = 19589'.format(project))","def get_pull_requests():\n pull_requests = []\n url_base = f\"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/pull/\"\n repo = GITHUB.get_user(GITHUB_OWNER).get_repo(GITHUB_REPO)\n pulls = repo.get_pulls(base=\"main\", state=\"closed\")\n last_release_date = repo.get_latest_release().published_at\n for pull in pulls:\n if not pull.draft and pull.closed_at > last_release_date and pull.merged:\n log_line = f\"* {pull.title} [#{pull.number}]({url_base}{pull.number})\"\n pull_requests.append(log_line)\n return pull_requests","async def pr(ctx, number: Option(int, \"Pull request number\")):\n url = f\"{repo}/issues/{number}\"\n view = discord.ui.View()\n view.add_item(discord.ui.Button(label=\"View Pull Request\", url=url))\n await ctx.respond(f\"Here's a link\", view=view)","async def get_pull_requests(self, issues: list) -> list:\n tasks = []\n async with ClientSession(auth=BasicAuth(*self.auth)) as session:\n for issue in issues:\n data = {\n 'issueId': issue['id'],\n 'applicationType': 'bitbucket',\n 'dataType': 'pullrequest',\n }\n tasks.append(\n asyncio.create_task(\n self._get_pull_requests_for_issue(session, issue, data),\n ),\n )\n\n pull_requests = await asyncio.gather(*tasks)\n\n return self._parser.parse_pull_request_info(pull_requests)","def get_jira_issues(query):\n jira_issues = []\n defects = []\n count, maxlen = 0, 1\n while count < maxlen:\n issues = jira_client.search_issues(query, startAt=count, maxResults=50, expand='changelog')\n jira_issues.extend(issues)\n count = len(jira_issues)\n maxlen = issues.total\n\n return jira_issues","def getissue(s,refconvdf,issuetaglist):\r\n #check if empty\r\n taglist=gettotaltags(s,refconvdf)\r\n issuename=list(set(issuetaglist.name.values).intersection(taglist)) \r\n if not issuename:\r\n return 'None'\r\n else:\r\n return issuename","async def remind_about_pull_requests(self, issues: list) -> None:\n author = deepcopy(self.blocks['author'])\n author['elements'][1]['text'] = self.version\n starting_blocks = [\n self.blocks['header'],\n author,\n self.blocks['divider'],\n ]\n message = {'blocks': deepcopy(starting_blocks)}\n tasks = []\n for issue in issues:\n pull_requests = self._create_pull_requests_descriptions(issue['pull_requests'])\n if pull_requests:\n title = deepcopy(self.blocks['title'])\n title['text']['text'] = f':bender: *[{issue[\"key\"]}] {issue[\"title\"]}*'\n message['blocks'].extend([title] + pull_requests + [self.blocks['divider']])\n\n if len(message['blocks']) > 45:\n tasks.append(asyncio.create_task(self.send_message(message)))\n message = {'blocks': deepcopy(starting_blocks)}\n\n if not tasks:\n tasks = [asyncio.create_task(self.send_message(message))]\n\n set_key_in_redis('slack-known-user-ids', self.known_user_ids)\n await asyncio.gather(*tasks)","def _validate_pr(pull_request):\n title_valid = _validate_title(pull_request[\"title\"])\n commits, all_commits_ok = _validate_commits(pull_request)\n\n report = {\n \"title\": {\"message\": pull_request[\"title\"], \"standard\": title_valid},\n \"commits\": commits,\n }\n\n if not title_valid:\n result = False\n reason = TITLE_FAILURE_REASON\n elif not all_commits_ok:\n result = False\n reason = COMMITS_FAILURE_REASON\n else:\n result = True\n reason = SUCCESS_REASON\n\n return report, result, reason","def issues(self):\r\n return issues.RepoIssues(self)","def issues(self):\r\n return issues.RepoIssues(self)","def locate_fixed_problems(commit_message):\n \n identifiers = set()\n \n commit_message = commit_message.strip()\n lines = commit_message.splitlines()\n \n match_urls = True\n for line in lines:\n ids = identifiers_from_line(line, match_urls)\n if len(ids) == 0:\n match_urls = False\n \n identifiers.update(ids)\n \n return identifiers","def test_issue_edit_issue(self):\n pass","def test_api_can_get_filtered_issues_list(self):\n path = '/issues/?language=python&tech_stack=django&experience_needed=moderate'\n response = self.client.get(path, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertGreater(len(api_response_issues), len(json.loads(response.content)))","def test_issue_get_issue_reactions(self):\n pass","def check_pr_details(self, pr_number):\n pr = self.repo.get_pull(pr_number)\n email_pattern = re.compile(r'^.*@suse\\.(com|cz|de)$')\n\n for commit in pr.get_commits():\n sha = commit.sha\n author = commit.author\n title = message = commit.commit.message\n # Not sure why we need to use the nested commit for the email\n email = commit.commit.author.email\n user_id = f'{author.login}({email})'\n body = ''\n\n # This could be probably smarter but commit contains something like the following\n # message=\"$commit_title\\n\\n$long_commit_message\" and as such maybe we can split it and\n # check for the following limits: title max 50 chars, body max 72 chars per line and at\n # least as long as the commit title to avoid commit message bodies full of whitespaces\n try:\n title, body = message.split('\\n\\n', 1)\n except ValueError:\n print('No commit body was detected')\n\n print(f'Checking commit \"{sha}: {title}\"')\n\n if not email_pattern.fullmatch(email):\n print(f'Checking if {user_id} is part of the SUSE organization...')\n\n if self.org.has_in_members(commit.author):\n print(f'{user_id} is part of SUSE organization but a SUSE e-mail address was not used for commit: {sha}')\n sys.exit(1)\n\n # replace case-insensitive \"(bsc#)\" (or []) and surrounding spaces\n # with a single space, then prune leading/trailing spaces\n title = re.sub(r'\\s*[([]\\s*(?i:bsc)#\\d+\\s*[)\\]]\\s*', ' ', title).strip()\n if len(title) > 50:\n print('Commit message title should be less than 50 characters (excluding the bsc# reference)')\n sys.exit(1)\n\n # No body detected. Nothing else to do here.\n if not body:\n continue\n\n if len(body) < len(title):\n print('Commit message body is too short')\n sys.exit(1)\n\n # strip multi-line '```code```' blocks & lines starting w\\ `code`\n code_pattern = re.compile(\n r'''\n ((?m:^)\\s*```) # multi-line beginning, 0-more whitespace, ```\n (?s:.*?) # non-greedy, zero or more chars, including \\n\n \\1 # whatever matched at the beginning\n | # or...\n (?m:^)\\s*` # start of line, optional whitespace, backtick\n [^`]+ # oneor more non-backtick chars\n `\\s*(?m:$) # and a backtick at the end of the line\n ''',\n re.VERBOSE\n )\n for body_line in re.sub(code_pattern, '', body).splitlines():\n if len(body_line) > 72:\n print('Each line in the commit body should be less than 72 characters')\n sys.exit(1)\n\n print(f'PR-{pr_number} commits verified.')","def getREVIssues(db):\n return map(trimmedREVDoc,\n db.reviews.find({\"done\": False, \"lgtms\": {\"$exists\": False}}))","def test_issue_create_issue(self):\n pass","def github_issue(issue_url: str, check_rate_limit: bool = True) -> Dict[str, Any]:\n user_agent = os.environ.get('THUMBSUP_USER_AGENT', 'thumbsup')\n headers = {\n 'Accept': GITHUB_ACCEPT_HEADER,\n 'User-Agent': user_agent,\n }\n github_token_file = os.environ.get('THUMBSUP_GITHUB_TOKEN_FILE')\n if github_token_file is not None:\n with open(github_token_file, 'r') as ifp:\n github_token = ifp.read().strip()\n if github_token != UNAUTHENTICATED and github_token != '':\n headers['Authorization'] = f'token {github_token}'\n\n if check_rate_limit:\n r = requests.get(GITHUB_RATE_LIMIT_URL, headers=headers)\n rate_limit_response = r.json()\n remaining_rate_limit = (\n rate_limit_response.get('resources', {}).get('core', {}).get('remaining', 0)\n )\n rate_limit_bound = os.environ.get('THUMBSUP_RATE_LIMIT_BOUND', '10')\n rate_limit_bound = int(rate_limit_bound)\n if remaining_rate_limit < rate_limit_bound:\n raise RateLimitError(f'Remaining GitHub rate limit too low: {remaining_rate_limit}')\n\n match = RE_GITHUB_ISSUE_EXTRACTOR.search(issue_url)\n if not match:\n raise SummaryError(f'URL does not match form of link to GitHub Issue: {issue_url}')\n\n owner, repo, issue_number = match.groups()\n\n issue_url = f'https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}'\n r = requests.get(issue_url, headers=headers)\n issue_response = r.json()\n\n comments_url = f'{issue_url}/comments'\n r = requests.get(comments_url, headers=headers)\n comment_response = r.json()\n comment_response.sort(\n key=lambda c: github_num_reactions(c) + github_num_positive_reactions(c),\n reverse=True\n )\n return {\n 'summarizer': 'github_issue',\n 'issue': issue_response,\n 'comments': comment_response,\n 'emojis': GITHUB_EMOJIS\n }","def issues_closed_since(period=timedelta(days=365), project=\"nipy/nitime\", pulls=False):\r\n\r\n which = 'pulls' if pulls else 'issues'\r\n\r\n if isinstance(period, timedelta):\r\n period = datetime.now() - period\r\n url = \"https://api.github.com/repos/%s/%s?state=closed&sort=updated&since=%s&per_page=%i\" % (project, which, period.strftime(ISO8601), PER_PAGE)\r\n allclosed = get_paged_request(url)\r\n # allclosed = get_issues(project=project, state='closed', pulls=pulls, since=period)\r\n filtered = [i for i in allclosed if _parse_datetime(i['closed_at']) > period]\r\n return filtered","def test_obtain_issues(self, mock_url_read):\n mock_url_read.side_effect = [LAST_SCAN, '{\"reportId\": 22}', '{\"status\": {\"value\": \"Created\"}}',\n SAST_REPORT.format(false_positive=False, severity='High')]\n\n self.__report.obtain_issues(['id'], 'high')\n issues = self.__report.issues()\n\n self.assertIsInstance(issues, List)\n self.assertIsInstance(issues[0], Checkmarx.Issue)\n self.assertEqual('JScript Vulnerabilities', issues[0].group)\n self.assertEqual('Reflected XSS', issues[0].title)\n self.assertEqual('http://url/CxWebClient/ScanQueryDescription.aspx?queryID=789&'\n 'queryVersionCode=842956&queryTitle=Reflected_XSS', issues[0].display_url)\n self.assertEqual(1, issues[0].count)\n self.assertEqual(\"Recurrent\", issues[0].status)","def list_issues(self, chat):\n issues = self.url_handler.get_json_from_url(constants.URL_GITHUB)\n msg = ''\n msg += '\\U0001F4CB Issues List\\n\\n'\n for aux in issues:\n msg += \"[[{}]] - {}\\n\\n\".format(str(aux['number']), aux['title'])\n\n self.url_handler.send_message(msg, chat)","def do_the_issues(user_id, repo_id):\n with tempfile.TemporaryDirectory() as tmp:\n path = os.path.join(tmp, \"{}_{}_issues.txt\".format(repo_id, user_id))\n issues_initial_url = get_initial_url_issues(user_id, repo_id)\n resp_obj = requests.get(issues_initial_url, headers=headers)\n # prase the initial request. for Issue\n all_issues = json.loads(resp_obj.text)\n with open(path, \"w\") as out_stream:\n for an_issue in all_issues:\n print(an_issue, file=out_stream)\n print(\"the len of resp is {}\".format(len(all_issues)))\n LINK_HEADER = \"Link\"\n next_url = None\n if LINK_HEADER in resp_obj.headers:\n # parse next page (if present)\n next_url = parse_next_url(resp_obj.headers[LINK_HEADER])\n # subsequent page\n while next_url:\n resp_obj = requests.get(next_url, headers=headers)\n all_issues = json.loads(resp_obj.text)\n with open(path, \"a\") as out_stream:\n for an_issue in all_issues:\n print(an_issue, file=out_stream)\n if LINK_HEADER in resp_obj.headers:\n next_url = parse_next_url(resp_obj.headers[LINK_HEADER])\n print(next_url)\n else:\n next_url = None\n GsUpload.upload_blob(GS_BUCKET_NAME, path, basename(path))\n print(\"the issues path is \" + str(path))","def is_pull_request(issue):\r\n return 'pull_request_url' in issue","def issue_closed():\n parser = argparse.ArgumentParser(description=issue_closed.__doc__)\n\n parser.add_argument(\"project\", help=\"the project name\")\n parser.add_argument(\n \"--column\",\n default=\"done\",\n help=\"the column closed issues should go to, default `done`\",\n )\n\n args = parser.parse_args()\n\n column = args.column.lower()\n\n session = GithubSession()\n\n project = session.get_project(args.project)\n\n for column_data in session.get_columns(project):\n column_name = column_data[\"name\"].lower()\n if column_name == column:\n continue\n\n print(f\"\\nlooking at column {column_name}\")\n\n # print(json.dumps(column_data, indent=4))\n\n for card in session.get_cards(column_data):\n # print(json.dumps(card, indent=4))\n\n issue_data = session.request(\"get\", card[\"content_url\"]).json()\n\n if issue_data[\"state\"] != \"closed\":\n print(\".\", end=\"\")\n\n continue\n\n issue_number = issue_data[\"number\"]\n\n print(f\"\\nmoving issue {issue_number} to {column}\")\n\n issue_column(\n [\n \"issue_column\",\n args.project,\n issue_number,\n column,\n \"--position=bottom\",\n ]\n )","def get_issues(request, project):\n\n try:\n api_response = requests.get(constants.GITHUB_API_GET_ISSUES_URL.format(project_name=project))\n api_response_json = api_response.json()\n if api_response.status_code == 404:\n error_message = \"Repository does not exist\"\n return Response(error_message, status=status.HTTP_404_NOT_FOUND)\n if api_response.status_code == 401:\n raise Exception(\"Authentication fails. Invalid github access token.\")\n response = []\n for issue in api_response_json:\n labels_length = len(issue['labels'])\n tags = []\n # Making custom dictionary for tags\n for i in range(0, labels_length):\n # Searching inside \"labels\" key for tag_name\n for tag, tag_name in issue[\"labels\"][i].items():\n if tag in [\"name\"]:\n label = tag_name\n tags.append(label)\n result = IssueResponse(\n title=issue['title'],\n created_at=issue['created_at'],\n comments=issue['comments'],\n issue_number=issue['number'],\n repository_url=issue['repository_url'],\n labels=tags\n )\n result_as_json = result.to_json()\n response.append(result_as_json)\n\n except Exception:\n return DOWNSTREAM_ERROR_RESPONSE\n\n return Response(response)","def get_repo_issue_comments(owner, repo, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/issues/comments'\n return get_one_item_at_a_time(url, session=session)","def find_svn_issues(cls, svndb):\n print(\"Searching for Mantis issues in SVN log messages\")\n svn_issues = {}\n for entry in svndb.all_entries:\n numlist = IssueFinder.find(entry.loglines, fix_lines=True)\n if numlist is None or len(numlist) == 0:\n continue\n\n numlist.sort()\n svn_issues[entry.revision] = numlist\n\n num_found = len(svn_issues)\n num_total = svndb.num_entries()\n print(\"Found %d referenced issue%s from %d total issue%s\" %\n (num_found, pluralize(num_found), num_total,\n pluralize(num_total)))\n return svn_issues","def _get_suggestion_issues() -> Tuple[Optional[Issue], List[Issue]]:\n article_stages_for_opened_issues = (\n \"waiting\",\n \"proofreading_editor\",\n \"precheck\",\n \"spellcheck\",\n \"markup\",\n \"proofreading_spell\",\n \"proofreading_chief_dpt\",\n \"proofreading_chief\",\n \"publishing\",\n )\n opened_issues = (\n Issue.on_current_site.filter(posts__stage__slug__in=article_stages_for_opened_issues)\n .order_by(\"number\")\n .distinct()\n .all()[:5]\n )\n\n if not opened_issues:\n return None, []\n\n # Convert QuerySet to ordinary list to split for initial and least\n opened_issues: List[Issue] = list(opened_issues)\n initial_issue = opened_issues.pop()\n opened_issues.reverse()\n\n return initial_issue, opened_issues","def test_get_updated_issues_one_page(self):\n with open(\"issues_one_page.json\", \"r\") as issues_file:\n mock_response = issues_file.read()\n\n with requests_mock.Mocker() as m:\n m.register_uri('GET', '/rest/api/2/search', text=mock_response)\n issues = jiratimereport.get_updated_issues(\"https://jira_url\", \"user_name\", \"api_token\", \"MYB\",\n \"2020-01-10\", \"2020-01-20\", \"\")\n\n issues_expected_result = [\n Issue(10005, \"MYB-5\", \"Summary of issue MYB-5\", \"MYB-3\", \"Summary of the parent issue of MYB-5\", 3600, 900, datetime(2020, 1, 20)),\n Issue(10004, \"MYB-4\", \"Summary of issue MYB-4\", \"MYB-3\", \"Summary of the parent issue of MYB-4\", 7200, 600, None)]\n\n self.assertListEqual(issues_expected_result, issues, \"Issues lists are unequal\")","def get_repo_issues(owner, repo, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/issues'\n query_params = {'state': 'all'}\n return get_one_item_at_a_time(url, query_params, session)","def get_sprint_board_issues(self) -> list:\n endpoint_path = f'agile/1.0/sprint/{self.sprint}/issue'\n data = {\n 'jql': 'status=\"In Review\"',\n 'fields': ['assignee', 'status', 'summary'],\n }\n response = self._get(endpoint_path, data)\n return self._parser.filter_out_important_data(response)","def get_review_comments_for_pr(owner, repo, pr_number, session=None):\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\n return get_one_item_at_a_time(url, session=session)","def get_open_pull_requests(self, required_labels=None):\n json = self.get_all('repos/%(owner)s/%(repo)s/pulls' % {\n 'owner': self.repo_owner,\n 'repo': self.repo_name,\n }, params={\n 'direction': 'asc',\n })\n required_labels = required_labels or []\n\n prs = []\n for pr_data in json:\n # Construct the pull request and issue data structures\n pr_id = pr_data['number']\n issue_obj = self.get_issue(pr_id)\n pr_obj = PullRequest(pr_id, pr_data['title'], pr_data['body'], pr_data['head']['ref'],\n pr_data['html_url'], pr_data['created_at'], pr_data['updated_at'], issue_obj)\n\n # Check if the PR survives the filters\n include_pr = True\n for required_label in required_labels:\n if not pr_obj.has_label(required_label):\n include_pr = False\n break\n if include_pr:\n prs.append(pr_obj)\n\n return prs","def slurm_check(path='.'):\n for file in shrunner.get_files(path, '.out'):\n with open(file, 'r') as f:\n for line in f.read().splitlines():\n if 'issue' in line.lower():\n print(file)\n print(line)\n print('-' * 40)","def test_issue_get_milestone(self):\n pass","def search_issues(self, query=None, sort=None, order=None):\n params = {}\n\n repo_q = \"repo:{}/{}\".format(self.owner, self.label)\n\n if query is not None:\n params[\"q\"] = \"{} {}\".format(query, repo_q)\n else:\n params[\"q\"] = repo_q\n\n if sort is not None:\n params[\"sort\"] = sort\n\n if order is not None:\n params[\"order\"] = order\n\n return self.client.request(\"/search/issues\", params or None)","def test_api_request_can_handle_errors(self):\n # wrong repo name to test error handling.\n payload = request_github_issues('razat249', 'wrong_repo')\n self.assertEqual(payload['error'], True)\n self.assertGreaterEqual(payload['status_code'], 400)","def review(args):\n try:\n pr = gh.get_pr(owner, repo, args.pull_request)\n except requests.exceptions.HTTPError:\n print('Couldn\\'t find pull request #%s in %s/%s.' %\n (args.pull_request, owner, repo))\n print('Make sure the number is correct and that you have read '\n 'permissions for this GitHub repository.')\n sys.exit(1)\n\n clone_url = pr['head']['repo']['clone_url']\n fork_branch = pr['head']['ref']\n fork_owner = pr['head']['repo']['owner']['login']\n\n repo_lib.fetch_fork(clone_url, fork_branch, fork_owner)\n repo_lib.checkout(fork_branch, fork_owner)\n sys.exit(0)","def get_pr_info(num):\r\n url = \"https://api.github.com/repos/edx/edx-platform/pulls/{num}\".format(num=num)\r\n username, token = get_github_creds()\r\n headers = {\r\n \"Authorization\": \"token {}\".format(token),\r\n \"User-Agent\": \"edx-release\",\r\n }\r\n response = requests.get(url, headers=headers)\r\n result = response.json()\r\n if not response.ok:\r\n raise requests.exceptions.RequestException(result[\"message\"])\r\n return result","def parse_status_file(jira, filename, issues):\n # Regexp to match Jira issue on a single line, i.e:\n # [SWG-28]\n # [LITE-32]\n # ...\n regex = r\"^\\[([A-Z]+-[0-9]+).*\\]\\n$\"\n\n # Regexp to match a tag that indicates we should stop processing, ex:\n # [STOP]\n # [JIPDATE-STOP]\n # [OTHER]\n # ...\n regex_stop = r\"^\\[.*\\]\\n$\"\n\n # Regexp to mach a tag that indicates to stop processing completely:\n # [FIN]\n regex_fin = r\"^\\[FIN\\]\\n$\"\n\n # Regexp to match for a status update, this will remove 'Status' from the\n # match:\n regex_status = r\"(?:^Status:) *(.+)\\n$\"\n\n # Contains the status text, it could be a file or a status email\n status = \"\"\n\n # Regexp to match for a time spent update, this will remove 'Time spent:'\n # from the match:\n regex_timespent = r\"(^Time spent:) \\d+\\w\\n$\"\n\n # List of resolutions (when doing a transition to Resolved). Query once globally.\n resolution_map = dict([(t.name.title(), t.id) for t in jira.resolutions()])\n\n with open(filename) as f:\n status = f.readlines()\n\n myissue = \"\"\n mycomment = \"\"\n\n # build list of {issue,comment} tuples found in status\n issue_comments = []\n for line in status:\n # New issue?\n match = re.search(regex, line)\n\n # Evaluate and save the transition regex for later. We have to do this\n # here, since we cannot assign and save the variable in the if\n # construction as you can do in C for example.\n transition = re.search(regex_status, line)\n\n if match:\n myissue = match.group(1)\n validissue = True\n\n # if we ran a query, we might already have fetched the issue\n # let's try to find the issue there first, otherwise ask Jira\n try:\n issue = [x for x in issues if str(x) == myissue][0]\n issue_comments.append((issue, \"\", \"\", None))\n\n # IndexError: we had fetched already, but issue is not found\n # TypeError: issues is None, we haven't queried Jira yet, at all\n except (IndexError, TypeError) as e:\n try:\n issue = jira.issue(myissue)\n issue_comments.append((issue, \"\", \"\", None))\n except Exception as e:\n if \"Issue Does Not Exist\" in e.text:\n print(\"[{}] : {}\".format(myissue, e.text))\n validissue = False\n\n # Stop parsing entirely. This needs to be placed before regex_stop\n # or the .* will match and [FIN] won't be processed\n elif re.search(regex_fin, line):\n break\n # If we have non-JIRA issue tags, stop parsing until we find a valid tag\n elif re.search(regex_stop, line):\n validissue = False\n elif transition and validissue:\n # If we have a match, then the new status should be first in the\n # group. Jira always expect the name of the state transitions to be\n # word capitalized, hence the call to the title() function. This\n # means that it doesn't matter if the user enter all lower case,\n # mixed or all upper case. All of them will work.\n new_status = transition.groups()[0].title()\n (i, c, _, ts) = issue_comments[-1]\n issue_comments[-1] = (i, c, new_status, ts)\n elif re.search(regex_timespent, line, re.IGNORECASE):\n timespent = line.split(\":\")[1].strip()\n (i, c, t, _) = issue_comments[-1]\n issue_comments[-1] = (i, c, t, timespent)\n else:\n # Don't add lines with comments\n if line[0] != \"#\" and issue_comments and validissue:\n (i, c, t, ts) = issue_comments[-1]\n issue_comments[-1] = (i, c + line, t, ts)\n\n issue_upload = []\n print(\"These JIRA cards will be updated as follows:\\n\")\n for idx, t in enumerate(issue_comments):\n (issue, comment, transition, timespent) = issue_comments[idx]\n\n # Strip beginning and trailing blank lines\n comment = comment.strip(\"\\n\")\n\n # initialize here to avoid unassigned variables and useless code complexity\n resolution_id = transition_id = None\n resolution = transition_summary = \"\"\n\n if transition != \"\" and transition != str(issue.fields.status):\n # An optional 'resolution' attribute can be set when doing a transition\n # to Resolved, using the following pattern: Resolved / <resolution>\n if (\n transition.startswith(\"Resolved\") or transition.startswith(\"Closed\")\n ) and \"/\" in transition:\n (transition, resolution) = map(str.strip, transition.split(\"/\"))\n if not resolution in resolution_map:\n print(\n 'Invalid resolution \"{}\" for issue {}'.format(resolution, issue)\n )\n print(\"Possible resolution: {}\".format([t for t in resolution_map]))\n sys.exit(1)\n resolution_id = resolution_map[resolution]\n\n transition_map = dict(\n [(t[\"name\"].title(), t[\"id\"]) for t in jira.transitions(issue)]\n )\n if not transition in transition_map:\n print('Invalid transition \"{}\" for issue {}'.format(transition, issue))\n print(\"Possible transitions: {}\".format([t for t in transition_map]))\n sys.exit(1)\n\n transition_id = transition_map[transition]\n if resolution:\n transition_summary = \" %s => %s (%s)\" % (\n issue.fields.status,\n transition,\n resolution,\n )\n else:\n transition_summary = \" %s => %s\" % (issue.fields.status, transition)\n\n if comment == \"\" and not transition_id:\n log.debug(\n \"Issue [%s] has no comment or transitions, not updating the issue\"\n % (issue)\n )\n continue\n\n issue_upload.append(\n (\n issue,\n comment,\n {\"transition\": transition_id, \"resolution\": resolution_id},\n timespent,\n )\n )\n print(\n \"[%s]%s\\n %s\"\n % (issue, transition_summary, \"\\n \".join(comment.splitlines()))\n )\n if timespent:\n print(\" Time spent: %s\" % timespent)\n print(\"\")\n\n issue_comments = issue_upload\n if issue_comments == [] or cfg.args.dry_run or should_update() == \"n\":\n if issue_comments == []:\n print(\"No change, Jira was not updated!\\n\")\n else:\n print(\"Comments will not be written to Jira!\\n\")\n if not cfg.args.s:\n print_status(status)\n sys.exit()\n\n # if we found something, let's update jira\n for issue, comment, transition, timespent in issue_comments:\n update_jira(jira, issue, comment, transition, timespent)\n\n print(\"Successfully updated your Jira tickets!\\n\")\n if not cfg.args.s:\n print_status(status)","def test_get_release_pr_no_pulls():\n with patch(\n 'github.requests.get', return_value=Mock(json=Mock(return_value=[OTHER_PR]))\n ):\n assert get_release_pr('access_token', 'org', 'repo-missing') is None","def test_get_updated_issues_without_parent(self):\n with open(\"issues_without_parent.json\", \"r\") as issues_file:\n mock_response = issues_file.read()\n\n with requests_mock.Mocker() as m:\n m.register_uri('GET', '/rest/api/2/search', text=mock_response)\n issues = jiratimereport.get_updated_issues(\"https://jira_url\", \"user_name\", \"api_token\", \"MYB\",\n \"2020-01-10\", \"2020-01-20\", \"\")\n\n issues_expected_result = [\n Issue(10005, \"MYB-5\", \"Summary of issue MYB-5\", None, None, 3600, 900, None)]\n\n self.assertListEqual(issues_expected_result, issues, \"Issues lists are unequal\")","def report_tests(args, test_summary):\n try:\n if None not in [args.repo_github_token, args.repo_owner, args.repo_name, args.pr_number]:\n comment_on_pr(args.repo_github_token, test_summary, args.repo_owner, args.repo_name, args.pr_number)\n\n except Exception as e:\n logging.error(\"Posting test report on PR failed with error '{ERROR}'\".format(ERROR=e))","def get_project_issues(repo_slug, max_issues_per_project=None, max_date=None):\n # type: (str, int, str) -> pd.DataFrame\n logging.info(\"Processing %s\", repo_slug)\n all_issues = pd.DataFrame(\n json_imap({\n 'reporter': 'user__login',\n 'role': 'author_association',\n 'number': 'number',\n 'title': 'title',\n 'created_at': 'created_at',\n 'body': 'body',\n 'state': 'state',\n },\n api.repo_issues(repo_slug)),\n ).sort_values('created_at')\n if max_date:\n all_issues = all_issues[all_issues['created_at'] < max_date]\n last_reported = all_issues.groupby(\n 'reporter').last().iloc[:max_issues_per_project]\n first_reported = all_issues.groupby('reporter').first()['created_at']\n # int(timedelta) is ns, times 86400 seconds in a day\n last_reported['tenure'] = (\n pd.to_datetime(last_reported['created_at'])\n - pd.to_datetime(last_reported.index.map(first_reported))\n ).astype(int) // 86400000000000\n last_reported['project'] = repo_slug\n return last_reported.reset_index().sort_values('number')","def test_issue_get_comment_reactions(self):\n pass","def issues_by_id(self, repository_id, access_token=None):\n return self._complete_request_by_id(\n repository_id, \"issues\", access_token)","def get_jira_issues(jira, username):\n exclude_stories = cfg.args.x\n epics_only = cfg.args.e\n all_status = cfg.args.all\n filename = cfg.args.file\n user = cfg.args.user\n last_comment = cfg.args.l\n\n issue_types = [\"Sub-task\", \"Epic\"]\n if not epics_only:\n issue_types.append(\"Initiative\")\n if not exclude_stories:\n issue_types.extend([\"Story\", \"Task\", \"Sub-task\", \"Bug\"])\n issue_type = \"issuetype in (%s)\" % \", \".join(issue_types)\n\n status = 'status in (\"In Progress\")'\n if all_status:\n status = \"status not in (Resolved, Closed)\"\n\n if user is None:\n user = \"currentUser()\"\n else:\n user = '\"%s\"' % add_domain(user)\n\n jql = \"%s AND assignee = %s AND %s\" % (issue_type, user, status)\n log.debug(jql)\n\n my_issues = jira.search_issues(jql)\n if my_issues.total > my_issues.maxResults:\n my_issues = jira.search_issues(jql, maxResults=my_issues.total)\n\n showdate = strftime(\"%Y-%m-%d\", gmtime())\n subject = \"Subject: [Weekly] Week ending \" + showdate + \"\\n\\n\"\n\n msg = get_header()\n if msg != \"\":\n msg += email_to_name(username) + \"\\n\\n\"\n\n f = open_file(filename)\n filename = f.name\n\n f.write(subject)\n\n f.write(msg)\n log.debug(\"Found issue:\")\n for issue in my_issues:\n log.debug(\"%s : %s\" % (issue, issue.fields.summary))\n\n if merge_issue_header():\n f.write(\n \"[%s%s%s]\\n\" % (issue, get_header_separator(), issue.fields.summary)\n )\n else:\n f.write(\"[%s]\\n\" % issue)\n f.write(\"# Header: %s\\n\" % issue.fields.summary)\n\n f.write(\"# Type: %s\\n\" % issue.fields.issuetype)\n f.write(\"# Status: %s\\n\" % issue.fields.status)\n f.write(get_extra_comments())\n if last_comment:\n write_last_jira_comment(f, jira, issue)\n f.write(\"\\n\")\n\n f.close()\n return (filename, my_issues)","def test_api_can_get_issues_list(self):\n response = self.client.get('/issues/', format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(len(api_response_issues), len(json.loads(response.content)))","def dependent_prs(self):\n comments = self.data['body'].replace('\\r\\n', ' ')\n for comment in self.comments():\n comments += comment['body'].replace('\\r\\n', ' ')\n\n dependent_prs = []\n dependent_keywords = ['depends on']\n for keyword in dependent_keywords:\n pattern = r'%s %s/(\\S+)/(\\S+)/pull/(\\d+)' % (keyword, GITHUB)\n LOGGER.info(\"Finding dependent PRs by '%s' in the comments\")\n dependent_prs += re.findall(pattern, comments)\n return set(dependent_prs)","def test_get_existing_issue_passes(self):\n response = self.client.get(self.url)\n response_json = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.assertEqual(response_json[\"name\"], TEST_ISSUE_NAME)","def _validate_commits(pull_request):\n commits = github.get_commits(pull_request[\"commits_url\"])\n analyzed = []\n\n for commit_wrapper in commits:\n commit = {\n \"sha\": commit_wrapper[\"sha\"],\n \"message\": commit_wrapper[\"commit\"][\"message\"],\n }\n\n commit[\"standard\"] = _validate_title(commit[\"message\"])\n analyzed.append(commit)\n\n result = all(commit[\"standard\"] for commit in analyzed)\n return analyzed, result","def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\n reviewers_mapping = {}\n\n # Reviewers are supposed to be those mentions who have given thumbs up.\n for comment in issue_comments:\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\n reviewers_mapping[comment.user.login] = dict(\n tagged_at=None,\n responded_at=None,\n gave_thumbs_up_at=comment.created_at\n )\n\n # We have reviewers, now, look for the time for their first response in issue comments.\n for comment in issue_comments:\n if comment.user.login in reviewers_mapping.keys() \\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n # TODO: Scrap the time when the PR's body was updated.\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\n # for the reviewers that are in PR's body.\n\n # Look for time when each of reviewer was tagged, this should be\n # searched in pull request body and issue comments.\n for login in reviewers_mapping.keys():\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\n if reviewers_mapping[login]['responded_at'] is None \\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\n reviewers_mapping[login]['tagged_at'] = comment.created_at\n\n # Check for reviewers' first response in review comments too, and\n # update the reviewers_mapping if necessary.\n for comment in review_comments:\n if comment.user.login in reviewers_mapping.keys():\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\n\n return reviewers_mapping","def get_issues(self, start=None):\n\n page = 0 # current page\n last_page = None # last page\n url_next = self.__get_issues_url(start)\n\n logger.debug(\"Get GitHub issues from \" + url_next)\n r = self.__send_request(url_next, self.__get_payload(start),\n self.__get_headers())\n issues = r.text\n page += 1\n\n if 'last' in r.links:\n last_url = r.links['last']['url']\n last_page = last_url.split('&page=')[1].split('&')[0]\n last_page = int(last_page)\n logger.debug(\"Page: %i/%i\" % (page, last_page))\n\n while issues:\n yield issues\n\n issues = None\n\n if 'next' in r.links:\n url_next = r.links['next']['url'] # Loving requests :)\n r = self.__send_request(url_next, self.__get_payload(start), self.__get_headers())\n page += 1\n issues = r.text\n logger.debug(\"Page: %i/%i\" % (page, last_page))","def getIssuesEmail(self):\r\n base_url = \"http://beta.boost.org/development/tests/\"\r\n base_url += self.branch\r\n base_url += \"/developer/\";\r\n got_issues = False\r\n\r\n # Ping the server by looking for an HTML file\r\n print \"Pinging the server to initiate extraction...\"\r\n ping_url = base_url + \"issues.html\"\r\n os.system('curl -O ' + ping_url)\r\n os.system('rm -f issues.html')\r\n \r\n for x in range(30):\r\n # Update issues-email.txt\r\n url = base_url + \"issues-email.txt\"\r\n print 'Retrieving issues email from ' + url\r\n os.system('rm -f issues-email.txt')\r\n os.system('curl -O ' + url)\r\n\r\n if self.parseIssuesEmail():\r\n return True\r\n\r\n print 'Failed to fetch issues email. '\r\n time.sleep (30)\r\n\r\n return False","def issues(self):\r\n return issues.Issues(self)","def test_too_many_releases():\n pulls = [RELEASE_PR, RELEASE_PR]\n with pytest.raises(Exception) as ex, patch(\n 'github.requests.get', return_value=Mock(json=Mock(return_value=pulls))\n ):\n get_release_pr('access_token', 'org', 'repo')\n\n assert ex.value.args[0] == \"More than one pull request for the branch release-candidate\"","def issues_list(self, mar, request):\n if request.additionalProject:\n for project_name in request.additionalProject:\n project = self._services.project.GetProjectByName(\n mar.cnxn, project_name)\n if project and not permissions.UserCanViewProject(\n mar.auth.user_pb, mar.auth.effective_ids, project):\n raise permissions.PermissionException(\n 'The user %s has no permission for project %s' %\n (mar.auth.email, project_name))\n url_params = [(name, mar.GetParam(name)) for name in\n framework_helpers.RECOGNIZED_PARAMS]\n # TODO(jrobbins): This should go through work_env.\n pipeline = frontendsearchpipeline.FrontendSearchPipeline(\n mar.cnxn, self._services, mar.auth, [mar.me_user_id], mar.query,\n mar.query_project_names, mar.num, mar.start, url_params, mar.can,\n mar.group_by_spec, mar.sort_spec, mar.warnings, mar.errors,\n mar.use_cached_searches, mar.profiler, display_mode=mar.mode,\n project=mar.project)\n if not mar.errors.AnyErrors():\n pipeline.SearchForIIDs()\n pipeline.MergeAndSortIssues()\n pipeline.Paginate()\n else:\n raise endpoints.BadRequestException(mar.errors.query)\n\n issue_list = [\n api_pb2_v1_helpers.convert_issue(\n api_pb2_v1.IssueWrapper, r, mar, self._services)\n for r in pipeline.visible_results]\n return api_pb2_v1.IssuesListResponse(\n kind='monorail#issueList',\n totalResults=pipeline.total_count,\n items=issue_list)","def test_issue_list_labels(self):\n pass","def getRelevantIssues(db, data):\n last_updated = data.get('updated', None)\n query = {'$and': [\n {'jira.fields.issuetype.name': {'$nin': ['Tracking']}},\n {'jira.fields.project.key': {'$in': ['CS', 'MMSSUPPORT', 'SUPPORT',\n 'PARTNER']}},\n ]\n }\n\n if last_updated is None:\n # Only filter the first time, since we want to know if issues on the\n # dashboard have closed\n query['$and'].append({'jira.fields.status.name': {\n '$in': ['Open', 'Reopened', 'In Progress',\n 'Waiting for Customer', 'Waiting For User Input']}\n }\n )\n else:\n query[\"$and\"].append({\"jira.fields.updated\": {\n \"$gte\": last_updated\n }\n })\n\n # Only need these fields for determining if they belong, and displaying\n # them on the dashboard\n proj = {'_id': 0,\n 'dash.active.now': 1,\n 'deleted': 1,\n 'jira.fields.assignee': 1,\n 'jira.fields.created': 1,\n 'jira.fields.issuetype': 1,\n 'jira.fields.labels': 1,\n 'jira.fields.priority.id': 1,\n 'jira.fields.reporter': 1,\n 'jira.fields.status': 1,\n 'jira.fields.updated': 1,\n 'jira.fields.comment.comments.author.emailAddress': 1,\n 'jira.fields.comment.comments.created': 1,\n 'jira.fields.comment.comments.updated': 1,\n 'jira.fields.comment.comments.visibility': 1,\n 'jira.key': 1,\n 'jira.tags': 1,\n 'sla': 1,\n }\n cur = db.issues.find(query, proj)\n cur.batch_size(100000)\n return cur","def issueListing(self, v, i):\n #list of URLS within the issue\n# links = []\n issURL = self.link(vol = v, iss = i )\n html=urlopen(issURL)\n soup=BeautifulSoup(html,'html.parser')\n URLs = [] #Empty list\n \n# titles = soup.find_all('h5', class_=\"title\")\n# authors = soup.find_all('h6', class_=\"authors\")\n# pubs = soup.find_all('h6', class_=\"pub-info\")\n# for t, a, p in zip(titles, authors, pubs):\n blocks = soup.find_all('div', class_=\"article panel article-result\")\n for b in blocks:\n# print(b)\n titletag = b.find('h5', class_=\"title\")\n title = titletag.get_text()\n #Extract abstract url from title head\n aURL = titletag.find('a', href = True)['href']\n alink = 'https://journals.aps.org' + aURL\n #Print out the scraped information\n print(title)\n print(alink)\n #Extract research area and topic keywords\n kwlist = b.find('ul', class_=\"inline-list subjects\")\n #If the list tag exists\n if kwlist:\n lis = kwlist.find_all('li')\n kws = [li.get_text() for li in lis] \n print(kws)\n #Add utf-8 encode\n# print(kws.encode('utf-8')) \n print('----------------------------------------------------------------') \n #Collect URLs in the issue\n URLs.append('https://journals.aps.org' + aURL)\n return URLs","async def get_issues(self) -> [\"AIOGitHubAPIRepositoryIssue\"]:\n _endpoint = f\"/repos/{self.full_name}/issues\"\n\n response = await self.client.get(endpoint=_endpoint)\n return [AIOGitHubAPIRepositoryIssue(self.client, x) for x in response or []]","def test_issues_list(self):\n response = self.client.get(url_for('issues.issuesresource'))\n self.assertEqual(response.status_code, 200)\n self.assertTrue(response.json)","def find_issue_in_target(connection, issue):\n check_jql = 'project = %s and \"SPIN Issue ID\" ~ %s' % (DST_PROJECT, issue.key)\n\n return find_one_issue(connection, check_jql)","def _return_specific_status_prs(all_prs, filters):\n if _validate_list_of_dict(all_prs):\n pr_issue = []\n for pull_request in all_prs:\n commits = pull_request['pr'].get_commits()\n statuses = [[status.state] for status in commits.reversed[0].get_statuses() if filters['status'] == status.state]\n if statuses:\n pr_issue.append({'pr':pull_request['pr'], 'issue':pull_request['issue']})\n statuses = []\n logger.debug(\"SPECIFIC PR STATUSES: %s\", [pr['pr'].number for pr in pr_issue])\n return pr_issue\n else:\n return []","def run_tests(self):\n self.ignore_errors()\n return self.issues","def resolve_issues(user_input):\n\n iids = []\n\n issue_match = re.compile(\n r\"\"\"^\\s*[iI](?P<iid>[0-9]+)\\s*$\"\"\",\n re.VERBOSE\n ) \n\n for needle in user_input:\n match = issue_match.match(needle)\n if not match:\n vlog(2, 'unable to resolve %s to an issue' % (needle))\n continue\n\n iids.append(int(match.group('iid')))\n\n return iids","def getIssues(db, data):\n start = datetime.utcnow() # Time this and log how long refreshing took.\n try:\n cur = getRelevantIssues(db, data)\n except pymongo.errors.PyMongoError as e:\n return {\"error\": \"Error querying the Mongo database: \" +\n e.message}\n\n count = 0\n dbd_data = {\n # TODO: make sets of these to make the lookups below faster\n \"SLA\": data.get(\"SLA\", []),\n \"FTS\": data.get(\"FTS\", []),\n \"REV\": [], # Just refresh these every time\n \"UNA\": data.get(\"UNA\", []),\n \"active\": data.get(\"active\", {}),\n \"waiting\": data.get(\"waiting\", {})\n }\n\n try:\n revIssues = getREVIssues(db)\n except pymongo.errors.PyMongoError as e:\n return {\"error\": \"Error querying the Mongo database: \" +\n e.message}\n\n updated_data = {\n \"SLA\": [],\n \"FTS\": [],\n \"REV\": revIssues,\n \"UNA\": []\n }\n for i in cur:\n count += 1\n issue = SupportIssue().fromDoc(i)\n\n # Keep track of the totals:\n # --- Active issue count ---\n if issue.isActive():\n dbd_data['active'][issue.key] = 1\n elif issue.key in dbd_data['active']:\n del dbd_data['active'][issue.key]\n # --- Waiting For Customer issue count ---\n if issue.isWFC() and not issue.doc['deleted']:\n dbd_data['waiting'][issue.key] = 1\n elif issue.key in dbd_data['waiting']:\n del dbd_data['waiting'][issue.key]\n\n # For each category, see if the issue belongs, and if not, remove it\n # from the dashboard issues if it was there.\n if isSLA(issue):\n updated_data[\"SLA\"].append(trimmedSLAIssue(issue))\n else:\n removeCompressedIssueIfPresent(issue, dbd_data[\"SLA\"])\n if isFTS(issue):\n updated_data[\"FTS\"].append(trimmedFTSIssue(issue))\n else:\n removeCompressedIssueIfPresent(issue, dbd_data[\"FTS\"])\n if isUNA(issue):\n updated_data[\"UNA\"].append(trimmedUNAIssue(issue))\n else:\n removeCompressedIssueIfPresent(issue, dbd_data[\"UNA\"])\n\n mergeAndSortIssues(dbd_data, updated_data)\n\n duration = datetime.utcnow() - start\n logger.info(\"getIssues took {0}, count: {1}\".format(duration, count))\n return dbd_data","def test_correct_issue_parsing(self):\n issue = SAMPLE_ISSUE.copy()\n parsed = parse_issue(issue['body'])\n for item in parsed:\n self.assertTrue(item)","def test_issue(self):\n issue = Checkmarx.Issue('a_group', 'the_name', 'http://url', 3, 'New')\n\n self.assertEqual('a group', issue.group)\n self.assertEqual('the name', issue.title)\n self.assertEqual('http://url', issue.display_url)\n self.assertEqual(3, issue.count)\n self.assertEqual('New', issue.status)","def test_get_repositories_by_username_by_repo_slug_pullrequests_by_pull_request_id_statuses(self):\n pass","def test_issue_edit_comment(self):\n pass","def test_obtain_issues_exclude_wrong_severity(self, mock_url_read):\n mock_url_read.side_effect = [LAST_SCAN, '{\"reportId\": 22}', '{\"status\": {\"value\": \"Created\"}}',\n SAST_REPORT.format(false_positive=False, severity='Low')]\n self.__report.obtain_issues(['id'], 'high')\n issues = self.__report.issues()\n self.assertIsInstance(issues, List)\n self.assertEqual(len(issues), 0)","def _get_issue(repo, objid):\n issue = None\n if not repo.settings.get(\"issue_tracker\", True):\n raise PagureEvException(\"No issue tracker found for this project\")\n\n session = _get_session()\n issue = pagure.lib.query.search_issues(session, repo, issueid=objid)\n\n if issue is None or issue.project != repo:\n raise PagureEvException(\"Issue '%s' not found\" % objid)\n\n if issue.private:\n # TODO: find a way to do auth\n raise PagureEvException(\n \"This issue is private and you are not allowed to view it\"\n )\n\n return issue"],"string":"[\n \"def test_issue_list_issues(self):\\n pass\",\n \"def get_issues(): # pragma: no cover\\n global issue_data\\n team = {\\n 'stevex196x': 0,\\n 'TheSchaft': 0,\\n 'melxtru': 0,\\n 'aylish19': 0,\\n 'connormlewis': 0,\\n 'tsukkisuki': 0\\n }\\n all_issues = 0\\n while all_issues == 0:\\n url = ('https://api.github.com/repos/connormlewis/idb/'\\n 'issues?state=all&filter=all&per_page=100')\\n data = requests.get(\\n url, headers={'Authorization': 'token ' + os.environ['API_TOKEN']})\\n link = data.headers.get('Link', None)\\n for i in range(1, int(find_last_page(link)) + 1):\\n url = (\\n 'https://api.github.com/repos/connormlewis/idb/'\\n 'issues?state=all&filter=all&per_page=100' + '&page=' + str(i))\\n data = requests.get(\\n url,\\n headers={'Authorization': 'token ' + os.environ['API_TOKEN']})\\n json_list = data.json()\\n for entry in json_list:\\n if 'pull_request' not in entry:\\n all_issues += 1\\n if entry['user']['login'] in team:\\n team[entry['user']['login']] += 1\\n return team, all_issues\",\n \"def test_issue_get_repo_comments(self):\\n pass\",\n \"def test_issue_search_issues(self):\\n pass\",\n \"def test_issue_get_issue(self):\\n pass\",\n \"async def _get_pull_requests_for_issue(self, session: ClientSession, issue: dict, data: dict) -> dict:\\n url = self._build_url('dev-status/1.0/issue/detail')\\n async with session.get(url, params=data) as resp:\\n response = await resp.json()\\n response['detail'][0].update(issue)\\n return response\",\n \"def test_issue_get_comments(self):\\n pass\",\n \"def main():\\n verbose = False\\n online = True\\n\\n if online:\\n TOKEN = \\\"\\\"\\n g = Github(base_url=\\\"https://github.ibm.com/api/v3\\\", login_or_token=TOKEN)\\n repo = g.get_repo(\\\"Raphael-Lambert/test_note\\\")\\n\\n path = \\\"C:/Users/RaphaelLambert/Documents/git_issues\\\"\\n onlyfiles = [f for f in listdir(path) if isfile(join(path, f))]\\n if verbose:\\n print(onlyfiles)\\n treated = []\\n issues = []\\n\\n with open(join(path, 'log.txt'), 'r') as doc:\\n for line in doc:\\n treated.append(line.rstrip('\\\\n'))\\n\\n with open(join(path, 'issues.txt'), 'r') as doc:\\n for line in doc:\\n issues.append(int(line.rstrip('\\\\n')))\\n\\n for title in onlyfiles:\\n if title != 'log.txt' and title != 'issues.txt' and title not in treated:\\n with open(join(path, title), 'rb') as fhdl:\\n raw_email = fhdl.read()\\n\\n parsed_eml = eml_parser.eml_parser.decode_email_b(raw_email, include_raw_body=True)\\n if verbose:\\n print('-----------------')\\n print(title)\\n print('-----------------')\\n print(parsed_eml)\\n print('-----------------')\\n body = parsed_eml['body']\\n if len(body) > 0:\\n raw_text = body[0]['content']\\n else:\\n raw_text = \\\"unable to retrieve the message\\\"\\n raw_text = link_breaker(raw_text)\\n num_get = 0\\n if online and title[:4] == 'Re ' and title[4:] in treated:\\n cont_issue = repo.get_issue(issues[treated.index(title[4:])])\\n num_get = cont_issue.number\\n cont_issue.create_comment(body=raw_text)\\n elif online:\\n new_issue = repo.create_issue(title=\\\"Conversation number {}: {}\\\".format(len(treated), title[:10]+\\\"...\\\"),\\n body=raw_text)\\n if verbose:\\n print(new_issue)\\n num_get = new_issue.number\\n treated.append(title)\\n issues.append(num_get)\\n\\n if verbose:\\n print(treated)\\n\\n with open(join(path, 'log.txt'), 'w') as doc:\\n for title in treated:\\n doc.write(title+'\\\\n')\\n with open(join(path, 'issues.txt'), 'w') as doc:\\n for title in issues:\\n doc.write(str(title)+'\\\\n')\",\n \"def get_open_issues_and_prs(repo):\\n open_issues = []\\n open_pull_requests = []\\n params = {\\\"state\\\": \\\"open\\\"}\\n result = github.get(\\\"/repos/adafruit/\\\" + repo[\\\"name\\\"] + \\\"/issues\\\", params=params)\\n if not result.ok:\\n return [], []\\n\\n issues = result.json()\\n for issue in issues:\\n created = datetime.datetime.strptime(issue[\\\"created_at\\\"], \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n days_open = datetime.datetime.today() - created\\n if days_open.days < 0: # opened earlier today\\n days_open += datetime.timedelta(days=(days_open.days * -1))\\n\\n issue_title = \\\"{0} (Open {1} days)\\\".format(issue[\\\"title\\\"], days_open.days)\\n if \\\"pull_request\\\" not in issue: # ignore pull requests\\n issue_labels = [\\\"None\\\"]\\n if len(issue[\\\"labels\\\"]) != 0:\\n issue_labels = [label[\\\"name\\\"] for label in issue[\\\"labels\\\"]]\\n\\n issue_dict = {\\n \\\"title\\\": issue_title,\\n \\\"url\\\": issue[\\\"html_url\\\"],\\n \\\"labels\\\": issue_labels,\\n }\\n\\n open_issues.append(issue_dict)\\n else:\\n open_pull_requests.append({issue[\\\"html_url\\\"]: issue_title})\\n\\n return open_issues, open_pull_requests\",\n \"def find_issue_id(self):\",\n \"def _search_issues(self, summary):\\n try:\\n issues = self.jira.get_issues_by_summary(summary)\\n except Exception as e:\\n logging.error(\\\"Failed searching issues: \\\"+ str(e))\\n return []\\n return issues\",\n \"def test_api_can_request_issues(self):\\n payload = request_github_issues('razat249', 'github-view')\\n self.assertEqual(payload['error'], False)\\n self.assertLess(payload['status_code'], 400)\",\n \"def getRelevantPRData():\\n prInfoFromAPI = getPRsFromAPI()\\n diffHeader = headers.copy()\\n diffHeader['Accept'] = \\\"application/vnd.github.v3.diff\\\"\\n textForReviewPRs = []\\n\\n for PR in prInfoFromAPI:\\n labels = [label[\\\"name\\\"] for label in PR['labels']]\\n if \\\"Text for Review\\\" in labels:\\n diffResponse = requests.get(PR[\\\"url\\\"], headers=diffHeader)\\n diff = diffResponse.text\\n # Add the info the list\\n textForReviewPRs.append({\\n \\\"pull_request_link\\\": PR[\\\"html_url\\\"],\\n \\\"diff\\\": diff\\n })\\n if int(diffResponse.headers[\\\"X-RateLimit-Remaining\\\"]) <= 2:\\n print('GitHub api rate limit will be exceeded; the GITHUB_TOKEN env variable needs to be set.')\\n break\\n return textForReviewPRs\",\n \"def matching_pull_requests(age):\\n today = datetime.utcnow().date()\\n created = today - relativedelta(years=age)\\n response = requests.get(GITHUB + '/search/issues?q=type:pr created:{:%Y-%m-%d} is:open'.format(created))\\n return response.json()\",\n \"def detect_issues(ctx, sha, message):\\n\\n if sha and message:\\n raise click.UsageError('Use either --sha or --message, not both.')\\n\\n if not sha and not message:\\n raise click.UsageError('Must specify either --sha or --message.')\\n\\n try:\\n log.echo('Detecting issue...', break_line=False)\\n issues = ctx.obj.github.detect_issues(sha=sha, message=message)\\n log.checkmark()\\n for issue in issues:\\n log.echo('Issue detected: {}'.format(issue.url))\\n except BaseException as _:\\n log.xmark()\\n raise\",\n \"def getIssuesFromAPI():\\n issues = []\\n pageNumber = 1\\n numberOfIssuesReturned = 1\\n while numberOfIssuesReturned != 0:\\n issuesResponse = requests.get(\\n \\\"https://api.github.com/repos/greenelab/covid19-review/issues?state=all&per_page=50&page=\\\" +\\n str(pageNumber), headers=headers)\\n issues_page = json.loads(issuesResponse.text)\\n issues = issues + issues_page\\n numberOfIssuesReturned = len(issues_page)\\n pageNumber += 1\\n return issues\",\n \"def find_lint_bot_comments(repo, token, pr_number):\\n # repo is in the form of \\\"org/repo\\\"\\n # API doc: https://docs.github.com/en/rest/issues/comments?apiVersion=2022-11-28#list-issue-comments # noqa\\n response = requests.get(\\n f\\\"https://api.github.com/repos/{repo}/issues/{pr_number}/comments\\\",\\n headers=get_headers(token),\\n )\\n response.raise_for_status()\\n all_comments = response.json()\\n\\n failed_comment = \\\"❌ Linting issues\\\"\\n success_comment = \\\"✔️ Linting Passed\\\"\\n\\n # Find all comments that match the linting bot, and return the first one.\\n # There should always be only one such comment, or none, if the PR is\\n # just created.\\n comments = [\\n comment\\n for comment in all_comments\\n if comment[\\\"user\\\"][\\\"login\\\"] == \\\"github-actions[bot]\\\"\\n and (failed_comment in comment[\\\"body\\\"] or success_comment in comment[\\\"body\\\"])\\n ]\\n\\n if len(all_comments) > 25 and not comments:\\n # By default the API returns the first 30 comments. If we can't find the\\n # comment created by the bot in those, then we raise and we skip creating\\n # a comment in the first place.\\n raise RuntimeError(\\\"Comment not found in the first 30 comments.\\\")\\n\\n return comments[0] if comments else None\",\n \"def test_issue_get_comment(self):\\n pass\",\n \"def markdown_report(issues, commits):\\n print()\\n print('Handled issues:')\\n print()\\n\\n for issue in issues:\\n markdown_item(\\n '#{0} {1}'.format(\\n issue.number,\\n issue.title,\\n ),\\n issue.html_url,\\n )\\n\\n print()\\n print('Commits:')\\n print()\\n\\n for commit in commits:\\n markdown_item(\\n '{0} - {1}'.format(\\n commit.sha[:7],\\n commit.commit.message.split('\\\\n')[0]\\n ),\\n commit.html_url,\\n )\",\n \"def search_pulls(self, query=None, sort=None, order=None):\\n base_q = \\\"type:pr\\\"\\n\\n if query is None:\\n query = base_q\\n else:\\n query = \\\"{} {}\\\".format(query, base_q)\\n\\n return self.search_issues(query, sort, order)\",\n \"def get_issues(project=\\\"nipy/nitime\\\", state=\\\"closed\\\", pulls=False):\\r\\n which = 'pulls' if pulls else 'issues'\\r\\n url = \\\"https://api.github.com/repos/%s/%s?state=%s&per_page=%i\\\" % (project, which, state, PER_PAGE)\\r\\n return get_paged_request(url)\",\n \"def report(issues, show_urls=False):\\r\\n # titles may have unicode in them, so we must encode everything below\\r\\n if show_urls:\\r\\n for i in issues:\\r\\n role = 'ghpull' if 'merged' in i else 'ghissue'\\r\\n print('* :%s:`%d`: %s' % (role, i['number'],\\r\\n i['title'].encode('utf-8')))\\r\\n else:\\r\\n for i in issues:\\r\\n print('* %d: %s' % (i['number'], i['title'].encode('utf-8')))\",\n \"def test_findBugfixes(self):\\n bugfixes = self.builder._findChanges(\\n self.project, self.builder._BUGFIX)\\n self.assertEquals(\\n bugfixes,\\n [(23, 'Broken stuff was fixed.')])\",\n \"def visit_all_issues_in_list(self, issues):\\n for issue in issues:\\n self.driver.implicitly_wait(3)\\n self.driver.get(issue)\\n config_type_text = self.driver.find_element_by_xpath(\\\"/html/body/b-service-bootstrap/\\\"\\\\\\n \\\"app-root/div[7]/div/div/edit-issue-page/b-resolving-issue-references/div[2]/div[1]/\\\"\\\\\\n \\\"div[3]/div/div/div[2]/div[2]/div[3]/div/div[1]/div/span/span[6]/span/span/a\\\").text\\n\\n source_html = self.driver.page_source\\n soup = BeautifulSoup(source_html, \\\"html.parser\\\")\\n\\n advanced_fields = {}\\n advanced_fields[\\\"Issue Id\\\"] = issue.replace(\\\"https://b.corp.google.com/issues/\\\", \\\"\\\")\\n reporter_tag = soup.find(\\\"div\\\", \\\"bv2-issue-metadata-field-inner \\\"\\\\\\n \\\"bv2-issue-metadata-field-reporter\\\")\\n reporter = reporter_tag[\\\"aria-label\\\"].replace(\\n \\\" value is \\\", \\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n advanced_fields[reporter[0]] = reporter[1]\\n assignee_tag = soup.find(\\\"div\\\", \\\"bv2-issue-metadata-field-inner bv2-issue-metadata-\\\"\\\\\\n \\\"field-assignee\\\")\\n assignee = assignee_tag[\\\"aria-label\\\"].replace(\\n \\\" value is \\\", \\\"\\\\n\\\").split(\\\"\\\\n\\\")\\n if assignee[1] != \\\"empty\\\":\\n advanced_fields[assignee[0]] = assignee[1]\\n\\n if \\\"EnqueueRule\\\" in config_type_text:\\n config_type = \\\"EnqueueRules\\\"\\n elif \\\"RoutingTargets\\\" in config_type_text:\\n config_type = \\\"RoutingTargets\\\"\\n elif \\\"QueueInfo\\\" in config_type_text:\\n config_type = \\\"QueueInfo\\\"\\n\\n advanced_fields[\\\"Config Type\\\"] = config_type\\n\\n if config_type == \\\"QueueInfo\\\":\\n if assignee[1] != constants.AUTOMATION_USER:\\n continue\\n\\n self.scrape_queue_info(advanced_fields)\\n elif config_type == \\\"RoutingTargets\\\":\\n if assignee[1] != constants.AUTOMATION_USER:\\n continue\\n self.scrape_routing_targets(advanced_fields)\\n elif config_type == \\\"EnqueueRules\\\":\\n self._message_parsing_util.parse_page(soup, reporter[1], issue)\",\n \"def getIssues(url):\\n r = requests.get(url)\\n if r.status_code != 200:\\n raise \\\"There call to the GitHub issues API failed\\\"\\n return r.json()\",\n \"def _return_specific_comment_prs(all_prs, filters):\\n if _validate_list_of_dict(all_prs):\\n pr_issue = []\\n for pull_request in all_prs:\\n issue = pull_request['issue']\\n comments = issue.get_comments()\\n logger.debug(\\\"COMMENTS: %s\\\", [comment.body for comment in comments])\\n matched_comments = [comment.body for comment in comments if re.search(filters['comment'], comment.body)]\\n if matched_comments:\\n pr_issue.append({'pr':pull_request['pr'], 'issue':pull_request['issue']})\\n logger.debug(\\\"MATCHED COMMENTS: %s\\\", matched_comments)\\n return pr_issue\\n else:\\n return []\",\n \"def get_issue(self, context):\",\n \"def get_jira_defects(project):\\n return get_jira_issues('project = \\\"{}\\\" AND filter = 19589'.format(project))\",\n \"def get_pull_requests():\\n pull_requests = []\\n url_base = f\\\"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/pull/\\\"\\n repo = GITHUB.get_user(GITHUB_OWNER).get_repo(GITHUB_REPO)\\n pulls = repo.get_pulls(base=\\\"main\\\", state=\\\"closed\\\")\\n last_release_date = repo.get_latest_release().published_at\\n for pull in pulls:\\n if not pull.draft and pull.closed_at > last_release_date and pull.merged:\\n log_line = f\\\"* {pull.title} [#{pull.number}]({url_base}{pull.number})\\\"\\n pull_requests.append(log_line)\\n return pull_requests\",\n \"async def pr(ctx, number: Option(int, \\\"Pull request number\\\")):\\n url = f\\\"{repo}/issues/{number}\\\"\\n view = discord.ui.View()\\n view.add_item(discord.ui.Button(label=\\\"View Pull Request\\\", url=url))\\n await ctx.respond(f\\\"Here's a link\\\", view=view)\",\n \"async def get_pull_requests(self, issues: list) -> list:\\n tasks = []\\n async with ClientSession(auth=BasicAuth(*self.auth)) as session:\\n for issue in issues:\\n data = {\\n 'issueId': issue['id'],\\n 'applicationType': 'bitbucket',\\n 'dataType': 'pullrequest',\\n }\\n tasks.append(\\n asyncio.create_task(\\n self._get_pull_requests_for_issue(session, issue, data),\\n ),\\n )\\n\\n pull_requests = await asyncio.gather(*tasks)\\n\\n return self._parser.parse_pull_request_info(pull_requests)\",\n \"def get_jira_issues(query):\\n jira_issues = []\\n defects = []\\n count, maxlen = 0, 1\\n while count < maxlen:\\n issues = jira_client.search_issues(query, startAt=count, maxResults=50, expand='changelog')\\n jira_issues.extend(issues)\\n count = len(jira_issues)\\n maxlen = issues.total\\n\\n return jira_issues\",\n \"def getissue(s,refconvdf,issuetaglist):\\r\\n #check if empty\\r\\n taglist=gettotaltags(s,refconvdf)\\r\\n issuename=list(set(issuetaglist.name.values).intersection(taglist)) \\r\\n if not issuename:\\r\\n return 'None'\\r\\n else:\\r\\n return issuename\",\n \"async def remind_about_pull_requests(self, issues: list) -> None:\\n author = deepcopy(self.blocks['author'])\\n author['elements'][1]['text'] = self.version\\n starting_blocks = [\\n self.blocks['header'],\\n author,\\n self.blocks['divider'],\\n ]\\n message = {'blocks': deepcopy(starting_blocks)}\\n tasks = []\\n for issue in issues:\\n pull_requests = self._create_pull_requests_descriptions(issue['pull_requests'])\\n if pull_requests:\\n title = deepcopy(self.blocks['title'])\\n title['text']['text'] = f':bender: *[{issue[\\\"key\\\"]}] {issue[\\\"title\\\"]}*'\\n message['blocks'].extend([title] + pull_requests + [self.blocks['divider']])\\n\\n if len(message['blocks']) > 45:\\n tasks.append(asyncio.create_task(self.send_message(message)))\\n message = {'blocks': deepcopy(starting_blocks)}\\n\\n if not tasks:\\n tasks = [asyncio.create_task(self.send_message(message))]\\n\\n set_key_in_redis('slack-known-user-ids', self.known_user_ids)\\n await asyncio.gather(*tasks)\",\n \"def _validate_pr(pull_request):\\n title_valid = _validate_title(pull_request[\\\"title\\\"])\\n commits, all_commits_ok = _validate_commits(pull_request)\\n\\n report = {\\n \\\"title\\\": {\\\"message\\\": pull_request[\\\"title\\\"], \\\"standard\\\": title_valid},\\n \\\"commits\\\": commits,\\n }\\n\\n if not title_valid:\\n result = False\\n reason = TITLE_FAILURE_REASON\\n elif not all_commits_ok:\\n result = False\\n reason = COMMITS_FAILURE_REASON\\n else:\\n result = True\\n reason = SUCCESS_REASON\\n\\n return report, result, reason\",\n \"def issues(self):\\r\\n return issues.RepoIssues(self)\",\n \"def issues(self):\\r\\n return issues.RepoIssues(self)\",\n \"def locate_fixed_problems(commit_message):\\n \\n identifiers = set()\\n \\n commit_message = commit_message.strip()\\n lines = commit_message.splitlines()\\n \\n match_urls = True\\n for line in lines:\\n ids = identifiers_from_line(line, match_urls)\\n if len(ids) == 0:\\n match_urls = False\\n \\n identifiers.update(ids)\\n \\n return identifiers\",\n \"def test_issue_edit_issue(self):\\n pass\",\n \"def test_api_can_get_filtered_issues_list(self):\\n path = '/issues/?language=python&tech_stack=django&experience_needed=moderate'\\n response = self.client.get(path, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertGreater(len(api_response_issues), len(json.loads(response.content)))\",\n \"def test_issue_get_issue_reactions(self):\\n pass\",\n \"def check_pr_details(self, pr_number):\\n pr = self.repo.get_pull(pr_number)\\n email_pattern = re.compile(r'^.*@suse\\\\.(com|cz|de)$')\\n\\n for commit in pr.get_commits():\\n sha = commit.sha\\n author = commit.author\\n title = message = commit.commit.message\\n # Not sure why we need to use the nested commit for the email\\n email = commit.commit.author.email\\n user_id = f'{author.login}({email})'\\n body = ''\\n\\n # This could be probably smarter but commit contains something like the following\\n # message=\\\"$commit_title\\\\n\\\\n$long_commit_message\\\" and as such maybe we can split it and\\n # check for the following limits: title max 50 chars, body max 72 chars per line and at\\n # least as long as the commit title to avoid commit message bodies full of whitespaces\\n try:\\n title, body = message.split('\\\\n\\\\n', 1)\\n except ValueError:\\n print('No commit body was detected')\\n\\n print(f'Checking commit \\\"{sha}: {title}\\\"')\\n\\n if not email_pattern.fullmatch(email):\\n print(f'Checking if {user_id} is part of the SUSE organization...')\\n\\n if self.org.has_in_members(commit.author):\\n print(f'{user_id} is part of SUSE organization but a SUSE e-mail address was not used for commit: {sha}')\\n sys.exit(1)\\n\\n # replace case-insensitive \\\"(bsc#)\\\" (or []) and surrounding spaces\\n # with a single space, then prune leading/trailing spaces\\n title = re.sub(r'\\\\s*[([]\\\\s*(?i:bsc)#\\\\d+\\\\s*[)\\\\]]\\\\s*', ' ', title).strip()\\n if len(title) > 50:\\n print('Commit message title should be less than 50 characters (excluding the bsc# reference)')\\n sys.exit(1)\\n\\n # No body detected. Nothing else to do here.\\n if not body:\\n continue\\n\\n if len(body) < len(title):\\n print('Commit message body is too short')\\n sys.exit(1)\\n\\n # strip multi-line '```code```' blocks & lines starting w\\\\ `code`\\n code_pattern = re.compile(\\n r'''\\n ((?m:^)\\\\s*```) # multi-line beginning, 0-more whitespace, ```\\n (?s:.*?) # non-greedy, zero or more chars, including \\\\n\\n \\\\1 # whatever matched at the beginning\\n | # or...\\n (?m:^)\\\\s*` # start of line, optional whitespace, backtick\\n [^`]+ # oneor more non-backtick chars\\n `\\\\s*(?m:$) # and a backtick at the end of the line\\n ''',\\n re.VERBOSE\\n )\\n for body_line in re.sub(code_pattern, '', body).splitlines():\\n if len(body_line) > 72:\\n print('Each line in the commit body should be less than 72 characters')\\n sys.exit(1)\\n\\n print(f'PR-{pr_number} commits verified.')\",\n \"def getREVIssues(db):\\n return map(trimmedREVDoc,\\n db.reviews.find({\\\"done\\\": False, \\\"lgtms\\\": {\\\"$exists\\\": False}}))\",\n \"def test_issue_create_issue(self):\\n pass\",\n \"def github_issue(issue_url: str, check_rate_limit: bool = True) -> Dict[str, Any]:\\n user_agent = os.environ.get('THUMBSUP_USER_AGENT', 'thumbsup')\\n headers = {\\n 'Accept': GITHUB_ACCEPT_HEADER,\\n 'User-Agent': user_agent,\\n }\\n github_token_file = os.environ.get('THUMBSUP_GITHUB_TOKEN_FILE')\\n if github_token_file is not None:\\n with open(github_token_file, 'r') as ifp:\\n github_token = ifp.read().strip()\\n if github_token != UNAUTHENTICATED and github_token != '':\\n headers['Authorization'] = f'token {github_token}'\\n\\n if check_rate_limit:\\n r = requests.get(GITHUB_RATE_LIMIT_URL, headers=headers)\\n rate_limit_response = r.json()\\n remaining_rate_limit = (\\n rate_limit_response.get('resources', {}).get('core', {}).get('remaining', 0)\\n )\\n rate_limit_bound = os.environ.get('THUMBSUP_RATE_LIMIT_BOUND', '10')\\n rate_limit_bound = int(rate_limit_bound)\\n if remaining_rate_limit < rate_limit_bound:\\n raise RateLimitError(f'Remaining GitHub rate limit too low: {remaining_rate_limit}')\\n\\n match = RE_GITHUB_ISSUE_EXTRACTOR.search(issue_url)\\n if not match:\\n raise SummaryError(f'URL does not match form of link to GitHub Issue: {issue_url}')\\n\\n owner, repo, issue_number = match.groups()\\n\\n issue_url = f'https://api.github.com/repos/{owner}/{repo}/issues/{issue_number}'\\n r = requests.get(issue_url, headers=headers)\\n issue_response = r.json()\\n\\n comments_url = f'{issue_url}/comments'\\n r = requests.get(comments_url, headers=headers)\\n comment_response = r.json()\\n comment_response.sort(\\n key=lambda c: github_num_reactions(c) + github_num_positive_reactions(c),\\n reverse=True\\n )\\n return {\\n 'summarizer': 'github_issue',\\n 'issue': issue_response,\\n 'comments': comment_response,\\n 'emojis': GITHUB_EMOJIS\\n }\",\n \"def issues_closed_since(period=timedelta(days=365), project=\\\"nipy/nitime\\\", pulls=False):\\r\\n\\r\\n which = 'pulls' if pulls else 'issues'\\r\\n\\r\\n if isinstance(period, timedelta):\\r\\n period = datetime.now() - period\\r\\n url = \\\"https://api.github.com/repos/%s/%s?state=closed&sort=updated&since=%s&per_page=%i\\\" % (project, which, period.strftime(ISO8601), PER_PAGE)\\r\\n allclosed = get_paged_request(url)\\r\\n # allclosed = get_issues(project=project, state='closed', pulls=pulls, since=period)\\r\\n filtered = [i for i in allclosed if _parse_datetime(i['closed_at']) > period]\\r\\n return filtered\",\n \"def test_obtain_issues(self, mock_url_read):\\n mock_url_read.side_effect = [LAST_SCAN, '{\\\"reportId\\\": 22}', '{\\\"status\\\": {\\\"value\\\": \\\"Created\\\"}}',\\n SAST_REPORT.format(false_positive=False, severity='High')]\\n\\n self.__report.obtain_issues(['id'], 'high')\\n issues = self.__report.issues()\\n\\n self.assertIsInstance(issues, List)\\n self.assertIsInstance(issues[0], Checkmarx.Issue)\\n self.assertEqual('JScript Vulnerabilities', issues[0].group)\\n self.assertEqual('Reflected XSS', issues[0].title)\\n self.assertEqual('http://url/CxWebClient/ScanQueryDescription.aspx?queryID=789&'\\n 'queryVersionCode=842956&queryTitle=Reflected_XSS', issues[0].display_url)\\n self.assertEqual(1, issues[0].count)\\n self.assertEqual(\\\"Recurrent\\\", issues[0].status)\",\n \"def list_issues(self, chat):\\n issues = self.url_handler.get_json_from_url(constants.URL_GITHUB)\\n msg = ''\\n msg += '\\\\U0001F4CB Issues List\\\\n\\\\n'\\n for aux in issues:\\n msg += \\\"[[{}]] - {}\\\\n\\\\n\\\".format(str(aux['number']), aux['title'])\\n\\n self.url_handler.send_message(msg, chat)\",\n \"def do_the_issues(user_id, repo_id):\\n with tempfile.TemporaryDirectory() as tmp:\\n path = os.path.join(tmp, \\\"{}_{}_issues.txt\\\".format(repo_id, user_id))\\n issues_initial_url = get_initial_url_issues(user_id, repo_id)\\n resp_obj = requests.get(issues_initial_url, headers=headers)\\n # prase the initial request. for Issue\\n all_issues = json.loads(resp_obj.text)\\n with open(path, \\\"w\\\") as out_stream:\\n for an_issue in all_issues:\\n print(an_issue, file=out_stream)\\n print(\\\"the len of resp is {}\\\".format(len(all_issues)))\\n LINK_HEADER = \\\"Link\\\"\\n next_url = None\\n if LINK_HEADER in resp_obj.headers:\\n # parse next page (if present)\\n next_url = parse_next_url(resp_obj.headers[LINK_HEADER])\\n # subsequent page\\n while next_url:\\n resp_obj = requests.get(next_url, headers=headers)\\n all_issues = json.loads(resp_obj.text)\\n with open(path, \\\"a\\\") as out_stream:\\n for an_issue in all_issues:\\n print(an_issue, file=out_stream)\\n if LINK_HEADER in resp_obj.headers:\\n next_url = parse_next_url(resp_obj.headers[LINK_HEADER])\\n print(next_url)\\n else:\\n next_url = None\\n GsUpload.upload_blob(GS_BUCKET_NAME, path, basename(path))\\n print(\\\"the issues path is \\\" + str(path))\",\n \"def is_pull_request(issue):\\r\\n return 'pull_request_url' in issue\",\n \"def issue_closed():\\n parser = argparse.ArgumentParser(description=issue_closed.__doc__)\\n\\n parser.add_argument(\\\"project\\\", help=\\\"the project name\\\")\\n parser.add_argument(\\n \\\"--column\\\",\\n default=\\\"done\\\",\\n help=\\\"the column closed issues should go to, default `done`\\\",\\n )\\n\\n args = parser.parse_args()\\n\\n column = args.column.lower()\\n\\n session = GithubSession()\\n\\n project = session.get_project(args.project)\\n\\n for column_data in session.get_columns(project):\\n column_name = column_data[\\\"name\\\"].lower()\\n if column_name == column:\\n continue\\n\\n print(f\\\"\\\\nlooking at column {column_name}\\\")\\n\\n # print(json.dumps(column_data, indent=4))\\n\\n for card in session.get_cards(column_data):\\n # print(json.dumps(card, indent=4))\\n\\n issue_data = session.request(\\\"get\\\", card[\\\"content_url\\\"]).json()\\n\\n if issue_data[\\\"state\\\"] != \\\"closed\\\":\\n print(\\\".\\\", end=\\\"\\\")\\n\\n continue\\n\\n issue_number = issue_data[\\\"number\\\"]\\n\\n print(f\\\"\\\\nmoving issue {issue_number} to {column}\\\")\\n\\n issue_column(\\n [\\n \\\"issue_column\\\",\\n args.project,\\n issue_number,\\n column,\\n \\\"--position=bottom\\\",\\n ]\\n )\",\n \"def get_issues(request, project):\\n\\n try:\\n api_response = requests.get(constants.GITHUB_API_GET_ISSUES_URL.format(project_name=project))\\n api_response_json = api_response.json()\\n if api_response.status_code == 404:\\n error_message = \\\"Repository does not exist\\\"\\n return Response(error_message, status=status.HTTP_404_NOT_FOUND)\\n if api_response.status_code == 401:\\n raise Exception(\\\"Authentication fails. Invalid github access token.\\\")\\n response = []\\n for issue in api_response_json:\\n labels_length = len(issue['labels'])\\n tags = []\\n # Making custom dictionary for tags\\n for i in range(0, labels_length):\\n # Searching inside \\\"labels\\\" key for tag_name\\n for tag, tag_name in issue[\\\"labels\\\"][i].items():\\n if tag in [\\\"name\\\"]:\\n label = tag_name\\n tags.append(label)\\n result = IssueResponse(\\n title=issue['title'],\\n created_at=issue['created_at'],\\n comments=issue['comments'],\\n issue_number=issue['number'],\\n repository_url=issue['repository_url'],\\n labels=tags\\n )\\n result_as_json = result.to_json()\\n response.append(result_as_json)\\n\\n except Exception:\\n return DOWNSTREAM_ERROR_RESPONSE\\n\\n return Response(response)\",\n \"def get_repo_issue_comments(owner, repo, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/issues/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def find_svn_issues(cls, svndb):\\n print(\\\"Searching for Mantis issues in SVN log messages\\\")\\n svn_issues = {}\\n for entry in svndb.all_entries:\\n numlist = IssueFinder.find(entry.loglines, fix_lines=True)\\n if numlist is None or len(numlist) == 0:\\n continue\\n\\n numlist.sort()\\n svn_issues[entry.revision] = numlist\\n\\n num_found = len(svn_issues)\\n num_total = svndb.num_entries()\\n print(\\\"Found %d referenced issue%s from %d total issue%s\\\" %\\n (num_found, pluralize(num_found), num_total,\\n pluralize(num_total)))\\n return svn_issues\",\n \"def _get_suggestion_issues() -> Tuple[Optional[Issue], List[Issue]]:\\n article_stages_for_opened_issues = (\\n \\\"waiting\\\",\\n \\\"proofreading_editor\\\",\\n \\\"precheck\\\",\\n \\\"spellcheck\\\",\\n \\\"markup\\\",\\n \\\"proofreading_spell\\\",\\n \\\"proofreading_chief_dpt\\\",\\n \\\"proofreading_chief\\\",\\n \\\"publishing\\\",\\n )\\n opened_issues = (\\n Issue.on_current_site.filter(posts__stage__slug__in=article_stages_for_opened_issues)\\n .order_by(\\\"number\\\")\\n .distinct()\\n .all()[:5]\\n )\\n\\n if not opened_issues:\\n return None, []\\n\\n # Convert QuerySet to ordinary list to split for initial and least\\n opened_issues: List[Issue] = list(opened_issues)\\n initial_issue = opened_issues.pop()\\n opened_issues.reverse()\\n\\n return initial_issue, opened_issues\",\n \"def test_get_updated_issues_one_page(self):\\n with open(\\\"issues_one_page.json\\\", \\\"r\\\") as issues_file:\\n mock_response = issues_file.read()\\n\\n with requests_mock.Mocker() as m:\\n m.register_uri('GET', '/rest/api/2/search', text=mock_response)\\n issues = jiratimereport.get_updated_issues(\\\"https://jira_url\\\", \\\"user_name\\\", \\\"api_token\\\", \\\"MYB\\\",\\n \\\"2020-01-10\\\", \\\"2020-01-20\\\", \\\"\\\")\\n\\n issues_expected_result = [\\n Issue(10005, \\\"MYB-5\\\", \\\"Summary of issue MYB-5\\\", \\\"MYB-3\\\", \\\"Summary of the parent issue of MYB-5\\\", 3600, 900, datetime(2020, 1, 20)),\\n Issue(10004, \\\"MYB-4\\\", \\\"Summary of issue MYB-4\\\", \\\"MYB-3\\\", \\\"Summary of the parent issue of MYB-4\\\", 7200, 600, None)]\\n\\n self.assertListEqual(issues_expected_result, issues, \\\"Issues lists are unequal\\\")\",\n \"def get_repo_issues(owner, repo, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/issues'\\n query_params = {'state': 'all'}\\n return get_one_item_at_a_time(url, query_params, session)\",\n \"def get_sprint_board_issues(self) -> list:\\n endpoint_path = f'agile/1.0/sprint/{self.sprint}/issue'\\n data = {\\n 'jql': 'status=\\\"In Review\\\"',\\n 'fields': ['assignee', 'status', 'summary'],\\n }\\n response = self._get(endpoint_path, data)\\n return self._parser.filter_out_important_data(response)\",\n \"def get_review_comments_for_pr(owner, repo, pr_number, session=None):\\n url = f'{GITHUB_API_URL}/repos/{owner}/{repo}/pulls/{pr_number}/comments'\\n return get_one_item_at_a_time(url, session=session)\",\n \"def get_open_pull_requests(self, required_labels=None):\\n json = self.get_all('repos/%(owner)s/%(repo)s/pulls' % {\\n 'owner': self.repo_owner,\\n 'repo': self.repo_name,\\n }, params={\\n 'direction': 'asc',\\n })\\n required_labels = required_labels or []\\n\\n prs = []\\n for pr_data in json:\\n # Construct the pull request and issue data structures\\n pr_id = pr_data['number']\\n issue_obj = self.get_issue(pr_id)\\n pr_obj = PullRequest(pr_id, pr_data['title'], pr_data['body'], pr_data['head']['ref'],\\n pr_data['html_url'], pr_data['created_at'], pr_data['updated_at'], issue_obj)\\n\\n # Check if the PR survives the filters\\n include_pr = True\\n for required_label in required_labels:\\n if not pr_obj.has_label(required_label):\\n include_pr = False\\n break\\n if include_pr:\\n prs.append(pr_obj)\\n\\n return prs\",\n \"def slurm_check(path='.'):\\n for file in shrunner.get_files(path, '.out'):\\n with open(file, 'r') as f:\\n for line in f.read().splitlines():\\n if 'issue' in line.lower():\\n print(file)\\n print(line)\\n print('-' * 40)\",\n \"def test_issue_get_milestone(self):\\n pass\",\n \"def search_issues(self, query=None, sort=None, order=None):\\n params = {}\\n\\n repo_q = \\\"repo:{}/{}\\\".format(self.owner, self.label)\\n\\n if query is not None:\\n params[\\\"q\\\"] = \\\"{} {}\\\".format(query, repo_q)\\n else:\\n params[\\\"q\\\"] = repo_q\\n\\n if sort is not None:\\n params[\\\"sort\\\"] = sort\\n\\n if order is not None:\\n params[\\\"order\\\"] = order\\n\\n return self.client.request(\\\"/search/issues\\\", params or None)\",\n \"def test_api_request_can_handle_errors(self):\\n # wrong repo name to test error handling.\\n payload = request_github_issues('razat249', 'wrong_repo')\\n self.assertEqual(payload['error'], True)\\n self.assertGreaterEqual(payload['status_code'], 400)\",\n \"def review(args):\\n try:\\n pr = gh.get_pr(owner, repo, args.pull_request)\\n except requests.exceptions.HTTPError:\\n print('Couldn\\\\'t find pull request #%s in %s/%s.' %\\n (args.pull_request, owner, repo))\\n print('Make sure the number is correct and that you have read '\\n 'permissions for this GitHub repository.')\\n sys.exit(1)\\n\\n clone_url = pr['head']['repo']['clone_url']\\n fork_branch = pr['head']['ref']\\n fork_owner = pr['head']['repo']['owner']['login']\\n\\n repo_lib.fetch_fork(clone_url, fork_branch, fork_owner)\\n repo_lib.checkout(fork_branch, fork_owner)\\n sys.exit(0)\",\n \"def get_pr_info(num):\\r\\n url = \\\"https://api.github.com/repos/edx/edx-platform/pulls/{num}\\\".format(num=num)\\r\\n username, token = get_github_creds()\\r\\n headers = {\\r\\n \\\"Authorization\\\": \\\"token {}\\\".format(token),\\r\\n \\\"User-Agent\\\": \\\"edx-release\\\",\\r\\n }\\r\\n response = requests.get(url, headers=headers)\\r\\n result = response.json()\\r\\n if not response.ok:\\r\\n raise requests.exceptions.RequestException(result[\\\"message\\\"])\\r\\n return result\",\n \"def parse_status_file(jira, filename, issues):\\n # Regexp to match Jira issue on a single line, i.e:\\n # [SWG-28]\\n # [LITE-32]\\n # ...\\n regex = r\\\"^\\\\[([A-Z]+-[0-9]+).*\\\\]\\\\n$\\\"\\n\\n # Regexp to match a tag that indicates we should stop processing, ex:\\n # [STOP]\\n # [JIPDATE-STOP]\\n # [OTHER]\\n # ...\\n regex_stop = r\\\"^\\\\[.*\\\\]\\\\n$\\\"\\n\\n # Regexp to mach a tag that indicates to stop processing completely:\\n # [FIN]\\n regex_fin = r\\\"^\\\\[FIN\\\\]\\\\n$\\\"\\n\\n # Regexp to match for a status update, this will remove 'Status' from the\\n # match:\\n regex_status = r\\\"(?:^Status:) *(.+)\\\\n$\\\"\\n\\n # Contains the status text, it could be a file or a status email\\n status = \\\"\\\"\\n\\n # Regexp to match for a time spent update, this will remove 'Time spent:'\\n # from the match:\\n regex_timespent = r\\\"(^Time spent:) \\\\d+\\\\w\\\\n$\\\"\\n\\n # List of resolutions (when doing a transition to Resolved). Query once globally.\\n resolution_map = dict([(t.name.title(), t.id) for t in jira.resolutions()])\\n\\n with open(filename) as f:\\n status = f.readlines()\\n\\n myissue = \\\"\\\"\\n mycomment = \\\"\\\"\\n\\n # build list of {issue,comment} tuples found in status\\n issue_comments = []\\n for line in status:\\n # New issue?\\n match = re.search(regex, line)\\n\\n # Evaluate and save the transition regex for later. We have to do this\\n # here, since we cannot assign and save the variable in the if\\n # construction as you can do in C for example.\\n transition = re.search(regex_status, line)\\n\\n if match:\\n myissue = match.group(1)\\n validissue = True\\n\\n # if we ran a query, we might already have fetched the issue\\n # let's try to find the issue there first, otherwise ask Jira\\n try:\\n issue = [x for x in issues if str(x) == myissue][0]\\n issue_comments.append((issue, \\\"\\\", \\\"\\\", None))\\n\\n # IndexError: we had fetched already, but issue is not found\\n # TypeError: issues is None, we haven't queried Jira yet, at all\\n except (IndexError, TypeError) as e:\\n try:\\n issue = jira.issue(myissue)\\n issue_comments.append((issue, \\\"\\\", \\\"\\\", None))\\n except Exception as e:\\n if \\\"Issue Does Not Exist\\\" in e.text:\\n print(\\\"[{}] : {}\\\".format(myissue, e.text))\\n validissue = False\\n\\n # Stop parsing entirely. This needs to be placed before regex_stop\\n # or the .* will match and [FIN] won't be processed\\n elif re.search(regex_fin, line):\\n break\\n # If we have non-JIRA issue tags, stop parsing until we find a valid tag\\n elif re.search(regex_stop, line):\\n validissue = False\\n elif transition and validissue:\\n # If we have a match, then the new status should be first in the\\n # group. Jira always expect the name of the state transitions to be\\n # word capitalized, hence the call to the title() function. This\\n # means that it doesn't matter if the user enter all lower case,\\n # mixed or all upper case. All of them will work.\\n new_status = transition.groups()[0].title()\\n (i, c, _, ts) = issue_comments[-1]\\n issue_comments[-1] = (i, c, new_status, ts)\\n elif re.search(regex_timespent, line, re.IGNORECASE):\\n timespent = line.split(\\\":\\\")[1].strip()\\n (i, c, t, _) = issue_comments[-1]\\n issue_comments[-1] = (i, c, t, timespent)\\n else:\\n # Don't add lines with comments\\n if line[0] != \\\"#\\\" and issue_comments and validissue:\\n (i, c, t, ts) = issue_comments[-1]\\n issue_comments[-1] = (i, c + line, t, ts)\\n\\n issue_upload = []\\n print(\\\"These JIRA cards will be updated as follows:\\\\n\\\")\\n for idx, t in enumerate(issue_comments):\\n (issue, comment, transition, timespent) = issue_comments[idx]\\n\\n # Strip beginning and trailing blank lines\\n comment = comment.strip(\\\"\\\\n\\\")\\n\\n # initialize here to avoid unassigned variables and useless code complexity\\n resolution_id = transition_id = None\\n resolution = transition_summary = \\\"\\\"\\n\\n if transition != \\\"\\\" and transition != str(issue.fields.status):\\n # An optional 'resolution' attribute can be set when doing a transition\\n # to Resolved, using the following pattern: Resolved / <resolution>\\n if (\\n transition.startswith(\\\"Resolved\\\") or transition.startswith(\\\"Closed\\\")\\n ) and \\\"/\\\" in transition:\\n (transition, resolution) = map(str.strip, transition.split(\\\"/\\\"))\\n if not resolution in resolution_map:\\n print(\\n 'Invalid resolution \\\"{}\\\" for issue {}'.format(resolution, issue)\\n )\\n print(\\\"Possible resolution: {}\\\".format([t for t in resolution_map]))\\n sys.exit(1)\\n resolution_id = resolution_map[resolution]\\n\\n transition_map = dict(\\n [(t[\\\"name\\\"].title(), t[\\\"id\\\"]) for t in jira.transitions(issue)]\\n )\\n if not transition in transition_map:\\n print('Invalid transition \\\"{}\\\" for issue {}'.format(transition, issue))\\n print(\\\"Possible transitions: {}\\\".format([t for t in transition_map]))\\n sys.exit(1)\\n\\n transition_id = transition_map[transition]\\n if resolution:\\n transition_summary = \\\" %s => %s (%s)\\\" % (\\n issue.fields.status,\\n transition,\\n resolution,\\n )\\n else:\\n transition_summary = \\\" %s => %s\\\" % (issue.fields.status, transition)\\n\\n if comment == \\\"\\\" and not transition_id:\\n log.debug(\\n \\\"Issue [%s] has no comment or transitions, not updating the issue\\\"\\n % (issue)\\n )\\n continue\\n\\n issue_upload.append(\\n (\\n issue,\\n comment,\\n {\\\"transition\\\": transition_id, \\\"resolution\\\": resolution_id},\\n timespent,\\n )\\n )\\n print(\\n \\\"[%s]%s\\\\n %s\\\"\\n % (issue, transition_summary, \\\"\\\\n \\\".join(comment.splitlines()))\\n )\\n if timespent:\\n print(\\\" Time spent: %s\\\" % timespent)\\n print(\\\"\\\")\\n\\n issue_comments = issue_upload\\n if issue_comments == [] or cfg.args.dry_run or should_update() == \\\"n\\\":\\n if issue_comments == []:\\n print(\\\"No change, Jira was not updated!\\\\n\\\")\\n else:\\n print(\\\"Comments will not be written to Jira!\\\\n\\\")\\n if not cfg.args.s:\\n print_status(status)\\n sys.exit()\\n\\n # if we found something, let's update jira\\n for issue, comment, transition, timespent in issue_comments:\\n update_jira(jira, issue, comment, transition, timespent)\\n\\n print(\\\"Successfully updated your Jira tickets!\\\\n\\\")\\n if not cfg.args.s:\\n print_status(status)\",\n \"def test_get_release_pr_no_pulls():\\n with patch(\\n 'github.requests.get', return_value=Mock(json=Mock(return_value=[OTHER_PR]))\\n ):\\n assert get_release_pr('access_token', 'org', 'repo-missing') is None\",\n \"def test_get_updated_issues_without_parent(self):\\n with open(\\\"issues_without_parent.json\\\", \\\"r\\\") as issues_file:\\n mock_response = issues_file.read()\\n\\n with requests_mock.Mocker() as m:\\n m.register_uri('GET', '/rest/api/2/search', text=mock_response)\\n issues = jiratimereport.get_updated_issues(\\\"https://jira_url\\\", \\\"user_name\\\", \\\"api_token\\\", \\\"MYB\\\",\\n \\\"2020-01-10\\\", \\\"2020-01-20\\\", \\\"\\\")\\n\\n issues_expected_result = [\\n Issue(10005, \\\"MYB-5\\\", \\\"Summary of issue MYB-5\\\", None, None, 3600, 900, None)]\\n\\n self.assertListEqual(issues_expected_result, issues, \\\"Issues lists are unequal\\\")\",\n \"def report_tests(args, test_summary):\\n try:\\n if None not in [args.repo_github_token, args.repo_owner, args.repo_name, args.pr_number]:\\n comment_on_pr(args.repo_github_token, test_summary, args.repo_owner, args.repo_name, args.pr_number)\\n\\n except Exception as e:\\n logging.error(\\\"Posting test report on PR failed with error '{ERROR}'\\\".format(ERROR=e))\",\n \"def get_project_issues(repo_slug, max_issues_per_project=None, max_date=None):\\n # type: (str, int, str) -> pd.DataFrame\\n logging.info(\\\"Processing %s\\\", repo_slug)\\n all_issues = pd.DataFrame(\\n json_imap({\\n 'reporter': 'user__login',\\n 'role': 'author_association',\\n 'number': 'number',\\n 'title': 'title',\\n 'created_at': 'created_at',\\n 'body': 'body',\\n 'state': 'state',\\n },\\n api.repo_issues(repo_slug)),\\n ).sort_values('created_at')\\n if max_date:\\n all_issues = all_issues[all_issues['created_at'] < max_date]\\n last_reported = all_issues.groupby(\\n 'reporter').last().iloc[:max_issues_per_project]\\n first_reported = all_issues.groupby('reporter').first()['created_at']\\n # int(timedelta) is ns, times 86400 seconds in a day\\n last_reported['tenure'] = (\\n pd.to_datetime(last_reported['created_at'])\\n - pd.to_datetime(last_reported.index.map(first_reported))\\n ).astype(int) // 86400000000000\\n last_reported['project'] = repo_slug\\n return last_reported.reset_index().sort_values('number')\",\n \"def test_issue_get_comment_reactions(self):\\n pass\",\n \"def issues_by_id(self, repository_id, access_token=None):\\n return self._complete_request_by_id(\\n repository_id, \\\"issues\\\", access_token)\",\n \"def get_jira_issues(jira, username):\\n exclude_stories = cfg.args.x\\n epics_only = cfg.args.e\\n all_status = cfg.args.all\\n filename = cfg.args.file\\n user = cfg.args.user\\n last_comment = cfg.args.l\\n\\n issue_types = [\\\"Sub-task\\\", \\\"Epic\\\"]\\n if not epics_only:\\n issue_types.append(\\\"Initiative\\\")\\n if not exclude_stories:\\n issue_types.extend([\\\"Story\\\", \\\"Task\\\", \\\"Sub-task\\\", \\\"Bug\\\"])\\n issue_type = \\\"issuetype in (%s)\\\" % \\\", \\\".join(issue_types)\\n\\n status = 'status in (\\\"In Progress\\\")'\\n if all_status:\\n status = \\\"status not in (Resolved, Closed)\\\"\\n\\n if user is None:\\n user = \\\"currentUser()\\\"\\n else:\\n user = '\\\"%s\\\"' % add_domain(user)\\n\\n jql = \\\"%s AND assignee = %s AND %s\\\" % (issue_type, user, status)\\n log.debug(jql)\\n\\n my_issues = jira.search_issues(jql)\\n if my_issues.total > my_issues.maxResults:\\n my_issues = jira.search_issues(jql, maxResults=my_issues.total)\\n\\n showdate = strftime(\\\"%Y-%m-%d\\\", gmtime())\\n subject = \\\"Subject: [Weekly] Week ending \\\" + showdate + \\\"\\\\n\\\\n\\\"\\n\\n msg = get_header()\\n if msg != \\\"\\\":\\n msg += email_to_name(username) + \\\"\\\\n\\\\n\\\"\\n\\n f = open_file(filename)\\n filename = f.name\\n\\n f.write(subject)\\n\\n f.write(msg)\\n log.debug(\\\"Found issue:\\\")\\n for issue in my_issues:\\n log.debug(\\\"%s : %s\\\" % (issue, issue.fields.summary))\\n\\n if merge_issue_header():\\n f.write(\\n \\\"[%s%s%s]\\\\n\\\" % (issue, get_header_separator(), issue.fields.summary)\\n )\\n else:\\n f.write(\\\"[%s]\\\\n\\\" % issue)\\n f.write(\\\"# Header: %s\\\\n\\\" % issue.fields.summary)\\n\\n f.write(\\\"# Type: %s\\\\n\\\" % issue.fields.issuetype)\\n f.write(\\\"# Status: %s\\\\n\\\" % issue.fields.status)\\n f.write(get_extra_comments())\\n if last_comment:\\n write_last_jira_comment(f, jira, issue)\\n f.write(\\\"\\\\n\\\")\\n\\n f.close()\\n return (filename, my_issues)\",\n \"def test_api_can_get_issues_list(self):\\n response = self.client.get('/issues/', format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(len(api_response_issues), len(json.loads(response.content)))\",\n \"def dependent_prs(self):\\n comments = self.data['body'].replace('\\\\r\\\\n', ' ')\\n for comment in self.comments():\\n comments += comment['body'].replace('\\\\r\\\\n', ' ')\\n\\n dependent_prs = []\\n dependent_keywords = ['depends on']\\n for keyword in dependent_keywords:\\n pattern = r'%s %s/(\\\\S+)/(\\\\S+)/pull/(\\\\d+)' % (keyword, GITHUB)\\n LOGGER.info(\\\"Finding dependent PRs by '%s' in the comments\\\")\\n dependent_prs += re.findall(pattern, comments)\\n return set(dependent_prs)\",\n \"def test_get_existing_issue_passes(self):\\n response = self.client.get(self.url)\\n response_json = response.get_json()\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(response_json[\\\"name\\\"], TEST_ISSUE_NAME)\",\n \"def _validate_commits(pull_request):\\n commits = github.get_commits(pull_request[\\\"commits_url\\\"])\\n analyzed = []\\n\\n for commit_wrapper in commits:\\n commit = {\\n \\\"sha\\\": commit_wrapper[\\\"sha\\\"],\\n \\\"message\\\": commit_wrapper[\\\"commit\\\"][\\\"message\\\"],\\n }\\n\\n commit[\\\"standard\\\"] = _validate_title(commit[\\\"message\\\"])\\n analyzed.append(commit)\\n\\n result = all(commit[\\\"standard\\\"] for commit in analyzed)\\n return analyzed, result\",\n \"def get_reviewers(mentions, pull_request_body, issue_comments, review_comments):\\n reviewers_mapping = {}\\n\\n # Reviewers are supposed to be those mentions who have given thumbs up.\\n for comment in issue_comments:\\n if comment.user.login in mentions and bool(thumbs_up.search(comment.body)):\\n reviewers_mapping[comment.user.login] = dict(\\n tagged_at=None,\\n responded_at=None,\\n gave_thumbs_up_at=comment.created_at\\n )\\n\\n # We have reviewers, now, look for the time for their first response in issue comments.\\n for comment in issue_comments:\\n if comment.user.login in reviewers_mapping.keys() \\\\\\n and reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n # TODO: Scrap the time when the PR's body was updated.\\n # Story behind: Mostly, people just create the PR and update their body with description and reviewers\\n # once the PR is ready for the review. Unfortunately, github v3 api dont have end point for knowing the\\n # time when the PR's body was updated. So, most likely, we will not get precise 'tagged_at' attribute\\n # for the reviewers that are in PR's body.\\n\\n # Look for time when each of reviewer was tagged, this should be\\n # searched in pull request body and issue comments.\\n for login in reviewers_mapping.keys():\\n if login in comment.body and reviewers_mapping[login]['tagged_at'] is None:\\n if reviewers_mapping[login]['responded_at'] is None \\\\\\n or reviewers_mapping[login]['responded_at'] > comment.created_at:\\n reviewers_mapping[login]['tagged_at'] = comment.created_at\\n\\n # Check for reviewers' first response in review comments too, and\\n # update the reviewers_mapping if necessary.\\n for comment in review_comments:\\n if comment.user.login in reviewers_mapping.keys():\\n if reviewers_mapping[comment.user.login]['responded_at'] is None:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n elif reviewers_mapping[comment.user.login]['responded_at'] > comment.created_at:\\n reviewers_mapping[comment.user.login]['responded_at'] = comment.created_at\\n\\n return reviewers_mapping\",\n \"def get_issues(self, start=None):\\n\\n page = 0 # current page\\n last_page = None # last page\\n url_next = self.__get_issues_url(start)\\n\\n logger.debug(\\\"Get GitHub issues from \\\" + url_next)\\n r = self.__send_request(url_next, self.__get_payload(start),\\n self.__get_headers())\\n issues = r.text\\n page += 1\\n\\n if 'last' in r.links:\\n last_url = r.links['last']['url']\\n last_page = last_url.split('&page=')[1].split('&')[0]\\n last_page = int(last_page)\\n logger.debug(\\\"Page: %i/%i\\\" % (page, last_page))\\n\\n while issues:\\n yield issues\\n\\n issues = None\\n\\n if 'next' in r.links:\\n url_next = r.links['next']['url'] # Loving requests :)\\n r = self.__send_request(url_next, self.__get_payload(start), self.__get_headers())\\n page += 1\\n issues = r.text\\n logger.debug(\\\"Page: %i/%i\\\" % (page, last_page))\",\n \"def getIssuesEmail(self):\\r\\n base_url = \\\"http://beta.boost.org/development/tests/\\\"\\r\\n base_url += self.branch\\r\\n base_url += \\\"/developer/\\\";\\r\\n got_issues = False\\r\\n\\r\\n # Ping the server by looking for an HTML file\\r\\n print \\\"Pinging the server to initiate extraction...\\\"\\r\\n ping_url = base_url + \\\"issues.html\\\"\\r\\n os.system('curl -O ' + ping_url)\\r\\n os.system('rm -f issues.html')\\r\\n \\r\\n for x in range(30):\\r\\n # Update issues-email.txt\\r\\n url = base_url + \\\"issues-email.txt\\\"\\r\\n print 'Retrieving issues email from ' + url\\r\\n os.system('rm -f issues-email.txt')\\r\\n os.system('curl -O ' + url)\\r\\n\\r\\n if self.parseIssuesEmail():\\r\\n return True\\r\\n\\r\\n print 'Failed to fetch issues email. '\\r\\n time.sleep (30)\\r\\n\\r\\n return False\",\n \"def issues(self):\\r\\n return issues.Issues(self)\",\n \"def test_too_many_releases():\\n pulls = [RELEASE_PR, RELEASE_PR]\\n with pytest.raises(Exception) as ex, patch(\\n 'github.requests.get', return_value=Mock(json=Mock(return_value=pulls))\\n ):\\n get_release_pr('access_token', 'org', 'repo')\\n\\n assert ex.value.args[0] == \\\"More than one pull request for the branch release-candidate\\\"\",\n \"def issues_list(self, mar, request):\\n if request.additionalProject:\\n for project_name in request.additionalProject:\\n project = self._services.project.GetProjectByName(\\n mar.cnxn, project_name)\\n if project and not permissions.UserCanViewProject(\\n mar.auth.user_pb, mar.auth.effective_ids, project):\\n raise permissions.PermissionException(\\n 'The user %s has no permission for project %s' %\\n (mar.auth.email, project_name))\\n url_params = [(name, mar.GetParam(name)) for name in\\n framework_helpers.RECOGNIZED_PARAMS]\\n # TODO(jrobbins): This should go through work_env.\\n pipeline = frontendsearchpipeline.FrontendSearchPipeline(\\n mar.cnxn, self._services, mar.auth, [mar.me_user_id], mar.query,\\n mar.query_project_names, mar.num, mar.start, url_params, mar.can,\\n mar.group_by_spec, mar.sort_spec, mar.warnings, mar.errors,\\n mar.use_cached_searches, mar.profiler, display_mode=mar.mode,\\n project=mar.project)\\n if not mar.errors.AnyErrors():\\n pipeline.SearchForIIDs()\\n pipeline.MergeAndSortIssues()\\n pipeline.Paginate()\\n else:\\n raise endpoints.BadRequestException(mar.errors.query)\\n\\n issue_list = [\\n api_pb2_v1_helpers.convert_issue(\\n api_pb2_v1.IssueWrapper, r, mar, self._services)\\n for r in pipeline.visible_results]\\n return api_pb2_v1.IssuesListResponse(\\n kind='monorail#issueList',\\n totalResults=pipeline.total_count,\\n items=issue_list)\",\n \"def test_issue_list_labels(self):\\n pass\",\n \"def getRelevantIssues(db, data):\\n last_updated = data.get('updated', None)\\n query = {'$and': [\\n {'jira.fields.issuetype.name': {'$nin': ['Tracking']}},\\n {'jira.fields.project.key': {'$in': ['CS', 'MMSSUPPORT', 'SUPPORT',\\n 'PARTNER']}},\\n ]\\n }\\n\\n if last_updated is None:\\n # Only filter the first time, since we want to know if issues on the\\n # dashboard have closed\\n query['$and'].append({'jira.fields.status.name': {\\n '$in': ['Open', 'Reopened', 'In Progress',\\n 'Waiting for Customer', 'Waiting For User Input']}\\n }\\n )\\n else:\\n query[\\\"$and\\\"].append({\\\"jira.fields.updated\\\": {\\n \\\"$gte\\\": last_updated\\n }\\n })\\n\\n # Only need these fields for determining if they belong, and displaying\\n # them on the dashboard\\n proj = {'_id': 0,\\n 'dash.active.now': 1,\\n 'deleted': 1,\\n 'jira.fields.assignee': 1,\\n 'jira.fields.created': 1,\\n 'jira.fields.issuetype': 1,\\n 'jira.fields.labels': 1,\\n 'jira.fields.priority.id': 1,\\n 'jira.fields.reporter': 1,\\n 'jira.fields.status': 1,\\n 'jira.fields.updated': 1,\\n 'jira.fields.comment.comments.author.emailAddress': 1,\\n 'jira.fields.comment.comments.created': 1,\\n 'jira.fields.comment.comments.updated': 1,\\n 'jira.fields.comment.comments.visibility': 1,\\n 'jira.key': 1,\\n 'jira.tags': 1,\\n 'sla': 1,\\n }\\n cur = db.issues.find(query, proj)\\n cur.batch_size(100000)\\n return cur\",\n \"def issueListing(self, v, i):\\n #list of URLS within the issue\\n# links = []\\n issURL = self.link(vol = v, iss = i )\\n html=urlopen(issURL)\\n soup=BeautifulSoup(html,'html.parser')\\n URLs = [] #Empty list\\n \\n# titles = soup.find_all('h5', class_=\\\"title\\\")\\n# authors = soup.find_all('h6', class_=\\\"authors\\\")\\n# pubs = soup.find_all('h6', class_=\\\"pub-info\\\")\\n# for t, a, p in zip(titles, authors, pubs):\\n blocks = soup.find_all('div', class_=\\\"article panel article-result\\\")\\n for b in blocks:\\n# print(b)\\n titletag = b.find('h5', class_=\\\"title\\\")\\n title = titletag.get_text()\\n #Extract abstract url from title head\\n aURL = titletag.find('a', href = True)['href']\\n alink = 'https://journals.aps.org' + aURL\\n #Print out the scraped information\\n print(title)\\n print(alink)\\n #Extract research area and topic keywords\\n kwlist = b.find('ul', class_=\\\"inline-list subjects\\\")\\n #If the list tag exists\\n if kwlist:\\n lis = kwlist.find_all('li')\\n kws = [li.get_text() for li in lis] \\n print(kws)\\n #Add utf-8 encode\\n# print(kws.encode('utf-8')) \\n print('----------------------------------------------------------------') \\n #Collect URLs in the issue\\n URLs.append('https://journals.aps.org' + aURL)\\n return URLs\",\n \"async def get_issues(self) -> [\\\"AIOGitHubAPIRepositoryIssue\\\"]:\\n _endpoint = f\\\"/repos/{self.full_name}/issues\\\"\\n\\n response = await self.client.get(endpoint=_endpoint)\\n return [AIOGitHubAPIRepositoryIssue(self.client, x) for x in response or []]\",\n \"def test_issues_list(self):\\n response = self.client.get(url_for('issues.issuesresource'))\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue(response.json)\",\n \"def find_issue_in_target(connection, issue):\\n check_jql = 'project = %s and \\\"SPIN Issue ID\\\" ~ %s' % (DST_PROJECT, issue.key)\\n\\n return find_one_issue(connection, check_jql)\",\n \"def _return_specific_status_prs(all_prs, filters):\\n if _validate_list_of_dict(all_prs):\\n pr_issue = []\\n for pull_request in all_prs:\\n commits = pull_request['pr'].get_commits()\\n statuses = [[status.state] for status in commits.reversed[0].get_statuses() if filters['status'] == status.state]\\n if statuses:\\n pr_issue.append({'pr':pull_request['pr'], 'issue':pull_request['issue']})\\n statuses = []\\n logger.debug(\\\"SPECIFIC PR STATUSES: %s\\\", [pr['pr'].number for pr in pr_issue])\\n return pr_issue\\n else:\\n return []\",\n \"def run_tests(self):\\n self.ignore_errors()\\n return self.issues\",\n \"def resolve_issues(user_input):\\n\\n iids = []\\n\\n issue_match = re.compile(\\n r\\\"\\\"\\\"^\\\\s*[iI](?P<iid>[0-9]+)\\\\s*$\\\"\\\"\\\",\\n re.VERBOSE\\n ) \\n\\n for needle in user_input:\\n match = issue_match.match(needle)\\n if not match:\\n vlog(2, 'unable to resolve %s to an issue' % (needle))\\n continue\\n\\n iids.append(int(match.group('iid')))\\n\\n return iids\",\n \"def getIssues(db, data):\\n start = datetime.utcnow() # Time this and log how long refreshing took.\\n try:\\n cur = getRelevantIssues(db, data)\\n except pymongo.errors.PyMongoError as e:\\n return {\\\"error\\\": \\\"Error querying the Mongo database: \\\" +\\n e.message}\\n\\n count = 0\\n dbd_data = {\\n # TODO: make sets of these to make the lookups below faster\\n \\\"SLA\\\": data.get(\\\"SLA\\\", []),\\n \\\"FTS\\\": data.get(\\\"FTS\\\", []),\\n \\\"REV\\\": [], # Just refresh these every time\\n \\\"UNA\\\": data.get(\\\"UNA\\\", []),\\n \\\"active\\\": data.get(\\\"active\\\", {}),\\n \\\"waiting\\\": data.get(\\\"waiting\\\", {})\\n }\\n\\n try:\\n revIssues = getREVIssues(db)\\n except pymongo.errors.PyMongoError as e:\\n return {\\\"error\\\": \\\"Error querying the Mongo database: \\\" +\\n e.message}\\n\\n updated_data = {\\n \\\"SLA\\\": [],\\n \\\"FTS\\\": [],\\n \\\"REV\\\": revIssues,\\n \\\"UNA\\\": []\\n }\\n for i in cur:\\n count += 1\\n issue = SupportIssue().fromDoc(i)\\n\\n # Keep track of the totals:\\n # --- Active issue count ---\\n if issue.isActive():\\n dbd_data['active'][issue.key] = 1\\n elif issue.key in dbd_data['active']:\\n del dbd_data['active'][issue.key]\\n # --- Waiting For Customer issue count ---\\n if issue.isWFC() and not issue.doc['deleted']:\\n dbd_data['waiting'][issue.key] = 1\\n elif issue.key in dbd_data['waiting']:\\n del dbd_data['waiting'][issue.key]\\n\\n # For each category, see if the issue belongs, and if not, remove it\\n # from the dashboard issues if it was there.\\n if isSLA(issue):\\n updated_data[\\\"SLA\\\"].append(trimmedSLAIssue(issue))\\n else:\\n removeCompressedIssueIfPresent(issue, dbd_data[\\\"SLA\\\"])\\n if isFTS(issue):\\n updated_data[\\\"FTS\\\"].append(trimmedFTSIssue(issue))\\n else:\\n removeCompressedIssueIfPresent(issue, dbd_data[\\\"FTS\\\"])\\n if isUNA(issue):\\n updated_data[\\\"UNA\\\"].append(trimmedUNAIssue(issue))\\n else:\\n removeCompressedIssueIfPresent(issue, dbd_data[\\\"UNA\\\"])\\n\\n mergeAndSortIssues(dbd_data, updated_data)\\n\\n duration = datetime.utcnow() - start\\n logger.info(\\\"getIssues took {0}, count: {1}\\\".format(duration, count))\\n return dbd_data\",\n \"def test_correct_issue_parsing(self):\\n issue = SAMPLE_ISSUE.copy()\\n parsed = parse_issue(issue['body'])\\n for item in parsed:\\n self.assertTrue(item)\",\n \"def test_issue(self):\\n issue = Checkmarx.Issue('a_group', 'the_name', 'http://url', 3, 'New')\\n\\n self.assertEqual('a group', issue.group)\\n self.assertEqual('the name', issue.title)\\n self.assertEqual('http://url', issue.display_url)\\n self.assertEqual(3, issue.count)\\n self.assertEqual('New', issue.status)\",\n \"def test_get_repositories_by_username_by_repo_slug_pullrequests_by_pull_request_id_statuses(self):\\n pass\",\n \"def test_issue_edit_comment(self):\\n pass\",\n \"def test_obtain_issues_exclude_wrong_severity(self, mock_url_read):\\n mock_url_read.side_effect = [LAST_SCAN, '{\\\"reportId\\\": 22}', '{\\\"status\\\": {\\\"value\\\": \\\"Created\\\"}}',\\n SAST_REPORT.format(false_positive=False, severity='Low')]\\n self.__report.obtain_issues(['id'], 'high')\\n issues = self.__report.issues()\\n self.assertIsInstance(issues, List)\\n self.assertEqual(len(issues), 0)\",\n \"def _get_issue(repo, objid):\\n issue = None\\n if not repo.settings.get(\\\"issue_tracker\\\", True):\\n raise PagureEvException(\\\"No issue tracker found for this project\\\")\\n\\n session = _get_session()\\n issue = pagure.lib.query.search_issues(session, repo, issueid=objid)\\n\\n if issue is None or issue.project != repo:\\n raise PagureEvException(\\\"Issue '%s' not found\\\" % objid)\\n\\n if issue.private:\\n # TODO: find a way to do auth\\n raise PagureEvException(\\n \\\"This issue is private and you are not allowed to view it\\\"\\n )\\n\\n return issue\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70138097","0.6760061","0.66123015","0.66048265","0.65544665","0.6547893","0.64266086","0.63871706","0.63705385","0.6270671","0.62466","0.6183235","0.61762655","0.61605066","0.61473805","0.6101282","0.60798544","0.6076719","0.6035414","0.602907","0.60161304","0.60151076","0.60107434","0.60073125","0.59532416","0.59429324","0.592761","0.5925048","0.5897928","0.5877508","0.5877082","0.58334213","0.5823798","0.57832795","0.5744221","0.57303286","0.57303286","0.57292545","0.5728222","0.57220876","0.57180923","0.57047737","0.5702722","0.56437683","0.5637463","0.5635427","0.56301713","0.5629877","0.56297576","0.5621641","0.5614229","0.5608967","0.5603242","0.56029487","0.5601449","0.5581305","0.5580716","0.5579165","0.5559103","0.55563337","0.55530345","0.5539304","0.55384225","0.5535073","0.55324554","0.5528394","0.55237776","0.55039763","0.5503867","0.5503425","0.55020654","0.55008125","0.54915965","0.54878956","0.5487518","0.548624","0.54859585","0.5474724","0.54635763","0.54616463","0.5456678","0.54439986","0.54325575","0.5424579","0.5412513","0.5407542","0.540015","0.5396888","0.5390324","0.53843755","0.53793764","0.5378642","0.537534","0.53658485","0.53603333","0.5358621","0.53556675","0.53494406","0.5345403","0.53451824"],"string":"[\n \"0.70138097\",\n \"0.6760061\",\n \"0.66123015\",\n \"0.66048265\",\n \"0.65544665\",\n \"0.6547893\",\n \"0.64266086\",\n \"0.63871706\",\n \"0.63705385\",\n \"0.6270671\",\n \"0.62466\",\n \"0.6183235\",\n \"0.61762655\",\n \"0.61605066\",\n \"0.61473805\",\n \"0.6101282\",\n \"0.60798544\",\n \"0.6076719\",\n \"0.6035414\",\n \"0.602907\",\n \"0.60161304\",\n \"0.60151076\",\n \"0.60107434\",\n \"0.60073125\",\n \"0.59532416\",\n \"0.59429324\",\n \"0.592761\",\n \"0.5925048\",\n \"0.5897928\",\n \"0.5877508\",\n \"0.5877082\",\n \"0.58334213\",\n \"0.5823798\",\n \"0.57832795\",\n \"0.5744221\",\n \"0.57303286\",\n \"0.57303286\",\n \"0.57292545\",\n \"0.5728222\",\n \"0.57220876\",\n \"0.57180923\",\n \"0.57047737\",\n \"0.5702722\",\n \"0.56437683\",\n \"0.5637463\",\n \"0.5635427\",\n \"0.56301713\",\n \"0.5629877\",\n \"0.56297576\",\n \"0.5621641\",\n \"0.5614229\",\n \"0.5608967\",\n \"0.5603242\",\n \"0.56029487\",\n \"0.5601449\",\n \"0.5581305\",\n \"0.5580716\",\n \"0.5579165\",\n \"0.5559103\",\n \"0.55563337\",\n \"0.55530345\",\n \"0.5539304\",\n \"0.55384225\",\n \"0.5535073\",\n \"0.55324554\",\n \"0.5528394\",\n \"0.55237776\",\n \"0.55039763\",\n \"0.5503867\",\n \"0.5503425\",\n \"0.55020654\",\n \"0.55008125\",\n \"0.54915965\",\n \"0.54878956\",\n \"0.5487518\",\n \"0.548624\",\n \"0.54859585\",\n \"0.5474724\",\n \"0.54635763\",\n \"0.54616463\",\n \"0.5456678\",\n \"0.54439986\",\n \"0.54325575\",\n \"0.5424579\",\n \"0.5412513\",\n \"0.5407542\",\n \"0.540015\",\n \"0.5396888\",\n \"0.5390324\",\n \"0.53843755\",\n \"0.53793764\",\n \"0.5378642\",\n \"0.537534\",\n \"0.53658485\",\n \"0.53603333\",\n \"0.5358621\",\n \"0.53556675\",\n \"0.53494406\",\n \"0.5345403\",\n \"0.53451824\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7080025"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":85198,"cells":{"query":{"kind":"string","value":"counts reactions to issue comments"},"document":{"kind":"string","value":"def issue_reactions(self):\n if self.issue_nums:\n repo = self.g.get_repo(\"apache/airflow\")\n for num in self.issue_nums:\n try:\n issue = repo.get_issue(num)\n except UnknownObjectException:\n continue\n for reaction in issue.get_reactions():\n self._users.add(reaction.user.login)\n self.num_issue_reactions += 1\n for issue_comment in issue.get_comments():\n self.num_issue_comments += 1\n self._users.add(issue_comment.user.login)\n if issue_comment.body is not None:\n self.len_issue_comments += len(issue_comment.body)"},"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 github_num_reactions(comment_object: Dict[str, Any]) -> int:\n return comment_object.get('reactions', {}).get('total_count', 0)","def test_issue_get_comment_reactions(self):\n pass","def github_num_positive_reactions(comment_object: Dict[str, Any]) -> int:\n num_positive_reactions = 0\n positive_emojis = {'+1', 'laugh', 'hooray', 'heart', 'rocket', 'eyes'}\n reactions = comment_object.get('reactions', {})\n for emoji in positive_emojis:\n num_positive_reactions += reactions.get(emoji, 0)\n return num_positive_reactions","def reactions(self, request, *args, **kwargs):\n comment = self.get_object()\n reactions = ReactionComment.objects.filter(comment=comment)\n serializer = ReactionCommentModelSummarySerializer(\n reactions, many=True)\n return Response(serializer.data, status=status.HTTP_200_OK)","def calc_conv_comments(self):\n for conv_comment in self.pull_request.get_issue_comments():\n self._users.add(conv_comment.user.login)\n lowercase_body = conv_comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_conv_comments += 1\n for reaction in conv_comment.get_reactions():\n self._users.add(reaction.user.login)\n self.conv_comment_reactions += 1\n if conv_comment.body is not None:\n self.len_issue_comments += len(conv_comment.body)","def calc_comments(self):\n for comment in self.pull_request.get_comments():\n self._users.add(comment.user.login)\n lowercase_body = comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_comments += 1\n if comment.body is not None:\n self.len_comments += len(comment.body)\n for reaction in comment.get_reactions():\n self._users.add(reaction.user.login)\n self.comment_reactions += 1","def count_comments(self):\n return self.run_query(f\"count({self.r}/comment)\")","def test_issue_get_issue_reactions(self):\n pass","def get_number_of_reactions(self):\n return self._performed_actions[REACT]","def test_get_reaction_count(self):\n post = PostFactory()\n\n reactions = {\n Reaction.ANGRY: 3,\n Reaction.LIKE: 2,\n }\n\n for reaction, count in reactions.items():\n ReactionFactory.create_batch(\n count,\n post=post,\n description=reaction,\n )\n self.assertEqual(\n post.get_reaction_counter(),\n [\n (Reaction.IMAGE_URLS[reaction], count)\n for reaction, count in reactions.items()\n ]\n )","def test_status_reply_count(self):\n with self.app.app_context():\n u = user(save=True)\n s = status(user=u, project=None, save=True)\n for i in range(5):\n status(user=u, project=None, reply_to=s, save=True)\n\n eq_(s.reply_count, 5)","def comments_count(self) -> int:\n return pulumi.get(self, \"comments_count\")","def comment_count(self):\n return self.comments.filter_by(state=0).count()","def cmd_account_comment_count(client, args):\n account_comment_count = client.get_account_comment_count(args.username)\n generate_output({'account_comment_count': account_comment_count})","def test_issue_post_comment_reaction(self):\n pass","def cmd_gallery_comment_count(client, args):\n gallery_comment_count = client.gallery_comment_count(args.item_id)\n generate_output({'gallery_comment_count': gallery_comment_count})","def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\n if project_name == PROJECT_ALL:\n # comments in changes across all projects after from_datetime\n comments = reviewer.comments.filter(\n timestamp__gte=from_datetime).distinct()\n else:\n # comments in changes in given project after from_datetime\n comments = reviewer.comments.filter(\n change__project_name=project_name,\n timestamp__gte=from_datetime).distinct()\n\n return comments.count()","def getCommentCount(self, source):\n commentStart = source.find('item?id=')\n commentCountStart = source.find('>', commentStart) + 1\n commentEnd = source.find('</a>', commentStart)\n commentCountString = source[commentCountStart:commentEnd]\n if commentCountString == \"discuss\":\n return 0\n elif commentCountString == \"\":\n return 0\n else:\n commentCountString = commentCountString.split(' ')[0]\n return int(commentCountString)","def getNumReactions(self):\n return _libsbml.Model_getNumReactions(self)","def get_number_of_comments(self):\n return self._performed_actions[WRITE_COMMENT]","async def reactions(self, ctx):\n\n\t\tawait self.message_leaderboard(ctx, \"reactions\")","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def _get_comment_counts(account, patchset):\n # A key-only query won't work because we need to fetch the patch key\n # in the for loop further down.\n comment_query = models.Comment.query(ancestor=patchset.key)\n\n # Get all comment counts with one query rather than one per patch.\n comments_by_patch = {}\n drafts_by_patch = {}\n for c in comment_query:\n pkey = c.patch_key\n if not c.draft:\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\n elif account and c.author == account.user:\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\n\n return comments_by_patch, drafts_by_patch","def test_issue_delete_comment_reaction(self):\n pass","def addCommentCount(self,count):\n self.commentCount += count\n return None","def action_count(self):\n raise NotImplementedError","def _get_modified_counts(issue):\n modified_added_count = 0\n modified_removed_count = 0\n\n # Count the modified lines in the patchset.\n patchsets = list(issue.patchsets)\n if patchsets:\n for patch in patchsets[-1].patches:\n modified_added_count += patch.num_added\n modified_removed_count += patch.num_removed\n\n return modified_added_count, modified_removed_count","def get_comments_num(self): \n num=len(self.comments_set.all())\n return num","def get_num_actions():\n return 6","def get_comment_count(self, postid=0, blogid=1):\n \n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)","def increment_comment_count():\n\n with _conn.cursor() as cur:\n cur.execute(\"UPDATE comment_count SET count = count + 1;\")\n _conn.commit()","def get_comments_count(self, thread_uid: str) -> int:\n pass","def add_reactions(_) -> int:\n return 1 << 6","def add_reactions(_) -> int:\n return 1 << 6","def sent_count(comment):\n return comment.__len__()","def count_comment_karma(user):\r\n\r\n karma = 0\r\n comments = Comment.objects.filter(name=user).all()\r\n for comment in comments:\r\n karma += comment.likes.count()\r\n\r\n return karma","def message_count(self):\n pass","def update_comments(self):\n self.nb_comments = self.comments.count()\n self.save()","def test_issue_get_comments(self):\n pass","def on_issue_comment(self, payload):\n pass","def get_marble_count(self):","def increment_count(self, state):\n if state not in domain.REVIEW_STATES:\n raise ValueError('%s not in %s' % (state, domain.REVIEW_STATES))\n\n self._check_count()\n\n if state == domain.REVIEW_STATE_ASSIGNED:\n self.assigned_count += 1\n elif state == domain.REVIEW_STATE_COMPLETED:\n self.completed_count += 1\n elif state == domain.REVIEW_STATE_EXPIRED:\n self.expired_count += 1","def count():","def count_comments(self):\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\n count = comments.count()\n return count","def counter(self) -> int:","def counter(self) -> int:","def test_issue_get_repo_comments(self):\n pass","def get_replies_count(khoros_object, user_settings=None, user_id=None, login=None, email=None):\n user_settings = _process_settings_and_user_id(khoros_object, user_settings, user_id, login, email)\n select_fields = ('messages.count(*)', 'topics.count(*)')\n api_response = query_users_table_by_id(khoros_object, select_fields, user_settings['id'])\n items_list = api.get_items_list(api_response)\n return int(items_list['messages']['count']) - int(items_list['topics']['count'])","def count_issues(issues):\n counts = {issue: 0 for issue in ISSUE_TYPES}\n for (_, _, issue_type, _) in issues:\n counts[issue_type] += 1\n counts = sorted(counts.items(),\n key=lambda item: item[1],\n reverse=True)\n return counts","async def _total_notes(self, ctx: Context):\n\n async with self.config.member(ctx.author).notes() as notes:\n await ctx.send(_(\"You have {} notes saved.\").format(len(notes)))","def test_issue_get_comment(self):\n pass","def set_n_comments_observed_task2(posts):\n for p in posts:\n p['n_comments_observed'] = get_hostile_indices(p)[0] + 1","def react(self, request, *args, **kwargs):\n comment = self.get_object()\n serializer = ReactionCommentModelSerializer(\n data=request.data, context={'user': request.user, 'comment': comment})\n \n try:\n serializer.is_valid(raise_exception=True)\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n except AssertionError:\n return Response(\n {'message': \"The comment's reaction has been delete.\"}, status=status.HTTP_200_OK)","def notification_count(request):\n\n # Check if logged in\n user = request.user\n if not user.is_authenticated():\n return {}\n\n return {\n 'notification_count': len(user.profile.notifications.filter(read=False))\n }","def save(self, *args, **kwargs):\n self.item.comments_total += 1\n self.item.save()\n super(Comment, self).save(*args, **kwargs)","def test_issue_post_issue_reaction(self):\n pass","def _optimize_draft_counts(issues):\n account = models.Account.current_user_account\n if account is None:\n issue_ids = None\n else:\n issue_ids = account.drafts\n for issue in issues:\n if issue_ids is None or issue.key.id() not in issue_ids:\n issue._num_drafts = issue._num_drafts or {}\n if account:\n issue._num_drafts[account.email] = 0","def _optimize_draft_counts(issues):\n cur_account = models.Account.current_user_account\n if cur_account is None:\n issue_ids = None\n else:\n issue_ids = cur_account.drafts\n for issue in issues:\n if issue_ids is None or issue.key.id() not in issue_ids:\n issue._num_drafts = issue._num_drafts or {}\n if cur_account:\n issue._num_drafts[cur_account.email] = 0","def make_count_change():\n \"*** YOUR CODE HERE ***\"","def reply_count(self, url, mode=5, after=0):\n\n sql = \"\"\"\n SELECT\n c.parent, count(*)\n FROM comments AS c\n INNER JOIN threads AS t\n ON t.uri=%s AND c.tid = t.id AND\n (%s | c.mode = %s) AND\n c.created > %s\n GROUP BY c.parent\n \"\"\"\n\n return dict(self.db.fetchall(sql, [url, mode, mode, after]))","def update_count(self):\n pass","def question_comments(request, lot_id, question_pk):\n question = get_object_or_404(Question, lot__slug=lot_id, pk=question_pk)\n question.views += 1\n question.save()\n return render(request, 'comments_on_question.html', {'question': question})","def get_num_displayed_responses(self):\r\n return len(self._find_within(\".discussion-response\"))","def count_reddit_comments_ngram_strs(year, month, n):\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\n return Counter(itertools.chain.from_iterable(ngram_strs))","def num_actions(cls) -> int:\n return 2","def update_count(self):\n pass # Do nothing","def parseCommentsTotalCount(data):\n p = re.compile(r\"\\d+ Reviews\")\n\n for line in data:\n line = line.replace(\",\", \"\")\n match = re.search(p, line)\n if match != None:\n getNmbr = match.group().split(\" \")\n return int(getNmbr[0])\n return -1","async def scrape_comments(self):\n\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\n\n comment_count = 0\n async for comment in subreddit_origin.comments(limit=self.limit):\n if self.memory.contains(comment.id):\n continue\n\n self.memory.add(comment.id)\n\n # Parse Comment\n comment = self.parse_comment(comment)\n\n # Save in Pub/Sub\n if self.enable_publish:\n self.publish(comment)\n\n comment_count += 1\n\n return comment_count","def test_update_post_comment_count(\n mocker, reddit_comment_obj, update_comment_count_func, expected_increment\n):\n patched_task = mocker.patch(\n \"search.search_index_helpers.increment_document_integer_field\"\n )\n update_comment_count_func(reddit_comment_obj)\n assert patched_task.delay.called is True\n assert patched_task.delay.call_args[0] == (\n gen_post_id(reddit_comment_obj.submission.id),\n )\n assert patched_task.delay.call_args[1] == {\n \"field_name\": \"num_comments\",\n \"incr_amount\": expected_increment,\n \"object_type\": POST_TYPE,\n }","def prepare_count_incidents(self, object):\n roles = object.actorrole_set.all()\n return Incident.objects.filter(actors_role__in=roles).count()","def increment_counter(self) -> None:","def count(request):\r\n n = request.user.profile.unread_message_count()\r\n data = {\r\n 'count': n,\r\n }\r\n return HttpResponse(json.dumps(data), mimetype='application/json')","def test_issue_create_comment(self):\n pass","def count_tickets_closed(self, cursor, closed_statuses, metric):\n\n # Group changes by date\n closed_per_date = []\n for date, changes in groupby(cursor, itemgetter(1)):\n closed_ids = []\n effort = {}\n for change in changes:\n # Get all closed statuses for ticket type\n closed_status_for_type = closed_statuses[change[2]]\n\n # if moved from an open to closed status\n if change[3] not in closed_status_for_type and change[4] in closed_status_for_type:\n closed_ids.append(change[0])\n\n # keep track of story point values for each ticket\n if len(change) >= 6 and change[0] not in effort:\n # use id for key, points for the value\n effort[change[0]] = change[5]\n\n # if moved from a closed status to open\n if change[3] in closed_status_for_type and change[4] not in closed_status_for_type:\n # remove id from our list and story points from effort\n try:\n closed_ids.remove(change[0])\n del effort[change[0]]\n except (ValueError, KeyError):\n # we don't catch worry about these exceptions as\n # sometimes the ticket wont be in closed_ids or effort\n pass\n\n if metric =='tickets':\n # List of tuples (date, closed_count)\n closed_per_date.append((date.strftime('%Y-%m-%d'), len(closed_ids)))\n elif metric == 'story_points':\n # List of tuples (date, total of effort for all closed tickets)\n closed_per_date.append((date.strftime('%Y-%m-%d'), sum(effort.values())))\n\n return closed_per_date","def flag_comment(request, submission_id, comment_id):\n # If not flagged, flag and decrement author's karma.\n # If flagged, undo flag and increment author's karma.\n # If upvoted, undo upvote and decrement author's karma.\n # If downvoted, undo upvote and increment author's karma.\n # No need to downvote and flag.\n # (Can't flag something you've upvoted.)\n\n next_page = request.META.get('HTTP_REFERER', None) or '/'\n comment = Comment.objects.get(id=comment_id)\n\n flaggers = comment.flags.all()\n\n if request.user == comment.author or not request.user.has_perm('ed_news.can_flag_comment'):\n return redirect(next_page)\n\n if request.user not in flaggers:\n # Flag comment, and decrement author's karma.\n comment.flags.add(request.user)\n comment.save()\n decrement_karma(comment.author)\n\n if request.user in flaggers:\n # Undo the flag, and increment author's karma.\n comment.flags.remove(request.user)\n comment.save()\n increment_karma(comment.author)\n\n if request.user in comment.upvotes.all():\n # Undo the upvote, and decrement author's karma.\n comment.upvotes.remove(request.user)\n comment.save()\n decrement_karma(comment.author)\n\n if request.user in comment.downvotes.all():\n # Undo the downvote, and increment author's karma.\n comment.downvotes.remove(request.user)\n comment.save()\n increment_karma(comment.author)\n\n # Recalculate comment order.\n update_comment_ranking_points(Submission.objects.get(id=submission_id))\n\n # Invalidate caches: index, \n invalidate_caches('ed_news', 'index', 'new')\n invalidate_cache('discuss', (submission_id, ), namespace='ed_news')\n\n return redirect(next_page)","def info_reactions_simple_get():\n reactions = _reaction_by_group(436) # 436 == Simple Reaction\n return reactions, 200","def getReviewNumbers(singleStoryFooter):\n\twords = singleStoryFooter.get_text()\n\treview = re.compile(r\"Reviews: \\d+\").search(words)\n\tif review:\n\t\treviewNum = review.group()[9:]\n\t\treturn int(reviewNum)\n\telse: return 0","def decrement_comment_count():\n\n with _conn.cursor() as cur:\n cur.execute(\"UPDATE comment_count SET count = count - 1;\")\n _conn.commit()","def prepare_count_bulletins(self, object):\n roles = object.actorrole_set.all()\n return Bulletin.objects.filter(actors_role__in=roles).count()","def num_actions(self) -> int:\n return self.max_order_quantity + 1","def message_nums(request):\n if request.user.is_authenticated:\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\n else:\n return {}","def count_change(amount):\n \"*** YOUR CODE HERE ***\"\n\n return helper(1, amount)","def test_updates_count(self):\n user = self.create_user()\n thread = self.create_thread(sender=user)\n\n original_count = thread.message_set.count()\n\n for _ in range(0, 5):\n msg = mommy.make(Message, thread=thread, sender=user)\n\n send_message(msg.pk)\n\n # Because django caches querysets, we need to request the thread again\n refreshed_thread = Thread.objects.get(pk=msg.thread.pk)\n\n self.assertEqual(refreshed_thread.total_messages, original_count + 5)","def info_reactions_get():\n reactions = _reaction_by_group()\n return reactions, 200","def counts(url, key='author.email'):\n LOG.info('Getting counts', url=url, key=key)\n authors = GitTool.commits(url, key, include_defaults=False, result_format='flat_list')\n counts = defaultdict(lambda: 0)\n for x in authors:\n if key == 'author.email':\n x = re.sub(r'@.+', '', x)\n counts[x] += 1\n\n return OrderedDict(reversed(sorted(counts.items(), key=lambda x: x[1])))","def _get_reviewer_change_count(reviewer, project_name, from_datetime):\n if project_name == PROJECT_ALL:\n # changes across all projects after from_datetime\n changes = reviewer.changes.filter(\n timestamp__gte=from_datetime).distinct()\n else:\n # changes in given project after from_datetime\n changes = reviewer.changes.filter(\n project_name=project_name,\n timestamp__gte=from_datetime).distinct()\n\n return changes.count()","async def setnx_actions_count():\n cache_pool = await kafka.cache_pool()\n redis_lock_manager = await kafka.redis_lock_manager()\n\n await cache.set_key_with_lock('action_count', 0, redis_lock_manager, cache_pool, execute_cmd='setnx')","def counter_reactionary(our_hist, their_hist):\n if len(our_hist) == 0 or len(their_hist) == 0:\n return choice(CHOICES)\n elif our_hist[-1] == CHOICES[(their_hist[-1] + 1) % 3]:\n return CHOICES[(our_hist[-1] + 1) % 3]\n elif our_hist[-1] == CHOICES[(their_hist[-1] + 2) % 3]:\n return CHOICES[(our_hist[-1] + 2) % 3]","async def messagecount(self, ctx, name=None):\r\n if await bMsg(ctx,ctx.message.author.name,client):\r\n return\r\n async with ctx.channel.typing():\r\n username = name\r\n if username is None:\r\n username = ctx.message.author.name\r\n resp = await self.req('https://api.scratch.mit.edu/users/' + username + '/messages/count')\r\n if resp is None and name is None:\r\n username = getattr(ctx.message.author, 'nick', '_')\r\n resp = await self.req('https://api.scratch.mit.edu/users/' + username + '/messages/count')\r\n logger.info('Scratch.messagecount: ' + username, extra={'invoker': ctx.message.author.name})\r\n if resp is None:\r\n await ctx.send(\"Couldn't get message count for \" + username)\r\n else:\r\n await ctx.send('{} has {} messages'.format(\r\n username,\r\n json.loads(resp)['count']\r\n ))","def disqus_num_replies(context, shortname=''):\n shortname = getattr(settings, 'DISQUS_WEBSITE_SHORTNAME', shortname)\n \n return {\n 'shortname': shortname,\n 'config': get_config(context),\n }","def update_counter(self, counter, entity):","def test_issue_delete_comment(self):\n pass","def updateActionExp(self):\n self.action_cnt += 1","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def nr_of_over_due_actions(self, *board_ids: str) -> int:\n return len(list(self.__over_due_cards(*board_ids))) if self.__boards(*board_ids) else -1","def comments(self):\r\n return IssueComments(self)","def comments(self):\r\n return IssueComments(self)"],"string":"[\n \"def github_num_reactions(comment_object: Dict[str, Any]) -> int:\\n return comment_object.get('reactions', {}).get('total_count', 0)\",\n \"def test_issue_get_comment_reactions(self):\\n pass\",\n \"def github_num_positive_reactions(comment_object: Dict[str, Any]) -> int:\\n num_positive_reactions = 0\\n positive_emojis = {'+1', 'laugh', 'hooray', 'heart', 'rocket', 'eyes'}\\n reactions = comment_object.get('reactions', {})\\n for emoji in positive_emojis:\\n num_positive_reactions += reactions.get(emoji, 0)\\n return num_positive_reactions\",\n \"def reactions(self, request, *args, **kwargs):\\n comment = self.get_object()\\n reactions = ReactionComment.objects.filter(comment=comment)\\n serializer = ReactionCommentModelSummarySerializer(\\n reactions, many=True)\\n return Response(serializer.data, status=status.HTTP_200_OK)\",\n \"def calc_conv_comments(self):\\n for conv_comment in self.pull_request.get_issue_comments():\\n self._users.add(conv_comment.user.login)\\n lowercase_body = conv_comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_conv_comments += 1\\n for reaction in conv_comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.conv_comment_reactions += 1\\n if conv_comment.body is not None:\\n self.len_issue_comments += len(conv_comment.body)\",\n \"def calc_comments(self):\\n for comment in self.pull_request.get_comments():\\n self._users.add(comment.user.login)\\n lowercase_body = comment.body.lower()\\n if \\\"protm\\\" in lowercase_body:\\n self.num_protm += 1\\n self.num_comments += 1\\n if comment.body is not None:\\n self.len_comments += len(comment.body)\\n for reaction in comment.get_reactions():\\n self._users.add(reaction.user.login)\\n self.comment_reactions += 1\",\n \"def count_comments(self):\\n return self.run_query(f\\\"count({self.r}/comment)\\\")\",\n \"def test_issue_get_issue_reactions(self):\\n pass\",\n \"def get_number_of_reactions(self):\\n return self._performed_actions[REACT]\",\n \"def test_get_reaction_count(self):\\n post = PostFactory()\\n\\n reactions = {\\n Reaction.ANGRY: 3,\\n Reaction.LIKE: 2,\\n }\\n\\n for reaction, count in reactions.items():\\n ReactionFactory.create_batch(\\n count,\\n post=post,\\n description=reaction,\\n )\\n self.assertEqual(\\n post.get_reaction_counter(),\\n [\\n (Reaction.IMAGE_URLS[reaction], count)\\n for reaction, count in reactions.items()\\n ]\\n )\",\n \"def test_status_reply_count(self):\\n with self.app.app_context():\\n u = user(save=True)\\n s = status(user=u, project=None, save=True)\\n for i in range(5):\\n status(user=u, project=None, reply_to=s, save=True)\\n\\n eq_(s.reply_count, 5)\",\n \"def comments_count(self) -> int:\\n return pulumi.get(self, \\\"comments_count\\\")\",\n \"def comment_count(self):\\n return self.comments.filter_by(state=0).count()\",\n \"def cmd_account_comment_count(client, args):\\n account_comment_count = client.get_account_comment_count(args.username)\\n generate_output({'account_comment_count': account_comment_count})\",\n \"def test_issue_post_comment_reaction(self):\\n pass\",\n \"def cmd_gallery_comment_count(client, args):\\n gallery_comment_count = client.gallery_comment_count(args.item_id)\\n generate_output({'gallery_comment_count': gallery_comment_count})\",\n \"def _get_reviewer_comment_count(reviewer, project_name, from_datetime):\\n if project_name == PROJECT_ALL:\\n # comments in changes across all projects after from_datetime\\n comments = reviewer.comments.filter(\\n timestamp__gte=from_datetime).distinct()\\n else:\\n # comments in changes in given project after from_datetime\\n comments = reviewer.comments.filter(\\n change__project_name=project_name,\\n timestamp__gte=from_datetime).distinct()\\n\\n return comments.count()\",\n \"def getCommentCount(self, source):\\n commentStart = source.find('item?id=')\\n commentCountStart = source.find('>', commentStart) + 1\\n commentEnd = source.find('</a>', commentStart)\\n commentCountString = source[commentCountStart:commentEnd]\\n if commentCountString == \\\"discuss\\\":\\n return 0\\n elif commentCountString == \\\"\\\":\\n return 0\\n else:\\n commentCountString = commentCountString.split(' ')[0]\\n return int(commentCountString)\",\n \"def getNumReactions(self):\\n return _libsbml.Model_getNumReactions(self)\",\n \"def get_number_of_comments(self):\\n return self._performed_actions[WRITE_COMMENT]\",\n \"async def reactions(self, ctx):\\n\\n\\t\\tawait self.message_leaderboard(ctx, \\\"reactions\\\")\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def _get_comment_counts(account, patchset):\\n # A key-only query won't work because we need to fetch the patch key\\n # in the for loop further down.\\n comment_query = models.Comment.query(ancestor=patchset.key)\\n\\n # Get all comment counts with one query rather than one per patch.\\n comments_by_patch = {}\\n drafts_by_patch = {}\\n for c in comment_query:\\n pkey = c.patch_key\\n if not c.draft:\\n comments_by_patch[pkey] = comments_by_patch.setdefault(pkey, 0) + 1\\n elif account and c.author == account.user:\\n drafts_by_patch[pkey] = drafts_by_patch.setdefault(pkey, 0) + 1\\n\\n return comments_by_patch, drafts_by_patch\",\n \"def test_issue_delete_comment_reaction(self):\\n pass\",\n \"def addCommentCount(self,count):\\n self.commentCount += count\\n return None\",\n \"def action_count(self):\\n raise NotImplementedError\",\n \"def _get_modified_counts(issue):\\n modified_added_count = 0\\n modified_removed_count = 0\\n\\n # Count the modified lines in the patchset.\\n patchsets = list(issue.patchsets)\\n if patchsets:\\n for patch in patchsets[-1].patches:\\n modified_added_count += patch.num_added\\n modified_removed_count += patch.num_removed\\n\\n return modified_added_count, modified_removed_count\",\n \"def get_comments_num(self): \\n num=len(self.comments_set.all())\\n return num\",\n \"def get_num_actions():\\n return 6\",\n \"def get_comment_count(self, postid=0, blogid=1):\\n \\n return self.execute('wp.getCommentCount', blogid, self.username, self.password, postid)\",\n \"def increment_comment_count():\\n\\n with _conn.cursor() as cur:\\n cur.execute(\\\"UPDATE comment_count SET count = count + 1;\\\")\\n _conn.commit()\",\n \"def get_comments_count(self, thread_uid: str) -> int:\\n pass\",\n \"def add_reactions(_) -> int:\\n return 1 << 6\",\n \"def add_reactions(_) -> int:\\n return 1 << 6\",\n \"def sent_count(comment):\\n return comment.__len__()\",\n \"def count_comment_karma(user):\\r\\n\\r\\n karma = 0\\r\\n comments = Comment.objects.filter(name=user).all()\\r\\n for comment in comments:\\r\\n karma += comment.likes.count()\\r\\n\\r\\n return karma\",\n \"def message_count(self):\\n pass\",\n \"def update_comments(self):\\n self.nb_comments = self.comments.count()\\n self.save()\",\n \"def test_issue_get_comments(self):\\n pass\",\n \"def on_issue_comment(self, payload):\\n pass\",\n \"def get_marble_count(self):\",\n \"def increment_count(self, state):\\n if state not in domain.REVIEW_STATES:\\n raise ValueError('%s not in %s' % (state, domain.REVIEW_STATES))\\n\\n self._check_count()\\n\\n if state == domain.REVIEW_STATE_ASSIGNED:\\n self.assigned_count += 1\\n elif state == domain.REVIEW_STATE_COMPLETED:\\n self.completed_count += 1\\n elif state == domain.REVIEW_STATE_EXPIRED:\\n self.expired_count += 1\",\n \"def count():\",\n \"def count_comments(self):\\n comments = YoutubeComment.query.outerjoin((QueryVideoMM, QueryVideoMM.video_id == YoutubeComment.video_id)).filter_by(youtube_query_id=self.id)\\n count = comments.count()\\n return count\",\n \"def counter(self) -> int:\",\n \"def counter(self) -> int:\",\n \"def test_issue_get_repo_comments(self):\\n pass\",\n \"def get_replies_count(khoros_object, user_settings=None, user_id=None, login=None, email=None):\\n user_settings = _process_settings_and_user_id(khoros_object, user_settings, user_id, login, email)\\n select_fields = ('messages.count(*)', 'topics.count(*)')\\n api_response = query_users_table_by_id(khoros_object, select_fields, user_settings['id'])\\n items_list = api.get_items_list(api_response)\\n return int(items_list['messages']['count']) - int(items_list['topics']['count'])\",\n \"def count_issues(issues):\\n counts = {issue: 0 for issue in ISSUE_TYPES}\\n for (_, _, issue_type, _) in issues:\\n counts[issue_type] += 1\\n counts = sorted(counts.items(),\\n key=lambda item: item[1],\\n reverse=True)\\n return counts\",\n \"async def _total_notes(self, ctx: Context):\\n\\n async with self.config.member(ctx.author).notes() as notes:\\n await ctx.send(_(\\\"You have {} notes saved.\\\").format(len(notes)))\",\n \"def test_issue_get_comment(self):\\n pass\",\n \"def set_n_comments_observed_task2(posts):\\n for p in posts:\\n p['n_comments_observed'] = get_hostile_indices(p)[0] + 1\",\n \"def react(self, request, *args, **kwargs):\\n comment = self.get_object()\\n serializer = ReactionCommentModelSerializer(\\n data=request.data, context={'user': request.user, 'comment': comment})\\n \\n try:\\n serializer.is_valid(raise_exception=True)\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n except AssertionError:\\n return Response(\\n {'message': \\\"The comment's reaction has been delete.\\\"}, status=status.HTTP_200_OK)\",\n \"def notification_count(request):\\n\\n # Check if logged in\\n user = request.user\\n if not user.is_authenticated():\\n return {}\\n\\n return {\\n 'notification_count': len(user.profile.notifications.filter(read=False))\\n }\",\n \"def save(self, *args, **kwargs):\\n self.item.comments_total += 1\\n self.item.save()\\n super(Comment, self).save(*args, **kwargs)\",\n \"def test_issue_post_issue_reaction(self):\\n pass\",\n \"def _optimize_draft_counts(issues):\\n account = models.Account.current_user_account\\n if account is None:\\n issue_ids = None\\n else:\\n issue_ids = account.drafts\\n for issue in issues:\\n if issue_ids is None or issue.key.id() not in issue_ids:\\n issue._num_drafts = issue._num_drafts or {}\\n if account:\\n issue._num_drafts[account.email] = 0\",\n \"def _optimize_draft_counts(issues):\\n cur_account = models.Account.current_user_account\\n if cur_account is None:\\n issue_ids = None\\n else:\\n issue_ids = cur_account.drafts\\n for issue in issues:\\n if issue_ids is None or issue.key.id() not in issue_ids:\\n issue._num_drafts = issue._num_drafts or {}\\n if cur_account:\\n issue._num_drafts[cur_account.email] = 0\",\n \"def make_count_change():\\n \\\"*** YOUR CODE HERE ***\\\"\",\n \"def reply_count(self, url, mode=5, after=0):\\n\\n sql = \\\"\\\"\\\"\\n SELECT\\n c.parent, count(*)\\n FROM comments AS c\\n INNER JOIN threads AS t\\n ON t.uri=%s AND c.tid = t.id AND\\n (%s | c.mode = %s) AND\\n c.created > %s\\n GROUP BY c.parent\\n \\\"\\\"\\\"\\n\\n return dict(self.db.fetchall(sql, [url, mode, mode, after]))\",\n \"def update_count(self):\\n pass\",\n \"def question_comments(request, lot_id, question_pk):\\n question = get_object_or_404(Question, lot__slug=lot_id, pk=question_pk)\\n question.views += 1\\n question.save()\\n return render(request, 'comments_on_question.html', {'question': question})\",\n \"def get_num_displayed_responses(self):\\r\\n return len(self._find_within(\\\".discussion-response\\\"))\",\n \"def count_reddit_comments_ngram_strs(year, month, n):\\n ngram_strs = ngram_extract.extract_reddit_comments_ngram_strs(year, month, n)\\n return Counter(itertools.chain.from_iterable(ngram_strs))\",\n \"def num_actions(cls) -> int:\\n return 2\",\n \"def update_count(self):\\n pass # Do nothing\",\n \"def parseCommentsTotalCount(data):\\n p = re.compile(r\\\"\\\\d+ Reviews\\\")\\n\\n for line in data:\\n line = line.replace(\\\",\\\", \\\"\\\")\\n match = re.search(p, line)\\n if match != None:\\n getNmbr = match.group().split(\\\" \\\")\\n return int(getNmbr[0])\\n return -1\",\n \"async def scrape_comments(self):\\n\\n subreddit_origin = await self.reddit.subreddit(self.subreddit)\\n\\n comment_count = 0\\n async for comment in subreddit_origin.comments(limit=self.limit):\\n if self.memory.contains(comment.id):\\n continue\\n\\n self.memory.add(comment.id)\\n\\n # Parse Comment\\n comment = self.parse_comment(comment)\\n\\n # Save in Pub/Sub\\n if self.enable_publish:\\n self.publish(comment)\\n\\n comment_count += 1\\n\\n return comment_count\",\n \"def test_update_post_comment_count(\\n mocker, reddit_comment_obj, update_comment_count_func, expected_increment\\n):\\n patched_task = mocker.patch(\\n \\\"search.search_index_helpers.increment_document_integer_field\\\"\\n )\\n update_comment_count_func(reddit_comment_obj)\\n assert patched_task.delay.called is True\\n assert patched_task.delay.call_args[0] == (\\n gen_post_id(reddit_comment_obj.submission.id),\\n )\\n assert patched_task.delay.call_args[1] == {\\n \\\"field_name\\\": \\\"num_comments\\\",\\n \\\"incr_amount\\\": expected_increment,\\n \\\"object_type\\\": POST_TYPE,\\n }\",\n \"def prepare_count_incidents(self, object):\\n roles = object.actorrole_set.all()\\n return Incident.objects.filter(actors_role__in=roles).count()\",\n \"def increment_counter(self) -> None:\",\n \"def count(request):\\r\\n n = request.user.profile.unread_message_count()\\r\\n data = {\\r\\n 'count': n,\\r\\n }\\r\\n return HttpResponse(json.dumps(data), mimetype='application/json')\",\n \"def test_issue_create_comment(self):\\n pass\",\n \"def count_tickets_closed(self, cursor, closed_statuses, metric):\\n\\n # Group changes by date\\n closed_per_date = []\\n for date, changes in groupby(cursor, itemgetter(1)):\\n closed_ids = []\\n effort = {}\\n for change in changes:\\n # Get all closed statuses for ticket type\\n closed_status_for_type = closed_statuses[change[2]]\\n\\n # if moved from an open to closed status\\n if change[3] not in closed_status_for_type and change[4] in closed_status_for_type:\\n closed_ids.append(change[0])\\n\\n # keep track of story point values for each ticket\\n if len(change) >= 6 and change[0] not in effort:\\n # use id for key, points for the value\\n effort[change[0]] = change[5]\\n\\n # if moved from a closed status to open\\n if change[3] in closed_status_for_type and change[4] not in closed_status_for_type:\\n # remove id from our list and story points from effort\\n try:\\n closed_ids.remove(change[0])\\n del effort[change[0]]\\n except (ValueError, KeyError):\\n # we don't catch worry about these exceptions as\\n # sometimes the ticket wont be in closed_ids or effort\\n pass\\n\\n if metric =='tickets':\\n # List of tuples (date, closed_count)\\n closed_per_date.append((date.strftime('%Y-%m-%d'), len(closed_ids)))\\n elif metric == 'story_points':\\n # List of tuples (date, total of effort for all closed tickets)\\n closed_per_date.append((date.strftime('%Y-%m-%d'), sum(effort.values())))\\n\\n return closed_per_date\",\n \"def flag_comment(request, submission_id, comment_id):\\n # If not flagged, flag and decrement author's karma.\\n # If flagged, undo flag and increment author's karma.\\n # If upvoted, undo upvote and decrement author's karma.\\n # If downvoted, undo upvote and increment author's karma.\\n # No need to downvote and flag.\\n # (Can't flag something you've upvoted.)\\n\\n next_page = request.META.get('HTTP_REFERER', None) or '/'\\n comment = Comment.objects.get(id=comment_id)\\n\\n flaggers = comment.flags.all()\\n\\n if request.user == comment.author or not request.user.has_perm('ed_news.can_flag_comment'):\\n return redirect(next_page)\\n\\n if request.user not in flaggers:\\n # Flag comment, and decrement author's karma.\\n comment.flags.add(request.user)\\n comment.save()\\n decrement_karma(comment.author)\\n\\n if request.user in flaggers:\\n # Undo the flag, and increment author's karma.\\n comment.flags.remove(request.user)\\n comment.save()\\n increment_karma(comment.author)\\n\\n if request.user in comment.upvotes.all():\\n # Undo the upvote, and decrement author's karma.\\n comment.upvotes.remove(request.user)\\n comment.save()\\n decrement_karma(comment.author)\\n\\n if request.user in comment.downvotes.all():\\n # Undo the downvote, and increment author's karma.\\n comment.downvotes.remove(request.user)\\n comment.save()\\n increment_karma(comment.author)\\n\\n # Recalculate comment order.\\n update_comment_ranking_points(Submission.objects.get(id=submission_id))\\n\\n # Invalidate caches: index, \\n invalidate_caches('ed_news', 'index', 'new')\\n invalidate_cache('discuss', (submission_id, ), namespace='ed_news')\\n\\n return redirect(next_page)\",\n \"def info_reactions_simple_get():\\n reactions = _reaction_by_group(436) # 436 == Simple Reaction\\n return reactions, 200\",\n \"def getReviewNumbers(singleStoryFooter):\\n\\twords = singleStoryFooter.get_text()\\n\\treview = re.compile(r\\\"Reviews: \\\\d+\\\").search(words)\\n\\tif review:\\n\\t\\treviewNum = review.group()[9:]\\n\\t\\treturn int(reviewNum)\\n\\telse: return 0\",\n \"def decrement_comment_count():\\n\\n with _conn.cursor() as cur:\\n cur.execute(\\\"UPDATE comment_count SET count = count - 1;\\\")\\n _conn.commit()\",\n \"def prepare_count_bulletins(self, object):\\n roles = object.actorrole_set.all()\\n return Bulletin.objects.filter(actors_role__in=roles).count()\",\n \"def num_actions(self) -> int:\\n return self.max_order_quantity + 1\",\n \"def message_nums(request):\\n if request.user.is_authenticated:\\n return {'unread_nums': request.user.usermessage_set.filter(has_read=False).count()}\\n else:\\n return {}\",\n \"def count_change(amount):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n return helper(1, amount)\",\n \"def test_updates_count(self):\\n user = self.create_user()\\n thread = self.create_thread(sender=user)\\n\\n original_count = thread.message_set.count()\\n\\n for _ in range(0, 5):\\n msg = mommy.make(Message, thread=thread, sender=user)\\n\\n send_message(msg.pk)\\n\\n # Because django caches querysets, we need to request the thread again\\n refreshed_thread = Thread.objects.get(pk=msg.thread.pk)\\n\\n self.assertEqual(refreshed_thread.total_messages, original_count + 5)\",\n \"def info_reactions_get():\\n reactions = _reaction_by_group()\\n return reactions, 200\",\n \"def counts(url, key='author.email'):\\n LOG.info('Getting counts', url=url, key=key)\\n authors = GitTool.commits(url, key, include_defaults=False, result_format='flat_list')\\n counts = defaultdict(lambda: 0)\\n for x in authors:\\n if key == 'author.email':\\n x = re.sub(r'@.+', '', x)\\n counts[x] += 1\\n\\n return OrderedDict(reversed(sorted(counts.items(), key=lambda x: x[1])))\",\n \"def _get_reviewer_change_count(reviewer, project_name, from_datetime):\\n if project_name == PROJECT_ALL:\\n # changes across all projects after from_datetime\\n changes = reviewer.changes.filter(\\n timestamp__gte=from_datetime).distinct()\\n else:\\n # changes in given project after from_datetime\\n changes = reviewer.changes.filter(\\n project_name=project_name,\\n timestamp__gte=from_datetime).distinct()\\n\\n return changes.count()\",\n \"async def setnx_actions_count():\\n cache_pool = await kafka.cache_pool()\\n redis_lock_manager = await kafka.redis_lock_manager()\\n\\n await cache.set_key_with_lock('action_count', 0, redis_lock_manager, cache_pool, execute_cmd='setnx')\",\n \"def counter_reactionary(our_hist, their_hist):\\n if len(our_hist) == 0 or len(their_hist) == 0:\\n return choice(CHOICES)\\n elif our_hist[-1] == CHOICES[(their_hist[-1] + 1) % 3]:\\n return CHOICES[(our_hist[-1] + 1) % 3]\\n elif our_hist[-1] == CHOICES[(their_hist[-1] + 2) % 3]:\\n return CHOICES[(our_hist[-1] + 2) % 3]\",\n \"async def messagecount(self, ctx, name=None):\\r\\n if await bMsg(ctx,ctx.message.author.name,client):\\r\\n return\\r\\n async with ctx.channel.typing():\\r\\n username = name\\r\\n if username is None:\\r\\n username = ctx.message.author.name\\r\\n resp = await self.req('https://api.scratch.mit.edu/users/' + username + '/messages/count')\\r\\n if resp is None and name is None:\\r\\n username = getattr(ctx.message.author, 'nick', '_')\\r\\n resp = await self.req('https://api.scratch.mit.edu/users/' + username + '/messages/count')\\r\\n logger.info('Scratch.messagecount: ' + username, extra={'invoker': ctx.message.author.name})\\r\\n if resp is None:\\r\\n await ctx.send(\\\"Couldn't get message count for \\\" + username)\\r\\n else:\\r\\n await ctx.send('{} has {} messages'.format(\\r\\n username,\\r\\n json.loads(resp)['count']\\r\\n ))\",\n \"def disqus_num_replies(context, shortname=''):\\n shortname = getattr(settings, 'DISQUS_WEBSITE_SHORTNAME', shortname)\\n \\n return {\\n 'shortname': shortname,\\n 'config': get_config(context),\\n }\",\n \"def update_counter(self, counter, entity):\",\n \"def test_issue_delete_comment(self):\\n pass\",\n \"def updateActionExp(self):\\n self.action_cnt += 1\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def nr_of_over_due_actions(self, *board_ids: str) -> int:\\n return len(list(self.__over_due_cards(*board_ids))) if self.__boards(*board_ids) else -1\",\n \"def comments(self):\\r\\n return IssueComments(self)\",\n \"def comments(self):\\r\\n return IssueComments(self)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76340306","0.74687517","0.7269382","0.6970428","0.6815051","0.67963237","0.6664741","0.6631019","0.65597695","0.64880365","0.6383443","0.63385135","0.6307957","0.6293642","0.6261808","0.62437093","0.619304","0.618121","0.6169378","0.6130174","0.6072496","0.60548633","0.60548633","0.60383886","0.59925485","0.5963881","0.5955385","0.593049","0.5913508","0.58882844","0.58309543","0.5821225","0.5820104","0.5820104","0.57986605","0.5789865","0.5781499","0.5773756","0.5750584","0.572251","0.5679246","0.567312","0.5665921","0.56190956","0.5555597","0.5555597","0.5503091","0.5493292","0.54725736","0.54626185","0.54601675","0.54379326","0.543374","0.5432251","0.54313195","0.5404411","0.54042846","0.54021657","0.5395634","0.53920895","0.53897864","0.5387232","0.53850436","0.53822684","0.5378005","0.5352445","0.5349414","0.5347401","0.53439474","0.53435117","0.53187823","0.531521","0.5311607","0.5306107","0.53030854","0.52767026","0.52726805","0.52725714","0.5270806","0.52653736","0.52632797","0.52492714","0.5247173","0.52409863","0.524031","0.5235672","0.5226613","0.5224467","0.52164465","0.5205378","0.5200321","0.5200026","0.51981163","0.51978093","0.51978093","0.51978093","0.51978093","0.5191695","0.51865715","0.51865715"],"string":"[\n \"0.76340306\",\n \"0.74687517\",\n \"0.7269382\",\n \"0.6970428\",\n \"0.6815051\",\n \"0.67963237\",\n \"0.6664741\",\n \"0.6631019\",\n \"0.65597695\",\n \"0.64880365\",\n \"0.6383443\",\n \"0.63385135\",\n \"0.6307957\",\n \"0.6293642\",\n \"0.6261808\",\n \"0.62437093\",\n \"0.619304\",\n \"0.618121\",\n \"0.6169378\",\n \"0.6130174\",\n \"0.6072496\",\n \"0.60548633\",\n \"0.60548633\",\n \"0.60383886\",\n \"0.59925485\",\n \"0.5963881\",\n \"0.5955385\",\n \"0.593049\",\n \"0.5913508\",\n \"0.58882844\",\n \"0.58309543\",\n \"0.5821225\",\n \"0.5820104\",\n \"0.5820104\",\n \"0.57986605\",\n \"0.5789865\",\n \"0.5781499\",\n \"0.5773756\",\n \"0.5750584\",\n \"0.572251\",\n \"0.5679246\",\n \"0.567312\",\n \"0.5665921\",\n \"0.56190956\",\n \"0.5555597\",\n \"0.5555597\",\n \"0.5503091\",\n \"0.5493292\",\n \"0.54725736\",\n \"0.54626185\",\n \"0.54601675\",\n \"0.54379326\",\n \"0.543374\",\n \"0.5432251\",\n \"0.54313195\",\n \"0.5404411\",\n \"0.54042846\",\n \"0.54021657\",\n \"0.5395634\",\n \"0.53920895\",\n \"0.53897864\",\n \"0.5387232\",\n \"0.53850436\",\n \"0.53822684\",\n \"0.5378005\",\n \"0.5352445\",\n \"0.5349414\",\n \"0.5347401\",\n \"0.53439474\",\n \"0.53435117\",\n \"0.53187823\",\n \"0.531521\",\n \"0.5311607\",\n \"0.5306107\",\n \"0.53030854\",\n \"0.52767026\",\n \"0.52726805\",\n \"0.52725714\",\n \"0.5270806\",\n \"0.52653736\",\n \"0.52632797\",\n \"0.52492714\",\n \"0.5247173\",\n \"0.52409863\",\n \"0.524031\",\n \"0.5235672\",\n \"0.5226613\",\n \"0.5224467\",\n \"0.52164465\",\n \"0.5205378\",\n \"0.5200321\",\n \"0.5200026\",\n \"0.51981163\",\n \"0.51978093\",\n \"0.51978093\",\n \"0.51978093\",\n \"0.51978093\",\n \"0.5191695\",\n \"0.51865715\",\n \"0.51865715\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7240344"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":85199,"cells":{"query":{"kind":"string","value":"Initiate a password reset with a complex token, multi step"},"document":{"kind":"string","value":"def create_password_reset_token(self, user_id):\n try:\n self.logger.debug('Password Reset attempt %s', user_id)\n password_reset_token = ''\n nosqldb = self.pers.nosql_db\n db_user_record = nosqldb['users'].find_one(\n {\n '$or': [\n {'username': user_id},\n {'email': user_id}\n ]\n }\n )\n # Confirm the user exists from previous query\n if db_user_record:\n # purge any old requests, even if unrelated\n nosqldb['passwordResets'].delete_many(\n {\n 'requestDate': {'$lt': datetime.datetime.utcnow() -\n datetime.timedelta(minutes=5)}\n }\n )\n\n already_sent = nosqldb['passwordResets'].find_one(\n {\n 'email': user_id\n }\n )\n if not already_sent:\n # create a password reset token\n #password_reset_token = hashlib.sha512('abc'.encode('utf-8')).hexdigest()\n password_reset_token = secrets.token_urlsafe(255)\n #persist the password reset request\n nosqldb['passwordResets'].insert_one(\n {\n 'username': db_user_record['username'],\n 'email': db_user_record['email'],\n 'requestDate': datetime.datetime.utcnow(),\n 'resetToken': password_reset_token,\n }\n )\n else:\n self.logger.debug('Password Reset Email Denied: existing request in flight')\n return password_reset_token\n except Exception as exc:\n self.logger.debug('Unexpected Error %s', str(exc))\n raise"},"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 request_password_reset():","def password_resetenter(request, uidb64=None, token=None):\n\n\tcontext_dict = {}\n\tif request.method == 'POST':\n\t\tassert uidb64 is not None and token is not None\n\t\tuid = urlsafe_base64_decode(uidb64)\n\t\tuser = models.Teacher.objects.get(\n\t\t\tsoft_delete=False, pk=uid\n\t\t)\n\t\tdb_user = user.user\n\t\treset_token = models.PasswordReset.objects.get(\n\t\t\ttoken=token, user=user\n\t\t)\n\t\ttoken_check = models.PasswordReset.objects.filter(\n\t\t\tuser=user, soft_delete=False, token_consumed=False,\n\t\t).exclude(token=token).first()\n\t\tupdate_fields = []\n\t\ttoken_check.token_consumed = True\n\t\tupdate_fields.append('token_consumed')\n\t\ttoken_check.soft_delete = True\n\t\tupdate_fields.append('soft_delete')\n\t\ttoken_check.save(update_fields=update_fields)\n\t\ttime_threshold = timezone.now() - reset_token.password_request_created_at\n\t\tif time_threshold > timedelta(minutes=30):\n\t\t\ttry:\n\t\t\t\tupdate_fields = []\n\t\t\t\treset_token.token_consumed = True\n\t\t\t\tupdate_fields.append('token_consumed')\n\t\t\t\treset_token.soft_delete = True\n\t\t\t\tupdate_fields.append('soft_delete')\n\t\t\t\treset_token.save(update_fields=update_fields)\n\t\t\texcept Exception as e:\n\t\t\t\tprint (e)\n\t\tif reset_token.user == user and reset_token.token == token:\n\t\t\tif reset_token.token_consumed == False and reset_token.soft_delete == False:\n\t\t\t\ttry:\n\t\t\t\t\tupdate_fields = []\n\t\t\t\t\treset_token.token_consumed = True\n\t\t\t\t\tupdate_fields.append('token_consumed')\n\t\t\t\t\treset_token.soft_delete = True\n\t\t\t\t\tupdate_fields.append('soft_delete')\n\t\t\t\t\treset_token.save(update_fields=update_fields)\n\t\t\t\texcept Exception as e:\n\t\t\t\t\tprint (e)\n\t\t\t\tform = AdminPasswordChangeForm(user=db_user, data=request.POST)\n\t\t\t\tif form.is_valid():\n\t\t\t\t\tform.save()\n\t\t\t\t\thistory = models.History(\n\t\t\t\t\t\tuser=user,\n\t\t\t\t\t\tactivity = \"\",\n\t\t\t\t\t\tactivity_type = \"Reset Password\"\n\t\t\t\t\t)\n\t\t\t\t\thistory.save()\n\t\t\t\t\tcontext_dict[\"message\"] = \"Password changed successfully\"\n\t\t\t\telse:\n\t\t\t\t\tcontext_dict[\"message\"] = \"Password not changed\"\n\t\t\telse:\n\t\t\t\tcontext_dict[\"message\"] = \"Link is no longer valid\"\n\treturn render(request, \"reset.html\", context_dict)","def reset_password(newpass, challenge):","def resetPassword(self, customerguid, password, jobguid=\"\", executionparams=None):","def reset_password():\n pass","def do_password(token):\n password_reset_token = token\n requested_password = request.form['password']\n requested_password_repeat = request.form['passwordRepeat']\n\n # Only pending states can be used.\n target_user = User.query.filter_by(\n password_reset_token=password_reset_token).first()\n\n if target_user is None:\n return Response(render_template('password/failure.html',\n message=('Unbekannter token. Stellen '\n 'sie sicher, dass Sie nicht mehrfach '\n 'eine Passwortzurücksetzung '\n 'angefordert haben und nehmen sie '\n 'immer die aktuelle.')))\n\n if not target_user.state == StateType.PASSWORT_RESET_PENDING:\n return Response(render_template('password/failure.html',\n message='User has no pending password reset.'))\n\n if not requested_password == requested_password_repeat:\n return Response(render_template('password/request.html',\n passwordResetToken=token,\n message='Passwörter stimmen nicht überein.'))\n\n if not target_user.check_password_length(requested_password):\n return Response(render_template('password/request.html',\n passwordResetToken=token,\n message=('Passwort zu kurz. Das '\n 'Passwort muss mindestens {} '\n 'Zeichen haben').format(PASSWORD_MIN_LENGTH)))\n\n if not target_user.check_password_format(requested_password):\n return Response(render_template('password/request.html',\n passwordResetToken=token,\n message='Falsches Passwort Format. Das '\n 'Passwort muss mindestens eine Ziffer enthalten.'))\n\n target_user.set_password(requested_password)\n target_user.state = StateType.ACTIVE\n db.session.commit()\n\n return Response(render_template('password/success.html'))","def _request_reset(self, email):\n response = self.client.post(reverse('users.send_password_reset'),\n {'email': email})\n return response.context['token']","def reset_password(self, reset_token_url, password):\n query = parse.parse_qs(parse.urlparse(reset_token_url).query)\n return self._action('resetPasswordSubmitForm', {\n 'token': query['token'][0],\n 'key': query['key'][0],\n 'newpassword': password,\n 'confirmpassword': password,\n }, api='resetpassword')","def reset_token(token):\n if current_user.is_authenticated:\n return redirect(url_for('LoadDonor'))\n staff = Staff.verify_reset_token(token)\n if staff is None:\n flash('That is an invalid or expired token', 'warning')\n return redirect(url_for('reset_request'))\n form = ResetPasswordForm()\n if form.validate_on_submit():\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\n staff.password = hashed_password\n db.session.commit()\n flash('Your password has been updated! You are now able to log in', 'success')\n return redirect(url_for('login'))\n return render_template('reset_token.html', title='Reset Password', form=form)","def test_api_user_reset_password_post(self):\n pass","def InitiateResetPassword(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def request_password_reset_token():\n j = request.get_json(force=True)\n user_requested = j['user'].lower()\n\n # Disabled user accounts can not request for a new password.\n target_user = User.query.filter_by(mail=user_requested).first()\n\n if target_user is None:\n return Errors.UNKNOWN_USER.make_json_response(status.HTTP_400_BAD_REQUEST)\n\n if target_user.state == StateType.DEACTIVATED:\n return Errors.DEACTIVATED_USER.make_json_response(status.HTTP_400_BAD_REQUEST)\n\n target_user.generate_password_request_token()\n\n send_mail(target_user.mail, render_template(\"password/reset_password_mail.txt\",\n greeting=get_opening_greeting(target_user),\n wlink=\"{}/password/reset/{}\".format(\n app.config['BUZZN_BASE_URL'],\n target_user.password_reset_token\n )), 'Passwort zurücksetzen für Buzzn-App')\n\n db.session.commit()\n return '', status.HTTP_201_CREATED","def reset_token(token):\n if current_user.is_authenticated:\n return redirect(url_for('home'))\n user = User.verify_reset_token(token)\n if user is None:\n message = \"This is an invalid or expired token\"\n return redirect(url_for(\"forgot\", message=message))\n form = ResetPasswordForm()\n if form.validate_on_submit():\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\n user.password = hashed_password\n db.session.commit()\n message = f'Password has been updated for {user.display_username}'\n return redirect(url_for('login', message=message))\n return render_template(\"reset_token.html\", title=\"Reset Pasword\", form=form, offer_login=True, offer_register=True)","def post(self, request, token):\n form = PasswordResetForm(request.DATA)\n if form.is_valid():\n user_data = get_user_data(\n signing.loads(\n token,\n max_age=self.token_expires,\n salt=self.salt))\n if user_data:\n user_data.set_password(request.DATA['password1'])\n user_data.save()\n return render_to_response(\n 'registration/show_message.html',\n {\n 'title': \"Change successfully\",\n 'message': \"your password has Change successfully\"})\n return render_to_response(\n 'registration/show_message.html',\n {\n 'title': \"Sorry something wrong\",\n 'message': \"sorry try again to set new password\"})\n return render_to_response(\n 'registration/show_message.html',\n {\n 'title': \"Sorry something wrong\",\n 'message': \"sorry try again to set new password\"})","def reset_post():\n if g.session:\n # User is already authenticated\n return jsonify({'redirect': url_for('index.index')})\n\n form = request.values.get('form', default='email')\n token = request.values.get('token', default='')\n email = request.values.get('email', default='')\n password = request.values.get('password', default='')\n\n if form == 'password':\n try:\n user: User = db.session.query(User) \\\n .filter((User.password_token == token) & User.reset_active) \\\n .one()\n if user.is_reset_expired():\n return jsonify({'success': False, 'reason': 'expired'}), 401\n\n if len(password) < 8:\n return jsonify({'success': False, 'reason': 'password'}), 401\n\n user.set_password(password)\n db.session.commit()\n next_url = url_for('auth.reset_status', success=True)\n return jsonify({'success': True, 'redirect': next_url})\n except NoResultFound:\n return jsonify({'success': False, 'reason': 'token not found'}), 401\n else:\n try:\n user: User = db.session.query(User) \\\n .filter(User.email == email).one()\n user.reset_password()\n db.session.commit()\n\n reset_url = urllib.parse.urljoin(\n request.host_url,\n url_for('auth.reset_get', token=user.password_token))\n kwargs = {\n 'subject': gettext('Reset Password'),\n 'body': reset_url,\n 'recipients': [user.email]\n }\n mail.send_mail(**kwargs)\n next_url = url_for('auth.reset_status', sent=True)\n return jsonify({'success': True, 'redirect': next_url})\n except NoResultFound:\n return jsonify({'success': False, 'reason': 'email'}), 401","def reset_password(token):\n if current_user.is_authenticated:\n return redirect(url_for('main.index'))\n user = User.verify_reset_password_token(token)\n if not user:\n return redirect(url_for('main.index'))\n form = ResetPasswordForm()\n if form.validate_on_submit():\n user.set_password(form.password.data)\n user.email_confirmed = True\n db.session.commit()\n return render_template(\n 'successful_pass_reset.html', title=\"Password Reset\")\n return render_template('reset_password.html', title=\"Password Reset\",\n form=form), 417","def password_reset(self, password, vtoken, welcomeEmailTemplate = ''):\n auth = 'appkey='+ self._lr_object._get_api_key()+ '&appsecret='+ self._lr_object._get_api_secret() + '&vtoken=' + vtoken\n payload = {'password': password}\n url = SECURE_API_URL + \"raas/v1/account/password/reset\" + \"?\" + auth\n return self._lr_object._post_json(url, payload)","def POST(self):\n session = web.ctx.session\n nav = get_nav_bar(session)\n data = web.input(reset_token = \"\", new_password=\"\")\n \n reset_password_colum = reset_password_form()\n \n # check each field is endered values.\n if not reset_password_colum.validates():\n return render.reset_password(nav, reset_password_form, \"All fields must be valid.\")\n \n try:\n # log ip information\n ip_addr = web.ctx[\"ip\"]\n accessed_path = web.ctx[\"fullpath\"]\n\n # query user's name (username) and token (extra secruity)\n token = data.reset_token\n username = search_for_user(token, ip_addr, accessed_path)\n #print(\"-\"*16)\n #print(username)\n \n #update token to null database\n result_update_token = update_token_to_null(username, token, ip_addr, accessed_path)\n print(\"-\" * 16 + \"updated!\")\n\n # generate new password\n new_salt = generate_salt()\n hashed_password = hashed_value(data.new_password, new_salt)\n hashed_password = new_salt + hashed_password\n\n # update password \n result_update_password = update_user_password(username, hashed_password, ip_addr, accessed_path )\n raise web.seeother(\"/\")\n except Exception as e:\n print(e)\n except:\n print(exit[0])\n return render.login(nav, reset_password_form, \"- Something went wrong!\")","def password_reset_token_created(sender, reset_password_token, *args, **kwargs):\n # send an e-mail to the user\n context = {\n 'current_user': reset_password_token.user,\n 'username': reset_password_token.user.username,\n 'email': reset_password_token.user.email,\n # ToDo: The URL can (and should) be constructed using pythons built-in `reverse` method.\n 'reset_password_url': \"http://some_url/reset/?token={token}\".format(token=reset_password_token.key)\n }\n\n # render email text\n email_html_message = render_to_string('email/user_reset_password.html', context)\n email_plaintext_message = render_to_string('email/user_reset_password.txt', context)\n\n msg = EmailMultiAlternatives(\n # title:\n \"Password Reset for {title}\".format(title=\"Some website title\"),\n # message:\n email_plaintext_message,\n # from:\n \"noreply@somehost.local\",\n # to:\n [reset_password_token.user.email]\n )\n msg.attach_alternative(email_html_message, \"text/html\")\n msg.send()","def reset_password():\n body = request.get_json()\n reset_token = body.get('reset_token')\n password = body.get('password')\n\n if not reset_token or not password:\n return jsonify(msg.MISSING_PARAMETER), 400\n\n user_email = decode_token(reset_token)['identity']\n is_changed = views.UserManagement().change_password(email=user_email, password=password)\n if not is_changed:\n return jsonify(msg.NO_DATA), 404\n\n send_email('[Shodita] Password reset successful', sender='shodita@shodita.com', recipients=[user_email],\n text_body='Password reset was successful', html_body='<p>Password reset was successful</p>')\n\n return jsonify(msg.SUCCESS), 200","def reset_password(self):\n self.password = passwordResetter(self.user_id, self.password)","def post(self, request):\n import pdb\n pdb.set_trace()\n form = ConfirmPasswordForm(request.POST)\n token = request.GET.get('token')\n if not token:\n raise Http404('Tocken not found.')\n if not form.is_valid():\n import pdb\n pdb.set_trace()\n return render(request, 'user_registrations/set_password.html', {'form': form, 'token': token, 'errors': form.errors})\n token_obj = PasswordResetTokens.objects.filter(token=token)\n if not token_obj:\n raise Http404('Fake token supplied.')\n password_1 = form.cleaned_data.get('password_1')\n user = token_obj[0].user\n user.set_password(password_1)\n user.save()\n token_obj[0].delete()\n return HttpResponseRedirect(reverse('login'))","def password_token_oracle():\n past_time = int(time.time()) - random.randint(1, 3600)\n return generate_password_reset_token(past_time), past_time","def reset_password(token):\n # this token just active in 300s\n if request.method == \"POST\":\n email = s.loads(token, salt='email-confirm', max_age=300)\n print(email)\n user = User.query.filter_by(email=email).first()\n\n newPassword1 = request.form.get('newPassword1')\n newPassword2 = request.form.get('newPassword2')\n\n print(user)\n if user:\n \"\"\"kiểm tra password hợp lệ-chỗ này cần chỉnh thêm file html-----------------------------------------------------\"\"\"\n if re.search(PASSWORD_PATTERN, newPassword1) is None:\n flash('Password must be from 6-10 characters, have a digit must occur at least , '\n 'a lower case letter must occur at least once, no whitespace allowed in the entire string.',\n category='error')\n elif newPassword1 != newPassword2:\n flash('Passwords don\\'t match.', category='success')\n else:\n user.password = generate_password_hash(newPassword1, method='sha256')\n db.session.commit()\n print(user.password)\n print(\"đang thay đổi đây.............\")\n flash('Change password successfully!.', category='success')\n return redirect(url_for('auth.login'))\n # ------------------------------------------------------------------------------------------------------------------\n return render_template(\"forgotPass.html\")","def ChangePasswordWithRPToken(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def test_reset_password_good_token(self, reset_confirm):\r\n\r\n good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(self.uidb36, self.token))\r\n password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)\r\n confirm_kwargs = reset_confirm.call_args[1]\r\n self.assertEquals(confirm_kwargs['uidb36'], self.uidb36)\r\n self.assertEquals(confirm_kwargs['token'], self.token)\r\n self.user = User.objects.get(pk=self.user.pk)\r\n self.assertTrue(self.user.is_active)","def reset_token(token):\n if current_user.is_authenticated:\n return redirect(url_for('users.home'))\n\n user = User.verify_secret_token(token)\n\n if user is None:\n flash('That is invalid or expired token', 'warning')\n\n return redirect(url_for('users.reset_password'))\n\n form = ResetPasswordForm()\n\n if form.validate_on_submit():\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\n user.password = hashed_password\n db.session.commit()\n\n return redirect(url_for('users.login'))\n\n return render_template('reset_token.html', form=form)","def user_reset_password(request, token):\n\n if request.user.is_authenticated():\n return redirect(settings.AFTER_LOGIN_REDIRECT_URL)\n\n form = ResetPasswordForm(request.POST or None)\n\n if request.method == \"POST\":\n if form.is_valid():\n user_auth = get_object_or_404(PasswordResetAuth, token=token)\n user = get_object_or_404(User, email=user_auth.email)\n\n if user_auth.choose_me is True:\n new_password = form.cleaned_data[\"new_password\"]\n user.set_password(new_password)\n user.save()\n\n user_auth.choose_me = False\n user_auth.save()\n return redirect(\"/login/\")\n\n error_message = \"* Either you are not an identified user or \"\\\n \"token has been expired. So please click on back.\"\n return render_to_response(\"login/reset_password.html\", {\n \"form\": form,\n \"error_message\": error_message\n }, context_instance=RequestContext(request))\n\n return render_to_response(\"login/reset_password.html\", {\n \"form\": form\n }, context_instance=RequestContext(request))","def test_reset_password_with_reused_password(self, reset_confirm):\r\n\r\n good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(self.uidb36, self.token))\r\n password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)\r\n confirm_kwargs = reset_confirm.call_args[1]\r\n self.assertEquals(confirm_kwargs['uidb36'], self.uidb36)\r\n self.assertEquals(confirm_kwargs['token'], self.token)\r\n self.user = User.objects.get(pk=self.user.pk)\r\n self.assertTrue(self.user.is_active)","def reset_password(token):\n\n if not current_user.is_anonymous():\n return redirect(url_for(\"forum.index\"))\n\n form = ResetPasswordForm()\n if form.validate_on_submit():\n user = User.query.filter_by(email=form.email.data).first()\n expired, invalid, data = user.verify_reset_token(form.token.data)\n\n if invalid:\n flash((\"Your password token is invalid.\"), \"danger\")\n return redirect(url_for(\"auth.forgot_password\"))\n\n if expired:\n flash((\"Your password is expired.\"), \"danger\")\n return redirect(url_for(\"auth.forgot_password\"))\n\n if user and data:\n user.password = form.password.data\n user.save()\n flash((\"Your password has been updated.\"), \"success\")\n return redirect(url_for(\"auth.login\"))\n\n form.token.data = token\n return render_template(\"auth/reset_password.html\", form=form)","def start_reset_password_process_step_1(self):\n # start from the login page\n start_url = self.home_url + \"users/login/\"\n self.driver.get(start_url)\n # click on the link \"Mot de passe oublié ?\"\n reset_link = self.driver.find_element_by_id(\"forgotten_password\")\n reset_link.click()\n # wait for page loading\n WebDriverWait(\n self.driver,\n timeout=10\n ).until(EC.url_changes(start_url))\n # redirect to the password reset page: True or False?\n expected_url = self.home_url + \"profile/reset_password/\"\n self.assertEqual(self.driver.current_url, expected_url)\n # change the site in the email\n site = Site.objects.get(id=settings.SITE_ID)\n site.domain = self.live_server_url\n site.name = self.live_server_url\n site.save()","def token_request(request):\n try:\n l_user = request.data[\"user\"] #or email\n except:\n return Response({'message':'No user information received.'}, status=status.HTTP_400_BAD_REQUEST)\n\n l_user = l_user.lower()\n\n try:\n user = User.objects.get(username=l_user)\n except:\n try:\n user = User.objects.get(email=l_user)\n except:\n return Response({'message': l_user + ' does not match any record.'}, status=status.HTTP_400_BAD_REQUEST)\n\n pin = random.randint(0, 1000000)\n try:\n subject = \"Password Reset Token.\"\n sendEmail(user, subject, \"Password Reset\", otp=pin)\n\n #Write to use record\n ResetRequests.objects.create(user = user, token = pin, use_case = 'password reset')\n \n #Add password reset request date here\n return Response({'message':'Token sent to registered email.', 'username' : user.username}, status=status.HTTP_200_OK)\n except Exception as e:\n return Response({'message':'We could not send an email', 'error':e}, status=status.HTTP_400_BAD_REQUEST)","def test_reset_password_bad_token(self, reset_confirm):\r\n\r\n bad_reset_req = self.request_factory.get('/password_reset_confirm/NO-OP/')\r\n password_reset_confirm_wrapper(bad_reset_req, 'NO', 'OP')\r\n confirm_kwargs = reset_confirm.call_args[1]\r\n self.assertEquals(confirm_kwargs['uidb36'], 'NO')\r\n self.assertEquals(confirm_kwargs['token'], 'OP')\r\n self.user = User.objects.get(pk=self.user.pk)\r\n self.assertFalse(self.user.is_active)","def PasswordResetViaOTP(request):\n current_time = datetime.now(utc)\n request_data = json.loads(request.body)\n\n if not type(request_data) == dict:\n return StandardHttpResponse.login_bad_rsp([], 'Bad data')\n\n if not PasswordResetUtils().validate_request_data(request_data):\n return StandardHttpResponse.login_bad_rsp([], 'Missing data fields')\n\n if not request_data['password'] == request_data['confirm_password']:\n return StandardHttpResponse.login_bad_rsp([], 'Password Not Matched')\n\n result, response = MobileOtpService.validate_otp(otp=request_data['otp'],\n otp_ref=request_data['otp_ref'],\n o_type='ForgetPassword',\n current_time=current_time,\n return_obj=True)\n if not result:\n return StandardHttpResponse.login_bad_rsp([], response)\n if not response.mobile:\n return StandardHttpResponse.login_bad_rsp([], 'Invalid request. Please contact Admin.')\n user_profile_obj = UserModelQueries.get_user_profile_by_mobile(response.mobile)\n if not user_profile_obj:\n return StandardHttpResponse.login_bad_rsp([], 'Mobile not registered')\n user_obj = UserModelQueries.get_user_by_id(user_profile_obj.user_id)\n response.delete()\n user_obj.set_password(request_data['password'])\n user_obj.save()\n json_body = dict()\n json_body['username'] = user_obj.username\n json_body['password'] = request_data['password']\n json_body['grant_type'] = 'password'\n request._body = urllib.urlencode(json_body)\n json_body['redirect_uri'] = REDIRECT_URL\n request._post = json_body\n view = TokenView.as_view()\n request.META[\n \"HTTP_AUTHORIZATION\"] = \"Basic YlVhOFBCTTFCQTFGb3JPUlp5RVB0RmFBSUJZOGNhUWF5N2hTbTE4dDpla25ENkVzenlJZEZMeUM1RmhqSFlnUnVuMlk2alpqMTN0Mll1ZzZhVWNJc0ZYYk9VMnNyWDRjRmJLQkpwMnpVVVRZNnV6U0U5V3AyN3JJTmNPZ09FWmVDVlB4NXVEWXV0ZHBFMHhVcEROTTBGUlluRERMQzlTTnNNN3RRZUhEbA==\"\n request.META[\"CONTENT_TYPE\"] = \"application/x-www-form-urlencoded\"\n return StandardHttpResponse.login_rsp(json.loads(view(request).content), 'User Logged-In Successfully.')","def login_resetrequest():\n if request.method == \"GET\":\n # In browser request that user wants to reset the password\n return flask.render_template('reset-request.html', message=\"Please reset the password\")\n\n if request.method == \"POST\":\n # Create a token\n email = flask.request.form[\"email\"]\n\n # Find if an account with that name exists\n conn.register([model.User])\n admindb = conn[current_app.config[\"CONFIGDB\"]]\n\n userdoc = admindb[\"users\"].User.find_one({\"name\" : email, \"type\" : \"passwd\"})\n if userdoc == None:\n # user not found\n return flask.Response('{\"error\" : \"User not found\"}')\n\n # First reset the password\n name = userdoc[\"label\"]\n emailto = userdoc[\"name\"]\n\n # Create accout and a random tocken\n userdoc[\"token\"] = bson.ObjectId()\n userdoc[\"password_status\"] = \"reset-request\"\n\n # May only be useful for some\n if \"password_ready\" in userdoc:\n del userdoc[\"password_ready\"]\n\n userdoc.validate()\n userdoc.save()\n\n # Create email\n emailfrom = current_app.config[\"EMAIL_FROM\"] \n\n body = \"Hello \" + name + \",\\n\\n\"\n body = body + \"You recently requested a password reset for your account at https://slide-atlas.org.\"\n body = body + \"\\n To complete the request operation please follow the link below- \\n\"\n body = body + \"\\n \" + url_for('.login_confirm', _external=True) + \"?token=\" + str(userdoc[\"token\"]) + \" \\n\"\n body = body + \"\\nIf clicking on the link doesn't work, try copying and pasting it into your browser.\\n\"\n body = body + \"\\nThis link will work only once, and will let you create a new password. \\n\"\n body = body + \"\\nIf you did not request password reset, please disregard this message.\\n\"\n body = body + \"\\nThank you,\\nThe SlideAtlas Administration Team\\n\"\n\n # Create a text/plain message\n msg = MIMEText(body)\n\n # me == the sender's email address\n # you == the recipient's email address\n msg['Subject'] = 'Password reset confirmation for slide-atlas.org'\n msg['From'] = emailfrom\n msg['To'] = emailto\n print msg\n s = smtplib.SMTP(current_app.config[\"SMTP\"])\n try:\n out = s.sendmail(emailfrom, [emailto], msg.as_string())\n except:\n return flask.Response(\"{\\\"error\\\" : \\\"Error sending email\\\"}\")\n\n s.quit()\n return flask.Response(\"{\\\"success\\\" : \\\"\" + str(out) + \"\\\"}\")","def test_user_resetpassword(self):\n\n data = {\n \"email\": \"testuser@gmail.com\"\n }\n response = self.client.post(reverse('account:request-reset-email'), data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n user = User.objects.get(email=\"testuser@gmail.com\")\n uidb64 = urlsafe_base64_encode(smart_bytes(user.id))\n token = PasswordResetTokenGenerator().make_token(user)\n relativeLink = reverse(\n 'accounts:password-reset-confirm',\n kwargs={'uidb64': uidb64, 'token': token}\n )\n resetconfirm_response = self.client.get(reverse(\n 'accounts:password-reset-confirm',\n kwargs={'uidb64': uidb64, 'token': token}\n ))\n\n self.assertEqual(resetconfirm_response.status_code, status.HTTP_200_OK)\n reset_data = {\n \"uidb64\": resetconfirm_response.data[\"uidb64\"],\n \"token\": resetconfirm_response.data[\"token\"],\n \"password\": \"1234567\"\n }\n resetcomplete_response = self.client.patch(reverse('account:password-reset-complete'), reset_data,\n format=\"json\")\n self.assertEqual(resetcomplete_response.status_code, status.HTTP_200_OK)\n # test if now user can login with new password\n updatedlogin_data = {\n \"email\": \"testuser@gmail.com\",\n \"password\": \"1234567\"\n }\n\n response = self.client.post(self.login_url, updatedlogin_data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n # test if user can login with old password\n response = self.client.post(self.login_url, self.login_data, format=\"json\")\n self.assertNotEqual(response.status_code, status.HTTP_200_OK)","async def reset_post_handler(req: web.Request) -> web.Response:\n db = req.app[\"db\"]\n\n client = req[\"client\"]\n\n form_data = await req.post()\n\n password = form_data.get(\"password\", \"\")\n confirm = form_data.get(\"confirm\", \"\")\n verification_key = form_data.get(\"verification\", None)\n return_to = get_return_to_from_query(req)\n\n # Check that the hidden verification key matches the one attached to the logging-in session. Redirect to `return_to`\n # URL if verification fails (this will end up on login page with correct query parameter.\n if not await virtool.db.sessions.check_verification_key(db, client.session_id, verification_key, mode=\"reset\"):\n return web.Response(status=302, headers={\"Location\": return_to})\n\n user_id = await virtool.db.utils.get_one_field(db.sessions, \"reset_user_id\", client.session_id)\n\n if not user_id:\n return web.Response(status=302, headers={\"Location\": return_to})\n\n errors = list()\n\n # Re-render the reset page with an error message if the new password is invalid.\n if password != confirm:\n errors.append(\"Passwords do not match\")\n\n minimum_password_length = req.app[\"settings\"][\"minimum_password_length\"]\n\n if len(password) < minimum_password_length:\n errors.append(f\"Password must contain at least {minimum_password_length} characters\")\n\n if errors:\n reset_code = await virtool.db.sessions.set_reset_errors(db, client.session_id, errors)\n return web.Response(status=302, headers={\"Location\": f\"/reset?return_to={return_to}&code={reset_code}\"})\n\n # Unset all reset page errors.\n await virtool.db.sessions.set_reset_errors(db, client.session_id)\n\n # Update the user password and disable the `force_reset`.\n await virtool.db.users.edit(db, user_id, force_reset=False, password=password)\n\n # Authenticate and return a redirect response to the `return_to` path. This is identical to the process used for\n # successful login requests.\n return await auth_response(req, return_to, user_id, False)","def password_reset_confirm(request, uidb64, token):\n uid = force_text(urlsafe_base64_decode(uidb64))\n user = User.objects.get(pk=uid)\n try:\n reset_form = ResetPasswordForm(instance=user)\n # urlsafe_base64_decode() decodes to bytestring on Python 3\n except (TypeError, ValueError, OverflowError, user.DoesNotExist):\n user = None\n if user is not None and default_token_generator.check_token(user, token):\n validlink = True\n title = ('Enter new password')\n if request.method == 'POST':\n if 'password-submit' in (request.POST):\n reset_form = ResetPasswordForm(request.POST,instance=user)\n password = request.POST.get(\"password_reset\", None)\n \n if reset_form.is_valid():\n user=reset_form.save(commit = False)\n user.save()\n return redirect('password_reset_complete')\n else:\n reset_form = ResetPasswordForm(instance=user)\n else:\n validlink = False\n reset_form = ResetPasswordForm(instance=user)\n title = ('Password reset unsuccessful')\n return redirect ('invalid_password_link')\n context = {\n 'reset_form': ResetPasswordForm,\n 'title': title,\n 'validlink': validlink,\n }\n return render(request, 'reset_confirm.html', context, {'reset_form': ResetPasswordForm})","def set_new_pw_extra_security_token(\n code: str,\n password: str,\n tokenResponse: Optional[str] = None,\n authenticatorData: Optional[str] = None,\n clientDataJSON: Optional[str] = None,\n credentialId: Optional[str] = None,\n signature: Optional[str] = None,\n) -> FluxData:\n data = _load_data(code, password)\n if data.error:\n return error_response(message=data.error)\n\n # Process POSTed data\n success = False\n if tokenResponse:\n # CTAP1/U2F\n token_response = request.get_json().get('tokenResponse', '')\n current_app.logger.debug(f'U2F token response: {token_response}')\n\n _challenge = session.get(SESSION_PREFIX + '.u2f.challenge')\n if not isinstance(_challenge, bytes):\n raise TypeError(f'U2F challenge in session is not bytes {repr(_challenge)}')\n current_app.logger.debug(f'Challenge: {_challenge!r}')\n\n result = fido_tokens.verify_u2f(data.user, _challenge, token_response)\n\n if result is not None:\n success = result['success']\n\n elif not success and authenticatorData:\n # CTAP2/Webauthn\n try:\n result = fido_tokens.verify_webauthn(\n data.user,\n dict(\n credentialId=credentialId,\n clientDataJSON=clientDataJSON,\n authenticatorData=authenticatorData,\n signature=signature,\n ),\n SESSION_PREFIX,\n )\n except fido_tokens.VerificationProblem:\n pass\n else:\n success = result['success']\n\n else:\n current_app.logger.error(f'Neither U2F nor Webauthn data in request to authn {data.user}')\n\n if not success:\n return error_response(message=ResetPwMsg.fido_token_fail)\n\n current_app.logger.info(f'Resetting password for user {data.user}')\n reset_user_password(data.user, data.state, password)\n current_app.logger.info(f'Password reset done, removing state for {data.user}')\n current_app.password_reset_state_db.remove_state(data.state)\n return success_response(message=ResetPwMsg.pw_resetted)","def post(self):\n try:\n body = request.get_json()\n bearer = request.headers.get('Authorization')\n base_url = request.url_root\n token = bearer.split()[1]\n password = body.get('password')\n\n if not token or not password:\n raise SchemaValidationError\n\n user_id = decode_token(token)['sub']['user_id']\n\n user = User.objects.get(id=user_id)\n\n user.modify(password=password)\n user.hash_password()\n user.save()\n\n return send_email('[Unboxit] Password reset successful',\n sender='contact@tsantos.dev',\n recipients=[user.email],\n text_body='Password Reset',\n html_body=render_template(\n 'components/reset_password_response.html',\n first_name=user.first_name,\n base_url=base_url))\n\n except SchemaValidationError:\n raise SchemaValidationError\n except ExpiredSignatureError:\n raise ExpiredTokenError\n except (DecodeError, InvalidTokenError):\n raise BadTokenError\n except Exception as e:\n raise InternalServerError","def login_reset():\n # Start with the currently logged in user\n\n if request.method == \"GET\":\n # In browser request that user wants to reset the password\n # Create a token\n # Send out an email\n #\n return flask.render_template('profile.html', name=session[\"user\"][\"label\"], email=session[\"user\"][\"email\"])\n\n if request.method == \"POST\":\n # In browser request that user wants to reset the password\n label = flask.request.form[\"label\"]\n passwd = flask.request.form[\"passwd\"]\n\n # Verify that the user is logged in or return\n if not session.has_key(\"user\"):\n return flask.Response('{\"error\" : \"User not logged in\" }')\n else:\n # Chagne the information in the session\n session[\"user\"][\"label\"] = label\n # Locate the record\n conn.register([model.User])\n dbobj = conn[current_app.config[\"CONFIGDB\"]]\n userdoc = dbobj[\"users\"].User.find_one({'_id' : ObjectId(session[\"user\"][\"id\"])})\n userdoc[\"passwd\"] = passwd\n userdoc[\"password_status\"] = \"ready\"\n userdoc[\"label\"] = label\n userdoc.validate()\n userdoc.save()\n\n return flask.Response('{\"success\" : \"\" }')","def test_request_reset(mock_save, api_client, password_reset_token_factory):\n token = password_reset_token_factory()\n data = {\"key\": token.key, \"password\": \"new_passw0rd\"}\n\n response = api_client.post(url, data)\n\n assert response.status_code == status.HTTP_200_OK\n assert mock_save.call_count == 1","def send_token(user):\n if 'research' in user.get_domains():\n domain = 'research'\n else: domain = 'academic'\n subject = \"ECE/CIS Password Reset\"\n url = \"https://www.eecis.udel.edu/accounts/reset_password/token/%s\" % user.token\n message = \"A request has been made for a password reset for your ECE/CIS %s account: %s\\n\\n\" % (domain, user.username)\n message += \"To reset your password, please visit the follow the reset link below:\\n\\n%s\\n\" % url\n message += \"This token will expire 30 minutes after the initial request was made\\n\\n\"\n message += \"If this is not your ECE/CIS username, or you did not request a password reset, please\\n\"\n message += \"submit a Help Request at https://www.eecis.udel.edu/helprequest\\n\\nECE/CIS Labstaff\"\n\n send('account@eecis.udel.edu', 'ECE/CIS Account System', \\\n [user.email], subject, message, MAILHOST)","def post(self):\n try:\n url = request.host_url + 'reset/password/'\n body = request.get_json()\n base_url = request.url_root\n email = body.get('email')\n\n if not email:\n raise SchemaValidationError\n\n user = User.objects.get(email=email)\n if not user:\n raise EmailDoesNotExistsError\n\n expires = datetime.timedelta(minutes=60)\n payload = {\"user_id\": str(user.id)}\n reset_token = create_access_token(payload, expires_delta=expires)\n\n return send_email('[Unboxit] Reset Your Password',\n sender='contact@tsantos.dev',\n recipients=[user.email],\n text_body=render_template(\n 'components/reset_password.txt',\n url=url + reset_token),\n html_body=render_template(\n 'components/reset_password.html',\n url=url + reset_token,\n first_name=user.first_name,\n base_url=base_url))\n except SchemaValidationError:\n raise SchemaValidationError\n except DoesNotExist:\n raise EmailDoesNotExistsError\n except Exception as e:\n raise InternalServerError","def password_reset_confirm_wrapper(\r\n request,\r\n uidb36=None,\r\n token=None,\r\n):\r\n # cribbed from django.contrib.auth.views.password_reset_confirm\r\n try:\r\n uid_int = base36_to_int(uidb36)\r\n user = User.objects.get(id=uid_int)\r\n user.is_active = True\r\n user.save()\r\n except (ValueError, User.DoesNotExist):\r\n pass\r\n\r\n # tie in password strength enforcement as an optional level of\r\n # security protection\r\n err_msg = None\r\n\r\n if request.method == 'POST':\r\n password = request.POST['new_password1']\r\n if settings.FEATURES.get('ENFORCE_PASSWORD_POLICY', False):\r\n try:\r\n validate_password_length(password)\r\n validate_password_complexity(password)\r\n validate_password_dictionary(password)\r\n except ValidationError, err:\r\n err_msg = _('Password: ') + '; '.join(err.messages)\r\n\r\n # also, check the password reuse policy\r\n if not PasswordHistory.is_allowable_password_reuse(user, password):\r\n if user.is_staff:\r\n num_distinct = settings.ADVANCED_SECURITY_CONFIG['MIN_DIFFERENT_STAFF_PASSWORDS_BEFORE_REUSE']\r\n else:\r\n num_distinct = settings.ADVANCED_SECURITY_CONFIG['MIN_DIFFERENT_STUDENT_PASSWORDS_BEFORE_REUSE']\r\n err_msg = _(\"You are re-using a password that you have used recently. You must \"\r\n \"have {0} distinct password(s) before reusing a previous password.\").format(num_distinct)\r\n\r\n # also, check to see if passwords are getting reset too frequent\r\n if PasswordHistory.is_password_reset_too_soon(user):\r\n num_days = settings.ADVANCED_SECURITY_CONFIG['MIN_TIME_IN_DAYS_BETWEEN_ALLOWED_RESETS']\r\n err_msg = _(\"You are resetting passwords too frequently. Due to security policies, \"\r\n \"{0} day(s) must elapse between password resets\").format(num_days)\r\n\r\n if err_msg:\r\n # We have an password reset attempt which violates some security policy, use the\r\n # existing Django template to communicate this back to the user\r\n context = {\r\n 'validlink': True,\r\n 'form': None,\r\n 'title': _('Password reset unsuccessful'),\r\n 'err_msg': err_msg,\r\n }\r\n return TemplateResponse(request, 'registration/password_reset_confirm.html', context)\r\n else:\r\n # we also want to pass settings.PLATFORM_NAME in as extra_context\r\n extra_context = {\"platform_name\": settings.PLATFORM_NAME}\r\n\r\n if request.method == 'POST':\r\n # remember what the old password hash is before we call down\r\n old_password_hash = user.password\r\n\r\n result = password_reset_confirm(\r\n request, uidb36=uidb36, token=token, extra_context=extra_context\r\n )\r\n\r\n # get the updated user\r\n updated_user = User.objects.get(id=uid_int)\r\n\r\n # did the password hash change, if so record it in the PasswordHistory\r\n if updated_user.password != old_password_hash:\r\n entry = PasswordHistory()\r\n entry.create(updated_user)\r\n\r\n return result\r\n else:\r\n return password_reset_confirm(\r\n request, uidb36=uidb36, token=token, extra_context=extra_context\r\n )","def post(self):\n data = request.get_json()\n user = actions.get_user_by_email(data['email'])\n html = '<p>To reset your password </p>'\n subject = 'Request for changing password, ' + user['username']\n actions.send_email(data['email'], user['username'], user['password'], subject,\n '/reset_password/', html, False)\n pass","def reset_token(sender, instance, **kwargs):\n new_password = instance.password\n\n try:\n old_password = User.objects.get(pk=instance.pk).password\n except User.DoesNotExist:\n old_password = None\n\n if new_password != old_password:\n Token.objects.filter(user=instance).delete()","def password_reset(*args, **kwargs):\n kwargs['password_reset_form'] = CustomPasswordResetForm\n return django_password_reset(*args, **kwargs)","def password_reset(request):\n\n\tcontext_dict = {}\n\tif request.method == 'POST':\n\t\temail = request.POST.get('email')\n\t\tif email:\n\t\t\tuser = models.Teacher.objects.get(\n\t\t\t\tsoft_delete=False, user__email=email\n\t\t\t)\n\t\t\tif not user:\n\t\t\t\tcontext_dict[\"message\"] = \"Email ID does'nt exist, Enter Correct details\"\n\t\t\tmail = {\n\t\t\t\t'email': email,\n\t\t\t\t'domain': request.META['HTTP_HOST'],\n\t\t\t\t'site_name': 'Placement Portal',\n\t\t\t\t'uid': urlsafe_base64_encode(force_bytes(user.pk)),\n\t\t\t\t'user': user,\n\t\t\t\t'token': ''.join([random.choice(ascii_letters+digits) for i in range (128)]),\n\t\t\t\t'protocol': 'http',\n\t\t\t}\n\t\t\ttry:\n\t\t\t\treset_token = models.PasswordReset(\n\t\t\t\t\tuser=user,\n\t\t\t\t\ttoken=mail['token'],\n\t\t\t\t\ttoken_consumed=False,\n\t\t\t\t)\n\t\t\t\treset_token.save()\n\t\t\texcept Exception as e:\n\t\t\t\tprint (e)\n\t\t\tsubject_template_name = 'password_reset_email_subject.txt'\n\t\t\temail_template_name = 'password_reset_email.html'\n\t\t\tsubject = loader.render_to_string(subject_template_name, mail)\n\t\t\tsubject = ''.join(subject.splitlines())\n\t\t\temail_data = loader.render_to_string(email_template_name, mail)\n\t\t\tsend_mail(subject, email_data, DEFAULT_FROM_EMAIL, [email], fail_silently=False)\n\t\t\tcontext_dict[\"message\"] = \"Email has been sent to your registered Email ID with instructions.\"\n\treturn render(request, \"password_reset_form.html\", context_dict)","def test_password_reset(client, models):\n user = models[\"user\"][0]\n encoded_token = user.get_reset_token()\n new_password = \"password\"\n response = client.post(\n f\"/password/reset/{encoded_token}\", json={\"password\": new_password}\n )\n assert response.status_code == 200\n assert user.check_password(new_password)","def reset_token(self, reset_token):\n\n self._reset_token = reset_token","def reset_password(token):\n\n expired, invalid, user = reset_password_token_status(token)\n\n if invalid:\n return redirect(url_for('frontend.forgot_password') + '?invalid')\n elif expired:\n send_reset_password_instructions(user)\n return redirect(url_for('frontend.forgot_password') + '?expired')\n elif request.method == 'GET':\n return redirect(url_for('frontend.reset_password', token=token))\n\n form = _security.reset_password_form()\n\n if form.validate_on_submit():\n after_this_request(_commit)\n update_password(user, form.newPassword.data)\n login_user(user)\n else:\n return jsonify({'errors': form.errors}), HTTPStatus.BAD_REQUEST\n\n return jsonify({\n 'token': user.get_auth_token(),\n 'user': user,\n })","def test_reset_passwd(self, test_client, user_test1):\n response = test_client.post('/api/auth/reset', json=dict(\n reset_password_token=create_access_token(identity=user_test1),\n password=\"Azerty!123\"\n ))\n res = json.loads(response.data)\n\n assert response.status_code == 200\n assert res['status'] == True","def password_reset(request):\n host = settings.TACC_USER_PORTAL_HOST\n return redirect(f\"{host}/password-reset?{urlencode(request.GET)}\")","def change_password(self, reset_token, new_password_hash):\n try:\n self.logger.debug('change_password running')\n nosqldb = self.pers.nosql_db\n reset_request = nosqldb['passwordResets'].find_one(\n {'resetToken': reset_token}\n )\n\n if reset_request:\n self.logger.debug('reset request match')\n nosqldb['users'].update_one(\n {\n 'username': reset_request['username']\n },\n {\n '$set': {'passwdHash': new_password_hash}\n }\n\n\n )\n else:\n self.logger.debug('reset request mismatch, nothing changed')\n except Exception as exc:\n self.logger.debug('Unexpected Error %s', str(exc))\n raise","def send_password_reset_mail(email, token):\n print(\"reset password\")\n url = f\"{settings.SITE_URL}/reset-password?email={email}&token={token}\"\n SUBJECT = \"Reset Password Request\"\n # The HTML body of the email.\n body = \"\"\"\n <html>\n <head></head>\n <body>\n <p>Here is your password reset link:</p>\n <p><a href='{0}'>{1}</a></p>\n </body>\n </html>\n \"\"\".format(url, url)\n send_mail(SUBJECT, body, email)","def test_reset_user(self):\n\n user = fake_clients.FakeUser(\n name=\"test@example.com\", password=\"123\", email=\"test@example.com\"\n )\n\n setup_identity_cache(users=[user])\n\n url = \"/v1/actions/ResetPassword\"\n data = {\"email\": \"test@example.com\"}\n response = self.client.post(url, data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\n self.assertEqual(\n response.json()[\"notes\"],\n [\"If user with email exists, reset token will be issued.\"],\n )\n\n new_token = Token.objects.all()[0]\n url = \"/v1/tokens/\" + new_token.token\n data = {\"password\": \"new_test_password\"}\n response = self.client.post(url, data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(user.password, \"new_test_password\")","def password_reset_confirm(request, uidb36=None, token=None,\n template_name='gallery/password_reset_confirm.html',\n token_generator=default_token_generator,\n set_password_form=SetPasswordForm,\n post_reset_redirect=None):\n assert uidb36 is not None and token is not None # checked by URLconf\n if post_reset_redirect is None:\n post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')\n try:\n uid_int = base36_to_int(uidb36)\n except ValueError:\n raise HttpResponseNotFound\n\n user = get_object_or_404(authmodels.User, id=uid_int)\n context_instance = RequestContext(request)\n\n if token_generator.check_token(user, token):\n context_instance['validlink'] = True\n if request.method == 'POST':\n form = set_password_form(user, request.POST)\n if form.is_valid():\n # we can't use form.save b/c that will update the p/w on the\n # model object, we need to do it in LDAP\n if settings.USE_LDAP:\n ldapper = get_ldap_connection()\n dn = get_user_dn(user.username)\n new_password = request.POST.get('new_password1')\n ldapper.passwd_s(dn, None, new_password)\n ldapper.unbind_s()\n request.notifications.add(_('Password change successful.'))\n else:\n form.save()\n return HttpResponseRedirect(post_reset_redirect)\n else:\n form = set_password_form(None)\n else:\n context_instance['validlink'] = False\n form = None\n context_instance['form'] = form\n return render_to_response(template_name, context_instance=context_instance)","def reset_password_token(email: str) -> str:\n data = {'email': email}\n response = requests.post(f'{URL}/reset_password', data=data)\n assert response.status_code == 200\n token = response.json()\n return token.get('reset_token')","def get_passreset_token(self, expiration_secs=1800):\n\t\treturn jwt_encode({'reset_pass': self.id, 'exp': time() + expiration_secs},\n\t\t\tapp.config['SECRET_KEY'], algorithm=\"HS256\").decode('utf-8')","async def password(self, ctx):\n pass","def change_password(reset_code):\n return dict(reset_code=reset_code)","def GET(self):\n session = web.ctx.session\n nav = get_nav_bar(session)\n self.token = web.input().reset_token\n return render.reset_password(nav, reset_password_form, \"\")","def forgot_passwd_check(request, uidb64=None, token=None):\n assert uidb64 is not None and token is not None\n dc1_settings = DefaultDc().settings\n sms_registration = dc1_settings.SMS_REGISTRATION_ENABLED\n\n if sms_registration:\n set_password_form = SMSSendPasswordResetForm\n else:\n set_password_form = PasswordResetForm\n\n if request.method == 'POST':\n try:\n user = User.objects.get(id=urlsafe_base64_decode(uidb64))\n profile = user.userprofile\n except (ValueError, OverflowError, User.DoesNotExist):\n profile = None\n\n if profile and profile.email_token == token:\n # Email address is verified, we cant compare to token as register token is different to reset one.\n profile.email_token = ''\n profile.email_verified = True\n # This may look strange - setting the phone_verified before the user logs in. It is not :) We are sending\n # new password to phone number in profile, after the user logs in we would set phone_verified to True anyway\n if sms_registration:\n profile.phone_verified = True\n profile.save()\n\n return password_reset_confirm(\n request,\n uidb64=uidb64,\n token=token,\n template_name='gui/accounts/forgot_check.html',\n set_password_form=set_password_form,\n post_reset_redirect=reverse('forgot_check_done'),\n current_app='gui',\n extra_context={\n 'sms_registration': sms_registration,\n }\n )","def generate_password_reset_token(self, expiration=3600):\n app = current_app._get_current_object()\n serializer = Serializer(app.config[\"SECRET_KEY\"], expiration)\n return serializer.dumps({\"reset\": self.id}).decode(\"utf-8\")","def make_reset_token(self, expiration=3600):\n return self._make_token({'id': self.id, 'op': 'reset'}, expiration)","def recover_password_token(pw_token: bytes):\n current_time = int(time.time())\n for ut in range(current_time - 3700, current_time):\n if generate_password_reset_token(ut) == pw_token:\n return ut","def test_staff_password_reset_reuse(self):\r\n staff_email, _ = self._setup_user(is_staff=True)\r\n user = User.objects.get(email=staff_email)\r\n\r\n err_msg = 'You are re-using a password that you have used recently. You must have 2 distinct password(s)'\r\n success_msg = 'Your Password Reset is Complete'\r\n\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n # try to do a password reset with the same password as before\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foo',\r\n 'new_password2': 'foo',\r\n }, follow=True)\r\n\r\n self.assertIn(\r\n err_msg,\r\n resp.content\r\n )\r\n\r\n # now use different one\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'bar',\r\n 'new_password2': 'bar',\r\n }, follow=True)\r\n\r\n self.assertIn(\r\n success_msg,\r\n resp.content\r\n )\r\n\r\n # now try again with the first one\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foo',\r\n 'new_password2': 'foo',\r\n }, follow=True)\r\n\r\n # should be rejected\r\n self.assertIn(\r\n err_msg,\r\n resp.content\r\n )\r\n\r\n # now use different one\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'baz',\r\n 'new_password2': 'baz',\r\n }, follow=True)\r\n\r\n self.assertIn(\r\n success_msg,\r\n resp.content\r\n )\r\n\r\n # now we should be able to reuse the first one\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foo',\r\n 'new_password2': 'foo',\r\n }, follow=True)\r\n\r\n self.assertIn(\r\n success_msg,\r\n resp.content\r\n )","def generate_password_reset_token(self, expiration=3600):\n s = Serializer(current_app.config['SECRET_KEY'], expiration)\n return s.dumps({'reset': self.id})","def test_dietitian_reset_password(self):\n\n data = {\"password\": \"newpass\"}\n result = self.client.post(\"/dietitian/1/account/reset-password\", \n data=data, follow_redirects=True)\n\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"successfully reset\", result.data)","def verify_reset_token(self, token):\n\n expired, invalid, data = self._verify_token(token)\n if data and data.get('id') == self.id and data.get('op') == 'reset':\n data = True\n else:\n data = False\n return expired, invalid, data","def password_reset(request):\n\tif not request.user.is_authenticated():\n\t\treturn django.contrib.auth.views.password_reset(request,\n template_name='usermgr/password_reset_form.html',\n email_template_name= 'usermgr/password_reset_email.html',\n post_reset_redirect='/usermgr/password_reset/done/')\n\telse:\n\t\treturn HttpResponseRedirect(settings.LOGIN_REDIRECT_URL)","def config_reset_pw(code: str) -> FluxData:\n current_app.logger.info(f'Configuring password reset form for {code}')\n try:\n state = get_pwreset_state(code)\n except BadCode as e:\n return error_response(message=e.msg)\n\n verify_email_address(state)\n\n new_password = generate_suggested_password()\n session.reset_password.generated_password_hash = hash_password(new_password)\n\n user = current_app.central_userdb.get_user_by_eppn(state.eppn)\n alternatives = get_extra_security_alternatives(user, SESSION_PREFIX)\n state.extra_security = alternatives\n current_app.password_reset_state_db.save(state)\n\n return success_response(\n payload={\n 'csrf_token': session.get_csrf_token(),\n 'suggested_password': new_password,\n 'email_code': state.email_code.code,\n 'email_address': state.email_address,\n 'extra_security': mask_alternatives(alternatives),\n 'password_entropy': current_app.config.password_entropy,\n 'password_length': current_app.config.password_length,\n 'password_service_url': current_app.config.password_service_url,\n 'zxcvbn_terms': get_zxcvbn_terms(state.eppn),\n },\n )","def test_reset_user_duplicate(self):\n\n user = fake_clients.FakeUser(\n name=\"test@example.com\", password=\"123\", email=\"test@example.com\"\n )\n\n setup_identity_cache(users=[user])\n\n # Submit password reset\n url = \"/v1/actions/ResetPassword\"\n data = {\"email\": \"test@example.com\"}\n response = self.client.post(url, data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\n self.assertEqual(\n response.json()[\"notes\"],\n [\"If user with email exists, reset token will be issued.\"],\n )\n\n # Verify the first token doesn't work\n first_token = Token.objects.all()[0]\n\n # Submit password reset again\n response = self.client.post(url, data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\n self.assertEqual(\n response.json()[\"notes\"],\n [\"If user with email exists, reset token will be issued.\"],\n )\n\n # confirm the old toke has been cleared:\n second_token = Token.objects.all()[0]\n self.assertNotEqual(first_token.token, second_token.token)\n\n # Now reset with the second token\n url = \"/v1/tokens/\" + second_token.token\n data = {\"password\": \"new_test_password2\"}\n response = self.client.post(url, data, format=\"json\")\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(user.password, \"new_test_password2\")","def test_password_policy_on_password_reset(self):\r\n staff_email, _ = self._setup_user(is_staff=True, password='foofoo')\r\n\r\n success_msg = 'Your Password Reset is Complete'\r\n\r\n # try to reset password, it should fail\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n # try to do a password reset with the same password as before\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foo',\r\n 'new_password2': 'foo',\r\n }, follow=True)\r\n\r\n self.assertNotIn(\r\n success_msg,\r\n resp.content\r\n )\r\n\r\n # try to reset password with a long enough password\r\n user = User.objects.get(email=staff_email)\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n # try to do a password reset with the same password as before\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foofoo',\r\n 'new_password2': 'foofoo',\r\n }, follow=True)\r\n\r\n self.assertIn(\r\n success_msg,\r\n resp.content\r\n )","def post(self):\n args = password_reset.parse_args()\n email = args.get('email')\n new_password = password_generator()\n\n validation_email = email_validation(email)\n if validation_email:\n return validation_email\n\n user = User.query.filter_by(email=email).first()\n if user:\n user.password = new_password\n user.save()\n response = {\n \"message\": \"Password has been reset\",\n \"status\": \"Reset password succesful!\",\n \"new_password\": new_password\n }\n return response, 200\n else:\n response = {\n 'message': 'User email does not exist, Please try again',\n 'status': 'Reset password failed!'\n }\n return response, 400","def step_impl(context):\n fields = {\n 'grant_type': 'refresh_token',\n 'refresh_token': context.oauth.refresh_token,\n 'scope': context.vendor_config['auth']['scope'],\n }\n\n context.response = token_request(fields,\n context.vendor_config['auth'],\n context.conformance)","def generate_forgot_password_token(self, email):\n payload = {'appkey': self._lr_object._get_api_key(), 'appsecret': self._lr_object._get_api_secret(),\n 'email': email}\n url = SECURE_API_URL + \"raas/v1/account/password/forgot\"\n return self._lr_object._get_json(url, payload)","def send_recovery_password_email(token: str, email: str) -> None:\n\n # TODO ...\n # Load html templates and get the content from it.\n # html_content = ...\n\n # You must have to send this as a anchor\n # to my-domain.com/reset-password?token=ad5a....\n link = f\"{SERVER_HOST}/reset-password?token={token}\"\n content = f\"\"\"\n <h1>Reset your password</h1>\n <p></p>\n <a href=\"{link}\" target=\"_blank\" rel=\"noopener noreferrer\">Press here</a>\n \"\"\"\n email = sender.create_email(\n to_list=[email],\n subject=f\"Recovery Password\",\n html_content=content,\n )\n sender.send_email(email_to_send=email)","def test_request_password_reset(live_server, mailoutbox, settings):\n reset_url_template = \"http://localhost/reset-password/{key}\"\n settings.EMAIL_AUTH = {\"PASSWORD_RESET_URL\": reset_url_template}\n\n user = get_user_model().objects.create_user(username=\"Test User\")\n email = models.EmailAddress.objects.create(\n address=\"test@example.com\", is_verified=True, user=user\n )\n\n data = {\"email\": email.address}\n url = f\"{live_server}/rest/password-reset-requests/\"\n response = requests.post(url, data)\n\n assert response.status_code == 201\n assert response.json() == data\n assert len(mailoutbox) == 1\n\n msg = mailoutbox[0]\n reset = models.PasswordReset.objects.get()\n\n assert msg.to == [data[\"email\"]]\n assert reset_url_template.format(key=reset.token) in msg.body","def reset_password():\n if current_user.is_authenticated:\n return redirect(url_for('main.home'))\n\n form = RequestResetForm()\n\n if form.validate_on_submit():\n user = User.query.filter_by(email=form.email.data).first()\n send_reset_email(user) # located in utils.py\n flash('An email has been sent with instruction to reset your password', 'info')\n return redirect(url_for('users.login'))\n\n return render_template('reset_password_request.html', form=form)","def generate_reset_password_token(self, expiration=3600):\n ser = Serializer(current_app.config['SECRET_KEY'], expiration)\n return ser.dumps({'reset_password': self.id}).decode('utf-8')","def test_patient_reset_password(self):\n\n data = {\"password\": \"newpass\"}\n result = self.client.post(\"/patient/1/account/reset-password\", \n data=data, follow_redirects=True)\n\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"successfully reset\", result.data)","def test_user_can_reset_password(self):\n # first register a user\n self.register_user()\n # registered user forgets password \n # its a post request with the user email as the payload\n response = self.client().post(AuthTestCase.reset, data=self.reset_email)\n self.assertIn(\"Password successfully reset.Check email for new password\", str(response.data))","def test_reset_passwd_bad_token(self, test_client):\n response = test_client.post('/api/auth/reset', json=dict(\n reset_password_token=str(\n create_access_token(identity=UserModel(uuid=uuid.uuid4()))),\n password=\"Azerty!123\"))\n res = json.loads(response.data)\n\n assert response.status_code == 401\n assert res['status'] == False","def test_reset_password_fails_for_missing_parameters(self):\n self.test_client.post(\n \"/api/v1/auth/register\", data=self.user_data)\n\n resp = self.test_client.post(\n \"/api/v1/auth/login\",\n data=self.user_data)\n\n data = json.loads(resp.data)\n token = data['token']\n\n resp = self.test_client.post(\n \"/api/v1/auth/reset-password\",\n headers=dict(Authorization=f'Bearer {token}'))\n\n self.assertEqual(resp.status_code, 400)\n data = json.loads(resp.data)\n self.assertEqual(data[\"status\"], \"failure\")\n self.assertEqual(\n data[\"message\"],\n \"the fields 'password' and 'confirm password' are required\")","def auth_token(self):","def reset_password():\n json_data = request.get_json()\n user_email = json_data.get('email') or None\n\n if user_email is None:\n raise BadRequest(description=INCORRECT_RESET_PARAMS_MSG)\n\n user_account = db.session.query(UserAccount).filter(\n UserAccount.email == user_email).first()\n if user_account is None:\n raise BadRequest(description=INCORRECT_RESET_PARAMS_MSG)\n\n # Generate password hash\n temp_password = str(random.randint(10000,99999))\n update_user = {'password_hashed': get_hashed_password(temp_password)}\n user_account.update(**update_user)\n user_account.save()\n\n email.send('reset_password', user_email, temp_password)\n\n return {'status_code': 200, 'message': 'Password reset success!'}","def start_reset_password_process_step_2(self):\n # fill in the form with no error\n email_field = self.driver.find_element_by_id(\"id_email\")\n email_field.send_keys(\"toto@mail.com\")\n submit_button = self.driver.find_element_by_id(\"submit-id-submit\")\n submit_button.click()\n # wait for email receiving\n actions = ActionChains(self.driver)\n actions.pause(1)\n actions.perform()\n # test that one message has been sent\n self.assertEqual(len(mail.outbox), 1)\n # get the mail content\n mail_content = mail.outbox[0].body\n # extract \"reset password link\"\n match = re.search(\n \"choisir un nouveau mot de passe :\\n(.*)\\nPour mémoire\",\n mail_content\n )\n return match","def user_password_reset(self, request):\n reset_password_form = ResetPasswordForm(request.form)\n\n if request.method == \"POST\":\n if reset_password_form.validate_on_submit():\n if check_password_hash(current_user.password, reset_password_form.old_password.data):\n new_hashed_password = generate_password_hash(reset_password_form.password.data)\n\n temp = current_user.get_id()\n (role, email) = temp.split(\":\")\n\n # if first element is `sysadmin` instead of a scheme_id\n # call function to reset `sysadmin` pass\n if role == \"sysadmin\":\n self._scheme_handler.update_hash_password(email, new_hashed_password)\n else:\n # regular user reset\n self._student_handler.update_hash_password(current_user.scheme_id, current_user.k_number, new_hashed_password)\n\n flash(\"Password successfully updated\")\n else:\n flash(\"Old password incorrect\")\n else:\n flash(\"Please double check your new password is valid.\")\n \n return render_template(\"user/reset_password.html\", reset_password_form=reset_password_form)","def get_password_reset_token(known_plaintext, current_time):\n return encryption_oracle(known_plaintext, current_time)[1].encode('hex')","def test_reset_password(client, admin_user):\n # Step 1: Password reset form\n url = reverse(\"admin_password_reset\")\n\n response = client.get(url)\n templates_used = [t.name for t in response.templates]\n\n assert response.status_code == 200\n assert templates_used == [\n \"registration/password_reset_form.html\",\n \"registration/base.html\",\n ]\n\n # Step 2: Password reset done\n response = client.post(\n url,\n data={\"email\": admin_user.email},\n follow=True,\n )\n templates_used = [t.name for t in response.templates]\n\n assert response.status_code == 200\n assert response.resolver_match.url_name == \"password_reset_done\"\n assert templates_used == [\n \"registration/password_reset_done.html\",\n \"registration/base.html\",\n ]\n assert \"We’ve emailed you instructions for setting your password\" in response.content.decode()\n\n # Get password reset link from reset email\n email = django.core.mail.outbox[0]\n url = re.search(r\"https?://[^/]*(/.*reset/\\S*)\", email.body).group(1)\n\n # Step 3: Password reset confirm\n response = client.get(url, follow=True)\n templates_used = [t.name for t in response.templates]\n\n assert response.status_code == 200\n assert response.resolver_match.url_name == \"password_reset_confirm\"\n assert templates_used == [\n \"registration/password_reset_confirm.html\",\n \"registration/base.html\",\n ]\n\n # Step 4: Password reset complete\n response = client.post(\n response.request[\"PATH_INFO\"],\n data={\"username\": admin_user.username, \"new_password1\": \"new_password\", \"new_password2\": \"new_password\"},\n follow=True,\n )\n templates_used = [t.name for t in response.templates]\n\n assert response.status_code == 200\n assert response.resolver_match.url_name == \"password_reset_complete\"\n assert templates_used == [\n \"registration/password_reset_complete.html\",\n \"registration/base.html\",\n ]\n assert \"Your password has been set.\" in response.content.decode()","def forgot_passwd(request):\n dc_settings = request.dc.settings\n\n return password_reset(\n request,\n template_name='gui/accounts/forgot.html',\n email_template_name='gui/accounts/forgot_email.txt',\n subject_template_name='gui/accounts/forgot_subject.txt',\n password_reset_form=partial(ForgotForm, request),\n post_reset_redirect=reverse('forgot_done'),\n from_email=dc_settings.DEFAULT_FROM_EMAIL,\n current_app='gui',\n extra_context={\n 'e_site_name': dc_settings.SITE_NAME,\n 'e_site_link': dc_settings.SITE_LINK,\n })","def init_reset_pw(email: str) -> FluxData:\n current_app.logger.info(f'Trying to send password reset email to {email}')\n try:\n send_password_reset_mail(email)\n except BadCode as error:\n current_app.logger.error(f'Sending password reset e-mail for {email} failed: {error}')\n return error_response(message=error.msg)\n\n return success_response(message=ResetPwMsg.send_pw_success)","def test_allow_all_password_reuse(self):\r\n student_email, _ = self._setup_user()\r\n user = User.objects.get(email=student_email)\r\n\r\n err_msg = 'You are re-using a password that you have used recently.'\r\n\r\n token = default_token_generator.make_token(user)\r\n uidb36 = int_to_base36(user.id)\r\n\r\n # try to do a password reset with the same password as before\r\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\r\n 'new_password1': 'foo',\r\n 'new_password2': 'foo'\r\n }, follow=True)\r\n\r\n self.assertNotIn(\r\n err_msg,\r\n resp.content\r\n )","def test_successful_password_change(self):\n token = str((jwt.encode(\n {\"email\": \"bagendadeogracious@gmail.com\"}, settings.SECRET_KEY)).decode('utf-8'))\n self.client.post(self.registration_url, valid_user, format='json')\n response = self.client.patch(\n self.change_password_url+\"?token=\"+token,\n {\"password\": \"bagenda1234\"},\n format='json'\n )\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(\n response.data['message'],\n \"you have reset your password successfully.\"\n )","def reset_password(self, request):\n password = request.data['password']\n forgot_password_hash = request.data['uuid']\n url_expired_response = Response(\n {\"message\": 'Password reset url expired'}, status=status.HTTP_400_BAD_REQUEST)\n\n try:\n user = CurationUser.objects.get(\n forgot_password_hash=forgot_password_hash)\n\n # get pwd_expiry_cycle_days value from admin_settings table\n pwd_expiry_cycle_days = get_password_expiry_cycle_days()\n\n if user is None:\n return url_expired_response\n if user.forgot_password_hash_expiry_on.isoformat() < datetime.now().isoformat():\n return url_expired_response\n\n successs_response = {\n \"message\": \"password set successfully\"\n }\n\n mfaUrl = self._get_mfa_uri(user.email, user.otp_secret_key)\n\n if (not user.is_active and user.mfa_type == CurationUser.MfaType.google) or user.is_staff:\n successs_response[\"mfaUrl\"] = mfaUrl\n\n # if password reset is requrested by admin then reset the otp secret key and return mfa_url\n if user.reset_password_requested_by is not None:\n reset_password_requested_by = UserSerializer(\n user.reset_password_requested_by).data\n reset_password_requested_by_user_group = reset_password_requested_by.get('groups')[0]\n admin_group = Group.objects.get(name='admin')\n\n if admin_group is not None \\\n and admin_group.name == reset_password_requested_by_user_group.get('name') \\\n and user.mfa_type == CurationUser.MfaType.google:\n successs_response[\"mfaUrl\"] = mfaUrl\n\n if can_update_user_password(user, password):\n user.update_password(password, pwd_expiry_cycle_days)\n user.is_active = True\n user.reset_password_requested_by = None\n user.forgot_password_hash = None\n user.forgot_password_hash_expiry_on = None\n return Response(successs_response, status=status.HTTP_200_OK)\n else:\n error_response = {'errors': {}}\n error_response['errors']['new_password'] = [\"Password already used before.\"]\n raise serializers.ValidationError(error_response)\n except CurationUser.DoesNotExist:\n return url_expired_response\n except ValidationError as err:\n raise err\n except:\n return Response({\"message\": \"Unable to reset password\"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)","def update_password(email: str, token: str, new_passwd: str) -> None:\n data = {\n 'email': email,\n 'reset_token': token,\n 'new_password': new_passwd\n }\n response = requests.put(f'{URL}/reset_password', data=data)\n assert response.status_code == 200\n assert response.json() == {'email': email, 'message': 'Password updated'}","def test_password_reset(self):\n newpassword = 'neo.h1m1tsu!'\n pw_reset_url = reverse('auth_password_reset')\n\n # Step 1 - load the password reset page\n response = self.client.get(pw_reset_url)\n self.assertEqual(response.status_code, 200)\n # WARNING: uses Django's admin template\n self.assertTemplateUsed(\n response, 'registration/password_reset_form.html')\n\n # Step 2 - request password reset URL at specific email\n data = {'email': self.email}\n post_response = self.client.post(pw_reset_url, data=data, follow=True)\n self.assertRedirects(\n post_response, reverse('auth_password_reset_done'))\n # WARNING: uses Django's admin template\n self.assertTemplateUsed(\n post_response, 'registration/password_reset_done.html')\n\n # Step 3 - receive email with link back to site for reset\n self.assertEqual(len(mail.outbox), 1)\n self.assertEqual(mail.outbox[0].to, [self.email])\n self.assertEqual(\n mail.outbox[0].subject, 'Password reset on example.com')\n urlmatch = re_search(r'https?://[^/]*(/.*reset/\\S*)',\n mail.outbox[0].body)\n self.assertIsNotNone(urlmatch, 'No URL found in sent email')\n url_path = urlmatch.groups()[0]\n uidb64, token = list(filter(None, url_path.split('/')))[-2:]\n self.assertEqual(\n reverse('auth_password_reset_confirm',\n kwargs={'uidb64': uidb64, 'token': token}),\n url_path)\n\n # Step 4 - Access URL provided in reset email\n # TODO: remove condition when Django 1.10 dropped\n if DJANGO_VERSION >= (1, 11):\n # Django class-based auth views redirects to a URL without a\n # token to prevent leaking the token to third-parties\n reset_get_response = self.client.get(url_path)\n self.assertRedirects(\n reset_get_response,\n reverse('auth_password_reset_confirm',\n kwargs={\n 'uidb64': uidb64,\n 'token': INTERNAL_RESET_URL_TOKEN}))\n url_path = reset_get_response.url\n reset_get_response = self.client.get(url_path)\n self.assertEqual(reset_get_response.status_code, 200)\n # WARNING: uses Django's admin template\n self.assertTemplateUsed(\n reset_get_response, 'registration/password_reset_confirm.html')\n\n # Step 5 - Reset Password in Form\n data = {\n 'new_password1': newpassword,\n 'new_password2': newpassword,\n }\n reset_post_response = self.client.post(\n url_path, data=data, follow=True)\n self.assertRedirects(\n reset_post_response, reverse('auth_password_reset_complete'))\n\n # Ensure that Password Reset Worked Correct\n self.assertTrue(\n self.client.login(username=self.username, password=newpassword))","def __init__(self):\n self.token = None\n self.login()"],"string":"[\n \"def request_password_reset():\",\n \"def password_resetenter(request, uidb64=None, token=None):\\n\\n\\tcontext_dict = {}\\n\\tif request.method == 'POST':\\n\\t\\tassert uidb64 is not None and token is not None\\n\\t\\tuid = urlsafe_base64_decode(uidb64)\\n\\t\\tuser = models.Teacher.objects.get(\\n\\t\\t\\tsoft_delete=False, pk=uid\\n\\t\\t)\\n\\t\\tdb_user = user.user\\n\\t\\treset_token = models.PasswordReset.objects.get(\\n\\t\\t\\ttoken=token, user=user\\n\\t\\t)\\n\\t\\ttoken_check = models.PasswordReset.objects.filter(\\n\\t\\t\\tuser=user, soft_delete=False, token_consumed=False,\\n\\t\\t).exclude(token=token).first()\\n\\t\\tupdate_fields = []\\n\\t\\ttoken_check.token_consumed = True\\n\\t\\tupdate_fields.append('token_consumed')\\n\\t\\ttoken_check.soft_delete = True\\n\\t\\tupdate_fields.append('soft_delete')\\n\\t\\ttoken_check.save(update_fields=update_fields)\\n\\t\\ttime_threshold = timezone.now() - reset_token.password_request_created_at\\n\\t\\tif time_threshold > timedelta(minutes=30):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tupdate_fields = []\\n\\t\\t\\t\\treset_token.token_consumed = True\\n\\t\\t\\t\\tupdate_fields.append('token_consumed')\\n\\t\\t\\t\\treset_token.soft_delete = True\\n\\t\\t\\t\\tupdate_fields.append('soft_delete')\\n\\t\\t\\t\\treset_token.save(update_fields=update_fields)\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint (e)\\n\\t\\tif reset_token.user == user and reset_token.token == token:\\n\\t\\t\\tif reset_token.token_consumed == False and reset_token.soft_delete == False:\\n\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\tupdate_fields = []\\n\\t\\t\\t\\t\\treset_token.token_consumed = True\\n\\t\\t\\t\\t\\tupdate_fields.append('token_consumed')\\n\\t\\t\\t\\t\\treset_token.soft_delete = True\\n\\t\\t\\t\\t\\tupdate_fields.append('soft_delete')\\n\\t\\t\\t\\t\\treset_token.save(update_fields=update_fields)\\n\\t\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\t\\tprint (e)\\n\\t\\t\\t\\tform = AdminPasswordChangeForm(user=db_user, data=request.POST)\\n\\t\\t\\t\\tif form.is_valid():\\n\\t\\t\\t\\t\\tform.save()\\n\\t\\t\\t\\t\\thistory = models.History(\\n\\t\\t\\t\\t\\t\\tuser=user,\\n\\t\\t\\t\\t\\t\\tactivity = \\\"\\\",\\n\\t\\t\\t\\t\\t\\tactivity_type = \\\"Reset Password\\\"\\n\\t\\t\\t\\t\\t)\\n\\t\\t\\t\\t\\thistory.save()\\n\\t\\t\\t\\t\\tcontext_dict[\\\"message\\\"] = \\\"Password changed successfully\\\"\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tcontext_dict[\\\"message\\\"] = \\\"Password not changed\\\"\\n\\t\\t\\telse:\\n\\t\\t\\t\\tcontext_dict[\\\"message\\\"] = \\\"Link is no longer valid\\\"\\n\\treturn render(request, \\\"reset.html\\\", context_dict)\",\n \"def reset_password(newpass, challenge):\",\n \"def resetPassword(self, customerguid, password, jobguid=\\\"\\\", executionparams=None):\",\n \"def reset_password():\\n pass\",\n \"def do_password(token):\\n password_reset_token = token\\n requested_password = request.form['password']\\n requested_password_repeat = request.form['passwordRepeat']\\n\\n # Only pending states can be used.\\n target_user = User.query.filter_by(\\n password_reset_token=password_reset_token).first()\\n\\n if target_user is None:\\n return Response(render_template('password/failure.html',\\n message=('Unbekannter token. Stellen '\\n 'sie sicher, dass Sie nicht mehrfach '\\n 'eine Passwortzurücksetzung '\\n 'angefordert haben und nehmen sie '\\n 'immer die aktuelle.')))\\n\\n if not target_user.state == StateType.PASSWORT_RESET_PENDING:\\n return Response(render_template('password/failure.html',\\n message='User has no pending password reset.'))\\n\\n if not requested_password == requested_password_repeat:\\n return Response(render_template('password/request.html',\\n passwordResetToken=token,\\n message='Passwörter stimmen nicht überein.'))\\n\\n if not target_user.check_password_length(requested_password):\\n return Response(render_template('password/request.html',\\n passwordResetToken=token,\\n message=('Passwort zu kurz. Das '\\n 'Passwort muss mindestens {} '\\n 'Zeichen haben').format(PASSWORD_MIN_LENGTH)))\\n\\n if not target_user.check_password_format(requested_password):\\n return Response(render_template('password/request.html',\\n passwordResetToken=token,\\n message='Falsches Passwort Format. Das '\\n 'Passwort muss mindestens eine Ziffer enthalten.'))\\n\\n target_user.set_password(requested_password)\\n target_user.state = StateType.ACTIVE\\n db.session.commit()\\n\\n return Response(render_template('password/success.html'))\",\n \"def _request_reset(self, email):\\n response = self.client.post(reverse('users.send_password_reset'),\\n {'email': email})\\n return response.context['token']\",\n \"def reset_password(self, reset_token_url, password):\\n query = parse.parse_qs(parse.urlparse(reset_token_url).query)\\n return self._action('resetPasswordSubmitForm', {\\n 'token': query['token'][0],\\n 'key': query['key'][0],\\n 'newpassword': password,\\n 'confirmpassword': password,\\n }, api='resetpassword')\",\n \"def reset_token(token):\\n if current_user.is_authenticated:\\n return redirect(url_for('LoadDonor'))\\n staff = Staff.verify_reset_token(token)\\n if staff is None:\\n flash('That is an invalid or expired token', 'warning')\\n return redirect(url_for('reset_request'))\\n form = ResetPasswordForm()\\n if form.validate_on_submit():\\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\\n staff.password = hashed_password\\n db.session.commit()\\n flash('Your password has been updated! You are now able to log in', 'success')\\n return redirect(url_for('login'))\\n return render_template('reset_token.html', title='Reset Password', form=form)\",\n \"def test_api_user_reset_password_post(self):\\n pass\",\n \"def InitiateResetPassword(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def request_password_reset_token():\\n j = request.get_json(force=True)\\n user_requested = j['user'].lower()\\n\\n # Disabled user accounts can not request for a new password.\\n target_user = User.query.filter_by(mail=user_requested).first()\\n\\n if target_user is None:\\n return Errors.UNKNOWN_USER.make_json_response(status.HTTP_400_BAD_REQUEST)\\n\\n if target_user.state == StateType.DEACTIVATED:\\n return Errors.DEACTIVATED_USER.make_json_response(status.HTTP_400_BAD_REQUEST)\\n\\n target_user.generate_password_request_token()\\n\\n send_mail(target_user.mail, render_template(\\\"password/reset_password_mail.txt\\\",\\n greeting=get_opening_greeting(target_user),\\n wlink=\\\"{}/password/reset/{}\\\".format(\\n app.config['BUZZN_BASE_URL'],\\n target_user.password_reset_token\\n )), 'Passwort zurücksetzen für Buzzn-App')\\n\\n db.session.commit()\\n return '', status.HTTP_201_CREATED\",\n \"def reset_token(token):\\n if current_user.is_authenticated:\\n return redirect(url_for('home'))\\n user = User.verify_reset_token(token)\\n if user is None:\\n message = \\\"This is an invalid or expired token\\\"\\n return redirect(url_for(\\\"forgot\\\", message=message))\\n form = ResetPasswordForm()\\n if form.validate_on_submit():\\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\\n user.password = hashed_password\\n db.session.commit()\\n message = f'Password has been updated for {user.display_username}'\\n return redirect(url_for('login', message=message))\\n return render_template(\\\"reset_token.html\\\", title=\\\"Reset Pasword\\\", form=form, offer_login=True, offer_register=True)\",\n \"def post(self, request, token):\\n form = PasswordResetForm(request.DATA)\\n if form.is_valid():\\n user_data = get_user_data(\\n signing.loads(\\n token,\\n max_age=self.token_expires,\\n salt=self.salt))\\n if user_data:\\n user_data.set_password(request.DATA['password1'])\\n user_data.save()\\n return render_to_response(\\n 'registration/show_message.html',\\n {\\n 'title': \\\"Change successfully\\\",\\n 'message': \\\"your password has Change successfully\\\"})\\n return render_to_response(\\n 'registration/show_message.html',\\n {\\n 'title': \\\"Sorry something wrong\\\",\\n 'message': \\\"sorry try again to set new password\\\"})\\n return render_to_response(\\n 'registration/show_message.html',\\n {\\n 'title': \\\"Sorry something wrong\\\",\\n 'message': \\\"sorry try again to set new password\\\"})\",\n \"def reset_post():\\n if g.session:\\n # User is already authenticated\\n return jsonify({'redirect': url_for('index.index')})\\n\\n form = request.values.get('form', default='email')\\n token = request.values.get('token', default='')\\n email = request.values.get('email', default='')\\n password = request.values.get('password', default='')\\n\\n if form == 'password':\\n try:\\n user: User = db.session.query(User) \\\\\\n .filter((User.password_token == token) & User.reset_active) \\\\\\n .one()\\n if user.is_reset_expired():\\n return jsonify({'success': False, 'reason': 'expired'}), 401\\n\\n if len(password) < 8:\\n return jsonify({'success': False, 'reason': 'password'}), 401\\n\\n user.set_password(password)\\n db.session.commit()\\n next_url = url_for('auth.reset_status', success=True)\\n return jsonify({'success': True, 'redirect': next_url})\\n except NoResultFound:\\n return jsonify({'success': False, 'reason': 'token not found'}), 401\\n else:\\n try:\\n user: User = db.session.query(User) \\\\\\n .filter(User.email == email).one()\\n user.reset_password()\\n db.session.commit()\\n\\n reset_url = urllib.parse.urljoin(\\n request.host_url,\\n url_for('auth.reset_get', token=user.password_token))\\n kwargs = {\\n 'subject': gettext('Reset Password'),\\n 'body': reset_url,\\n 'recipients': [user.email]\\n }\\n mail.send_mail(**kwargs)\\n next_url = url_for('auth.reset_status', sent=True)\\n return jsonify({'success': True, 'redirect': next_url})\\n except NoResultFound:\\n return jsonify({'success': False, 'reason': 'email'}), 401\",\n \"def reset_password(token):\\n if current_user.is_authenticated:\\n return redirect(url_for('main.index'))\\n user = User.verify_reset_password_token(token)\\n if not user:\\n return redirect(url_for('main.index'))\\n form = ResetPasswordForm()\\n if form.validate_on_submit():\\n user.set_password(form.password.data)\\n user.email_confirmed = True\\n db.session.commit()\\n return render_template(\\n 'successful_pass_reset.html', title=\\\"Password Reset\\\")\\n return render_template('reset_password.html', title=\\\"Password Reset\\\",\\n form=form), 417\",\n \"def password_reset(self, password, vtoken, welcomeEmailTemplate = ''):\\n auth = 'appkey='+ self._lr_object._get_api_key()+ '&appsecret='+ self._lr_object._get_api_secret() + '&vtoken=' + vtoken\\n payload = {'password': password}\\n url = SECURE_API_URL + \\\"raas/v1/account/password/reset\\\" + \\\"?\\\" + auth\\n return self._lr_object._post_json(url, payload)\",\n \"def POST(self):\\n session = web.ctx.session\\n nav = get_nav_bar(session)\\n data = web.input(reset_token = \\\"\\\", new_password=\\\"\\\")\\n \\n reset_password_colum = reset_password_form()\\n \\n # check each field is endered values.\\n if not reset_password_colum.validates():\\n return render.reset_password(nav, reset_password_form, \\\"All fields must be valid.\\\")\\n \\n try:\\n # log ip information\\n ip_addr = web.ctx[\\\"ip\\\"]\\n accessed_path = web.ctx[\\\"fullpath\\\"]\\n\\n # query user's name (username) and token (extra secruity)\\n token = data.reset_token\\n username = search_for_user(token, ip_addr, accessed_path)\\n #print(\\\"-\\\"*16)\\n #print(username)\\n \\n #update token to null database\\n result_update_token = update_token_to_null(username, token, ip_addr, accessed_path)\\n print(\\\"-\\\" * 16 + \\\"updated!\\\")\\n\\n # generate new password\\n new_salt = generate_salt()\\n hashed_password = hashed_value(data.new_password, new_salt)\\n hashed_password = new_salt + hashed_password\\n\\n # update password \\n result_update_password = update_user_password(username, hashed_password, ip_addr, accessed_path )\\n raise web.seeother(\\\"/\\\")\\n except Exception as e:\\n print(e)\\n except:\\n print(exit[0])\\n return render.login(nav, reset_password_form, \\\"- Something went wrong!\\\")\",\n \"def password_reset_token_created(sender, reset_password_token, *args, **kwargs):\\n # send an e-mail to the user\\n context = {\\n 'current_user': reset_password_token.user,\\n 'username': reset_password_token.user.username,\\n 'email': reset_password_token.user.email,\\n # ToDo: The URL can (and should) be constructed using pythons built-in `reverse` method.\\n 'reset_password_url': \\\"http://some_url/reset/?token={token}\\\".format(token=reset_password_token.key)\\n }\\n\\n # render email text\\n email_html_message = render_to_string('email/user_reset_password.html', context)\\n email_plaintext_message = render_to_string('email/user_reset_password.txt', context)\\n\\n msg = EmailMultiAlternatives(\\n # title:\\n \\\"Password Reset for {title}\\\".format(title=\\\"Some website title\\\"),\\n # message:\\n email_plaintext_message,\\n # from:\\n \\\"noreply@somehost.local\\\",\\n # to:\\n [reset_password_token.user.email]\\n )\\n msg.attach_alternative(email_html_message, \\\"text/html\\\")\\n msg.send()\",\n \"def reset_password():\\n body = request.get_json()\\n reset_token = body.get('reset_token')\\n password = body.get('password')\\n\\n if not reset_token or not password:\\n return jsonify(msg.MISSING_PARAMETER), 400\\n\\n user_email = decode_token(reset_token)['identity']\\n is_changed = views.UserManagement().change_password(email=user_email, password=password)\\n if not is_changed:\\n return jsonify(msg.NO_DATA), 404\\n\\n send_email('[Shodita] Password reset successful', sender='shodita@shodita.com', recipients=[user_email],\\n text_body='Password reset was successful', html_body='<p>Password reset was successful</p>')\\n\\n return jsonify(msg.SUCCESS), 200\",\n \"def reset_password(self):\\n self.password = passwordResetter(self.user_id, self.password)\",\n \"def post(self, request):\\n import pdb\\n pdb.set_trace()\\n form = ConfirmPasswordForm(request.POST)\\n token = request.GET.get('token')\\n if not token:\\n raise Http404('Tocken not found.')\\n if not form.is_valid():\\n import pdb\\n pdb.set_trace()\\n return render(request, 'user_registrations/set_password.html', {'form': form, 'token': token, 'errors': form.errors})\\n token_obj = PasswordResetTokens.objects.filter(token=token)\\n if not token_obj:\\n raise Http404('Fake token supplied.')\\n password_1 = form.cleaned_data.get('password_1')\\n user = token_obj[0].user\\n user.set_password(password_1)\\n user.save()\\n token_obj[0].delete()\\n return HttpResponseRedirect(reverse('login'))\",\n \"def password_token_oracle():\\n past_time = int(time.time()) - random.randint(1, 3600)\\n return generate_password_reset_token(past_time), past_time\",\n \"def reset_password(token):\\n # this token just active in 300s\\n if request.method == \\\"POST\\\":\\n email = s.loads(token, salt='email-confirm', max_age=300)\\n print(email)\\n user = User.query.filter_by(email=email).first()\\n\\n newPassword1 = request.form.get('newPassword1')\\n newPassword2 = request.form.get('newPassword2')\\n\\n print(user)\\n if user:\\n \\\"\\\"\\\"kiểm tra password hợp lệ-chỗ này cần chỉnh thêm file html-----------------------------------------------------\\\"\\\"\\\"\\n if re.search(PASSWORD_PATTERN, newPassword1) is None:\\n flash('Password must be from 6-10 characters, have a digit must occur at least , '\\n 'a lower case letter must occur at least once, no whitespace allowed in the entire string.',\\n category='error')\\n elif newPassword1 != newPassword2:\\n flash('Passwords don\\\\'t match.', category='success')\\n else:\\n user.password = generate_password_hash(newPassword1, method='sha256')\\n db.session.commit()\\n print(user.password)\\n print(\\\"đang thay đổi đây.............\\\")\\n flash('Change password successfully!.', category='success')\\n return redirect(url_for('auth.login'))\\n # ------------------------------------------------------------------------------------------------------------------\\n return render_template(\\\"forgotPass.html\\\")\",\n \"def ChangePasswordWithRPToken(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def test_reset_password_good_token(self, reset_confirm):\\r\\n\\r\\n good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(self.uidb36, self.token))\\r\\n password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)\\r\\n confirm_kwargs = reset_confirm.call_args[1]\\r\\n self.assertEquals(confirm_kwargs['uidb36'], self.uidb36)\\r\\n self.assertEquals(confirm_kwargs['token'], self.token)\\r\\n self.user = User.objects.get(pk=self.user.pk)\\r\\n self.assertTrue(self.user.is_active)\",\n \"def reset_token(token):\\n if current_user.is_authenticated:\\n return redirect(url_for('users.home'))\\n\\n user = User.verify_secret_token(token)\\n\\n if user is None:\\n flash('That is invalid or expired token', 'warning')\\n\\n return redirect(url_for('users.reset_password'))\\n\\n form = ResetPasswordForm()\\n\\n if form.validate_on_submit():\\n hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')\\n user.password = hashed_password\\n db.session.commit()\\n\\n return redirect(url_for('users.login'))\\n\\n return render_template('reset_token.html', form=form)\",\n \"def user_reset_password(request, token):\\n\\n if request.user.is_authenticated():\\n return redirect(settings.AFTER_LOGIN_REDIRECT_URL)\\n\\n form = ResetPasswordForm(request.POST or None)\\n\\n if request.method == \\\"POST\\\":\\n if form.is_valid():\\n user_auth = get_object_or_404(PasswordResetAuth, token=token)\\n user = get_object_or_404(User, email=user_auth.email)\\n\\n if user_auth.choose_me is True:\\n new_password = form.cleaned_data[\\\"new_password\\\"]\\n user.set_password(new_password)\\n user.save()\\n\\n user_auth.choose_me = False\\n user_auth.save()\\n return redirect(\\\"/login/\\\")\\n\\n error_message = \\\"* Either you are not an identified user or \\\"\\\\\\n \\\"token has been expired. So please click on back.\\\"\\n return render_to_response(\\\"login/reset_password.html\\\", {\\n \\\"form\\\": form,\\n \\\"error_message\\\": error_message\\n }, context_instance=RequestContext(request))\\n\\n return render_to_response(\\\"login/reset_password.html\\\", {\\n \\\"form\\\": form\\n }, context_instance=RequestContext(request))\",\n \"def test_reset_password_with_reused_password(self, reset_confirm):\\r\\n\\r\\n good_reset_req = self.request_factory.get('/password_reset_confirm/{0}-{1}/'.format(self.uidb36, self.token))\\r\\n password_reset_confirm_wrapper(good_reset_req, self.uidb36, self.token)\\r\\n confirm_kwargs = reset_confirm.call_args[1]\\r\\n self.assertEquals(confirm_kwargs['uidb36'], self.uidb36)\\r\\n self.assertEquals(confirm_kwargs['token'], self.token)\\r\\n self.user = User.objects.get(pk=self.user.pk)\\r\\n self.assertTrue(self.user.is_active)\",\n \"def reset_password(token):\\n\\n if not current_user.is_anonymous():\\n return redirect(url_for(\\\"forum.index\\\"))\\n\\n form = ResetPasswordForm()\\n if form.validate_on_submit():\\n user = User.query.filter_by(email=form.email.data).first()\\n expired, invalid, data = user.verify_reset_token(form.token.data)\\n\\n if invalid:\\n flash((\\\"Your password token is invalid.\\\"), \\\"danger\\\")\\n return redirect(url_for(\\\"auth.forgot_password\\\"))\\n\\n if expired:\\n flash((\\\"Your password is expired.\\\"), \\\"danger\\\")\\n return redirect(url_for(\\\"auth.forgot_password\\\"))\\n\\n if user and data:\\n user.password = form.password.data\\n user.save()\\n flash((\\\"Your password has been updated.\\\"), \\\"success\\\")\\n return redirect(url_for(\\\"auth.login\\\"))\\n\\n form.token.data = token\\n return render_template(\\\"auth/reset_password.html\\\", form=form)\",\n \"def start_reset_password_process_step_1(self):\\n # start from the login page\\n start_url = self.home_url + \\\"users/login/\\\"\\n self.driver.get(start_url)\\n # click on the link \\\"Mot de passe oublié ?\\\"\\n reset_link = self.driver.find_element_by_id(\\\"forgotten_password\\\")\\n reset_link.click()\\n # wait for page loading\\n WebDriverWait(\\n self.driver,\\n timeout=10\\n ).until(EC.url_changes(start_url))\\n # redirect to the password reset page: True or False?\\n expected_url = self.home_url + \\\"profile/reset_password/\\\"\\n self.assertEqual(self.driver.current_url, expected_url)\\n # change the site in the email\\n site = Site.objects.get(id=settings.SITE_ID)\\n site.domain = self.live_server_url\\n site.name = self.live_server_url\\n site.save()\",\n \"def token_request(request):\\n try:\\n l_user = request.data[\\\"user\\\"] #or email\\n except:\\n return Response({'message':'No user information received.'}, status=status.HTTP_400_BAD_REQUEST)\\n\\n l_user = l_user.lower()\\n\\n try:\\n user = User.objects.get(username=l_user)\\n except:\\n try:\\n user = User.objects.get(email=l_user)\\n except:\\n return Response({'message': l_user + ' does not match any record.'}, status=status.HTTP_400_BAD_REQUEST)\\n\\n pin = random.randint(0, 1000000)\\n try:\\n subject = \\\"Password Reset Token.\\\"\\n sendEmail(user, subject, \\\"Password Reset\\\", otp=pin)\\n\\n #Write to use record\\n ResetRequests.objects.create(user = user, token = pin, use_case = 'password reset')\\n \\n #Add password reset request date here\\n return Response({'message':'Token sent to registered email.', 'username' : user.username}, status=status.HTTP_200_OK)\\n except Exception as e:\\n return Response({'message':'We could not send an email', 'error':e}, status=status.HTTP_400_BAD_REQUEST)\",\n \"def test_reset_password_bad_token(self, reset_confirm):\\r\\n\\r\\n bad_reset_req = self.request_factory.get('/password_reset_confirm/NO-OP/')\\r\\n password_reset_confirm_wrapper(bad_reset_req, 'NO', 'OP')\\r\\n confirm_kwargs = reset_confirm.call_args[1]\\r\\n self.assertEquals(confirm_kwargs['uidb36'], 'NO')\\r\\n self.assertEquals(confirm_kwargs['token'], 'OP')\\r\\n self.user = User.objects.get(pk=self.user.pk)\\r\\n self.assertFalse(self.user.is_active)\",\n \"def PasswordResetViaOTP(request):\\n current_time = datetime.now(utc)\\n request_data = json.loads(request.body)\\n\\n if not type(request_data) == dict:\\n return StandardHttpResponse.login_bad_rsp([], 'Bad data')\\n\\n if not PasswordResetUtils().validate_request_data(request_data):\\n return StandardHttpResponse.login_bad_rsp([], 'Missing data fields')\\n\\n if not request_data['password'] == request_data['confirm_password']:\\n return StandardHttpResponse.login_bad_rsp([], 'Password Not Matched')\\n\\n result, response = MobileOtpService.validate_otp(otp=request_data['otp'],\\n otp_ref=request_data['otp_ref'],\\n o_type='ForgetPassword',\\n current_time=current_time,\\n return_obj=True)\\n if not result:\\n return StandardHttpResponse.login_bad_rsp([], response)\\n if not response.mobile:\\n return StandardHttpResponse.login_bad_rsp([], 'Invalid request. Please contact Admin.')\\n user_profile_obj = UserModelQueries.get_user_profile_by_mobile(response.mobile)\\n if not user_profile_obj:\\n return StandardHttpResponse.login_bad_rsp([], 'Mobile not registered')\\n user_obj = UserModelQueries.get_user_by_id(user_profile_obj.user_id)\\n response.delete()\\n user_obj.set_password(request_data['password'])\\n user_obj.save()\\n json_body = dict()\\n json_body['username'] = user_obj.username\\n json_body['password'] = request_data['password']\\n json_body['grant_type'] = 'password'\\n request._body = urllib.urlencode(json_body)\\n json_body['redirect_uri'] = REDIRECT_URL\\n request._post = json_body\\n view = TokenView.as_view()\\n request.META[\\n \\\"HTTP_AUTHORIZATION\\\"] = \\\"Basic YlVhOFBCTTFCQTFGb3JPUlp5RVB0RmFBSUJZOGNhUWF5N2hTbTE4dDpla25ENkVzenlJZEZMeUM1RmhqSFlnUnVuMlk2alpqMTN0Mll1ZzZhVWNJc0ZYYk9VMnNyWDRjRmJLQkpwMnpVVVRZNnV6U0U5V3AyN3JJTmNPZ09FWmVDVlB4NXVEWXV0ZHBFMHhVcEROTTBGUlluRERMQzlTTnNNN3RRZUhEbA==\\\"\\n request.META[\\\"CONTENT_TYPE\\\"] = \\\"application/x-www-form-urlencoded\\\"\\n return StandardHttpResponse.login_rsp(json.loads(view(request).content), 'User Logged-In Successfully.')\",\n \"def login_resetrequest():\\n if request.method == \\\"GET\\\":\\n # In browser request that user wants to reset the password\\n return flask.render_template('reset-request.html', message=\\\"Please reset the password\\\")\\n\\n if request.method == \\\"POST\\\":\\n # Create a token\\n email = flask.request.form[\\\"email\\\"]\\n\\n # Find if an account with that name exists\\n conn.register([model.User])\\n admindb = conn[current_app.config[\\\"CONFIGDB\\\"]]\\n\\n userdoc = admindb[\\\"users\\\"].User.find_one({\\\"name\\\" : email, \\\"type\\\" : \\\"passwd\\\"})\\n if userdoc == None:\\n # user not found\\n return flask.Response('{\\\"error\\\" : \\\"User not found\\\"}')\\n\\n # First reset the password\\n name = userdoc[\\\"label\\\"]\\n emailto = userdoc[\\\"name\\\"]\\n\\n # Create accout and a random tocken\\n userdoc[\\\"token\\\"] = bson.ObjectId()\\n userdoc[\\\"password_status\\\"] = \\\"reset-request\\\"\\n\\n # May only be useful for some\\n if \\\"password_ready\\\" in userdoc:\\n del userdoc[\\\"password_ready\\\"]\\n\\n userdoc.validate()\\n userdoc.save()\\n\\n # Create email\\n emailfrom = current_app.config[\\\"EMAIL_FROM\\\"] \\n\\n body = \\\"Hello \\\" + name + \\\",\\\\n\\\\n\\\"\\n body = body + \\\"You recently requested a password reset for your account at https://slide-atlas.org.\\\"\\n body = body + \\\"\\\\n To complete the request operation please follow the link below- \\\\n\\\"\\n body = body + \\\"\\\\n \\\" + url_for('.login_confirm', _external=True) + \\\"?token=\\\" + str(userdoc[\\\"token\\\"]) + \\\" \\\\n\\\"\\n body = body + \\\"\\\\nIf clicking on the link doesn't work, try copying and pasting it into your browser.\\\\n\\\"\\n body = body + \\\"\\\\nThis link will work only once, and will let you create a new password. \\\\n\\\"\\n body = body + \\\"\\\\nIf you did not request password reset, please disregard this message.\\\\n\\\"\\n body = body + \\\"\\\\nThank you,\\\\nThe SlideAtlas Administration Team\\\\n\\\"\\n\\n # Create a text/plain message\\n msg = MIMEText(body)\\n\\n # me == the sender's email address\\n # you == the recipient's email address\\n msg['Subject'] = 'Password reset confirmation for slide-atlas.org'\\n msg['From'] = emailfrom\\n msg['To'] = emailto\\n print msg\\n s = smtplib.SMTP(current_app.config[\\\"SMTP\\\"])\\n try:\\n out = s.sendmail(emailfrom, [emailto], msg.as_string())\\n except:\\n return flask.Response(\\\"{\\\\\\\"error\\\\\\\" : \\\\\\\"Error sending email\\\\\\\"}\\\")\\n\\n s.quit()\\n return flask.Response(\\\"{\\\\\\\"success\\\\\\\" : \\\\\\\"\\\" + str(out) + \\\"\\\\\\\"}\\\")\",\n \"def test_user_resetpassword(self):\\n\\n data = {\\n \\\"email\\\": \\\"testuser@gmail.com\\\"\\n }\\n response = self.client.post(reverse('account:request-reset-email'), data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n user = User.objects.get(email=\\\"testuser@gmail.com\\\")\\n uidb64 = urlsafe_base64_encode(smart_bytes(user.id))\\n token = PasswordResetTokenGenerator().make_token(user)\\n relativeLink = reverse(\\n 'accounts:password-reset-confirm',\\n kwargs={'uidb64': uidb64, 'token': token}\\n )\\n resetconfirm_response = self.client.get(reverse(\\n 'accounts:password-reset-confirm',\\n kwargs={'uidb64': uidb64, 'token': token}\\n ))\\n\\n self.assertEqual(resetconfirm_response.status_code, status.HTTP_200_OK)\\n reset_data = {\\n \\\"uidb64\\\": resetconfirm_response.data[\\\"uidb64\\\"],\\n \\\"token\\\": resetconfirm_response.data[\\\"token\\\"],\\n \\\"password\\\": \\\"1234567\\\"\\n }\\n resetcomplete_response = self.client.patch(reverse('account:password-reset-complete'), reset_data,\\n format=\\\"json\\\")\\n self.assertEqual(resetcomplete_response.status_code, status.HTTP_200_OK)\\n # test if now user can login with new password\\n updatedlogin_data = {\\n \\\"email\\\": \\\"testuser@gmail.com\\\",\\n \\\"password\\\": \\\"1234567\\\"\\n }\\n\\n response = self.client.post(self.login_url, updatedlogin_data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n # test if user can login with old password\\n response = self.client.post(self.login_url, self.login_data, format=\\\"json\\\")\\n self.assertNotEqual(response.status_code, status.HTTP_200_OK)\",\n \"async def reset_post_handler(req: web.Request) -> web.Response:\\n db = req.app[\\\"db\\\"]\\n\\n client = req[\\\"client\\\"]\\n\\n form_data = await req.post()\\n\\n password = form_data.get(\\\"password\\\", \\\"\\\")\\n confirm = form_data.get(\\\"confirm\\\", \\\"\\\")\\n verification_key = form_data.get(\\\"verification\\\", None)\\n return_to = get_return_to_from_query(req)\\n\\n # Check that the hidden verification key matches the one attached to the logging-in session. Redirect to `return_to`\\n # URL if verification fails (this will end up on login page with correct query parameter.\\n if not await virtool.db.sessions.check_verification_key(db, client.session_id, verification_key, mode=\\\"reset\\\"):\\n return web.Response(status=302, headers={\\\"Location\\\": return_to})\\n\\n user_id = await virtool.db.utils.get_one_field(db.sessions, \\\"reset_user_id\\\", client.session_id)\\n\\n if not user_id:\\n return web.Response(status=302, headers={\\\"Location\\\": return_to})\\n\\n errors = list()\\n\\n # Re-render the reset page with an error message if the new password is invalid.\\n if password != confirm:\\n errors.append(\\\"Passwords do not match\\\")\\n\\n minimum_password_length = req.app[\\\"settings\\\"][\\\"minimum_password_length\\\"]\\n\\n if len(password) < minimum_password_length:\\n errors.append(f\\\"Password must contain at least {minimum_password_length} characters\\\")\\n\\n if errors:\\n reset_code = await virtool.db.sessions.set_reset_errors(db, client.session_id, errors)\\n return web.Response(status=302, headers={\\\"Location\\\": f\\\"/reset?return_to={return_to}&code={reset_code}\\\"})\\n\\n # Unset all reset page errors.\\n await virtool.db.sessions.set_reset_errors(db, client.session_id)\\n\\n # Update the user password and disable the `force_reset`.\\n await virtool.db.users.edit(db, user_id, force_reset=False, password=password)\\n\\n # Authenticate and return a redirect response to the `return_to` path. This is identical to the process used for\\n # successful login requests.\\n return await auth_response(req, return_to, user_id, False)\",\n \"def password_reset_confirm(request, uidb64, token):\\n uid = force_text(urlsafe_base64_decode(uidb64))\\n user = User.objects.get(pk=uid)\\n try:\\n reset_form = ResetPasswordForm(instance=user)\\n # urlsafe_base64_decode() decodes to bytestring on Python 3\\n except (TypeError, ValueError, OverflowError, user.DoesNotExist):\\n user = None\\n if user is not None and default_token_generator.check_token(user, token):\\n validlink = True\\n title = ('Enter new password')\\n if request.method == 'POST':\\n if 'password-submit' in (request.POST):\\n reset_form = ResetPasswordForm(request.POST,instance=user)\\n password = request.POST.get(\\\"password_reset\\\", None)\\n \\n if reset_form.is_valid():\\n user=reset_form.save(commit = False)\\n user.save()\\n return redirect('password_reset_complete')\\n else:\\n reset_form = ResetPasswordForm(instance=user)\\n else:\\n validlink = False\\n reset_form = ResetPasswordForm(instance=user)\\n title = ('Password reset unsuccessful')\\n return redirect ('invalid_password_link')\\n context = {\\n 'reset_form': ResetPasswordForm,\\n 'title': title,\\n 'validlink': validlink,\\n }\\n return render(request, 'reset_confirm.html', context, {'reset_form': ResetPasswordForm})\",\n \"def set_new_pw_extra_security_token(\\n code: str,\\n password: str,\\n tokenResponse: Optional[str] = None,\\n authenticatorData: Optional[str] = None,\\n clientDataJSON: Optional[str] = None,\\n credentialId: Optional[str] = None,\\n signature: Optional[str] = None,\\n) -> FluxData:\\n data = _load_data(code, password)\\n if data.error:\\n return error_response(message=data.error)\\n\\n # Process POSTed data\\n success = False\\n if tokenResponse:\\n # CTAP1/U2F\\n token_response = request.get_json().get('tokenResponse', '')\\n current_app.logger.debug(f'U2F token response: {token_response}')\\n\\n _challenge = session.get(SESSION_PREFIX + '.u2f.challenge')\\n if not isinstance(_challenge, bytes):\\n raise TypeError(f'U2F challenge in session is not bytes {repr(_challenge)}')\\n current_app.logger.debug(f'Challenge: {_challenge!r}')\\n\\n result = fido_tokens.verify_u2f(data.user, _challenge, token_response)\\n\\n if result is not None:\\n success = result['success']\\n\\n elif not success and authenticatorData:\\n # CTAP2/Webauthn\\n try:\\n result = fido_tokens.verify_webauthn(\\n data.user,\\n dict(\\n credentialId=credentialId,\\n clientDataJSON=clientDataJSON,\\n authenticatorData=authenticatorData,\\n signature=signature,\\n ),\\n SESSION_PREFIX,\\n )\\n except fido_tokens.VerificationProblem:\\n pass\\n else:\\n success = result['success']\\n\\n else:\\n current_app.logger.error(f'Neither U2F nor Webauthn data in request to authn {data.user}')\\n\\n if not success:\\n return error_response(message=ResetPwMsg.fido_token_fail)\\n\\n current_app.logger.info(f'Resetting password for user {data.user}')\\n reset_user_password(data.user, data.state, password)\\n current_app.logger.info(f'Password reset done, removing state for {data.user}')\\n current_app.password_reset_state_db.remove_state(data.state)\\n return success_response(message=ResetPwMsg.pw_resetted)\",\n \"def post(self):\\n try:\\n body = request.get_json()\\n bearer = request.headers.get('Authorization')\\n base_url = request.url_root\\n token = bearer.split()[1]\\n password = body.get('password')\\n\\n if not token or not password:\\n raise SchemaValidationError\\n\\n user_id = decode_token(token)['sub']['user_id']\\n\\n user = User.objects.get(id=user_id)\\n\\n user.modify(password=password)\\n user.hash_password()\\n user.save()\\n\\n return send_email('[Unboxit] Password reset successful',\\n sender='contact@tsantos.dev',\\n recipients=[user.email],\\n text_body='Password Reset',\\n html_body=render_template(\\n 'components/reset_password_response.html',\\n first_name=user.first_name,\\n base_url=base_url))\\n\\n except SchemaValidationError:\\n raise SchemaValidationError\\n except ExpiredSignatureError:\\n raise ExpiredTokenError\\n except (DecodeError, InvalidTokenError):\\n raise BadTokenError\\n except Exception as e:\\n raise InternalServerError\",\n \"def login_reset():\\n # Start with the currently logged in user\\n\\n if request.method == \\\"GET\\\":\\n # In browser request that user wants to reset the password\\n # Create a token\\n # Send out an email\\n #\\n return flask.render_template('profile.html', name=session[\\\"user\\\"][\\\"label\\\"], email=session[\\\"user\\\"][\\\"email\\\"])\\n\\n if request.method == \\\"POST\\\":\\n # In browser request that user wants to reset the password\\n label = flask.request.form[\\\"label\\\"]\\n passwd = flask.request.form[\\\"passwd\\\"]\\n\\n # Verify that the user is logged in or return\\n if not session.has_key(\\\"user\\\"):\\n return flask.Response('{\\\"error\\\" : \\\"User not logged in\\\" }')\\n else:\\n # Chagne the information in the session\\n session[\\\"user\\\"][\\\"label\\\"] = label\\n # Locate the record\\n conn.register([model.User])\\n dbobj = conn[current_app.config[\\\"CONFIGDB\\\"]]\\n userdoc = dbobj[\\\"users\\\"].User.find_one({'_id' : ObjectId(session[\\\"user\\\"][\\\"id\\\"])})\\n userdoc[\\\"passwd\\\"] = passwd\\n userdoc[\\\"password_status\\\"] = \\\"ready\\\"\\n userdoc[\\\"label\\\"] = label\\n userdoc.validate()\\n userdoc.save()\\n\\n return flask.Response('{\\\"success\\\" : \\\"\\\" }')\",\n \"def test_request_reset(mock_save, api_client, password_reset_token_factory):\\n token = password_reset_token_factory()\\n data = {\\\"key\\\": token.key, \\\"password\\\": \\\"new_passw0rd\\\"}\\n\\n response = api_client.post(url, data)\\n\\n assert response.status_code == status.HTTP_200_OK\\n assert mock_save.call_count == 1\",\n \"def send_token(user):\\n if 'research' in user.get_domains():\\n domain = 'research'\\n else: domain = 'academic'\\n subject = \\\"ECE/CIS Password Reset\\\"\\n url = \\\"https://www.eecis.udel.edu/accounts/reset_password/token/%s\\\" % user.token\\n message = \\\"A request has been made for a password reset for your ECE/CIS %s account: %s\\\\n\\\\n\\\" % (domain, user.username)\\n message += \\\"To reset your password, please visit the follow the reset link below:\\\\n\\\\n%s\\\\n\\\" % url\\n message += \\\"This token will expire 30 minutes after the initial request was made\\\\n\\\\n\\\"\\n message += \\\"If this is not your ECE/CIS username, or you did not request a password reset, please\\\\n\\\"\\n message += \\\"submit a Help Request at https://www.eecis.udel.edu/helprequest\\\\n\\\\nECE/CIS Labstaff\\\"\\n\\n send('account@eecis.udel.edu', 'ECE/CIS Account System', \\\\\\n [user.email], subject, message, MAILHOST)\",\n \"def post(self):\\n try:\\n url = request.host_url + 'reset/password/'\\n body = request.get_json()\\n base_url = request.url_root\\n email = body.get('email')\\n\\n if not email:\\n raise SchemaValidationError\\n\\n user = User.objects.get(email=email)\\n if not user:\\n raise EmailDoesNotExistsError\\n\\n expires = datetime.timedelta(minutes=60)\\n payload = {\\\"user_id\\\": str(user.id)}\\n reset_token = create_access_token(payload, expires_delta=expires)\\n\\n return send_email('[Unboxit] Reset Your Password',\\n sender='contact@tsantos.dev',\\n recipients=[user.email],\\n text_body=render_template(\\n 'components/reset_password.txt',\\n url=url + reset_token),\\n html_body=render_template(\\n 'components/reset_password.html',\\n url=url + reset_token,\\n first_name=user.first_name,\\n base_url=base_url))\\n except SchemaValidationError:\\n raise SchemaValidationError\\n except DoesNotExist:\\n raise EmailDoesNotExistsError\\n except Exception as e:\\n raise InternalServerError\",\n \"def password_reset_confirm_wrapper(\\r\\n request,\\r\\n uidb36=None,\\r\\n token=None,\\r\\n):\\r\\n # cribbed from django.contrib.auth.views.password_reset_confirm\\r\\n try:\\r\\n uid_int = base36_to_int(uidb36)\\r\\n user = User.objects.get(id=uid_int)\\r\\n user.is_active = True\\r\\n user.save()\\r\\n except (ValueError, User.DoesNotExist):\\r\\n pass\\r\\n\\r\\n # tie in password strength enforcement as an optional level of\\r\\n # security protection\\r\\n err_msg = None\\r\\n\\r\\n if request.method == 'POST':\\r\\n password = request.POST['new_password1']\\r\\n if settings.FEATURES.get('ENFORCE_PASSWORD_POLICY', False):\\r\\n try:\\r\\n validate_password_length(password)\\r\\n validate_password_complexity(password)\\r\\n validate_password_dictionary(password)\\r\\n except ValidationError, err:\\r\\n err_msg = _('Password: ') + '; '.join(err.messages)\\r\\n\\r\\n # also, check the password reuse policy\\r\\n if not PasswordHistory.is_allowable_password_reuse(user, password):\\r\\n if user.is_staff:\\r\\n num_distinct = settings.ADVANCED_SECURITY_CONFIG['MIN_DIFFERENT_STAFF_PASSWORDS_BEFORE_REUSE']\\r\\n else:\\r\\n num_distinct = settings.ADVANCED_SECURITY_CONFIG['MIN_DIFFERENT_STUDENT_PASSWORDS_BEFORE_REUSE']\\r\\n err_msg = _(\\\"You are re-using a password that you have used recently. You must \\\"\\r\\n \\\"have {0} distinct password(s) before reusing a previous password.\\\").format(num_distinct)\\r\\n\\r\\n # also, check to see if passwords are getting reset too frequent\\r\\n if PasswordHistory.is_password_reset_too_soon(user):\\r\\n num_days = settings.ADVANCED_SECURITY_CONFIG['MIN_TIME_IN_DAYS_BETWEEN_ALLOWED_RESETS']\\r\\n err_msg = _(\\\"You are resetting passwords too frequently. Due to security policies, \\\"\\r\\n \\\"{0} day(s) must elapse between password resets\\\").format(num_days)\\r\\n\\r\\n if err_msg:\\r\\n # We have an password reset attempt which violates some security policy, use the\\r\\n # existing Django template to communicate this back to the user\\r\\n context = {\\r\\n 'validlink': True,\\r\\n 'form': None,\\r\\n 'title': _('Password reset unsuccessful'),\\r\\n 'err_msg': err_msg,\\r\\n }\\r\\n return TemplateResponse(request, 'registration/password_reset_confirm.html', context)\\r\\n else:\\r\\n # we also want to pass settings.PLATFORM_NAME in as extra_context\\r\\n extra_context = {\\\"platform_name\\\": settings.PLATFORM_NAME}\\r\\n\\r\\n if request.method == 'POST':\\r\\n # remember what the old password hash is before we call down\\r\\n old_password_hash = user.password\\r\\n\\r\\n result = password_reset_confirm(\\r\\n request, uidb36=uidb36, token=token, extra_context=extra_context\\r\\n )\\r\\n\\r\\n # get the updated user\\r\\n updated_user = User.objects.get(id=uid_int)\\r\\n\\r\\n # did the password hash change, if so record it in the PasswordHistory\\r\\n if updated_user.password != old_password_hash:\\r\\n entry = PasswordHistory()\\r\\n entry.create(updated_user)\\r\\n\\r\\n return result\\r\\n else:\\r\\n return password_reset_confirm(\\r\\n request, uidb36=uidb36, token=token, extra_context=extra_context\\r\\n )\",\n \"def post(self):\\n data = request.get_json()\\n user = actions.get_user_by_email(data['email'])\\n html = '<p>To reset your password </p>'\\n subject = 'Request for changing password, ' + user['username']\\n actions.send_email(data['email'], user['username'], user['password'], subject,\\n '/reset_password/', html, False)\\n pass\",\n \"def reset_token(sender, instance, **kwargs):\\n new_password = instance.password\\n\\n try:\\n old_password = User.objects.get(pk=instance.pk).password\\n except User.DoesNotExist:\\n old_password = None\\n\\n if new_password != old_password:\\n Token.objects.filter(user=instance).delete()\",\n \"def password_reset(*args, **kwargs):\\n kwargs['password_reset_form'] = CustomPasswordResetForm\\n return django_password_reset(*args, **kwargs)\",\n \"def password_reset(request):\\n\\n\\tcontext_dict = {}\\n\\tif request.method == 'POST':\\n\\t\\temail = request.POST.get('email')\\n\\t\\tif email:\\n\\t\\t\\tuser = models.Teacher.objects.get(\\n\\t\\t\\t\\tsoft_delete=False, user__email=email\\n\\t\\t\\t)\\n\\t\\t\\tif not user:\\n\\t\\t\\t\\tcontext_dict[\\\"message\\\"] = \\\"Email ID does'nt exist, Enter Correct details\\\"\\n\\t\\t\\tmail = {\\n\\t\\t\\t\\t'email': email,\\n\\t\\t\\t\\t'domain': request.META['HTTP_HOST'],\\n\\t\\t\\t\\t'site_name': 'Placement Portal',\\n\\t\\t\\t\\t'uid': urlsafe_base64_encode(force_bytes(user.pk)),\\n\\t\\t\\t\\t'user': user,\\n\\t\\t\\t\\t'token': ''.join([random.choice(ascii_letters+digits) for i in range (128)]),\\n\\t\\t\\t\\t'protocol': 'http',\\n\\t\\t\\t}\\n\\t\\t\\ttry:\\n\\t\\t\\t\\treset_token = models.PasswordReset(\\n\\t\\t\\t\\t\\tuser=user,\\n\\t\\t\\t\\t\\ttoken=mail['token'],\\n\\t\\t\\t\\t\\ttoken_consumed=False,\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\treset_token.save()\\n\\t\\t\\texcept Exception as e:\\n\\t\\t\\t\\tprint (e)\\n\\t\\t\\tsubject_template_name = 'password_reset_email_subject.txt'\\n\\t\\t\\temail_template_name = 'password_reset_email.html'\\n\\t\\t\\tsubject = loader.render_to_string(subject_template_name, mail)\\n\\t\\t\\tsubject = ''.join(subject.splitlines())\\n\\t\\t\\temail_data = loader.render_to_string(email_template_name, mail)\\n\\t\\t\\tsend_mail(subject, email_data, DEFAULT_FROM_EMAIL, [email], fail_silently=False)\\n\\t\\t\\tcontext_dict[\\\"message\\\"] = \\\"Email has been sent to your registered Email ID with instructions.\\\"\\n\\treturn render(request, \\\"password_reset_form.html\\\", context_dict)\",\n \"def test_password_reset(client, models):\\n user = models[\\\"user\\\"][0]\\n encoded_token = user.get_reset_token()\\n new_password = \\\"password\\\"\\n response = client.post(\\n f\\\"/password/reset/{encoded_token}\\\", json={\\\"password\\\": new_password}\\n )\\n assert response.status_code == 200\\n assert user.check_password(new_password)\",\n \"def reset_token(self, reset_token):\\n\\n self._reset_token = reset_token\",\n \"def reset_password(token):\\n\\n expired, invalid, user = reset_password_token_status(token)\\n\\n if invalid:\\n return redirect(url_for('frontend.forgot_password') + '?invalid')\\n elif expired:\\n send_reset_password_instructions(user)\\n return redirect(url_for('frontend.forgot_password') + '?expired')\\n elif request.method == 'GET':\\n return redirect(url_for('frontend.reset_password', token=token))\\n\\n form = _security.reset_password_form()\\n\\n if form.validate_on_submit():\\n after_this_request(_commit)\\n update_password(user, form.newPassword.data)\\n login_user(user)\\n else:\\n return jsonify({'errors': form.errors}), HTTPStatus.BAD_REQUEST\\n\\n return jsonify({\\n 'token': user.get_auth_token(),\\n 'user': user,\\n })\",\n \"def test_reset_passwd(self, test_client, user_test1):\\n response = test_client.post('/api/auth/reset', json=dict(\\n reset_password_token=create_access_token(identity=user_test1),\\n password=\\\"Azerty!123\\\"\\n ))\\n res = json.loads(response.data)\\n\\n assert response.status_code == 200\\n assert res['status'] == True\",\n \"def password_reset(request):\\n host = settings.TACC_USER_PORTAL_HOST\\n return redirect(f\\\"{host}/password-reset?{urlencode(request.GET)}\\\")\",\n \"def change_password(self, reset_token, new_password_hash):\\n try:\\n self.logger.debug('change_password running')\\n nosqldb = self.pers.nosql_db\\n reset_request = nosqldb['passwordResets'].find_one(\\n {'resetToken': reset_token}\\n )\\n\\n if reset_request:\\n self.logger.debug('reset request match')\\n nosqldb['users'].update_one(\\n {\\n 'username': reset_request['username']\\n },\\n {\\n '$set': {'passwdHash': new_password_hash}\\n }\\n\\n\\n )\\n else:\\n self.logger.debug('reset request mismatch, nothing changed')\\n except Exception as exc:\\n self.logger.debug('Unexpected Error %s', str(exc))\\n raise\",\n \"def send_password_reset_mail(email, token):\\n print(\\\"reset password\\\")\\n url = f\\\"{settings.SITE_URL}/reset-password?email={email}&token={token}\\\"\\n SUBJECT = \\\"Reset Password Request\\\"\\n # The HTML body of the email.\\n body = \\\"\\\"\\\"\\n <html>\\n <head></head>\\n <body>\\n <p>Here is your password reset link:</p>\\n <p><a href='{0}'>{1}</a></p>\\n </body>\\n </html>\\n \\\"\\\"\\\".format(url, url)\\n send_mail(SUBJECT, body, email)\",\n \"def test_reset_user(self):\\n\\n user = fake_clients.FakeUser(\\n name=\\\"test@example.com\\\", password=\\\"123\\\", email=\\\"test@example.com\\\"\\n )\\n\\n setup_identity_cache(users=[user])\\n\\n url = \\\"/v1/actions/ResetPassword\\\"\\n data = {\\\"email\\\": \\\"test@example.com\\\"}\\n response = self.client.post(url, data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\\n self.assertEqual(\\n response.json()[\\\"notes\\\"],\\n [\\\"If user with email exists, reset token will be issued.\\\"],\\n )\\n\\n new_token = Token.objects.all()[0]\\n url = \\\"/v1/tokens/\\\" + new_token.token\\n data = {\\\"password\\\": \\\"new_test_password\\\"}\\n response = self.client.post(url, data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(user.password, \\\"new_test_password\\\")\",\n \"def password_reset_confirm(request, uidb36=None, token=None,\\n template_name='gallery/password_reset_confirm.html',\\n token_generator=default_token_generator,\\n set_password_form=SetPasswordForm,\\n post_reset_redirect=None):\\n assert uidb36 is not None and token is not None # checked by URLconf\\n if post_reset_redirect is None:\\n post_reset_redirect = reverse('django.contrib.auth.views.password_reset_complete')\\n try:\\n uid_int = base36_to_int(uidb36)\\n except ValueError:\\n raise HttpResponseNotFound\\n\\n user = get_object_or_404(authmodels.User, id=uid_int)\\n context_instance = RequestContext(request)\\n\\n if token_generator.check_token(user, token):\\n context_instance['validlink'] = True\\n if request.method == 'POST':\\n form = set_password_form(user, request.POST)\\n if form.is_valid():\\n # we can't use form.save b/c that will update the p/w on the\\n # model object, we need to do it in LDAP\\n if settings.USE_LDAP:\\n ldapper = get_ldap_connection()\\n dn = get_user_dn(user.username)\\n new_password = request.POST.get('new_password1')\\n ldapper.passwd_s(dn, None, new_password)\\n ldapper.unbind_s()\\n request.notifications.add(_('Password change successful.'))\\n else:\\n form.save()\\n return HttpResponseRedirect(post_reset_redirect)\\n else:\\n form = set_password_form(None)\\n else:\\n context_instance['validlink'] = False\\n form = None\\n context_instance['form'] = form\\n return render_to_response(template_name, context_instance=context_instance)\",\n \"def reset_password_token(email: str) -> str:\\n data = {'email': email}\\n response = requests.post(f'{URL}/reset_password', data=data)\\n assert response.status_code == 200\\n token = response.json()\\n return token.get('reset_token')\",\n \"def get_passreset_token(self, expiration_secs=1800):\\n\\t\\treturn jwt_encode({'reset_pass': self.id, 'exp': time() + expiration_secs},\\n\\t\\t\\tapp.config['SECRET_KEY'], algorithm=\\\"HS256\\\").decode('utf-8')\",\n \"async def password(self, ctx):\\n pass\",\n \"def change_password(reset_code):\\n return dict(reset_code=reset_code)\",\n \"def GET(self):\\n session = web.ctx.session\\n nav = get_nav_bar(session)\\n self.token = web.input().reset_token\\n return render.reset_password(nav, reset_password_form, \\\"\\\")\",\n \"def forgot_passwd_check(request, uidb64=None, token=None):\\n assert uidb64 is not None and token is not None\\n dc1_settings = DefaultDc().settings\\n sms_registration = dc1_settings.SMS_REGISTRATION_ENABLED\\n\\n if sms_registration:\\n set_password_form = SMSSendPasswordResetForm\\n else:\\n set_password_form = PasswordResetForm\\n\\n if request.method == 'POST':\\n try:\\n user = User.objects.get(id=urlsafe_base64_decode(uidb64))\\n profile = user.userprofile\\n except (ValueError, OverflowError, User.DoesNotExist):\\n profile = None\\n\\n if profile and profile.email_token == token:\\n # Email address is verified, we cant compare to token as register token is different to reset one.\\n profile.email_token = ''\\n profile.email_verified = True\\n # This may look strange - setting the phone_verified before the user logs in. It is not :) We are sending\\n # new password to phone number in profile, after the user logs in we would set phone_verified to True anyway\\n if sms_registration:\\n profile.phone_verified = True\\n profile.save()\\n\\n return password_reset_confirm(\\n request,\\n uidb64=uidb64,\\n token=token,\\n template_name='gui/accounts/forgot_check.html',\\n set_password_form=set_password_form,\\n post_reset_redirect=reverse('forgot_check_done'),\\n current_app='gui',\\n extra_context={\\n 'sms_registration': sms_registration,\\n }\\n )\",\n \"def generate_password_reset_token(self, expiration=3600):\\n app = current_app._get_current_object()\\n serializer = Serializer(app.config[\\\"SECRET_KEY\\\"], expiration)\\n return serializer.dumps({\\\"reset\\\": self.id}).decode(\\\"utf-8\\\")\",\n \"def make_reset_token(self, expiration=3600):\\n return self._make_token({'id': self.id, 'op': 'reset'}, expiration)\",\n \"def recover_password_token(pw_token: bytes):\\n current_time = int(time.time())\\n for ut in range(current_time - 3700, current_time):\\n if generate_password_reset_token(ut) == pw_token:\\n return ut\",\n \"def test_staff_password_reset_reuse(self):\\r\\n staff_email, _ = self._setup_user(is_staff=True)\\r\\n user = User.objects.get(email=staff_email)\\r\\n\\r\\n err_msg = 'You are re-using a password that you have used recently. You must have 2 distinct password(s)'\\r\\n success_msg = 'Your Password Reset is Complete'\\r\\n\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n # try to do a password reset with the same password as before\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foo',\\r\\n 'new_password2': 'foo',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertIn(\\r\\n err_msg,\\r\\n resp.content\\r\\n )\\r\\n\\r\\n # now use different one\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'bar',\\r\\n 'new_password2': 'bar',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertIn(\\r\\n success_msg,\\r\\n resp.content\\r\\n )\\r\\n\\r\\n # now try again with the first one\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foo',\\r\\n 'new_password2': 'foo',\\r\\n }, follow=True)\\r\\n\\r\\n # should be rejected\\r\\n self.assertIn(\\r\\n err_msg,\\r\\n resp.content\\r\\n )\\r\\n\\r\\n # now use different one\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'baz',\\r\\n 'new_password2': 'baz',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertIn(\\r\\n success_msg,\\r\\n resp.content\\r\\n )\\r\\n\\r\\n # now we should be able to reuse the first one\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foo',\\r\\n 'new_password2': 'foo',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertIn(\\r\\n success_msg,\\r\\n resp.content\\r\\n )\",\n \"def generate_password_reset_token(self, expiration=3600):\\n s = Serializer(current_app.config['SECRET_KEY'], expiration)\\n return s.dumps({'reset': self.id})\",\n \"def test_dietitian_reset_password(self):\\n\\n data = {\\\"password\\\": \\\"newpass\\\"}\\n result = self.client.post(\\\"/dietitian/1/account/reset-password\\\", \\n data=data, follow_redirects=True)\\n\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"successfully reset\\\", result.data)\",\n \"def verify_reset_token(self, token):\\n\\n expired, invalid, data = self._verify_token(token)\\n if data and data.get('id') == self.id and data.get('op') == 'reset':\\n data = True\\n else:\\n data = False\\n return expired, invalid, data\",\n \"def password_reset(request):\\n\\tif not request.user.is_authenticated():\\n\\t\\treturn django.contrib.auth.views.password_reset(request,\\n template_name='usermgr/password_reset_form.html',\\n email_template_name= 'usermgr/password_reset_email.html',\\n post_reset_redirect='/usermgr/password_reset/done/')\\n\\telse:\\n\\t\\treturn HttpResponseRedirect(settings.LOGIN_REDIRECT_URL)\",\n \"def config_reset_pw(code: str) -> FluxData:\\n current_app.logger.info(f'Configuring password reset form for {code}')\\n try:\\n state = get_pwreset_state(code)\\n except BadCode as e:\\n return error_response(message=e.msg)\\n\\n verify_email_address(state)\\n\\n new_password = generate_suggested_password()\\n session.reset_password.generated_password_hash = hash_password(new_password)\\n\\n user = current_app.central_userdb.get_user_by_eppn(state.eppn)\\n alternatives = get_extra_security_alternatives(user, SESSION_PREFIX)\\n state.extra_security = alternatives\\n current_app.password_reset_state_db.save(state)\\n\\n return success_response(\\n payload={\\n 'csrf_token': session.get_csrf_token(),\\n 'suggested_password': new_password,\\n 'email_code': state.email_code.code,\\n 'email_address': state.email_address,\\n 'extra_security': mask_alternatives(alternatives),\\n 'password_entropy': current_app.config.password_entropy,\\n 'password_length': current_app.config.password_length,\\n 'password_service_url': current_app.config.password_service_url,\\n 'zxcvbn_terms': get_zxcvbn_terms(state.eppn),\\n },\\n )\",\n \"def test_reset_user_duplicate(self):\\n\\n user = fake_clients.FakeUser(\\n name=\\\"test@example.com\\\", password=\\\"123\\\", email=\\\"test@example.com\\\"\\n )\\n\\n setup_identity_cache(users=[user])\\n\\n # Submit password reset\\n url = \\\"/v1/actions/ResetPassword\\\"\\n data = {\\\"email\\\": \\\"test@example.com\\\"}\\n response = self.client.post(url, data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\\n self.assertEqual(\\n response.json()[\\\"notes\\\"],\\n [\\\"If user with email exists, reset token will be issued.\\\"],\\n )\\n\\n # Verify the first token doesn't work\\n first_token = Token.objects.all()[0]\\n\\n # Submit password reset again\\n response = self.client.post(url, data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)\\n self.assertEqual(\\n response.json()[\\\"notes\\\"],\\n [\\\"If user with email exists, reset token will be issued.\\\"],\\n )\\n\\n # confirm the old toke has been cleared:\\n second_token = Token.objects.all()[0]\\n self.assertNotEqual(first_token.token, second_token.token)\\n\\n # Now reset with the second token\\n url = \\\"/v1/tokens/\\\" + second_token.token\\n data = {\\\"password\\\": \\\"new_test_password2\\\"}\\n response = self.client.post(url, data, format=\\\"json\\\")\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(user.password, \\\"new_test_password2\\\")\",\n \"def test_password_policy_on_password_reset(self):\\r\\n staff_email, _ = self._setup_user(is_staff=True, password='foofoo')\\r\\n\\r\\n success_msg = 'Your Password Reset is Complete'\\r\\n\\r\\n # try to reset password, it should fail\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n # try to do a password reset with the same password as before\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foo',\\r\\n 'new_password2': 'foo',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertNotIn(\\r\\n success_msg,\\r\\n resp.content\\r\\n )\\r\\n\\r\\n # try to reset password with a long enough password\\r\\n user = User.objects.get(email=staff_email)\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n # try to do a password reset with the same password as before\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foofoo',\\r\\n 'new_password2': 'foofoo',\\r\\n }, follow=True)\\r\\n\\r\\n self.assertIn(\\r\\n success_msg,\\r\\n resp.content\\r\\n )\",\n \"def post(self):\\n args = password_reset.parse_args()\\n email = args.get('email')\\n new_password = password_generator()\\n\\n validation_email = email_validation(email)\\n if validation_email:\\n return validation_email\\n\\n user = User.query.filter_by(email=email).first()\\n if user:\\n user.password = new_password\\n user.save()\\n response = {\\n \\\"message\\\": \\\"Password has been reset\\\",\\n \\\"status\\\": \\\"Reset password succesful!\\\",\\n \\\"new_password\\\": new_password\\n }\\n return response, 200\\n else:\\n response = {\\n 'message': 'User email does not exist, Please try again',\\n 'status': 'Reset password failed!'\\n }\\n return response, 400\",\n \"def step_impl(context):\\n fields = {\\n 'grant_type': 'refresh_token',\\n 'refresh_token': context.oauth.refresh_token,\\n 'scope': context.vendor_config['auth']['scope'],\\n }\\n\\n context.response = token_request(fields,\\n context.vendor_config['auth'],\\n context.conformance)\",\n \"def generate_forgot_password_token(self, email):\\n payload = {'appkey': self._lr_object._get_api_key(), 'appsecret': self._lr_object._get_api_secret(),\\n 'email': email}\\n url = SECURE_API_URL + \\\"raas/v1/account/password/forgot\\\"\\n return self._lr_object._get_json(url, payload)\",\n \"def send_recovery_password_email(token: str, email: str) -> None:\\n\\n # TODO ...\\n # Load html templates and get the content from it.\\n # html_content = ...\\n\\n # You must have to send this as a anchor\\n # to my-domain.com/reset-password?token=ad5a....\\n link = f\\\"{SERVER_HOST}/reset-password?token={token}\\\"\\n content = f\\\"\\\"\\\"\\n <h1>Reset your password</h1>\\n <p></p>\\n <a href=\\\"{link}\\\" target=\\\"_blank\\\" rel=\\\"noopener noreferrer\\\">Press here</a>\\n \\\"\\\"\\\"\\n email = sender.create_email(\\n to_list=[email],\\n subject=f\\\"Recovery Password\\\",\\n html_content=content,\\n )\\n sender.send_email(email_to_send=email)\",\n \"def test_request_password_reset(live_server, mailoutbox, settings):\\n reset_url_template = \\\"http://localhost/reset-password/{key}\\\"\\n settings.EMAIL_AUTH = {\\\"PASSWORD_RESET_URL\\\": reset_url_template}\\n\\n user = get_user_model().objects.create_user(username=\\\"Test User\\\")\\n email = models.EmailAddress.objects.create(\\n address=\\\"test@example.com\\\", is_verified=True, user=user\\n )\\n\\n data = {\\\"email\\\": email.address}\\n url = f\\\"{live_server}/rest/password-reset-requests/\\\"\\n response = requests.post(url, data)\\n\\n assert response.status_code == 201\\n assert response.json() == data\\n assert len(mailoutbox) == 1\\n\\n msg = mailoutbox[0]\\n reset = models.PasswordReset.objects.get()\\n\\n assert msg.to == [data[\\\"email\\\"]]\\n assert reset_url_template.format(key=reset.token) in msg.body\",\n \"def reset_password():\\n if current_user.is_authenticated:\\n return redirect(url_for('main.home'))\\n\\n form = RequestResetForm()\\n\\n if form.validate_on_submit():\\n user = User.query.filter_by(email=form.email.data).first()\\n send_reset_email(user) # located in utils.py\\n flash('An email has been sent with instruction to reset your password', 'info')\\n return redirect(url_for('users.login'))\\n\\n return render_template('reset_password_request.html', form=form)\",\n \"def generate_reset_password_token(self, expiration=3600):\\n ser = Serializer(current_app.config['SECRET_KEY'], expiration)\\n return ser.dumps({'reset_password': self.id}).decode('utf-8')\",\n \"def test_patient_reset_password(self):\\n\\n data = {\\\"password\\\": \\\"newpass\\\"}\\n result = self.client.post(\\\"/patient/1/account/reset-password\\\", \\n data=data, follow_redirects=True)\\n\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"successfully reset\\\", result.data)\",\n \"def test_user_can_reset_password(self):\\n # first register a user\\n self.register_user()\\n # registered user forgets password \\n # its a post request with the user email as the payload\\n response = self.client().post(AuthTestCase.reset, data=self.reset_email)\\n self.assertIn(\\\"Password successfully reset.Check email for new password\\\", str(response.data))\",\n \"def test_reset_passwd_bad_token(self, test_client):\\n response = test_client.post('/api/auth/reset', json=dict(\\n reset_password_token=str(\\n create_access_token(identity=UserModel(uuid=uuid.uuid4()))),\\n password=\\\"Azerty!123\\\"))\\n res = json.loads(response.data)\\n\\n assert response.status_code == 401\\n assert res['status'] == False\",\n \"def test_reset_password_fails_for_missing_parameters(self):\\n self.test_client.post(\\n \\\"/api/v1/auth/register\\\", data=self.user_data)\\n\\n resp = self.test_client.post(\\n \\\"/api/v1/auth/login\\\",\\n data=self.user_data)\\n\\n data = json.loads(resp.data)\\n token = data['token']\\n\\n resp = self.test_client.post(\\n \\\"/api/v1/auth/reset-password\\\",\\n headers=dict(Authorization=f'Bearer {token}'))\\n\\n self.assertEqual(resp.status_code, 400)\\n data = json.loads(resp.data)\\n self.assertEqual(data[\\\"status\\\"], \\\"failure\\\")\\n self.assertEqual(\\n data[\\\"message\\\"],\\n \\\"the fields 'password' and 'confirm password' are required\\\")\",\n \"def auth_token(self):\",\n \"def reset_password():\\n json_data = request.get_json()\\n user_email = json_data.get('email') or None\\n\\n if user_email is None:\\n raise BadRequest(description=INCORRECT_RESET_PARAMS_MSG)\\n\\n user_account = db.session.query(UserAccount).filter(\\n UserAccount.email == user_email).first()\\n if user_account is None:\\n raise BadRequest(description=INCORRECT_RESET_PARAMS_MSG)\\n\\n # Generate password hash\\n temp_password = str(random.randint(10000,99999))\\n update_user = {'password_hashed': get_hashed_password(temp_password)}\\n user_account.update(**update_user)\\n user_account.save()\\n\\n email.send('reset_password', user_email, temp_password)\\n\\n return {'status_code': 200, 'message': 'Password reset success!'}\",\n \"def start_reset_password_process_step_2(self):\\n # fill in the form with no error\\n email_field = self.driver.find_element_by_id(\\\"id_email\\\")\\n email_field.send_keys(\\\"toto@mail.com\\\")\\n submit_button = self.driver.find_element_by_id(\\\"submit-id-submit\\\")\\n submit_button.click()\\n # wait for email receiving\\n actions = ActionChains(self.driver)\\n actions.pause(1)\\n actions.perform()\\n # test that one message has been sent\\n self.assertEqual(len(mail.outbox), 1)\\n # get the mail content\\n mail_content = mail.outbox[0].body\\n # extract \\\"reset password link\\\"\\n match = re.search(\\n \\\"choisir un nouveau mot de passe :\\\\n(.*)\\\\nPour mémoire\\\",\\n mail_content\\n )\\n return match\",\n \"def user_password_reset(self, request):\\n reset_password_form = ResetPasswordForm(request.form)\\n\\n if request.method == \\\"POST\\\":\\n if reset_password_form.validate_on_submit():\\n if check_password_hash(current_user.password, reset_password_form.old_password.data):\\n new_hashed_password = generate_password_hash(reset_password_form.password.data)\\n\\n temp = current_user.get_id()\\n (role, email) = temp.split(\\\":\\\")\\n\\n # if first element is `sysadmin` instead of a scheme_id\\n # call function to reset `sysadmin` pass\\n if role == \\\"sysadmin\\\":\\n self._scheme_handler.update_hash_password(email, new_hashed_password)\\n else:\\n # regular user reset\\n self._student_handler.update_hash_password(current_user.scheme_id, current_user.k_number, new_hashed_password)\\n\\n flash(\\\"Password successfully updated\\\")\\n else:\\n flash(\\\"Old password incorrect\\\")\\n else:\\n flash(\\\"Please double check your new password is valid.\\\")\\n \\n return render_template(\\\"user/reset_password.html\\\", reset_password_form=reset_password_form)\",\n \"def get_password_reset_token(known_plaintext, current_time):\\n return encryption_oracle(known_plaintext, current_time)[1].encode('hex')\",\n \"def test_reset_password(client, admin_user):\\n # Step 1: Password reset form\\n url = reverse(\\\"admin_password_reset\\\")\\n\\n response = client.get(url)\\n templates_used = [t.name for t in response.templates]\\n\\n assert response.status_code == 200\\n assert templates_used == [\\n \\\"registration/password_reset_form.html\\\",\\n \\\"registration/base.html\\\",\\n ]\\n\\n # Step 2: Password reset done\\n response = client.post(\\n url,\\n data={\\\"email\\\": admin_user.email},\\n follow=True,\\n )\\n templates_used = [t.name for t in response.templates]\\n\\n assert response.status_code == 200\\n assert response.resolver_match.url_name == \\\"password_reset_done\\\"\\n assert templates_used == [\\n \\\"registration/password_reset_done.html\\\",\\n \\\"registration/base.html\\\",\\n ]\\n assert \\\"We’ve emailed you instructions for setting your password\\\" in response.content.decode()\\n\\n # Get password reset link from reset email\\n email = django.core.mail.outbox[0]\\n url = re.search(r\\\"https?://[^/]*(/.*reset/\\\\S*)\\\", email.body).group(1)\\n\\n # Step 3: Password reset confirm\\n response = client.get(url, follow=True)\\n templates_used = [t.name for t in response.templates]\\n\\n assert response.status_code == 200\\n assert response.resolver_match.url_name == \\\"password_reset_confirm\\\"\\n assert templates_used == [\\n \\\"registration/password_reset_confirm.html\\\",\\n \\\"registration/base.html\\\",\\n ]\\n\\n # Step 4: Password reset complete\\n response = client.post(\\n response.request[\\\"PATH_INFO\\\"],\\n data={\\\"username\\\": admin_user.username, \\\"new_password1\\\": \\\"new_password\\\", \\\"new_password2\\\": \\\"new_password\\\"},\\n follow=True,\\n )\\n templates_used = [t.name for t in response.templates]\\n\\n assert response.status_code == 200\\n assert response.resolver_match.url_name == \\\"password_reset_complete\\\"\\n assert templates_used == [\\n \\\"registration/password_reset_complete.html\\\",\\n \\\"registration/base.html\\\",\\n ]\\n assert \\\"Your password has been set.\\\" in response.content.decode()\",\n \"def forgot_passwd(request):\\n dc_settings = request.dc.settings\\n\\n return password_reset(\\n request,\\n template_name='gui/accounts/forgot.html',\\n email_template_name='gui/accounts/forgot_email.txt',\\n subject_template_name='gui/accounts/forgot_subject.txt',\\n password_reset_form=partial(ForgotForm, request),\\n post_reset_redirect=reverse('forgot_done'),\\n from_email=dc_settings.DEFAULT_FROM_EMAIL,\\n current_app='gui',\\n extra_context={\\n 'e_site_name': dc_settings.SITE_NAME,\\n 'e_site_link': dc_settings.SITE_LINK,\\n })\",\n \"def init_reset_pw(email: str) -> FluxData:\\n current_app.logger.info(f'Trying to send password reset email to {email}')\\n try:\\n send_password_reset_mail(email)\\n except BadCode as error:\\n current_app.logger.error(f'Sending password reset e-mail for {email} failed: {error}')\\n return error_response(message=error.msg)\\n\\n return success_response(message=ResetPwMsg.send_pw_success)\",\n \"def test_allow_all_password_reuse(self):\\r\\n student_email, _ = self._setup_user()\\r\\n user = User.objects.get(email=student_email)\\r\\n\\r\\n err_msg = 'You are re-using a password that you have used recently.'\\r\\n\\r\\n token = default_token_generator.make_token(user)\\r\\n uidb36 = int_to_base36(user.id)\\r\\n\\r\\n # try to do a password reset with the same password as before\\r\\n resp = self.client.post('/password_reset_confirm/{0}-{1}/'.format(uidb36, token), {\\r\\n 'new_password1': 'foo',\\r\\n 'new_password2': 'foo'\\r\\n }, follow=True)\\r\\n\\r\\n self.assertNotIn(\\r\\n err_msg,\\r\\n resp.content\\r\\n )\",\n \"def test_successful_password_change(self):\\n token = str((jwt.encode(\\n {\\\"email\\\": \\\"bagendadeogracious@gmail.com\\\"}, settings.SECRET_KEY)).decode('utf-8'))\\n self.client.post(self.registration_url, valid_user, format='json')\\n response = self.client.patch(\\n self.change_password_url+\\\"?token=\\\"+token,\\n {\\\"password\\\": \\\"bagenda1234\\\"},\\n format='json'\\n )\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(\\n response.data['message'],\\n \\\"you have reset your password successfully.\\\"\\n )\",\n \"def reset_password(self, request):\\n password = request.data['password']\\n forgot_password_hash = request.data['uuid']\\n url_expired_response = Response(\\n {\\\"message\\\": 'Password reset url expired'}, status=status.HTTP_400_BAD_REQUEST)\\n\\n try:\\n user = CurationUser.objects.get(\\n forgot_password_hash=forgot_password_hash)\\n\\n # get pwd_expiry_cycle_days value from admin_settings table\\n pwd_expiry_cycle_days = get_password_expiry_cycle_days()\\n\\n if user is None:\\n return url_expired_response\\n if user.forgot_password_hash_expiry_on.isoformat() < datetime.now().isoformat():\\n return url_expired_response\\n\\n successs_response = {\\n \\\"message\\\": \\\"password set successfully\\\"\\n }\\n\\n mfaUrl = self._get_mfa_uri(user.email, user.otp_secret_key)\\n\\n if (not user.is_active and user.mfa_type == CurationUser.MfaType.google) or user.is_staff:\\n successs_response[\\\"mfaUrl\\\"] = mfaUrl\\n\\n # if password reset is requrested by admin then reset the otp secret key and return mfa_url\\n if user.reset_password_requested_by is not None:\\n reset_password_requested_by = UserSerializer(\\n user.reset_password_requested_by).data\\n reset_password_requested_by_user_group = reset_password_requested_by.get('groups')[0]\\n admin_group = Group.objects.get(name='admin')\\n\\n if admin_group is not None \\\\\\n and admin_group.name == reset_password_requested_by_user_group.get('name') \\\\\\n and user.mfa_type == CurationUser.MfaType.google:\\n successs_response[\\\"mfaUrl\\\"] = mfaUrl\\n\\n if can_update_user_password(user, password):\\n user.update_password(password, pwd_expiry_cycle_days)\\n user.is_active = True\\n user.reset_password_requested_by = None\\n user.forgot_password_hash = None\\n user.forgot_password_hash_expiry_on = None\\n return Response(successs_response, status=status.HTTP_200_OK)\\n else:\\n error_response = {'errors': {}}\\n error_response['errors']['new_password'] = [\\\"Password already used before.\\\"]\\n raise serializers.ValidationError(error_response)\\n except CurationUser.DoesNotExist:\\n return url_expired_response\\n except ValidationError as err:\\n raise err\\n except:\\n return Response({\\\"message\\\": \\\"Unable to reset password\\\"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)\",\n \"def update_password(email: str, token: str, new_passwd: str) -> None:\\n data = {\\n 'email': email,\\n 'reset_token': token,\\n 'new_password': new_passwd\\n }\\n response = requests.put(f'{URL}/reset_password', data=data)\\n assert response.status_code == 200\\n assert response.json() == {'email': email, 'message': 'Password updated'}\",\n \"def test_password_reset(self):\\n newpassword = 'neo.h1m1tsu!'\\n pw_reset_url = reverse('auth_password_reset')\\n\\n # Step 1 - load the password reset page\\n response = self.client.get(pw_reset_url)\\n self.assertEqual(response.status_code, 200)\\n # WARNING: uses Django's admin template\\n self.assertTemplateUsed(\\n response, 'registration/password_reset_form.html')\\n\\n # Step 2 - request password reset URL at specific email\\n data = {'email': self.email}\\n post_response = self.client.post(pw_reset_url, data=data, follow=True)\\n self.assertRedirects(\\n post_response, reverse('auth_password_reset_done'))\\n # WARNING: uses Django's admin template\\n self.assertTemplateUsed(\\n post_response, 'registration/password_reset_done.html')\\n\\n # Step 3 - receive email with link back to site for reset\\n self.assertEqual(len(mail.outbox), 1)\\n self.assertEqual(mail.outbox[0].to, [self.email])\\n self.assertEqual(\\n mail.outbox[0].subject, 'Password reset on example.com')\\n urlmatch = re_search(r'https?://[^/]*(/.*reset/\\\\S*)',\\n mail.outbox[0].body)\\n self.assertIsNotNone(urlmatch, 'No URL found in sent email')\\n url_path = urlmatch.groups()[0]\\n uidb64, token = list(filter(None, url_path.split('/')))[-2:]\\n self.assertEqual(\\n reverse('auth_password_reset_confirm',\\n kwargs={'uidb64': uidb64, 'token': token}),\\n url_path)\\n\\n # Step 4 - Access URL provided in reset email\\n # TODO: remove condition when Django 1.10 dropped\\n if DJANGO_VERSION >= (1, 11):\\n # Django class-based auth views redirects to a URL without a\\n # token to prevent leaking the token to third-parties\\n reset_get_response = self.client.get(url_path)\\n self.assertRedirects(\\n reset_get_response,\\n reverse('auth_password_reset_confirm',\\n kwargs={\\n 'uidb64': uidb64,\\n 'token': INTERNAL_RESET_URL_TOKEN}))\\n url_path = reset_get_response.url\\n reset_get_response = self.client.get(url_path)\\n self.assertEqual(reset_get_response.status_code, 200)\\n # WARNING: uses Django's admin template\\n self.assertTemplateUsed(\\n reset_get_response, 'registration/password_reset_confirm.html')\\n\\n # Step 5 - Reset Password in Form\\n data = {\\n 'new_password1': newpassword,\\n 'new_password2': newpassword,\\n }\\n reset_post_response = self.client.post(\\n url_path, data=data, follow=True)\\n self.assertRedirects(\\n reset_post_response, reverse('auth_password_reset_complete'))\\n\\n # Ensure that Password Reset Worked Correct\\n self.assertTrue(\\n self.client.login(username=self.username, password=newpassword))\",\n \"def __init__(self):\\n self.token = None\\n self.login()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74162245","0.70615184","0.6827222","0.6698908","0.6595932","0.6443836","0.6400114","0.63979876","0.63826585","0.63694924","0.6352916","0.63482845","0.6347419","0.6342296","0.63396615","0.63304526","0.63268495","0.6316747","0.6214706","0.6172585","0.6138724","0.6110544","0.61087173","0.6098198","0.60729927","0.60659283","0.60562885","0.60270864","0.60020727","0.59995544","0.5998662","0.59943515","0.5975487","0.5971296","0.59679806","0.5966956","0.59444207","0.59323937","0.59218276","0.5912348","0.5902273","0.58934134","0.58769417","0.586962","0.58597475","0.58547884","0.58478117","0.58438814","0.5838574","0.5829172","0.5825691","0.58208203","0.5810579","0.5799314","0.5798226","0.5794005","0.5788737","0.5785849","0.5778446","0.5742651","0.57386893","0.5725687","0.57252926","0.5723847","0.5719064","0.57173705","0.57167923","0.5699503","0.56989795","0.56893444","0.56849045","0.5673385","0.5662843","0.56596637","0.56548357","0.5646188","0.5642455","0.56368667","0.56358635","0.5633014","0.5623238","0.5622538","0.56220764","0.5613029","0.56100047","0.5584138","0.55826247","0.55374104","0.5536845","0.5535823","0.5532986","0.5516265","0.5512855","0.5509729","0.5508959","0.5502826","0.5489922","0.5488003","0.5487564","0.5484936"],"string":"[\n \"0.74162245\",\n \"0.70615184\",\n \"0.6827222\",\n \"0.6698908\",\n \"0.6595932\",\n \"0.6443836\",\n \"0.6400114\",\n \"0.63979876\",\n \"0.63826585\",\n \"0.63694924\",\n \"0.6352916\",\n \"0.63482845\",\n \"0.6347419\",\n \"0.6342296\",\n \"0.63396615\",\n \"0.63304526\",\n \"0.63268495\",\n \"0.6316747\",\n \"0.6214706\",\n \"0.6172585\",\n \"0.6138724\",\n \"0.6110544\",\n \"0.61087173\",\n \"0.6098198\",\n \"0.60729927\",\n \"0.60659283\",\n \"0.60562885\",\n \"0.60270864\",\n \"0.60020727\",\n \"0.59995544\",\n \"0.5998662\",\n \"0.59943515\",\n \"0.5975487\",\n \"0.5971296\",\n \"0.59679806\",\n \"0.5966956\",\n \"0.59444207\",\n \"0.59323937\",\n \"0.59218276\",\n \"0.5912348\",\n \"0.5902273\",\n \"0.58934134\",\n \"0.58769417\",\n \"0.586962\",\n \"0.58597475\",\n \"0.58547884\",\n \"0.58478117\",\n \"0.58438814\",\n \"0.5838574\",\n \"0.5829172\",\n \"0.5825691\",\n \"0.58208203\",\n \"0.5810579\",\n \"0.5799314\",\n \"0.5798226\",\n \"0.5794005\",\n \"0.5788737\",\n \"0.5785849\",\n \"0.5778446\",\n \"0.5742651\",\n \"0.57386893\",\n \"0.5725687\",\n \"0.57252926\",\n \"0.5723847\",\n \"0.5719064\",\n \"0.57173705\",\n \"0.57167923\",\n \"0.5699503\",\n \"0.56989795\",\n \"0.56893444\",\n \"0.56849045\",\n \"0.5673385\",\n \"0.5662843\",\n \"0.56596637\",\n \"0.56548357\",\n \"0.5646188\",\n \"0.5642455\",\n \"0.56368667\",\n \"0.56358635\",\n \"0.5633014\",\n \"0.5623238\",\n \"0.5622538\",\n \"0.56220764\",\n \"0.5613029\",\n \"0.56100047\",\n \"0.5584138\",\n \"0.55826247\",\n \"0.55374104\",\n \"0.5536845\",\n \"0.5535823\",\n \"0.5532986\",\n \"0.5516265\",\n \"0.5512855\",\n \"0.5509729\",\n \"0.5508959\",\n \"0.5502826\",\n \"0.5489922\",\n \"0.5488003\",\n \"0.5487564\",\n \"0.5484936\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56647867"},"document_rank":{"kind":"string","value":"72"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":851,"numItemsPerPage":100,"numTotalItems":95772,"offset":85100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTk5MTY1MSwianRpIjoiNzFiN2I2YTUtNDNiNS00MzM3LTgzNmUtMjJhNjM3N2E4MWU3Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU5OTUyNTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.GYJr_n-H8ofn1KMYwKQh2qIAOSYsyIzK-mo389amF3ZQXMmx9GCoLl9yG5Q8XK9N1XAzlXhyct1cQep5tKhUBQ","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 |
|---|---|---|---|---|---|---|
generate the subjects structure needed to create the folders in drive | def init(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_analysis_skeleton(project_dir,sub_stem):\n \n # Move from project_dir to ToProcess\n TP_dir = os.path.join(project_dir,'ToProcess')\n move_files(project_dir, TP_dir, '')\n \n all_files = glob.glob(os.path.join(TP_dir,'*%s*' % (sub_stem)))\n all_files = [os.path.basename(f) for f in a... | [
"0.66462374",
"0.6618272",
"0.6297069",
"0.62176675",
"0.6198142",
"0.6193512",
"0.61851746",
"0.6171276",
"0.6035251",
"0.59953237",
"0.5969861",
"0.59673655",
"0.59498274",
"0.5922048",
"0.59138757",
"0.58946705",
"0.5894622",
"0.5891271",
"0.5885636",
"0.5885636",
"0.58764... | 0.0 | -1 |
upload the folders created by init command and store the ids of those folders | def create(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def syncfolder():",
"def upload_handler(self):\n \n for root, dirs, files in os.walk(self.path):\n\n current_dir = os.path.basename(root)\n \n if root == self.path:\n root_id = self.gapy.create_file(current_dir, path=root, isFolder=True)\n else... | [
"0.7135781",
"0.69107336",
"0.6597334",
"0.63834125",
"0.63768333",
"0.61487734",
"0.60573316",
"0.5947639",
"0.5946258",
"0.5875613",
"0.5851059",
"0.58484143",
"0.5845889",
"0.5836926",
"0.582836",
"0.5809538",
"0.57464784",
"0.57359505",
"0.5716436",
"0.57146806",
"0.57087... | 0.0 | -1 |
List available subjects with its respective id, | def ls(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_all_subjects(self):\n self.load_subjects_in_twSubjects([self.pj[SUBJECTS][x][\"name\"] for x in self.pj[SUBJECTS]])",
"def subject_list():\n items = []\n\n soup = abcradionational.get_soup(URL + \"/podcasts/subjects\")\n \n subject_heading = abcradionational.get_podcast_heading(soup)\... | [
"0.7564551",
"0.7342874",
"0.71160054",
"0.6835792",
"0.6800803",
"0.6768294",
"0.66140616",
"0.65194505",
"0.6450174",
"0.6444373",
"0.6353457",
"0.6339355",
"0.6324993",
"0.6312181",
"0.63060343",
"0.62966466",
"0.62959385",
"0.62355834",
"0.6221914",
"0.6215571",
"0.620728... | 0.0 | -1 |
set the current class to upload screenshots and notes | def set(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._uploaded_file_ops = False",
"def __init__(self):\n self.label = \"Attachments to File\"\n self.description = \"Extract attachments from a feature class to file\"\n self.canRunInBackground = False",
"def _class(self, _class):\n\n self.__class = _cla... | [
"0.59720474",
"0.5885543",
"0.5759416",
"0.5759416",
"0.5745129",
"0.571496",
"0.5641162",
"0.555142",
"0.55076414",
"0.5460135",
"0.5361149",
"0.5250432",
"0.5223033",
"0.52166",
"0.52166",
"0.5196023",
"0.5161504",
"0.51547116",
"0.5143689",
"0.5122844",
"0.51184845",
"0.... | 0.0 | -1 |
take a screenshot and upload to drive | def ts(region, tags, reset): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def capture_and_upload_screenshot(self) -> None:",
"def take_screeshot():\n\n # generate a unique identifier for the screenshot\n if not settings.screenshot_app:\n return ('Screenshots are disabled', 404)\n\n url, width, height = parse_querystring(request)\n\n if url ... | [
"0.8495051",
"0.67579937",
"0.6725828",
"0.6612546",
"0.65725386",
"0.65676177",
"0.65237814",
"0.64896345",
"0.64476013",
"0.6365933",
"0.63239276",
"0.6300869",
"0.6244247",
"0.62289286",
"0.61827874",
"0.6180655",
"0.6180655",
"0.5982894",
"0.5978675",
"0.59644985",
"0.596... | 0.0 | -1 |
write a note and upload to drive | def note(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_note():\n\n title_note = request.form.get(\"title\")\n note = request.form.get(\"note\")\n\n date_string = datetime.today().strftime('%Y-%m-%d')\n diary = Note(user_id=session[\"user_id\"],title_note = title_note, note_created=date_string, note=note)\n\n db.session.add(diary)\n db.sessi... | [
"0.63436806",
"0.6299849",
"0.6289657",
"0.6258689",
"0.62170416",
"0.60311145",
"0.6003288",
"0.59646916",
"0.5945315",
"0.59226435",
"0.5851861",
"0.5838711",
"0.57635957",
"0.5729649",
"0.5624441",
"0.56025285",
"0.5579801",
"0.55744195",
"0.55653083",
"0.55628324",
"0.552... | 0.56140125 | 15 |
merge all notes in currentclass, ignore merged notes | def mergenotes(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def augment(self):\n for n in self.notes:\n n.augment()",
"def remove_duplicate_notes(self):\n res = []\n for x in self.notes:\n if x not in res:\n res.append(x)\n self.notes = res\n return res",
"def merge_docs(self):",
"def merge_notes... | [
"0.6050369",
"0.60432845",
"0.57947606",
"0.57807094",
"0.57020885",
"0.5661482",
"0.5608127",
"0.55626655",
"0.5536551",
"0.5486437",
"0.5468853",
"0.54607016",
"0.5439737",
"0.53964967",
"0.53964967",
"0.53695685",
"0.53639656",
"0.5339577",
"0.5308613",
"0.52500844",
"0.52... | 0.52022606 | 21 |
get notes, you can either copy to a sync folder or download to local | def getnotes(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetNotes(self, request, global_params=None):\n config = self.GetMethodConfig('GetNotes')\n return self._RunMethod(\n config, request, global_params=global_params)",
"async def _view_all_notes(self, ctx: Context):\n\n author = ctx.author\n\n note_infos = []\n\n embed_li... | [
"0.6348131",
"0.62294436",
"0.6095098",
"0.6090929",
"0.5969424",
"0.5913103",
"0.58877283",
"0.5875533",
"0.587039",
"0.5755032",
"0.57102007",
"0.5685677",
"0.5674463",
"0.5654117",
"0.5636658",
"0.5633647",
"0.56146985",
"0.5590802",
"0.5529989",
"0.55236137",
"0.5484942",... | 0.7081106 | 0 |
get images, you can either copy to a sync folder or download to local | def getimgs(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_images(self):\n # test\n for it in self.xml.iterfind('image'):\n print(it)\n\n elements = []\n els = self.xml.findall('image')\n for el in els:\n elements.push(el.find('src')[0])\n els = self.xml.findall('full_picture')\n elements = ele... | [
"0.72774976",
"0.7222684",
"0.72116727",
"0.7136989",
"0.7032972",
"0.70138687",
"0.694288",
"0.69381595",
"0.6933958",
"0.6932005",
"0.69210017",
"0.6874914",
"0.68325573",
"0.6811903",
"0.67718667",
"0.67658556",
"0.67449826",
"0.6718865",
"0.6667427",
"0.66618836",
"0.6644... | 0.70800644 | 4 |
Set the drive folder to copy files after getting its content | def syncfolder(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copydir(self):\n pass",
"def CopyFiles(self):\n pass",
"def __copyFiles(self):\n if os.path.isdir(self.__sourcePath):\n shutil.copytree(self.__sourcePath, self.__targetPath)\n else:\n shutil.copy2(self.__sourcePath, self.__targetPath)",
"def copy_files(self):... | [
"0.7134269",
"0.66678053",
"0.6458958",
"0.63541377",
"0.63032097",
"0.6300692",
"0.623825",
"0.6070141",
"0.6057919",
"0.60387754",
"0.5986305",
"0.5978761",
"0.5971984",
"0.5920381",
"0.5912804",
"0.59033316",
"0.5897482",
"0.5890843",
"0.5889729",
"0.58855975",
"0.58276963... | 0.6645535 | 2 |
Set the drive folder to copy files after getting its content | def tagger(): | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copydir(self):\n pass",
"def CopyFiles(self):\n pass",
"def syncfolder():",
"def __copyFiles(self):\n if os.path.isdir(self.__sourcePath):\n shutil.copytree(self.__sourcePath, self.__targetPath)\n else:\n shutil.copy2(self.__sourcePath, self.__targetPath)",
... | [
"0.713296",
"0.6666113",
"0.6648299",
"0.6457268",
"0.63525325",
"0.6302015",
"0.6299908",
"0.6238088",
"0.6070035",
"0.6057461",
"0.60360557",
"0.5986712",
"0.59776515",
"0.5970163",
"0.5919527",
"0.5913841",
"0.5900404",
"0.5895153",
"0.5888388",
"0.5887716",
"0.58868253",
... | 0.0 | -1 |
Find next node of a given node in a BST. | def next_node(node):
# is root
if not node.parent:
return _min_node(node.right)
# is subtree and is left
if node.parent.left == node:
if not node.right:
return node.parent
return _min_node(node.right)
# is subtree and is right
return node.parent.parent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_node(node):\n\n if node.right_child is not None:\n # First case: ``node`` has right child, the next node is in the subtree\n # rooted at the right child, and it is leftmost node in this subtree.\n current_node = node.right_child\n while current_node.left_child is not Non... | [
"0.74567485",
"0.7090742",
"0.6928549",
"0.68795377",
"0.67899877",
"0.6764543",
"0.669973",
"0.65375566",
"0.6487014",
"0.6486642",
"0.64003444",
"0.6399026",
"0.639506",
"0.63792956",
"0.6377282",
"0.63366306",
"0.63348866",
"0.63336825",
"0.6327812",
"0.62818664",
"0.62653... | 0.76324075 | 0 |
Return the min node of a BST subtree. | def _min_node(node):
if not node:
return None
i = node
while i.left:
i = i.left
return i | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_min(self) -> TreeNode:\n node = self.root\n while True:\n if not node.left:\n return node\n node = node.left",
"def _find_smallest(node):\n if node.left:\n return BinarySearchTree._find_smallest(node.left)\n else:\n r... | [
"0.8181223",
"0.7754536",
"0.7699864",
"0.7666253",
"0.7632981",
"0.76130587",
"0.7516755",
"0.75156",
"0.7462528",
"0.7420651",
"0.73975736",
"0.73489773",
"0.7188644",
"0.7147024",
"0.71064144",
"0.7091051",
"0.70677614",
"0.706635",
"0.70491433",
"0.7002115",
"0.69909126",... | 0.79107755 | 1 |
uses a set for duplicates, the dict is for frequencies only instead of an array of dicts separates each window length into an algorithm chunk (sliding window) 3x faster than clumpFinder() but still slow (many redundant operations!) | def chunkedClumpFinder(sequence, k, L, t):
frequentPatterns = set([])
for i in range(len(sequence)):
window = sequence[i:i + L]
frequencies = {}
for j in range(len(window)):
pattern = window[j:j + k]
if pattern not in frequencies:
frequencies[pat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_of_sets(l):\r\n distinct_sweets = set(l) #let's find all distinct sweets from input list\r\n dict_of = {} #empty dict to store key:value (sweet:number of occurrences)\r\n\r\n for i in distinct_sweets:\r\n dict_of[i] = l.count(i)\r\n \r\n key_min = min(dict_of.keys(), key=(lambda k... | [
"0.63687587",
"0.6196125",
"0.6118355",
"0.6066688",
"0.60510707",
"0.603749",
"0.6013759",
"0.5971861",
"0.59603256",
"0.5899018",
"0.5868384",
"0.58586293",
"0.58455414",
"0.5835125",
"0.5807947",
"0.5777659",
"0.5767623",
"0.57562715",
"0.57500553",
"0.5744204",
"0.5737346... | 0.63872755 | 0 |
uses a set for duplicates, the dict is for frequencies only instead of an array of dicts separates each window length into an algorithm chunk (sliding window) 3x faster than clumpFinder() but still slow (many redundant operations!) | def fastClumpFinder(sequence, k, L, t):
# to be implemented ;)
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chunkedClumpFinder(sequence, k, L, t):\n\n frequentPatterns = set([])\n for i in range(len(sequence)):\n window = sequence[i:i + L]\n frequencies = {}\n\n for j in range(len(window)):\n pattern = window[j:j + k]\n if pattern not in frequencies:\n ... | [
"0.6386038",
"0.6369567",
"0.619515",
"0.6119224",
"0.60642827",
"0.60519266",
"0.6037478",
"0.6013743",
"0.59721917",
"0.5960064",
"0.5898815",
"0.58673316",
"0.5858758",
"0.58453965",
"0.58349407",
"0.5806918",
"0.5777867",
"0.5766551",
"0.5756229",
"0.57486904",
"0.5741851... | 0.5265449 | 85 |
Return True if the update happened, False if it did not | def update(db, spec, doc):
resp = db.sole.sole.update(spec, doc, upsert=False, safe=True)
if (resp.get('updatedExisting') == False):
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_updated(self):\n return self.timestamp > 0",
"def needs_update(self) -> bool:\n return False",
"def hasChanged(self):\r\n if self.is_updated:\r\n self.is_updated = False\r\n return True\r\n else:\r\n return False\r\n\r\n # if not self.h... | [
"0.82221776",
"0.81986374",
"0.8170888",
"0.80791825",
"0.7879904",
"0.7732131",
"0.76466054",
"0.7580046",
"0.7571564",
"0.754413",
"0.7488154",
"0.746068",
"0.7378105",
"0.7359835",
"0.73528314",
"0.7308108",
"0.72857326",
"0.72699004",
"0.7263354",
"0.72479844",
"0.7240922... | 0.0 | -1 |
given params sent in with a POST request, return a doc that is ready to be stored in the database | def format_params_for_create(user_id, params):
s = {
A_TIME: params.get(A_TIME),
A_LON: params.get(A_LON),
A_LAT: params.get(A_LAT),
A_ADDRESS: params.get(A_ADDRESS),
A_COURSE_ID: params.get(A_COURSE_ID),
A_USER_ID: user_id
}
day = params.get(A_DAY)
m = re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_post(params, db_conn):\n\n tablename = post_schema['tablename']\n return get_document(tablename, params, db_conn)",
"def oparl_documentsss():\n start_time = time.time()\n jsonp_callback = request.args.get('callback', None)\n ref = request.args.get('reference', '')\n references = ref.split(',')\... | [
"0.7473108",
"0.6820269",
"0.64150715",
"0.6363577",
"0.63143444",
"0.62964106",
"0.6254058",
"0.62082756",
"0.6199685",
"0.6171967",
"0.61257607",
"0.6114795",
"0.6104304",
"0.60767525",
"0.60735416",
"0.5987432",
"0.5980778",
"0.59701914",
"0.59610623",
"0.5899309",
"0.5888... | 0.0 | -1 |
Objective function for optimization, when we optimize using multiple marginal SFSs. | def _object_func_marginals(params, data_vec, model_func, pts,
lower_bound=None, upper_bound=None,
verbose=0, multinom=True, flush_delay=0,
func_args=[], func_kwargs={}, fixed_params=None, ll_scale=1,
output_stream=sys.stdout, store_thetas=False):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def costFun(self, S, x):",
"def add_objective(self): \n \n if \"CSS\" in self.algorithm:\n \n if self.num_hidden == 0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n else:\n \n data_te... | [
"0.6199027",
"0.60962456",
"0.5875499",
"0.58583134",
"0.57640135",
"0.57609576",
"0.5720939",
"0.56782895",
"0.56628907",
"0.55962974",
"0.5555265",
"0.5554905",
"0.55286443",
"0.551337",
"0.55092394",
"0.55089766",
"0.55062085",
"0.54951364",
"0.54929906",
"0.5462576",
"0.5... | 0.5757614 | 6 |
Objective function for optimization, when we optimize using multiple marginal SFSs. | def _object_func_marginals_c(params, data_vec, model_func, pts,
lower_bound=None, upper_bound=None,
verbose=0, multinom=True, flush_delay=0,
func_args=[], func_kwargs={}, fixed_params=None, ll_scale=1,
output_stream=sys.stdout, store_thetas=False... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def costFun(self, S, x):",
"def add_objective(self): \n \n if \"CSS\" in self.algorithm:\n \n if self.num_hidden == 0:\n \n data_term = self.compute_energy(self.x, self.batch_size)\n \n else:\n \n data_te... | [
"0.6198953",
"0.6100035",
"0.58765996",
"0.5856214",
"0.5765808",
"0.5763503",
"0.57589847",
"0.5680736",
"0.56663513",
"0.55975723",
"0.5556067",
"0.5555249",
"0.55298555",
"0.55139184",
"0.5513455",
"0.550935",
"0.55041033",
"0.54962236",
"0.5494656",
"0.5465352",
"0.546478... | 0.57218295 | 7 |
Objective function for optimization in log(params). | def _object_func_marginals_c_log(log_params, *args, **kwargs):
return _object_func_marginals_c(numpy.exp(log_params), *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objective_llh(self, params):\n\n try:\n obj = self.log_likelihood(params[0], params[1], params[2:])\n except (LinAlgError, ZeroDivisionError, ValueError):\n obj = -np.inf\n return obj",
"def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self... | [
"0.72464484",
"0.72327834",
"0.7067476",
"0.70212835",
"0.70010036",
"0.6936446",
"0.69265854",
"0.685497",
"0.68126464",
"0.678558",
"0.6772992",
"0.6772992",
"0.6727183",
"0.6648505",
"0.66342664",
"0.6624805",
"0.6561634",
"0.6520975",
"0.64957696",
"0.6482517",
"0.6445161... | 0.5975172 | 81 |
Objective function for optimization in log(params). | def _object_func_marginals_log(log_params, *args, **kwargs):
return _object_func_marginals(numpy.exp(log_params), *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objective_llh(self, params):\n\n try:\n obj = self.log_likelihood(params[0], params[1], params[2:])\n except (LinAlgError, ZeroDivisionError, ValueError):\n obj = -np.inf\n return obj",
"def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self... | [
"0.72464484",
"0.72327834",
"0.7067476",
"0.70212835",
"0.70010036",
"0.6936446",
"0.69265854",
"0.685497",
"0.68126464",
"0.678558",
"0.6772992",
"0.6772992",
"0.6727183",
"0.6648505",
"0.66342664",
"0.6624805",
"0.6561634",
"0.6520975",
"0.64957696",
"0.6482517",
"0.6445161... | 0.6013213 | 68 |
Objective function for optimization in log(params). | def _object_func_marginals_coarse_log(log_params, *args, **kwargs):
return _object_func_marginals_coarse(numpy.exp(log_params), *args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objective_llh(self, params):\n\n try:\n obj = self.log_likelihood(params[0], params[1], params[2:])\n except (LinAlgError, ZeroDivisionError, ValueError):\n obj = -np.inf\n return obj",
"def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self... | [
"0.72464484",
"0.72327834",
"0.7067476",
"0.70212835",
"0.70010036",
"0.6936446",
"0.69265854",
"0.685497",
"0.68126464",
"0.678558",
"0.6772992",
"0.6772992",
"0.6727183",
"0.6648505",
"0.66342664",
"0.6624805",
"0.6561634",
"0.6520975",
"0.64957696",
"0.6482517",
"0.6445161... | 0.59806603 | 79 |
Optimize log(params) to fit model to data using the BFGS method. This optimization method works well when we start reasonably close to the optimum. It is best at burrowing down a single minimum. Because this works in log(params), it cannot explore values of params < 0. It should also perform better when parameters rang... | def optimize_log(p0, data, model_func, pts, lower_bound=None, upper_bound=None,
verbose=0, flush_delay=0.5, epsilon=1e-3,
gtol=1e-5, multinom=True, maxiter=None, full_output=False,
func_args=[], func_kwargs={}, fixed_params=None, ll_scale=1,
output_fi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maximize_loglik(model_params: Union[CupidParams, CupidParamsCSHeteroxy, CupidParamsFcmnl],\n x_init: np.ndarray,\n lower: Optional[np.ndarray] = None,\n upper: Optional[np.ndarray] = None,\n checkgrad: Optional[bool] = False,\n ... | [
"0.65304214",
"0.64780915",
"0.6177655",
"0.6161781",
"0.61599773",
"0.60868424",
"0.60741144",
"0.6044265",
"0.60271394",
"0.60215414",
"0.60146534",
"0.59783334",
"0.5933783",
"0.59062",
"0.5886293",
"0.5869606",
"0.58289564",
"0.5819565",
"0.5812694",
"0.5792707",
"0.57897... | 0.6719574 | 0 |
Optimize log(params) to fit model to data using NelderMead. This optimization method make work better than BFGS when far from a minimum. It is much slower, but more robust, because it doesn't use gradient information. Because this works in log(params), it cannot explore values of params < 0. It should also perform bett... | def optimize_log_fmin(p0, data, model_func, pts,
lower_bound=None, upper_bound=None,
verbose=0, flush_delay=0.5,
multinom=True, maxiter=None,
full_output=False, func_args=[],
func_kwargs={},
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self._LL(self.endog, rate=lambda_)\n\n return -np.log(ll_output)",
"def __log_likelihood(self, params, *args):\n\t\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\n\n\t\tno_example = len(X)\n\t\ttotal_logZ = 0\n... | [
"0.67615706",
"0.67385006",
"0.67084426",
"0.65556633",
"0.6543541",
"0.6473266",
"0.644554",
"0.64344704",
"0.63720936",
"0.63556635",
"0.63141555",
"0.63138676",
"0.6299224",
"0.622597",
"0.6189101",
"0.61648405",
"0.6129973",
"0.6100781",
"0.60894597",
"0.6047367",
"0.6043... | 0.58699507 | 29 |
Optimize log(params) to fit model to data using NelderMead. This optimization method make work better than BFGS when far from a minimum. It is much slower, but more robust, because it doesn't use gradient information. Because this works in log(params), it cannot explore values of params < 0. It should also perform bett... | def optimize_log_fmin_coarse(p0, coarsenings,data, model_func, pts,
lower_bound=None, upper_bound=None,
verbose=0, flush_delay=0.5,
multinom=True, maxiter=None,
full_output=False, func_args=[],
func_kwargs=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nloglikeobs(self, params):\n lambda_ = params[0]\n\n ll_output = self._LL(self.endog, rate=lambda_)\n\n return -np.log(ll_output)",
"def __log_likelihood(self, params, *args):\n\t\tX, y, feature_set, lambda_reg, empirical_weights, verbose, sign = args\n\n\t\tno_example = len(X)\n\t\ttotal_logZ = 0\n... | [
"0.67606986",
"0.6739016",
"0.67089283",
"0.6554713",
"0.654431",
"0.647485",
"0.6445823",
"0.64342856",
"0.6373043",
"0.63545066",
"0.6316349",
"0.63147515",
"0.62980264",
"0.6225396",
"0.6189243",
"0.61654437",
"0.61321706",
"0.61011934",
"0.608998",
"0.6047437",
"0.6043340... | 0.5554022 | 59 |
Spectrum from a dictionary of polymorphisms. | def from_data_dict(data_dict, pop_ids, projections, mask_corners=True,
polarized=True,print_successrate=False):
failed=0
Npops = len(pop_ids)
fs = numpy.zeros(numpy.asarray(projections)+1)
for snp, snp_info in data_dict.items():
# Skip SNPs that aren't ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spectra(self, value):\n\n _errtxt = f\"This assignment {value} does not contain valid spectra\"\n if type(value) == dict:\n _data = value\n # if not _data:\n # self.start_fit = False\n elif type(value).__name__ == \"SpectrumDataCollection\":\n _d... | [
"0.5118848",
"0.49894622",
"0.48169142",
"0.48116708",
"0.4687041",
"0.4682823",
"0.46786124",
"0.4653587",
"0.46364433",
"0.46307474",
"0.46270955",
"0.4620451",
"0.4561472",
"0.45467377",
"0.45438758",
"0.45324418",
"0.45044976",
"0.44949386",
"0.44943097",
"0.44928306",
"0... | 0.0 | -1 |
Read benchmark data and make scaling plots. | def post_process(self, filename):
title = self.title
outfile = open(filename, 'r')
data = outfile.readlines()
name = data[0].strip()
mode = data[1].strip()
ops = data[2].strip().split(',')
nl = 'True' in ops[0]
ln = 'True' in ops[1]
drv = 'True' ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(logy):\n filep = sys.stdin\n dataf = pd.read_csv(filep, sep=\" \", index_col=0, header=None)\n dataf.plot(logy=logy)\n print(dataf)\n plt.savefig(\"scaling.pdf\")",
"def main():\n df_data = import_clean_process()\n plot_data_matplotlib(df_data)\n return",
"def main():\n\n co... | [
"0.6262268",
"0.6241368",
"0.60495985",
"0.5843554",
"0.5773783",
"0.57549113",
"0.5750781",
"0.5728409",
"0.5685088",
"0.5643176",
"0.56256104",
"0.56139076",
"0.5595927",
"0.5574747",
"0.55527896",
"0.55416715",
"0.55249935",
"0.55140436",
"0.55054355",
"0.5498047",
"0.5485... | 0.0 | -1 |
0 > Main droite 1 > Main Gauche | def sphere(self, path, args):
note_name = args[0]
hands = args[1]
probability = args[2]
force = args[3]
print "got sphere : %s '%s', %d, %f, %f" % (path,
note_name,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def goToZero():\n #on remet tout à zero\n usr_choice = 0\n fonctions_pfc.x = 0\n fonctions_pfc.y = 0\n fonctions_pfc.result = \"\"\n fonctions_pfc.pc_score = \" SCORE DU PC : \"\n fonctions_pfc.usr_score = \" SCORE DU PC : \"\n #on ré-affiche tous les composants\n display_pack_component(... | [
"0.60082096",
"0.5796911",
"0.57385117",
"0.57088554",
"0.5694299",
"0.56703836",
"0.55788225",
"0.5578342",
"0.55587816",
"0.55525583",
"0.55124044",
"0.5471946",
"0.5468912",
"0.5454788",
"0.5433908",
"0.5432025",
"0.54042614",
"0.54018486",
"0.53990334",
"0.5394289",
"0.53... | 0.0 | -1 |
name, force, xyz_r, xyz_l | def two_hands_gesture(self, path, args):
name = args[0]
if name == 'chord':
# proba, force, position (R, L)
print "Got Chord"
engine._TheEngine().process(PitchbendEvent(engine.in_ports()[0],
1,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_xyz(atoms,coordinates,filename):\n coordinates = [[w / angtobh for w in ww] for ww in coordinates] #bh to ang\n xyz = open(filename,\"a\")\n xyz.write(str(len(atoms)))\n xyz.write(\"\\nOptimizer geometry\\n\")\n for i in xrange(len(atoms)):\n\txyz.write(atoms[i] + ' ')\n\txyz.write(\" \".j... | [
"0.58931416",
"0.58661944",
"0.56863695",
"0.54583025",
"0.54349345",
"0.54218984",
"0.5382613",
"0.5357074",
"0.53335613",
"0.5328906",
"0.529051",
"0.52662313",
"0.5220069",
"0.5215272",
"0.5201261",
"0.5187543",
"0.51764745",
"0.5168201",
"0.5167269",
"0.51668924",
"0.5144... | 0.0 | -1 |
Drops records from the dataframe df is var1 is greater than var2 For example, if var1 is spending on clothing and var2 is total income it is not logical that var1 is greater than var2 | def drop_illogical(df,var1,var2):
#Mask the illogical entries
mask = df[var1]>df[var2]
#Record the number of entries
NumRecords = df.shape[0]
#drop the illogical entries
df = df[df.keys()][~mask]
#Notify the user how many records were dropped
print('{} records dropped because {} ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_outliers(df, var):\n import numpy as np\n \n df = df.copy()\n \n # remove outliers\n Q1 = np.nanquantile(df[var] ,0.25)\n Q3 = np.nanquantile(df[var], 0.75)\n IQR = Q3 - Q1\n \n lower_end = Q1 - 1.5 * IQR \n high_end = Q3 + 1.5 * IQR \n \n df_filtered = df.drop(df[(... | [
"0.61005276",
"0.6079517",
"0.589066",
"0.5799702",
"0.5617992",
"0.55075836",
"0.5503977",
"0.55010396",
"0.55010396",
"0.54976255",
"0.5436637",
"0.54360694",
"0.5389384",
"0.53594834",
"0.535714",
"0.535346",
"0.5332813",
"0.53143257",
"0.5292683",
"0.5286526",
"0.52819777... | 0.7170435 | 0 |
This function (initiated by clicking the "Upload Tariff File" button) brings up a file browser window and lets the user select a tariff csv file to import into the tool. After successfully selecting a file to upload, the function reads the file into a pandas data frame, calls the validate_tariff() function to ensure th... | def uploaddata(self):
self.filename = filedialog.askopenfilename(filetypes=[('CSV', '*.csv')],
initialdir='./Tariffs')
if self.filename: # don't try to import anything if filename is empty
self.data = pd.read_csv(self.filename)
self.validate_tariff() # TODO: build out contingency when validati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upload_file(self):\n self.master.switch_frame(UploadFileView)",
"def start_upload(self):\n filename = filedialog.askopenfilename(filetypes=[('Data Frame files', '.csv .xls .xlsx .data .json .xsl .txt')],\n title='Select data frame file')\n if ... | [
"0.57963634",
"0.5779103",
"0.57500017",
"0.57128847",
"0.56889844",
"0.56412196",
"0.55905133",
"0.5528796",
"0.55150217",
"0.539664",
"0.53774077",
"0.5343562",
"0.5332065",
"0.5328703",
"0.53249145",
"0.5309067",
"0.52954215",
"0.5286032",
"0.5284576",
"0.5274875",
"0.5272... | 0.71449256 | 0 |
This function contains the tests required to validate that a tariff data frame is valid | def validate_tariff(self):
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_upload_to_df(upload_dataframe: pd.DataFrame) -> None:\n validated = UploadCollection.from_dataframe(upload_dataframe)\n assert upload_dataframe.equals(validated.to_dataframe()[upload_dataframe.columns])",
"def verify_pandas(self):\n self.check_dataset_duplicate_ids(self.vertices)\n #... | [
"0.6895882",
"0.62581795",
"0.62322396",
"0.62277174",
"0.61887205",
"0.6177782",
"0.6155625",
"0.6149133",
"0.6099006",
"0.6096892",
"0.6054584",
"0.6043061",
"0.6030683",
"0.6006912",
"0.60010093",
"0.5993058",
"0.59914565",
"0.5975324",
"0.5944749",
"0.591502",
"0.5887435"... | 0.775189 | 0 |
This function makes a visualization of a valid tariff data frame and draws it into a canvas in the frame. | def plot_tariff(self):
plt.figure(1)
plt.cla() # clear the plotting window to allow for re-plotting
if self.chargetypetoplot.get() == 'energy':
toplot = []
energy_filter = ('energy' == self.data["Charge"]) | ('Energy' == self.data["Charge"])
for mo in range(1, 13):
month_filter = (mo >= self.data["... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetCanvas(self,filebasename,plotname,legLabel = \"run\"):\n canvas = TCanvas(filebasename+\"_\".join([str(i) for i in self.runs]))\n leg = TLegend(0.75,0.65,0.85,0.85)\n option=\"Hist\"\n color=2\n for run in self.runs:\n rfile = self.runManager.GetTAFRootFile(run,... | [
"0.5762495",
"0.57607573",
"0.57272094",
"0.56894237",
"0.5662646",
"0.56590706",
"0.56198055",
"0.5605073",
"0.55738837",
"0.55490476",
"0.55442595",
"0.5543866",
"0.5537717",
"0.55325013",
"0.55304974",
"0.55229515",
"0.5512369",
"0.550883",
"0.5502392",
"0.54734075",
"0.54... | 0.0 | -1 |
1.1 Generate Fingerprint VCFs Here we use Dalmatian to run the fingerprint_bam_with_liftover workflow on Terra. This workflow calls Picard ExtractFingerprint to generate a fingerprint VCF and then calls Picard LiftoverVcf to covert this vcf to hg38. To fingerprint hg38 bam files just run fingerprint_bam instead. | async def addToFingerPrint(samples, sampleset=, allsampleset="all", workspace=WORKSPACE, sid=, vcf_list=None,
vcf_list_dir=, working_dir, crosscheck_batch_size, recreate_batch, bamcolname,
taiga_dataset, taiga_filename):
bams = samples[bamcolname]
bams[sid] = bams.index
print('adding '+str(len(bams))+' new sampl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fingerprint(self, algorithm):",
"def main():\n parser = argparse.ArgumentParser(description='MergeGVCFs and genotype them using the GATK')\n parser.add_argument('-g', '--gatk', dest='gatk', help=\"Location of the GATK\", required=True)\n parser.add_argument('-x', '--xmx', dest='xmx', help=\"Memory t... | [
"0.5775645",
"0.57632786",
"0.5658153",
"0.561844",
"0.54591256",
"0.5334822",
"0.5325309",
"0.5305328",
"0.52687347",
"0.5263997",
"0.5230877",
"0.521849",
"0.5206169",
"0.51302344",
"0.5123245",
"0.5070162",
"0.50444156",
"0.5006062",
"0.5003408",
"0.49965554",
"0.4986839",... | 0.6725894 | 0 |
Helper method to get all disks that are not in use, either by the boot pool or the user pools. | async def get_unused(self, join_partitions):
all_disks = await self.middleware.call('disk.query')
serial_to_disk = defaultdict(list)
for disk in all_disks:
serial_to_disk[(disk['serial'], disk['lunid'])].append(disk)
reserved = await self.middleware.call('disk.get_reserved'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_non_ovf_disks():\n return [\n d.get_id() for d in get_all_disks() if (\n d.get_alias() != ENUMS['ovf_disk_alias']\n )\n ]",
"def get_all_disks():\n return DISKS_API.get(abs_link=False)",
"def get_all_disk():\n\t\tdisks = []\n\t\tdisks_lines = linux.exe_shell(\"lsblk -o... | [
"0.7110578",
"0.6596567",
"0.63993245",
"0.6327407",
"0.63001627",
"0.6283016",
"0.61342686",
"0.6117332",
"0.610183",
"0.59533006",
"0.59367496",
"0.5926375",
"0.5924363",
"0.57731235",
"0.5771047",
"0.57462",
"0.56889755",
"0.5652023",
"0.56227106",
"0.5542059",
"0.54929835... | 0.6205291 | 6 |
Makes sure the disks are present in the system and not reserved by anything else (boot, pool, iscsi, etc). | async def check_disks_availability(self, disks, allow_duplicate_serials):
verrors = ValidationErrors()
disks_cache = dict(map(lambda x: (x['devname'], x), await self.middleware.call('disk.query')))
disks_set = set(disks)
disks_not_in_cache = disks_set - set(disks_cache.keys())
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _PreCheckDisks(self, ispec):\n self.diskparams = self.cfg.GetInstanceDiskParams(self.instance)\n\n inst_nodes = self.cfg.GetInstanceNodes(self.instance.uuid)\n excl_stor = compat.any(\n list(rpc.GetExclusiveStorageForNodes(self.cfg, inst_nodes).values())\n )\n\n # Get the group access typ... | [
"0.71250546",
"0.63917005",
"0.61703014",
"0.61318177",
"0.61042476",
"0.60634845",
"0.6014175",
"0.60058516",
"0.5998691",
"0.5984649",
"0.59578073",
"0.59428805",
"0.5934872",
"0.59283465",
"0.5911958",
"0.5880785",
"0.5870844",
"0.582219",
"0.58177876",
"0.5780115",
"0.576... | 0.66384786 | 1 |
Contructor of the class | def __init__(self):
# self.threshold = 3.
self.gamma_min = 3
self.gamma_max = 12
self.n_samples = 40
# self.do_plots = False
# self.do_albedo = True
# self.verbose = True
self.nbands = 7
self.bu = np.array([0.004, 0.015, 0.003, 0.004, 0.013, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object",
"def __init__ (self):\n pass",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",... | [
"0.8680643",
"0.8506947",
"0.8399",
"0.8399",
"0.8399",
"0.8399",
"0.8379655",
"0.83343095",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",
"0.8254885",... | 0.0 | -1 |
Creates a regulariser with a default lag of 1. Clearly, other lags can be specified by changing ``lag``. | def create_regulariser (self, nx, lag=1):
I = np.diag (np.ones(nx))
D = (I - np.roll ( I, -lag)).T
D2 = D.T.dot(D)
Z = np.zeros_like (I)
DD0 = np.array([D2, Z, Z]).reshape ( nx*3, nx).T
DD1 = np.array([Z, D2, Z]).reshape ( nx*3, nx).T # HACK! 10*
DD2 = np.array([Z... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_lag(self,inputLabels,lagNum,suffix=None,fillMissing=np.nan,verbose=0,n_jobs=1):\n self._transform_wrapper(\n inputLabels,\n None,\n make_lag,\n suffix,\n lagNum,\n False,\n n_jobs,\n verbose,\n lagNum... | [
"0.57087487",
"0.53776217",
"0.50716937",
"0.5034615",
"0.49503228",
"0.49326134",
"0.4897093",
"0.4829849",
"0.48250768",
"0.48185134",
"0.4808591",
"0.48084906",
"0.47779104",
"0.4774139",
"0.4773688",
"0.47535902",
"0.47450256",
"0.4730975",
"0.47273833",
"0.47186923",
"0.... | 0.5751384 | 0 |
Having an estimate of the kernel weights over an entire period of time, this function will simulate observations acquired for the same spectral band, stored in rho and with geometries given by vza, sza and raa. The doys are the dates of the observations and refer to the position of the time step in the xsol array. | def predict_refl (self, xsol, doys, vza, sza, raa, rho, do_plots=True, ndoys=365 ):
passer = (doys - 1).astype(np.int)
# Max: ndoys
f0 = xsol[:ndoys][passer]
f1 = xsol[ndoys:(ndoys*2)][passer]
f2 = xsol[(ndoys*2):][passer]
KK = Kernels( vza, sza, raa, \
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve_regularised_problem (self, lambdas, band_unc, doys, vza, sza, raa, rho,\n doy_range=None, do_unc=False):\n # The number of kernels is 3\n n_kernels = 3\n # Figure out how many spectral bands we'll be using...\n if np.ndim ( band_unc ) < 2:\n ... | [
"0.5685351",
"0.5599899",
"0.55112875",
"0.5492639",
"0.5338046",
"0.52963346",
"0.5255298",
"0.5202095",
"0.51412654",
"0.5132842",
"0.5120179",
"0.51088923",
"0.51087165",
"0.51008874",
"0.50944215",
"0.50872093",
"0.50496185",
"0.5046378",
"0.50438154",
"0.50413454",
"0.50... | 0.532401 | 5 |
Solve the regularised linear kernel BRDF problem. The function solves for the kernel weights (f0, f1 and f2) for one or more spectral bands, taking into account the inherent uncertainty in the observations, the acquisition timing and geometries. The inversion is made more robust with a regularisation term (1 lag at the... | def solve_regularised_problem (self, lambdas, band_unc, doys, vza, sza, raa, rho,
doy_range=None, do_unc=False):
# The number of kernels is 3
n_kernels = 3
# Figure out how many spectral bands we'll be using...
if np.ndim ( band_unc ) < 2:
n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_BCGPLVM_rbf_bias_white_kern_2D(self):\n N, input_dim, D = 50, 1, 2\n X = np.random.rand(N, input_dim)\n k = GPy.kern.RBF(input_dim, 0.5, 0.9 * np.ones((1,))) + GPy.kern.Bias(input_dim, 0.1) + GPy.kern.White(input_dim, 0.05)\n K = k.K(X)\n Y = np.random.multivariate_norma... | [
"0.56890315",
"0.56866467",
"0.56495404",
"0.56435627",
"0.55941147",
"0.54710853",
"0.54298985",
"0.5426635",
"0.5388084",
"0.5231405",
"0.5211121",
"0.5172353",
"0.51439714",
"0.5140322",
"0.512901",
"0.5103335",
"0.5101635",
"0.50989527",
"0.50945956",
"0.5093803",
"0.5022... | 0.5250373 | 9 |
Read time series of reflectance data and save to a pkl file | def get_time_series(self, tile, year, loc, px, py, cols=1, rows=1, step=1, save_dir='txt/'):
# keys = ['sza', 'saa', 'vza', 'vaa', 'qa', 'b01', 'b02', 'b03', 'b04', 'b05', 'b06', 'b07']
timeBefore = time.clock()
f_list = np.array(glob.glob(loc + '%s_%d_*_1km.nc' % (tile, year)))
# if... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n pathfolder = \"/home/vanessa/DATA_SEEG/PKL_FILE/\"\n filename = \"/data.pkl\"\n # pathfolder = argv[1]\n # filename = argv[2]\n\n ti = 10. # initial time\n tf = 590. # final time\n t_split = 300. # split\n fs = 1000. # s... | [
"0.584482",
"0.5595723",
"0.55526674",
"0.5443912",
"0.54403263",
"0.54293597",
"0.5404327",
"0.5394117",
"0.5311001",
"0.52930295",
"0.52906024",
"0.52605844",
"0.52552223",
"0.5253987",
"0.52471757",
"0.5227777",
"0.52184516",
"0.5202356",
"0.52016103",
"0.5197414",
"0.5175... | 0.0 | -1 |
Create an netCDF file where we store the results | def create_netcdf(self, netcdf_file, cols, rows, doy_range, do_zlib=True):
# least_significant_digit for createVariable(...)
lsd=None
# create a new netCDF file
rootgrp = nc.Dataset(netcdf_file, "w")
rootgrp.description = "NBAR reflectance and BB albedo"
# Create group... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_netcdf(self, outfile):",
"def output_netcdf(forecast,proj_dict,grid_dict,start_hour,end_hour,\n stride,size,run_date,target_dataset,smoothing,config):\n for d,date in enumerate(run_date):\n date_outpath = config.forecast_out_path+'20{0}/netcdf/'.format(\n date)\... | [
"0.81742424",
"0.7664478",
"0.7599359",
"0.7499293",
"0.7466186",
"0.74496263",
"0.7369795",
"0.7266277",
"0.72151846",
"0.7211757",
"0.71940386",
"0.70676875",
"0.7012102",
"0.6917403",
"0.677125",
"0.6757801",
"0.67547697",
"0.67115766",
"0.668003",
"0.6675043",
"0.6636511"... | 0.62261045 | 34 |
Calculate broad band albedo and reflectance for given BRDF kernel solution | def make_albedo(self, x_sol, unc, nbands=7):
n_doys = x_sol.shape[0] / 3
n_bands = x_sol.shape[1]
bhr_spectral = np.zeros((n_doys, n_bands))
bhr_spectral_unc = np.zeros((n_doys, n_bands))
bhr_spectral_nbar = np.zeros((n_doys, n_bands))
bhr_spectral_nbar_unc = np.zeros((n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_hbls_hbbl(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n z_u_r = self.grid_dict['z_u_r']\n u = self.u\n v = self.v\n \n v_upts = TTTW_func.v2u(v)\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\n\n\n\n # CALCULATE swr_frac\n ... | [
"0.6240019",
"0.6153248",
"0.598355",
"0.5953789",
"0.59093034",
"0.5867363",
"0.58337384",
"0.58280855",
"0.58218926",
"0.5677912",
"0.5673785",
"0.5670195",
"0.563399",
"0.5632684",
"0.56246775",
"0.5615285",
"0.5587835",
"0.5580431",
"0.55696726",
"0.55669475",
"0.5566303"... | 0.0 | -1 |
Solve problem for each pixel inside moving window. | def do_window(self, netcdf, output, year, cols, rows, cx, cy, n_days, doys, doy_range):
win_x = np.arange(cols)
win_y = np.arange(rows)
# ------------------------------------------------
# Get optimal gamma
# ------------------------------------------------
# get random... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solve(self):\n dim = self.puzzle.dimension\n\n # initial loop\n for value, (row, col) in self.puzzle:\n if value:\n self.clear_row(row, value)\n self.clear_col(col, value)\n self.clear_subgrid(row, col, value)\n self.up... | [
"0.63087326",
"0.62517476",
"0.61803126",
"0.6134465",
"0.6083904",
"0.6065481",
"0.6065481",
"0.6032246",
"0.59571964",
"0.58761084",
"0.5865916",
"0.58432245",
"0.58409566",
"0.58102006",
"0.5774845",
"0.57376975",
"0.57370627",
"0.57366765",
"0.5733906",
"0.57100964",
"0.5... | 0.0 | -1 |
Do the main job. Call the routine of hdf5 creation, estimate gamma, solve regularized problem and save a hdf5 file. | def do_job(self, nc_file, loc, pattern, year, tile, ul_px, ul_py, lr_px, lr_py, cols, rows, \
step=1, do_adj_years=True, do_vrt = False):
timeBefore = time.clock()
# Size of an image must be multiple of window size
N = (lr_px-ul_px) / int(cols) * cols
M = (lr_py-ul_py) /... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_output_database():\n\n# Do not alter the hdf5 file if it already exists\n if os.path.exists(database_path):\n print(\"DATABASE STATUS:\")\n print(\"\\t\" + database_path + \" already exists and is ready to store the results of computations\")\n return None\n# Create hdf5 file. The flag \"-w\" means \... | [
"0.665698",
"0.6522957",
"0.6506959",
"0.6447895",
"0.6251527",
"0.6232781",
"0.6221436",
"0.61841214",
"0.6106533",
"0.5949692",
"0.59292674",
"0.5917778",
"0.5898403",
"0.5855418",
"0.58377635",
"0.58365107",
"0.5789868",
"0.5789642",
"0.5769132",
"0.5759015",
"0.5744126",
... | 0.0 | -1 |
Returns component I/O for optical testing with single input and oputput fibers (no fiber array) | def route_fiber_single(
component: Component,
optical_io_spacing: int = 50,
grating_coupler: Component = grating_coupler_te,
min_input2output_spacing: int = 230,
optical_routing_type: int = 1,
optical_port_labels: None = None,
excluded_ports: List[Any] = [],
**kwargs
) -> Union[
Tupl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n op = help()\n for t in [\"bowtie2\", \"samtools\", \"bamToBed\"]:\n if not isTool(t):\n logger.error(\"%s not exits! Please install through conda.\" % t)\n return\n if not os.path.exists(op.fqd):\n logger.error(\"Input %s not exists! Return.\" % op.fqd)\n ... | [
"0.5328557",
"0.53075993",
"0.53037673",
"0.52203745",
"0.521377",
"0.5203995",
"0.5170913",
"0.5154463",
"0.5106008",
"0.506503",
"0.503149",
"0.5025848",
"0.5007072",
"0.4989395",
"0.4977966",
"0.4966646",
"0.4966646",
"0.49450508",
"0.49429226",
"0.4941513",
"0.4933067",
... | 0.5205837 | 5 |
Parse command line arguments | def params_args(args=None):
# parameters of model and files
params = argparse.ArgumentParser(
description='Run distribute model CTR DNN.')
params.add_argument("--name",
type=str,
default="ctr-dnn",
help="The name of current mode... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds ... | [
"0.8496655",
"0.7753886",
"0.7493129",
"0.7442371",
"0.74171716",
"0.74159735",
"0.7408078",
"0.7406955",
"0.73962003",
"0.7394545",
"0.73533267",
"0.7352908",
"0.73298883",
"0.732645",
"0.7312877",
"0.72991174",
"0.7295703",
"0.72947407",
"0.7294336",
"0.7288987",
"0.7278817... | 0.0 | -1 |
Format string payload generator. | def gen_fmt_payload(write_map, write_bits='hn', printed=0, testing=False):
if testing:
payload = ''.join('%{}$p'.format(idx) for value,idx in sorted(write_map))
else:
payload = ''
# sorted by value in ascending order.
for value, idx in sorted(write_map):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __gen_fmt_str__(self, fmt):\n return '=' + (self.num_pts_recv * (fmt + ' '))",
"def remap_payload(payload):\n i = 0\n for x in payload:\n i = i%10\n yield str((x+i)%10)[0]\n i += 1",
"def format(self) -> str:",
"def format(self, data):",
"def _get_fmt_string(self):\n ... | [
"0.61453587",
"0.6033142",
"0.6032285",
"0.596967",
"0.58249974",
"0.58163774",
"0.5788948",
"0.573833",
"0.56880134",
"0.5684776",
"0.56300914",
"0.55890155",
"0.555911",
"0.5544999",
"0.5530412",
"0.5526723",
"0.5508725",
"0.5496755",
"0.54892087",
"0.54570377",
"0.5434926"... | 0.59211266 | 4 |
Test for index settings page is included in this test because the database row does not appear to persist between tests. | def test_add_index_settings(self):
response = self.post('base:add_index', self.form_data(), **self.slugs())
assert 'base/project.html' in response.template_name
response = self.get('base:index_settings', **self.index_slugs())
assert 'base/index_update_form.html' in response.template_nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_act_on_settings(self):\n pass # TODO(tlarsen)",
"def test_act_on_settings(self):\n pass # TODO(tlarsen)",
"def test_indexPage(self):\n LOGGER.debug(\"XXX: test_indexPage entered\")\n LOGGER.debug(\"XXX: %s\", settings.TEMPLATES)\n self.post.status = 'publish'\n ... | [
"0.70742357",
"0.70742357",
"0.6653984",
"0.6399997",
"0.62087905",
"0.6084469",
"0.5994128",
"0.59871066",
"0.59534085",
"0.5902207",
"0.58989024",
"0.58647585",
"0.58597213",
"0.584537",
"0.5809805",
"0.57758653",
"0.5730176",
"0.57241803",
"0.56845737",
"0.5682785",
"0.568... | 0.68603957 | 2 |
Test that the unzip function works with zip files that contain files other than pdfs. | def test_verify_unzip(self):
assert os.path.exists(
os.path.join(
settings.MEDIA_ROOT,
"indices",
"test-index",
"data",
"sample.txt"
)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_unzip_file(self):\n\n # Path to the compressed file\n zipped_file = os.path.join(self.xmlfilepath, \"DLTINS_20210117_01of01.zip\")\n # Test for correct data\n # NOTE : For this test case to pass the source xml zipped file\n # should be present in the download path\n ... | [
"0.7355168",
"0.7098369",
"0.70498216",
"0.69765973",
"0.69159365",
"0.6854873",
"0.6835567",
"0.6797622",
"0.66845447",
"0.66813475",
"0.66783005",
"0.6655777",
"0.6611854",
"0.660133",
"0.6597193",
"0.6570835",
"0.6523277",
"0.65053606",
"0.6495154",
"0.6464771",
"0.6463756... | 0.64175653 | 24 |
Receive broadcasts from other nodes, launches a thread to connect to new nodes and exchange timestamps. | def receive_broadcast_thread():
global neighbor_information
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
client.bind(('', get_broadcast_port()))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receive_broadcast_thread():\n current_node = get_node_uuid()\n while True:\n # TODO: write logic for receiving broadcasts.\n data, (ip, port) = broadcaster.recvfrom(4096)\n items = data.decode('UTF-8').split(' ')\n key = items[0]\n actual_port = int(items[2])\n i... | [
"0.7504",
"0.74852496",
"0.7020729",
"0.67168087",
"0.6220197",
"0.6190433",
"0.6159416",
"0.6031282",
"0.59475446",
"0.5942349",
"0.59308153",
"0.5887535",
"0.58224946",
"0.57985353",
"0.57363206",
"0.56215864",
"0.5614009",
"0.5613697",
"0.5607666",
"0.5605568",
"0.56008685... | 0.6493267 | 4 |
Accept connections from other nodes and send them this node's timestamp once they connect. | def tcp_server_thread(id, tcpPort):
global server
# TCP Connection
conn,adrr = server.accept()
received_time_stamp = struct.unpack('!f', conn.recv(4096))[0]
exchange = daemon_thread_builder(CalcDelay, args=(received_time_stamp, id,tcpPort ))
exchange.start()
exchange.join()
pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tcp_server_thread():\n neigbour_sock, neighbour_addr = server.accept()\n my_timestamp = datetime.datetime.utcnow().timestamp()\n packed = struct.pack(\"!d\", my_timestamp)\n neigbour_sock.send(packed)\n pass",
"def tcp_server_thread():\n while True:\n server.listen(4096)\n con... | [
"0.6720128",
"0.6533498",
"0.6439251",
"0.6316046",
"0.6313253",
"0.6296173",
"0.6256884",
"0.6221823",
"0.6147624",
"0.6110266",
"0.61037403",
"0.609133",
"0.59992737",
"0.5917574",
"0.59052026",
"0.58938557",
"0.5878946",
"0.5848995",
"0.5839791",
"0.5825865",
"0.5822812",
... | 0.0 | -1 |
Open a connection to the other_ip, other_tcp_port and do the steps to exchange timestamps. Then update the neighbor_info map using other node's UUID. | def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):
tcpserver=daemon_thread_builder(tcp_server_thread, args=(other_uuid, other_tcp_port))
SENDER = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
SENDER.connect((other_ip,int(other_tcp_port)))
address = (other_ip, int(o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exchange_timestamps_thread(other_uuid: str, other_ip: str, other_tcp_port: int):\r\n print_yellow(f\"ATTEMPTING TO CONNECT TO {other_uuid}\")\r\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\r\n sock.connect((other_ip, int(other_tcp_port)))\r\n other_time = sock.recv(4096)\r\n other_... | [
"0.8264321",
"0.80638933",
"0.8030872",
"0.7862096",
"0.6225704",
"0.58393455",
"0.5660077",
"0.56123143",
"0.54760754",
"0.5442698",
"0.5426285",
"0.52990323",
"0.5269797",
"0.51783824",
"0.51644313",
"0.5143751",
"0.51365656",
"0.51334614",
"0.50976205",
"0.50662106",
"0.50... | 0.66718477 | 4 |
Use this function to make threads. Leave as is. | def daemon_thread_builder(target, args=()) -> threading.Thread:
th = threading.Thread(target=target, args=args)
th.setDaemon(True)
return th | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_and_start_threads(self):\r\n self.create_threads()\r\n self.start_threads()",
"def _make_thread(self):\r\n pass",
"def create_workers(self, threads_count):\n\n for _ in xrange(threads_count):\n new_thread = Thread(target=self.execute)\n self.threads.... | [
"0.78817755",
"0.7458283",
"0.6712016",
"0.66176367",
"0.6480147",
"0.6425454",
"0.64114654",
"0.63368505",
"0.63326395",
"0.62520283",
"0.624767",
"0.624767",
"0.62471247",
"0.6244331",
"0.6223761",
"0.6218233",
"0.6202923",
"0.6194842",
"0.614637",
"0.6122263",
"0.6099799",... | 0.0 | -1 |
Performs a single training step for critic and actor. | def update_step(self, replay_buffer_iter):
states, actions, rewards, discounts, next_states = next(
replay_buffer_iter)
critic_dict = self.fit(states, actions, next_states, rewards, discounts)
actor_dict = self.fit_alpha(states)
return {**actor_dict, **critic_dict} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train_actor_and_critic(self):\n\n # if not enough transitions in memory, don't train!\n if len(self.memory) < self.batch_size:\n return\n\n transitions = self.memory.sample() # sample a batch from memory\n\n # Convert experience tuples to separate arrays for each element\... | [
"0.7754257",
"0.6942381",
"0.67552686",
"0.6744409",
"0.64315784",
"0.6248872",
"0.61960554",
"0.6153682",
"0.61321175",
"0.6125277",
"0.6124174",
"0.6114244",
"0.6085445",
"0.6071526",
"0.59699905",
"0.59624714",
"0.595758",
"0.59572315",
"0.59403145",
"0.58573264",
"0.58545... | 0.0 | -1 |
Ensure we can retrieve a list of our own photos and photos accessible via album groups. | def test_paginated_photos(self):
own_album = AlbumFactory.create(user=self.user)
photos = PhotoFactory.create_batch(3, album=own_album)
PhotoFactory.create_batch(2, album=own_album, trash=True)
trash_album = AlbumFactory.create(user=self.user, trash=True)
PhotoFactory.create(alb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_users_photos_view_set_get_own_photos(self):\n # Create user and data\n user = account_models.User.objects.create_user(email='mrtest@mypapaya.io', password='pass', username='aov_hov')\n category = photo_models.PhotoClassification.objects\\\n .create_or_update(name='Test', cl... | [
"0.6538849",
"0.63964623",
"0.6376904",
"0.6322045",
"0.6120553",
"0.60942847",
"0.60395104",
"0.5947685",
"0.594612",
"0.5942414",
"0.59387887",
"0.5931279",
"0.59208906",
"0.59201974",
"0.58497167",
"0.5842505",
"0.5822845",
"0.578619",
"0.57696813",
"0.5761645",
"0.5749474... | 0.58845454 | 14 |
This callback is called on every http request to the server | def callback_uri(flow):
print("\033[93m" + "WARNING: Potential possible Attack detected on %s" % str(flow) + "\033[0m")
uri = flow.http_info.uri
if ((uri)and(len(uri) > 500)):
""" A URI bigger than 500 bytes could be suspicious """
items = uri.split("?")
args = items[1].split("&")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def onConnect(self, request_or_response):",
"def _process_request(self, request, response):\n ...",
"def event_handler(self, response):\n pass",
"async def _response_handler(self):",
"def connectionMade(self):",
"def on_response(self, response):\n pass",
"def run(self):\n se... | [
"0.68035215",
"0.66667825",
"0.66151416",
"0.6559298",
"0.64284265",
"0.6419971",
"0.6418524",
"0.6417652",
"0.63845855",
"0.6382211",
"0.6347527",
"0.6285853",
"0.6277875",
"0.6248943",
"0.6248943",
"0.6242948",
"0.6242948",
"0.624212",
"0.6197155",
"0.6197155",
"0.6190355",... | 0.0 | -1 |
Pad x and y so that the results have the same length (second dimension). | def _pad_tensors_to_same_length(x, y):
with tf.compat.v1.name_scope("pad_to_same_length"):
x_length = tf.shape(input=x)[1]
y_length = tf.shape(input=y)[1]
max_length = tf.maximum(x_length, y_length)
x = tf.pad(tensor=x, paddings=[[0, 0], [0, max_length - x_length], [0, 0]])
y = tf.pad(tensor=y, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pad_vals(x, y):\n\n xshapes = []\n for x_arr in x:\n\n x_arr = np.array(x_arr)\n xshapes.append(x_arr.shape[0])\n\n x_max_shape = np.max(xshapes)\n for i, x_arr in enumerate(x):\n\n pad_len = x_max_shape - x_arr.shape[0]\n x[i] = np.pad(x_arr, (0, pad_len), mode='constan... | [
"0.72084653",
"0.64343303",
"0.6101265",
"0.6084313",
"0.60171574",
"0.5993216",
"0.5956909",
"0.59541947",
"0.59405696",
"0.59165305",
"0.5867438",
"0.58579695",
"0.5835595",
"0.58168256",
"0.5816696",
"0.5811862",
"0.57709336",
"0.5734227",
"0.5715207",
"0.5693807",
"0.5685... | 0.7147605 | 1 |
Calculate cross entropy loss while ignoring padding. | def padded_cross_entropy_loss(logits, labels, smoothing, vocab_size):
with tf.compat.v1.name_scope("loss", values=[logits, labels]):
logits, labels = _pad_tensors_to_same_length(logits, labels)
# Calculate smoothing cross entropy
with tf.compat.v1.name_scope("smoothing_cross_entropy", values=[logits, lab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy_loss():\n return nn.CrossEntropyLoss()",
"def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))",
"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\n y_pred = tf.cast(y_pred, 'float... | [
"0.72118425",
"0.6977244",
"0.6913567",
"0.69001913",
"0.68212694",
"0.6808604",
"0.6790559",
"0.6770588",
"0.67624503",
"0.67545956",
"0.6719684",
"0.6712214",
"0.6701527",
"0.67001855",
"0.6690241",
"0.6655911",
"0.66522497",
"0.6647189",
"0.6639884",
"0.66260445",
"0.66160... | 0.60390383 | 99 |
Wrap a metric fn that returns scores and weights as an eval metric fn. The input metric_fn returns values for the current batch. The wrapper aggregates the return values collected over all of the batches evaluated. | def _convert_to_eval_metric(metric_fn):
def problem_metric_fn(*args):
"""Returns an aggregation of the metric_fn's returned values."""
(scores, weights) = metric_fn(*args)
# The tf.metrics.mean function assures correct aggregation.
return tf.compat.v1.metrics.mean(scores, weights)
return problem_me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_fn(\n # The pytype below must be Any, because the code below uses internal methods\n # only present on tff.learning.from_keras_model-derived TFF models.\n model: Any,\n dataset: tf.data.Dataset,\n batch_size: int = 1,\n) -> collections.OrderedDict[str, tf.Tensor]:\n # Resets the model'... | [
"0.6395356",
"0.6359279",
"0.629271",
"0.6235188",
"0.62173855",
"0.6195198",
"0.61704963",
"0.6149006",
"0.6123954",
"0.6117296",
"0.6049343",
"0.601445",
"0.5938186",
"0.5898094",
"0.58803093",
"0.58801115",
"0.58606005",
"0.58545065",
"0.5843001",
"0.58256847",
"0.5775458"... | 0.7159342 | 0 |
Returns an aggregation of the metric_fn's returned values. | def problem_metric_fn(*args):
(scores, weights) = metric_fn(*args)
# The tf.metrics.mean function assures correct aggregation.
return tf.compat.v1.metrics.mean(scores, weights) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def agg(self, values, agg_func):\n assert len(values) > 0, \"Empty list of values\"\n f = agg_func.strip().lower()\n assert f in self.__AGGREGATIONS, \"Aggregation function \" + agg_func + \" is not valid\"\n\n ret = 0 # just to avoid \"Local variable might be referenced before assignm... | [
"0.6408343",
"0.63543737",
"0.62959653",
"0.62449336",
"0.6215591",
"0.61848396",
"0.6074576",
"0.60159856",
"0.5993007",
"0.59578437",
"0.5943741",
"0.593868",
"0.59344465",
"0.59140265",
"0.5911688",
"0.5882706",
"0.58362037",
"0.5827314",
"0.5803448",
"0.5791047",
"0.57742... | 0.5814285 | 18 |
Return dictionary of model evaluation metrics. | def get_eval_metrics(logits, labels, params):
metrics = {
"accuracy": _convert_to_eval_metric(padded_accuracy)(logits, labels),
"accuracy_top5": _convert_to_eval_metric(padded_accuracy_top5)(
logits, labels),
"accuracy_per_sequence": _convert_to_eval_metric(
padded_sequence_accur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self) -> Dict[str, float]:\n eval_dataloader = self.get_eval_dataloader()\n\n output = self._prediction_loop(eval_dataloader, description=\"Evaluation\")\n return output.metrics",
"def calc_metrics(model, X, y):\n\n # Get model predictions\n y_predict_r = model.predict(X)\... | [
"0.78439504",
"0.7329396",
"0.72895527",
"0.71769637",
"0.7115815",
"0.7106972",
"0.7095427",
"0.69898015",
"0.6976603",
"0.6963649",
"0.6947694",
"0.69401413",
"0.6920403",
"0.69152176",
"0.683158",
"0.6821512",
"0.6805699",
"0.680537",
"0.6803111",
"0.6790149",
"0.67836165"... | 0.6120414 | 76 |
Percentage of times that predictions matches labels on non0s. | def padded_accuracy(logits, labels):
with tf.compat.v1.variable_scope("padded_accuracy", values=[logits, labels]):
logits, labels = _pad_tensors_to_same_length(logits, labels)
weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)
outputs = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0",
"def percent_accuracy(self, true_values, predicted_values):\n\n correct = 0\n size = len(true_values)\n for i in range(len(true_values)):\n tr... | [
"0.76227057",
"0.7379493",
"0.72297883",
"0.722671",
"0.71479374",
"0.71069294",
"0.7047552",
"0.70354223",
"0.7023279",
"0.7022213",
"0.70219743",
"0.6970781",
"0.6960516",
"0.69523424",
"0.69481045",
"0.6926855",
"0.692359",
"0.6909524",
"0.68767715",
"0.68717813",
"0.68661... | 0.0 | -1 |
Percentage of times that topk predictions matches labels on non0s. | def padded_accuracy_topk(logits, labels, k):
with tf.compat.v1.variable_scope("padded_accuracy_topk", values=[logits, labels]):
logits, labels = _pad_tensors_to_same_length(logits, labels)
weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)
effective_k = tf.minimum(k, tf.shape(input=logits)[-1])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def topk_accuracies(preds, labels, ks):\n num_topks_correct = topks_correct(preds, labels, ks)\n return [(x / preds.size(0)) * 100.0 for x in num_topks_correct]",
"def topk_errors(preds, labels, ks):\n num_topks_correct = topks_correct(preds, labels, ks)\n return [(1.0 - x / preds.size(0)) * 100.0 fo... | [
"0.78908753",
"0.73390025",
"0.7233049",
"0.72291976",
"0.7195095",
"0.70900184",
"0.7036402",
"0.70240974",
"0.69874215",
"0.6977213",
"0.6972062",
"0.6952351",
"0.6952351",
"0.69479007",
"0.69431925",
"0.69333524",
"0.69322234",
"0.6922573",
"0.6919798",
"0.6919798",
"0.691... | 0.0 | -1 |
Percentage of times that predictions matches labels everywhere (non0). | def padded_sequence_accuracy(logits, labels):
with tf.compat.v1.variable_scope("padded_sequence_accuracy", values=[logits, labels]):
logits, labels = _pad_tensors_to_same_length(logits, labels)
weights = tf.cast(tf.not_equal(labels, 0), dtype=tf.float32)
outputs = tf.cast(tf.argmax(input=logits, axis=-1),... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def label_accuracies(preds, labels):\n num_correct = num_correct_fun(preds, labels)\n return (num_correct / preds.size(0)) * 100.0",
"def accuracy(predictions, labels):\n predictions = list(predictions)\n labels = list(labels)\n count = 0\n for i in range(len(labels)):\n if labels[i] == ... | [
"0.7791173",
"0.7454314",
"0.73788065",
"0.7339361",
"0.73184043",
"0.72473156",
"0.7175092",
"0.7150846",
"0.71485466",
"0.71371794",
"0.70903116",
"0.7048925",
"0.7027989",
"0.6983812",
"0.6973967",
"0.6961783",
"0.6957565",
"0.6949172",
"0.6945957",
"0.6927787",
"0.6919117... | 0.0 | -1 |
Average logperplexity excluding padding 0s. No smoothing. | def padded_neg_log_perplexity(logits, labels, vocab_size):
num, den = padded_cross_entropy_loss(logits, labels, 0, vocab_size)
return -num, den | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculate_log_perplexity(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log2(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])",
"def mean_logprob(context, pos_lm):\n logprobs = []\n for tag in pos_lm.vocab:\n ... | [
"0.66184866",
"0.6430783",
"0.64092505",
"0.6403149",
"0.63637125",
"0.6289191",
"0.62084115",
"0.61952806",
"0.6139312",
"0.6139312",
"0.6114071",
"0.60729593",
"0.6072521",
"0.60281146",
"0.6023515",
"0.60105234",
"0.59943175",
"0.5982887",
"0.59648985",
"0.59572244",
"0.59... | 0.5679914 | 60 |
Approximate BLEU score computation between labels and predictions. An approximate BLEU scoring method since we do not glue word pieces or decode the ids and tokenize the output. By default, we use ngram order of 4 and use brevity penalty. Also, this does not have beam search. | def bleu_score(logits, labels):
predictions = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)
# TODO: Look into removing use of py_func
bleu = tf.compat.v1.py_func(compute_bleu, (labels, predictions), tf.float32)
return bleu, tf.constant(1.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, target_text, prediction_text):\n bleu_score = sacrebleu.corpus_bleu([prediction_text], [[target_text]],\n smooth_method=\"exp\",\n smooth_value=0.0,\n force=False,\n ... | [
"0.676764",
"0.6673371",
"0.6643084",
"0.66368395",
"0.6494957",
"0.6433774",
"0.6251299",
"0.61644274",
"0.6140684",
"0.6140684",
"0.6137825",
"0.61087483",
"0.60575855",
"0.6050852",
"0.5999082",
"0.5985014",
"0.596442",
"0.5956953",
"0.5927048",
"0.5841247",
"0.5831066",
... | 0.5997709 | 15 |
Extracts all ngrams up to a given maximum order from an input segment. | def _get_ngrams_with_counter(segment, max_order):
ngram_counts = collections.Counter()
for order in xrange(1, max_order + 1):
for i in xrange(0, len(segment) - order + 1):
ngram = tuple(segment[i:i + order])
ngram_counts[ngram] += 1
return ngram_counts | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_ngrams(line, min_order=1, max_order=BLEU.NGRAM_ORDER) -> Counter:\n\n ngrams = Counter() # type: Counter\n tokens = line.split()\n for n in range(min_order, max_order + 1):\n for i in range(0, len(tokens) - n + 1):\n ngram = ' '.join(tokens[i: i + n])\n ... | [
"0.6581706",
"0.65742457",
"0.64183784",
"0.62482524",
"0.6233594",
"0.6122576",
"0.6087275",
"0.6044856",
"0.6036233",
"0.59712744",
"0.59699684",
"0.5965845",
"0.59467024",
"0.59328526",
"0.5909492",
"0.59071153",
"0.5855572",
"0.58542573",
"0.5828259",
"0.5820391",
"0.5790... | 0.62992704 | 3 |
Computes BLEU score of translated segments against one or more references. | def compute_bleu(reference_corpus, translation_corpus, max_order=4,
use_bp=True):
reference_length = 0
translation_length = 0
bp = 1.0
geo_mean = 0
matches_by_order = [0] * max_order
possible_matches_by_order = [0] * max_order
precisions = []
for (references, translations) in zip(refe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bleu_score(references, generated, n_gram=4, smooth=False):\r\n formatted_ref = [[ref] for ref in references]\r\n bleu_s, _, _, _, _, _ = compute_bleu(formatted_ref, generated, n_gram, smooth)\r\n return bleu_s * 100",
"def calculate_bleu(output_lns, refs_lns):\n return round(corpus_bleu(output_ln... | [
"0.74093115",
"0.6367269",
"0.62644315",
"0.6251968",
"0.61092013",
"0.6055221",
"0.6055221",
"0.60060614",
"0.6000095",
"0.59870803",
"0.597151",
"0.5941071",
"0.59349793",
"0.59248674",
"0.5910593",
"0.57739943",
"0.5773284",
"0.5762745",
"0.57584465",
"0.57571113",
"0.5705... | 0.6329306 | 2 |
ROUGE2 F1 score computation between labels and predictions. This is an approximate ROUGE scoring method since we do not glue word pieces or decode the ids and tokenize the output. | def rouge_2_fscore(logits, labels):
predictions = tf.cast(tf.argmax(input=logits, axis=-1), dtype=tf.int32)
# TODO: Look into removing use of py_func
rouge_2_f_score = tf.compat.v1.py_func(rouge_n, (predictions, labels), tf.float32)
return rouge_2_f_score, tf.constant(1.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_f1_score(actual_labels, preds_labels, binary_classifcation, pos_label=\"malaria\", confusion_matrix_title=\"\"):\n # demonstration of calculating metrics for a neural network model using sklearn\n if not binary_classifcation:\n # For multiclass classification.\n accuracy = accuracy_scor... | [
"0.71954495",
"0.71191156",
"0.6963033",
"0.69378823",
"0.6911759",
"0.6779604",
"0.6772857",
"0.6724274",
"0.67095697",
"0.6671175",
"0.6646141",
"0.6631684",
"0.660936",
"0.66015124",
"0.6600215",
"0.6514463",
"0.6501403",
"0.6496312",
"0.6494798",
"0.64848906",
"0.6475837"... | 0.59118205 | 58 |
Computes ROUGEN f1 score of two text collections of sentences. | def rouge_n(eval_sentences, ref_sentences, n=2):
f1_scores = []
for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):
eval_ngrams = _get_ngrams(n, eval_sentence)
ref_ngrams = _get_ngrams(n, ref_sentence)
ref_count = len(ref_ngrams)
eval_count = len(eval_ngrams)
# Count the over... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wordSimilarityRatio(sent_1,sent_2):",
"def compare_word_selection(selection1,selection2):\n\n num_extra=0;\n num_total=0;\n total_score=0;\n for k in selection1.keys():\n num_total+=1;\n if k not in selection2:\n num_extra+=1;\n else:\n score=compare_sen... | [
"0.6674491",
"0.66676176",
"0.66379195",
"0.66306865",
"0.65985924",
"0.65764666",
"0.63913876",
"0.6372906",
"0.63459545",
"0.6281768",
"0.6273304",
"0.62707555",
"0.62299347",
"0.6229132",
"0.6220144",
"0.6207237",
"0.6142732",
"0.61302173",
"0.6130169",
"0.6127994",
"0.610... | 0.0 | -1 |
ROUGE scores computation between labels and predictions. This is an approximate ROUGE scoring method since we do not glue word pieces or decode the ids and tokenize the output. | def rouge_l_fscore(predictions, labels):
outputs = tf.cast(tf.argmax(input=predictions, axis=-1), dtype=tf.int32)
rouge_l_f_score = tf.compat.v1.py_func(rouge_l_sentence_level, (outputs, labels),
tf.float32)
return rouge_l_f_score, tf.constant(1.0) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, target_tokens, prediction_tokens):\n result = {}\n\n for rouge_type in self.rouge_types:\n if rouge_type == \"rougeL\":\n # Rouge from longest common subsequences.\n scores = _score_lcs(target_tokens, prediction_tokens)\n elif re.match(r\"rouge[0-9]$\", rouge_type):\n ... | [
"0.67164266",
"0.6673074",
"0.6545491",
"0.65359217",
"0.65239596",
"0.6493723",
"0.64730954",
"0.6470353",
"0.6446105",
"0.64450943",
"0.64450467",
"0.641691",
"0.6371628",
"0.63209",
"0.6273009",
"0.62670004",
"0.6264034",
"0.62606454",
"0.62603366",
"0.62595165",
"0.625553... | 0.61701393 | 28 |
Computes ROUGEL (sentence level) of two collections of sentences. | def rouge_l_sentence_level(eval_sentences, ref_sentences):
f1_scores = []
for eval_sentence, ref_sentence in zip(eval_sentences, ref_sentences):
m = float(len(ref_sentence))
n = float(len(eval_sentence))
lcs = _len_lcs(eval_sentence, ref_sentence)
f1_scores.append(_f_lcs(lcs, m, n))
return np.mea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rouge_l_sentence_level(evaluated_sentences, reference_sentences):\n if len(evaluated_sentences) <= 0 or len(reference_sentences) <= 0:\n raise ValueError(\"Collections must contain at least 1 sentence.\")\n reference_words = _split_into_words(reference_sentences)\n evaluated_words = _split_into_words(eva... | [
"0.6562477",
"0.6535288",
"0.6080566",
"0.6073384",
"0.5944744",
"0.5769236",
"0.57410604",
"0.56901485",
"0.5615614",
"0.556189",
"0.55066365",
"0.55035615",
"0.5495382",
"0.54569256",
"0.54294115",
"0.54145795",
"0.5409134",
"0.5398293",
"0.5385837",
"0.5370661",
"0.5333738... | 0.66352373 | 0 |
Returns the length of the Longest Common Subsequence between two seqs. | def _len_lcs(x, y):
table = _lcs(x, y)
n, m = len(x), len(y)
return table[n, m] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n if len(text1) == 0 or len(text2) == 0:\n return 0\n if text1[0] == text2[0]:\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\n else:\n return max(self.longestCommonSubsequence... | [
"0.793082",
"0.78713226",
"0.78309524",
"0.7427125",
"0.73440653",
"0.7278892",
"0.7266744",
"0.71712285",
"0.7093681",
"0.6894858",
"0.68482155",
"0.6788144",
"0.67197895",
"0.6692162",
"0.6673714",
"0.6666056",
"0.6649898",
"0.6628876",
"0.66177297",
"0.6613877",
"0.6545006... | 0.6606945 | 21 |
Computes the length of the LCS between two seqs. The implementation below uses a DP programming algorithm and runs in O(nm) time where n = len(x) and m = len(y). | def _lcs(x, y):
n, m = len(x), len(y)
table = dict()
for i in range(n + 1):
for j in range(m + 1):
if i == 0 or j == 0:
table[i, j] = 0
elif x[i - 1] == y[j - 1]:
table[i, j] = table[i - 1, j - 1] + 1
else:
table[i, j] = max(table[i - 1, j], table[i, j - 1])
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]",
"def _len_lcs(x, y):\n table = _lcs(x, y)\n n, m = len(x), len(y)\n return table[n, m]",
"def lcs_len(x, y):\r\n \r\n if len(x) == 0 or len(y) == 0:\r\n return 0\r\n \r\n xx = x[:-1] # xx = sequence x w... | [
"0.8111537",
"0.8111537",
"0.805192",
"0.8049781",
"0.79654235",
"0.7889462",
"0.77578354",
"0.77516085",
"0.762071",
"0.7560494",
"0.735811",
"0.72106427",
"0.6993349",
"0.6856335",
"0.67487043",
"0.66640663",
"0.6648296",
"0.6540758",
"0.654009",
"0.6442203",
"0.6368005",
... | 0.6708936 | 16 |
Computes the LCSbased Fmeasure score. | def _f_lcs(llcs, m, n):
r_lcs = llcs / m
p_lcs = llcs / n
beta = p_lcs / (r_lcs + 1e-12)
num = (1 + (beta ** 2)) * r_lcs * p_lcs
denom = r_lcs + ((beta ** 2) * p_lcs)
f_lcs = num / (denom + 1e-12)
return f_lcs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[... | [
"0.72489244",
"0.6807921",
"0.67379725",
"0.653737",
"0.619838",
"0.6129479",
"0.6101997",
"0.60964715",
"0.6069985",
"0.60437524",
"0.59976935",
"0.5977477",
"0.59438634",
"0.5916483",
"0.5908706",
"0.5908706",
"0.5908706",
"0.5908706",
"0.58445996",
"0.5814258",
"0.58096695... | 0.5989499 | 11 |
Lists all files in a folder that match the clipping.json format. | def _listdir(folder):
filePattern = r"^\d{4}\-(0?[1-9]|1[012])\-(0?[1-9]|[12][0-9]|3[01])\-clipping\-[\d]*\.json$"
filenames = [f for f in os.listdir(folder) if re.match(filePattern, f)]
return filenames | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def json_files_from_folder(folder: str) -> list:\n\n files = []\n for file_name in os.listdir(folder):\n splitted_filename = file_name.split(\".\")\n if splitted_filename[-1] == \"json\":\n files.append(file_name)\n return files",
"def list_files(path):\n return list(sorted([... | [
"0.66877824",
"0.60839224",
"0.5914875",
"0.5865345",
"0.5820445",
"0.58006823",
"0.5798163",
"0.5783536",
"0.5780574",
"0.57754827",
"0.5738916",
"0.5717606",
"0.5713355",
"0.56997764",
"0.5660107",
"0.56417465",
"0.5632708",
"0.56137383",
"0.5609525",
"0.55692714",
"0.55671... | 0.7092136 | 0 |
To handle exceptions. Some .jsons may not have the same keys. | def _get_clipping_value(clipping, key):
if key in clipping:
return clipping[key]
return "N/A" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def assert_json_failure_response_is_username_collision(self, response):\r\n self.assertEqual(400, response.status_code)\r\n payload = json.loads(response.content)\r\n self.assertFalse(payload.get('success'))\r\n self.assertIn('already exists', payload.get('value'))",
"def check_repeat... | [
"0.6223973",
"0.59830946",
"0.59771997",
"0.5899925",
"0.5856975",
"0.5799147",
"0.5791387",
"0.57734907",
"0.57483834",
"0.57410455",
"0.57091707",
"0.5696217",
"0.56931484",
"0.5691315",
"0.5677174",
"0.56699157",
"0.5655964",
"0.5650639",
"0.5624103",
"0.5604085",
"0.55974... | 0.0 | -1 |
Onetime use function. Method for rebasing .json files. Previous file versions did not include the base64 prefix. | def rebase_add_encoding_prefix():
filenames, clippings = load_clippings(inFolder)
for file, clip in zip(filenames, clippings):
img = clip["imgEncoding"]
str = "data:image/png;base64,"
if str not in img:
clip["imgEncoding"] = str + img
with open(file, "w") as outfile:
json.dump(clip, outfile) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_gen(self):\r\n current_path = os.path.join(self.settings.save_path, 'current.json')\r\n current_folder_path = os.path.join(self.settings.save_path, 'current')\r\n history_path = os.path.join(self.settings.save_path, 'history')\r\n archive_folder_path = os.path.join(history_p... | [
"0.6086128",
"0.6033686",
"0.59726596",
"0.59672356",
"0.5949546",
"0.5894795",
"0.58688366",
"0.5825079",
"0.5788089",
"0.5704787",
"0.5688017",
"0.56608254",
"0.559506",
"0.55057395",
"0.54784393",
"0.5455468",
"0.54384154",
"0.5428078",
"0.5389018",
"0.53759176",
"0.536490... | 0.6098598 | 0 |
Onetime use function. Method for rebasing .json files. Add a "clipDate" key to clippings. | def rebase_add_date():
filenames, clippings = load_clippings(inFolder)
for file, clip in zip(filenames, clippings):
date = "-".join(file.split("-")[:3])
date = date.split("/")[-1]
clip["clipDate"] = date
with open(file, "w") as outfile:
json.dump(clip, outfile) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_files_json():\n # chdir into beep root\n pwd = os.getcwd()\n os.chdir(os.environ.get(\"BEEP_ROOT\", \"/\"))\n\n meta_list = list(filter(lambda x: '_Metadata.csv' in x, os.listdir(SRC_DIR)))\n file_list = list(filter(lambda x: '.csv' in x if x not in meta_list else None, os.listdir(SRC_DI... | [
"0.57587606",
"0.55869764",
"0.53467065",
"0.52671915",
"0.5242644",
"0.5208656",
"0.51642597",
"0.5124621",
"0.50885236",
"0.5050152",
"0.5046206",
"0.5035444",
"0.5032294",
"0.5019946",
"0.50142884",
"0.5002037",
"0.49930683",
"0.49280834",
"0.49243683",
"0.49133766",
"0.49... | 0.7519383 | 0 |
Plots the piezo trace from piezo 0 and PMT pulse sizes near the acoustic signal on one figure. The green line indicates the time of acoustic t0. The red line indicates the time and size of the PMT t0 chosen by Matt's analysis. The yellow lines indicate the times and sizes of other PMT pulses. Also plots in separate win... | def PMTandPiezoPlot(datadir,run,event,gain):
en = event
mu = gain
e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)
print(e["fastDAQ"].keys())
cgate = e["fastDAQ"]["CAMgate"]
dcam = np.diff(cgate)
p0=e["fastDAQ"]["Piezo1"]
p1 = e["fastDAQ"]["Piezo2"]
fdt = e["fast... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plots(self, events=None, title=None):\n data = self.data\n P = PH.regular_grid(3 , 1, order='columnsfirst', figsize=(8., 6), showgrid=False,\n verticalspacing=0.08, horizontalspacing=0.08,\n margins={'leftmargin': 0.07, 'rightmargin': 0.20, 'topmarg... | [
"0.6307774",
"0.6264446",
"0.6067582",
"0.5951146",
"0.594318",
"0.59195983",
"0.59024936",
"0.5900452",
"0.5894213",
"0.5889887",
"0.58874977",
"0.5886258",
"0.58600056",
"0.58458775",
"0.58402437",
"0.5836458",
"0.5819858",
"0.57920396",
"0.5785791",
"0.5773497",
"0.577211"... | 0.72579896 | 0 |
Return content without the comments. If filter_multiline_comment is set to False, only the one line comment will be filtered out. If keep_content_size is set to True, the size of the content is preserved. | def filter_comments(
content, filter_multiline_comment=True, keep_content_size=False
):
def _replace_comment(element):
"""Replace matched *element* in content."""
replacement = ""
matched = element.group()
# Ensure that only the comment part is being replaced
if not matc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _strip_comments(file_contents):\n lines_without_comments = []\n for line in file_contents:\n comment_position = line.find(COMMENT_INDICATOR)\n if comment_position != -1:\n lines_without_comments.append(line[:comment_position])\n else:\n lines_without_comments.ap... | [
"0.5167605",
"0.51409805",
"0.4917135",
"0.4830618",
"0.46820927",
"0.46535304",
"0.46266067",
"0.46166417",
"0.4502041",
"0.44980857",
"0.44534415",
"0.4443194",
"0.44398215",
"0.44346082",
"0.43637702",
"0.43127203",
"0.4308069",
"0.42852294",
"0.42846525",
"0.42836487",
"0... | 0.7138743 | 0 |
Replace matched element in content. | def _replace_comment(element):
replacement = ""
matched = element.group()
# Ensure that only the comment part is being replaced
if not matched.startswith("/"):
replacement += matched[0]
matched = matched[1:]
count = matched.count("\n")
# Add emp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _replace_element(element):\n # Guess line number\n count = element.group().count(\"\\n\")\n\n # Ensure that the replacement string keep the same length that\n # the original content to be able to use the match positions\n _buffer = len(element.group()) - count - 2\n\n ... | [
"0.6922728",
"0.6515308",
"0.6332452",
"0.62553614",
"0.61960304",
"0.6170884",
"0.6162246",
"0.6047259",
"0.60279584",
"0.60038835",
"0.5947182",
"0.58738005",
"0.5823154",
"0.5736322",
"0.5640052",
"0.5575298",
"0.55390126",
"0.5501876",
"0.5462999",
"0.5449665",
"0.5448195... | 0.0 | -1 |
Return tuple of content with the top level elements only and dictionary containing the collapsed content associated with the line number. If filter_comment is set to True, all comment are removed from the content before collapsing the elements. The collapsed content dictionary preserve the comments. | def collapse_all(content, filter_comment=False):
_initial_content = content
collapsed_content = {}
if filter_comment:
# Filter comment before collapsing elements to prevent comment analysis
content = filter_comments(content, keep_content_size=True)
def _replace_element(element):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_comments(\n content, filter_multiline_comment=True, keep_content_size=False\n):\n def _replace_comment(element):\n \"\"\"Replace matched *element* in content.\"\"\"\n replacement = \"\"\n matched = element.group()\n\n # Ensure that only the comment part is being replace... | [
"0.53617066",
"0.49494117",
"0.48269865",
"0.47749653",
"0.47021854",
"0.46672785",
"0.46630976",
"0.46363974",
"0.45885256",
"0.45649537",
"0.45570302",
"0.45216203",
"0.44642898",
"0.44569367",
"0.44267008",
"0.43709692",
"0.43698663",
"0.42966306",
"0.4290518",
"0.42780748",... | 0.71825683 | 0 |
Replace matched element in content. | def _replace_element(element):
# Guess line number
count = element.group().count("\n")
# Ensure that the replacement string keep the same length that
# the original content to be able to use the match positions
_buffer = len(element.group()) - count - 2
if len(element.g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _update_content(self, content, siteurl):\n if not content:\n return content\n\n hrefs = self._get_intrasite_link_regex()\n return hrefs.sub(lambda m: self._link_replacer(siteurl, m), content)",
"def string_replace_xml_text(element, pattern, value):\n if element.text:\n ... | [
"0.6515308",
"0.6332452",
"0.62553614",
"0.61960304",
"0.6170884",
"0.6162246",
"0.6047259",
"0.60279584",
"0.60038835",
"0.5947182",
"0.58738005",
"0.5823154",
"0.5736322",
"0.5640052",
"0.5575298",
"0.55390126",
"0.5501876",
"0.5462999",
"0.5449665",
"0.54481953",
"0.542928... | 0.6922728 | 0 |
Return docstrings for an element at a specific line_number. Loop into the file lines in reverse, starting from the element's line_number in order to parse the docstring if available. | def get_docstring(line_number, lines):
docstring = None
for index in reversed(range(line_number-1)):
line = lines[index].strip()
if len(line) == 0 or line.startswith("//"):
# Do not look for docstring when more than two blank lines precede
# the element.
if i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_doxygen_docstring(lines, name):\n\n lines = lines[:]\n newlines = []\n indent = 0\n reading_desc = False\n\n while lines:\n line = lines.pop(0)\n if line.startswith(\"////\"):\n continue\n\n line = line.rstrip()\n if line.startswith('///<'):\n ... | [
"0.59708744",
"0.5864023",
"0.57362026",
"0.5729538",
"0.5353018",
"0.5304556",
"0.52516913",
"0.5187537",
"0.51576215",
"0.5119893",
"0.4906234",
"0.4906234",
"0.4906234",
"0.48642772",
"0.4851124",
"0.48384303",
"0.47899288",
"0.47810355",
"0.4746727",
"0.4719589",
"0.47194... | 0.67731166 | 0 |
Return a list of schedd ads representing all the schedds in the pool. | def get_schedds(args=None):
schedd_query = classad.ExprTree('!isUndefined(CMSGWMS_Type)')
collectors = ["cmssrv221.fnal.gov:9620",
"cmsgwms-collector-tier0.cern.ch:9620",
"cmssrv276.fnal.gov"]
schedd_ads = {}
for host in collectors:
coll = htcondor.Collector(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ads():\n return coll_ad.distinct(KEY_AD_ID)",
"def get_scnlist_all(self):\n logger.debug(\"Creating Database Engine and Session.\")\n db_engine = sqlalchemy.create_engine(self.db_info_obj.dbConn)\n session_sqlalc = sqlalchemy.orm.sessionmaker(bind=db_engine)\n ses = session... | [
"0.6366169",
"0.58527523",
"0.55230117",
"0.5514247",
"0.5457407",
"0.5414462",
"0.537656",
"0.5369209",
"0.53689307",
"0.53553814",
"0.53361785",
"0.5334375",
"0.53261983",
"0.53052175",
"0.5293422",
"0.5286213",
"0.5268966",
"0.5263969",
"0.525932",
"0.5256553",
"0.5237803"... | 0.59305084 | 1 |
Driver method for the spider script. | def main_driver(args):
starttime = time.time()
# Get all the schedd ads
schedd_ads = get_schedds(args)
logging.warning("&&& There are %d schedds to query.", len(schedd_ads))
pool = multiprocessing.Pool(processes=args.query_pool_size)
if not args.skip_history:
htcondor_es.history.proce... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_spider(self, spider):\n pass",
"def open_spider(self,Spider):\n pass",
"def _scrape(self):",
"def scrape(self):\n pass",
"def runSpider(spiderClass):\n\n\tprocess = CrawlerProcess({\n\t\t# 'USER_AGENT': 'Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)'\n\t})\n\n\tprocess.cr... | [
"0.69789076",
"0.6779831",
"0.6693511",
"0.6653942",
"0.6546695",
"0.6390095",
"0.62781423",
"0.6225595",
"0.61060053",
"0.60984313",
"0.59596026",
"0.59464854",
"0.5914226",
"0.5914064",
"0.5889635",
"0.5883018",
"0.5883018",
"0.5883018",
"0.58060247",
"0.5801764",
"0.578676... | 0.0 | -1 |
Main method for the spider_cms script. Parses arguments and invokes main_driver | def main():
parser = argparse.ArgumentParser()
parser.add_argument("--process_queue", action='store_true',
dest="process_queue",
help="Process also schedd queue (Running/Idle/Pending jobs)")
parser.add_argument("--feed_es", action='store_true',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n\n from scrapy.crawler import CrawlerProcess\n from scrapy.utils.project import get_project_settings\n\n process = CrawlerProcess(get_project_settings())\n process.crawl(NCBIGeoSpider)\n process.start()",
"def main():\n # get input params\n args = parm_parser.get_args()\n # i... | [
"0.70166576",
"0.69471085",
"0.6813321",
"0.66161793",
"0.6571456",
"0.63922524",
"0.6328098",
"0.63057745",
"0.62522024",
"0.6190267",
"0.6187147",
"0.61624885",
"0.6162456",
"0.6151359",
"0.6139654",
"0.6124047",
"0.6120733",
"0.6099212",
"0.6035318",
"0.60084355",
"0.59966... | 0.0 | -1 |
Prepare inputs for GTN, topo input and feat input together. | def gen_input(args, datareader, bkd_gids):
As = {}
Xs = {}
for gid in bkd_gids:
if gid not in As: As[gid] = torch.tensor(datareader.data['adj_list'][gid], dtype=torch.float)
if gid not in Xs: Xs[gid] = torch.tensor(datareader.data['features'][gid], dtype=torch.float)
Ainputs = {}
Xin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_inputs(\n cls,\n training_data: Dict[str, SupervisedDataset],\n task_feature: int,\n rank: Optional[int] = None,\n **kwargs: Any,\n ) -> Dict[str, Any]:\n inputs = super().construct_inputs(\n training_data=training_data, task_feature=task_featur... | [
"0.625194",
"0.61816275",
"0.59840703",
"0.5956487",
"0.59521675",
"0.5821427",
"0.57861555",
"0.57474005",
"0.5709486",
"0.57022744",
"0.570068",
"0.569275",
"0.56124747",
"0.5574784",
"0.55706114",
"0.5532864",
"0.55202353",
"0.5518523",
"0.5515399",
"0.55153596",
"0.551356... | 0.5643953 | 12 |
Test that the package provides customization_data that defines the function | def test_function_definition(self):
func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)
assert func is not None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_confirm_customization_details(self):\n pass",
"def pytest_funcarg__generate_golden_data(request):\r\n return request.config.option.generate_golden_data",
"def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func",
"def test... | [
"0.6494149",
"0.62934417",
"0.62290233",
"0.62290233",
"0.60117173",
"0.5846331",
"0.57936054",
"0.5786965",
"0.5635037",
"0.56308526",
"0.5616144",
"0.5589976",
"0.5589475",
"0.55771124",
"0.55632764",
"0.55560976",
"0.55560976",
"0.55545074",
"0.55533385",
"0.5547361",
"0.5... | 0.6025656 | 12 |
Test calling with sample values for the parameters | def test_success(self, worksheet, circuits_app, attachment_id, incident_id, task_id, excel_ranges,
excel_defined_names, expected_results):
function_params = {
"attachment_id": attachment_id,
"excel_ranges": excel_ranges,
"excel_defined_names": excel_defin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self, params):\r\n return self.sample(params)",
"def sample(self, *args, **kwargs):",
"def test_function_callparams(self):\n\n @Configurable(conf=category('', Parameter('test', value=True)))\n def twist(test=None):\n return test\n\n value = twist()\n\n ... | [
"0.74978554",
"0.7458379",
"0.6806208",
"0.67182815",
"0.66871434",
"0.66065896",
"0.6550513",
"0.6408485",
"0.63945335",
"0.63945335",
"0.6393947",
"0.63818336",
"0.6375116",
"0.6333833",
"0.6326504",
"0.6301726",
"0.6289962",
"0.62281895",
"0.6223233",
"0.6222367",
"0.62067... | 0.0 | -1 |
Uses the Win32 registry to return a iterator of serial (COM) ports existing on this computer. | def _enumerate_serial_ports():
path = 'HARDWARE\\DEVICEMAP\\SERIALCOMM'
try:
key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)
except WindowsError:
raise IterationError
for i in itertools.count():
try:
val = winreg.EnumVal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def enumerate_serial_ports():\n path = 'HARDWARE\\\\DEVICEMAP\\\\SERIALCOMM'\n try:\n key = winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, path)\n except WindowsError:\n raise IterationError\n\n for i in itertools.count():\n try:\n val = winreg.EnumValue(key, i)\n# ... | [
"0.86018956",
"0.8531883",
"0.7983318",
"0.7983318",
"0.7980792",
"0.7802933",
"0.77502596",
"0.7742627",
"0.7668107",
"0.764201",
"0.7632164",
"0.7632164",
"0.7631555",
"0.75972277",
"0.75972277",
"0.75972277",
"0.75972277",
"0.7596552",
"0.75547063",
"0.7551492",
"0.7501493... | 0.860505 | 0 |
Create scatter error plot to compare the Prediction. There is an example of how to use it in the main function below | def scatter_error_plot(y_true, y_predict, datelist,
xlab='Dates', ylab='Units sold', title='Error analysis',
ticks_separation='weeks'):
plt.style.use('seaborn')
#create plot
fig=plt.figure(figsize=(15,10))
#plot things
plt.plot(datelist,y_true, lab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_errors(self):\n\n plt.title(\"Prediction Error\")\n plt.plot(self.errors)\n plt.ylabel(\"MSE (Mean Squared Error)\")\n plt.xlabel(\"Iteration\")\n plt.show()",
"def plotPredictedError():\n\tglobal normalized\n\n\twarmthPred = []\n\twarmthObserved = []\n\tcompPred = []\... | [
"0.74629337",
"0.73333055",
"0.7297354",
"0.72578835",
"0.71555036",
"0.69879824",
"0.6962361",
"0.6863958",
"0.68618965",
"0.6843908",
"0.68003273",
"0.67923915",
"0.6791393",
"0.6774523",
"0.6764563",
"0.6723646",
"0.67137504",
"0.6705686",
"0.66826",
"0.664954",
"0.6558499... | 0.72337556 | 4 |
Function that plots a Calendar Map | def plot_calmap(df_serie, title='Calendar 2018'):
plt.style.use('seaborn')
fig = plt.figure(figsize=(15,6))
ax = fig.add_subplot(111)
cax = calmap.yearplot(df_serie, ax=ax )#, cmap='YlGn')
cb=fig.colorbar(cax.get_children()[1], ax=cax, orientation='horizontal')
plt.title(title)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_calmap(df, yr, s3_resource_bucket):\n calmap_data = pd.Series(df['Miles'].values, index=df['Date'])\n plt.figure(figsize=(15, 5))\n plt.title(f'CALENDAR HEATMAP')\n calmap.yearplot(calmap_data,\n year=int(yr),\n fillcolor='lightgrey')\n plt.savefig(f'... | [
"0.69210756",
"0.6444934",
"0.6395161",
"0.6322168",
"0.6316235",
"0.6248",
"0.62450975",
"0.62378526",
"0.62311244",
"0.62179315",
"0.6160899",
"0.6084357",
"0.60731095",
"0.60508186",
"0.60447294",
"0.6003607",
"0.5985491",
"0.5948202",
"0.593896",
"0.59218866",
"0.5912166"... | 0.7201914 | 0 |
counts reviewer comments, checks for protm tag, counts rxns | def calc_comments(self):
for comment in self.pull_request.get_comments():
self._users.add(comment.user.login)
lowercase_body = comment.body.lower()
if "protm" in lowercase_body:
self.num_protm += 1
self.num_comments += 1
if comment.body... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_conv_comments(self):\n for conv_comment in self.pull_request.get_issue_comments():\n self._users.add(conv_comment.user.login)\n lowercase_body = conv_comment.body.lower()\n if \"protm\" in lowercase_body:\n self.num_protm += 1\n self.num_co... | [
"0.6474507",
"0.6455249",
"0.6259978",
"0.62172806",
"0.61330706",
"0.60819334",
"0.6049567",
"0.6044032",
"0.5932042",
"0.59275013",
"0.5864903",
"0.5854539",
"0.5774755",
"0.57618237",
"0.57519615",
"0.5748041",
"0.5737438",
"0.57298326",
"0.5722486",
"0.57208025",
"0.57045... | 0.668312 | 0 |
counts conversational comments, checks for protm tag, counts rxns | def calc_conv_comments(self):
for conv_comment in self.pull_request.get_issue_comments():
self._users.add(conv_comment.user.login)
lowercase_body = conv_comment.body.lower()
if "protm" in lowercase_body:
self.num_protm += 1
self.num_conv_comments +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_comments(self):\n return self.run_query(f\"count({self.r}/comment)\")",
"def calc_comments(self):\n for comment in self.pull_request.get_comments():\n self._users.add(comment.user.login)\n lowercase_body = comment.body.lower()\n if \"protm\" in lowercase_b... | [
"0.66587913",
"0.6579101",
"0.6395755",
"0.6311714",
"0.6095312",
"0.6047312",
"0.5910355",
"0.5901797",
"0.5876962",
"0.5855314",
"0.58521634",
"0.5803708",
"0.57817703",
"0.5762721",
"0.57504636",
"0.5726828",
"0.5711957",
"0.57052165",
"0.57052165",
"0.57011557",
"0.569478... | 0.68003654 | 0 |
finds issues in PR | def issues(self):
if self.pull_request.body is not None:
regex = r"(?<=closes: #|elated: #)\d{5}"
issue_strs = re.findall(regex, self.pull_request.body)
self.issue_nums = [eval(s) for s in issue_strs] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_issue_list_issues(self):\n pass",
"def get_issues(): # pragma: no cover\n global issue_data\n team = {\n 'stevex196x': 0,\n 'TheSchaft': 0,\n 'melxtru': 0,\n 'aylish19': 0,\n 'connormlewis': 0,\n 'tsukkisuki': 0\n }\n all_issues = 0\n whil... | [
"0.70138097",
"0.6760061",
"0.66123015",
"0.66048265",
"0.65544665",
"0.6547893",
"0.64266086",
"0.63871706",
"0.63705385",
"0.6270671",
"0.62466",
"0.6183235",
"0.61762655",
"0.61605066",
"0.61473805",
"0.6101282",
"0.60798544",
"0.6076719",
"0.6035414",
"0.602907",
"0.60161... | 0.7080025 | 0 |
counts reactions to issue comments | def issue_reactions(self):
if self.issue_nums:
repo = self.g.get_repo("apache/airflow")
for num in self.issue_nums:
try:
issue = repo.get_issue(num)
except UnknownObjectException:
continue
for reactio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def github_num_reactions(comment_object: Dict[str, Any]) -> int:\n return comment_object.get('reactions', {}).get('total_count', 0)",
"def test_issue_get_comment_reactions(self):\n pass",
"def github_num_positive_reactions(comment_object: Dict[str, Any]) -> int:\n num_positive_reactions = 0\n p... | [
"0.76340306",
"0.74687517",
"0.7269382",
"0.6970428",
"0.6815051",
"0.67963237",
"0.6664741",
"0.6631019",
"0.65597695",
"0.64880365",
"0.6383443",
"0.63385135",
"0.6307957",
"0.6293642",
"0.6261808",
"0.62437093",
"0.619304",
"0.618121",
"0.6169378",
"0.6130174",
"0.6072496"... | 0.7240344 | 3 |
Initiate a password reset with a complex token, multi step | def create_password_reset_token(self, user_id):
try:
self.logger.debug('Password Reset attempt %s', user_id)
password_reset_token = ''
nosqldb = self.pers.nosql_db
db_user_record = nosqldb['users'].find_one(
{
'$or': [
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_password_reset():",
"def password_resetenter(request, uidb64=None, token=None):\n\n\tcontext_dict = {}\n\tif request.method == 'POST':\n\t\tassert uidb64 is not None and token is not None\n\t\tuid = urlsafe_base64_decode(uidb64)\n\t\tuser = models.Teacher.objects.get(\n\t\t\tsoft_delete=False, pk=uid... | [
"0.74162245",
"0.70615184",
"0.6827222",
"0.6698908",
"0.6595932",
"0.6443836",
"0.6400114",
"0.63979876",
"0.63826585",
"0.63694924",
"0.6352916",
"0.63482845",
"0.6347419",
"0.6342296",
"0.63396615",
"0.63304526",
"0.63268495",
"0.6316747",
"0.6214706",
"0.6172585",
"0.6138... | 0.56647867 | 72 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.